Exported: https://bugs.launchpad.net/smart/+bug/245606

Reason: Review Patch

further details:
https://blueprints.launchpad.net/smart/+spec/bug-reporting-migrationa

What is the status of this issue please?

Reference:

http://lists.labix.org/htdig.cgi/smart-labix.org/2006-June/001199.html

(check the complete thread)

mvo posted a patch to address this some time ago. I don't know when (if?) it
will become part of smart in the future, however.

Some additional interface and algorithmic ideas came into my mind that even go                    
beyond Defoster.               
                 
Let's take the following situation: Like above someone installed a single                    
Gnome app at at pure Qt/KDE desktop and now removes this app without removing                    
its dependencies. The problem is that now a larger number of libs is on top                    
level of dependencies but joe user has noe clue that they were installed                    
together for a single purpose and thus should also be removed together.                
                
But distros are writing install/uninstall logs that could be analyzed and                
could be checked for removed packages. For these removed packages the                
dependencies get also calculated and now you can reconstruct the root of a               
dependency tree and can group the now independent top level dependencies                
of the Gnome libs of our example together.               
               
So I now suggest an user interface where you have the top level packages like               
a tree with subgrouping the dependencies that only belong to this package (in             
that current installation, as the packages belonging to only one top package             
can change if you install more packages).             
             
So it would be look like this (in case the top leve application wasn't             
removed):               
               
[x][x] Application X               
 |               
  ---[x] Lib X               
 |               
  ---[x] Lib Y               
 |               
  ---[x] Lib Z               
            
If you unceck the first [x] at Application X all subpackages belonging to it         
get unchecked automatically too (but you can check single packages below            
this top package again so that they will be kept). If you uncheck the second         
[x] at Application X only the application gets removed but not the         
dependencies. As long as the second [x] at Application X is not unchecked the     
dependencies are greyed out as you cannot remove them as long as the package     
that depends from them is installed.     
         
In case the top Application was already removed the interface looks like that         
(note the empty [ ] at Application X):           
          
[x][ ] Application X               
 |               
  ---[x] Lib X               
 |               
  ---[x] Lib Y               
 |               
  ---[x] Lib Z               
        
So you can either reconstruct the package and reinstall the application        
package if you check the [ ] or remove the whole thing entirely if you also       
uncheck the first [x].

With Debfoster [1] from Debian it is possible to get a list of packages that         
are on top of all other depending packages and to delete such a top package        
with all its dependencies that are only installed because of this "top        
package".       
        
This is _very_ helpfull to keep the system clean as none remembers at       
uninstall all libs and other packages that were installed because of this       
(e.g. you have let's say KDE installed and now you install one Gnome app but       
you remove it some time later, now all gnomelibs are still sitting there       
although you don't need them). 
       
If this feature could be included in SmartPM this would be a great usability       
enhancement as dealing with hundreds of packages is often said to be one of       
the shortcommings on Linux (beside the time you save not doing this all      
manually).      
 
There is another tool at Debian with almost the same purpose called Deborphan     
[2], which is specialised in removing unused library packages.       
    
The only tool doing that job for RPM's is to my knowledge Rpmorphan [3].   
   
All theses tools are command line tools, so it would be a killer feature for   
SmartPM compared to other graphical package managers if it includes such a   
feature. 
   
I envision a a special uninstall page in SmartPM (for single packages you have  
install uninstall in one window) for that purpose and give the user the  
possibility removing all top packages with dependencies via a single mouse  
click as it is now with single packages. This would also be great for  
unexperienced users as they don't get confused with a huge list of installed  
packages. They are mostly interested in an application and not the libraries  
an app also needs.  
        
Greetings,  
Arnomane  
  
[1] http://www.fruit.je/debfoster/       
[2] http://packages.debian.org/deborphan    
[3] http://penguinppc.org/~jeramy/rpmorphan/