Merge lp:~barry/computer-janitor/uicleanup into lp:computer-janitor

[Barry Warsaw]

This removes the "Recommended" column, since it is never filled. It also does a few minor other ui tweaks such as move the progress bar and shrink the default size of the window.

[Barry Warsaw (barry)]

This will need a ui exception to make it into Lucid beta 1, but I think it's worth it.

=== added file '.bzrignore'
--- .bzrignore	1970-01-01 00:00:00 +0000
+++ .bzrignore	2010-03-10 21:40:30 +0000
@@ -0,0 +1,5 @@
+build
+computer_janitor.egg-info
+computerjanitord/tests/data/var/cache
+computerjanitord/tests/data/var/lib/dpkg
+computerjanitord/tests/data/var/lib/apt/lists/partial
 
=== modified file 'computer-janitor'
--- computer-janitor	2009-08-18 13:48:50 +0000
+++ computer-janitor	2010-03-10 21:40:30 +0000
@@ -1,7 +1,6 @@
 #!/usr/bin/python
 #
-# computer-janitor - clean up a Unix-like operating system
-# Copyright (C) 2008, 2009  Canonical, Ltd.
+# Copyright (C) 2008, 2009, 2010  Canonical, Ltd.
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -15,21 +14,14 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-
-import logging
-import os
-import sys
-import traceback
-
-import computerjanitor
-import computerjanitorapp
-
-
-try:
-    app = computerjanitorapp.Application()
-    app.run(computerjanitorapp.CommandLineUserInterface)
-except computerjanitor.Exception, e:
-    logging.debug(unicode(traceback.format_exc()))
-    logging.error(e._str)
-    sys.exit(1)
-
+"""Start the command-line computer janitor."""
+
+from __future__ import absolute_import, unicode_literals
+
+__metaclass__ = type
+__all__ = [
+    ]
+
+
+from computerjanitorapp.maincli import main
+main()
 
=== modified file 'computer-janitor-gtk'
--- computer-janitor-gtk	2009-02-11 17:21:24 +0000
+++ computer-janitor-gtk	2010-03-10 21:40:30 +0000
@@ -1,7 +1,7 @@
 #!/usr/bin/python
 #
 # computer-janitor-gtk - clean up a Unix-like operating system (GTK version)
-# Copyright (C) 2008, 2009  Canonical, Ltd.
+# Copyright (C) 2008, 2009, 2010  Canonical, Ltd.
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -15,20 +15,29 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-
-import logging
+"""Start the gtk computer janitor."""
+
+from __future__ import absolute_import, unicode_literals
+
+__metaclass__ = type
+__all__ = [
+    ]
+
+
 import os
 import sys
+import logging
 import traceback
-
 import computerjanitor
-import computerjanitorapp
+
+from computerjanitorapp.maingtk import main
 
 
 try:
-    app = computerjanitorapp.Application()
-    app.run(computerjanitorapp.GtkUserInterface)
-except computerjanitor.Exception, e:
+    main()
+except KeyboardInterrupt:
+    pass
+except computerjanitor.Exception as error:
     logging.debug(unicode(traceback.format_exc()))
-    logging.error(unicode(e))
+    logging.error(unicode(error))
     sys.exit(1)
 
=== modified file 'computerjanitorapp/__init__.py'
--- computerjanitorapp/__init__.py	2009-09-09 14:36:30 +0000
+++ computerjanitorapp/__init__.py	2010-03-10 21:40:30 +0000
@@ -1,5 +1,4 @@
-# __init__.py for computerjanitorapp
-# Copyright (C) 2008, 2009  Canonical, Ltd.
+# Copyright (C) 2008, 2009, 2010  Canonical, Ltd.
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -13,24 +12,29 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-
-VERSION = "1.13.3"
-
-
-# Set up gettext. This needs to be before the import statements below
-# so that if any modules call it right after importing, they find
-# setup_gettext.
-
+"""computerjanitorapp module."""
+
+from __future__ import absolute_import, unicode_literals
+
+__metaclass__ = type
+__all__ = [
+    '__version__',
+    'setup_gettext',
+    ]
+
+
+__version__ = '2.0'
+
+
+# Set up gettext.
 def setup_gettext():
     """Set up gettext for a module.
 
-    Return a method to be used for looking up translations. Usage:
-
-      import computerjanitorapp
-      _ = computerjanitorapp.setup_gettext()
-
+    Return a method to be used for looking up translations.  Usage:
+
+    >>> import computerjanitorapp
+    >>> _ = computerjanitorapp.setup_gettext()
     """
-
     import gettext
     import os
 
@@ -38,11 +42,3 @@
     localedir = os.environ.get('LOCPATH', None)
     t = gettext.translation(domain, localedir=localedir, fallback=True)
     return t.ugettext
-
-
-from app import Application
-from ui import UserInterface
-from ui_cli import CommandLineUserInterface
-from ui_gtk import GtkUserInterface
-from state import State
-from terminalsize import get_terminal_size
 
=== removed file 'computerjanitorapp/app.py'
--- computerjanitorapp/app.py	2009-11-10 20:01:34 +0000
+++ computerjanitorapp/app.py	1970-01-01 00:00:00 +0000
@@ -1,192 +0,0 @@
-# app.py - the application main program of Computer Janitor
-# Copyright (C) 2008, 2009  Canonical, Ltd.
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, version 3 of the License.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-
-import ConfigParser
-import logging
-import logging.handlers
-import optparse
-import os
-import sys
-
-import computerjanitor
-import computerjanitorapp
-_ = computerjanitorapp.setup_gettext()
-
-
-DEFAULT_PLUGINS_DIRS = "/usr/share/computerjanitor/plugins"
-DEFAULT_STATE_FILE = "/var/lib/computer-janitor/state.dat"
-
-
-class SourcesListProblem(computerjanitor.Exception):
-
-    def __init__(self, missing_package):
-        self._str = _("Essential package %s is missing. There may be "
-                      "problems with apt sources.list or Packages files may "
-                      "be missing?") % missing_package
-
-
-class AsciiFormatter(logging.Formatter):
-
-    def format(self, record): # pragma: no cover
-        msg = logging.Formatter.format(self, record)
-        return msg.encode('ascii', 'replace')
-
-
-def setup_logging(): # pragma: no cover
-    if os.environ.get("COMPUTER_JANITOR_DEBUG", None) == "yes":
-        level = logging.DEBUG
-    elif os.environ.get("COMPUTER_JANITOR_UNITTEST", None) == "yes":
-        level = logging.CRITICAL
-    else:
-        level = logging.INFO
-    logging.basicConfig(level=level, format="%(levelname)s: %(message)s")
-
-    try:
-        formatter = AsciiFormatter(
-                        "computer-janitor %(levelname)s: %(message)s")
-        handler = logging.handlers.SysLogHandler("/dev/log")
-        handler.setLevel(level)
-        handler.setFormatter(formatter)
-        logging.getLogger().addHandler(handler)
-    except:
-        # We're OK with something going wrong.
-        logging.debug(_("Logging to syslog cannot be set up."))
-
-
-class Application(object):
-
-    """The main class for the program."""
-
-    whitelist_dirs = ["/etc/computer-janitor.d"]
-
-    def __init__(self, apt=None):
-        self.state = computerjanitorapp.State()
-        self.parser = self.create_option_parser()
-        self.apt = computerjanitor.apt
-        if apt is not None:
-            self.apt = apt
-        self.refresh_apt_cache()
-        
-        # The Plugin API requires that we have a config that is a
-        # ConfigParser. We don't use it for anything, for now.
-        self.config = ConfigParser.ConfigParser()
-        
-    def run(self, ui_class, 
-            plugin_manager_class=computerjanitor.PluginManager):
-        setup_logging()
-        logging.debug(_("Running application, with:"))
-        logging.debug("  plugin_manager_class=%s" % plugin_manager_class)
-        
-        options, args = self.parse_options()
-
-        pluginpath = os.environ.get("COMPUTER_JANITOR_PLUGINS", 
-                                    DEFAULT_PLUGINS_DIRS)
-        plugindirs = pluginpath.split(":")
-        pm = plugin_manager_class(self, plugindirs)
-
-        ui = ui_class(self, pm)
-        ui.run(options, args)
-
-    def create_option_parser(self): # pragma: no cover
-        parser = optparse.OptionParser(version="%%prog %s" % 
-                                        computerjanitorapp.VERSION)
-        
-        parser.usage = _("""
-%prog [options] find
-%prog [options] cleanup [CRUFT]...
-%prog [options] ignore [CRUFT]...
-%prog [options] unignore [CRUFT]...
-
-%prog finds and removes cruft from your system. 
-
-Cruft is anything that shouldn't be on the system, but is. Stretching
-the definition, it is also things that should be on the system, but
-aren't.""")
-
-        parser.add_option("--all", action="store_true",
-                          help=_("Make the 'cleanup' command remove all "
-                                 "packages, if none are given on the "
-                                 "command line."))
-
-        parser.add_option("--state-file", metavar="FILE",
-                          default=DEFAULT_STATE_FILE,
-                          help=_("Store state of each piece of cruft in "
-                                 "FILE. (Default is %default)."))
-
-        parser.add_option("--no-act", action="store_true",
-                          help=_("Don't actually remove anything, just "
-                                 "pretend to do so. This is useful for "
-				 "testing stuff."))
-
-        parser.add_option("--verbose", action="store_true",
-                          help=_("Verbose operation: make find show an "
-                                 "explanation for each piece of cruft "
-				 "found."))
-
-        return parser
-
-    def parse_options(self, args=None):
-        return self.parser.parse_args(args=args)
-
-    def refresh_apt_cache(self):
-        self.apt_cache = self.apt.Cache()
-	self.apt_cache._depcache.ReadPinFile("/var/lib/synaptic/preferences")
-
-    def verify_apt_cache(self):
-        for name in ["dash", "gzip"]:
-            if name not in self.apt_cache:
-                raise SourcesListProblem(name)
-            if not any(v.downloadable for v in self.apt_cache[name].versions):
-                raise SourcesListProblem(name)
-
-    def whitelist_files(self, dirnames):
-        """Find files with whitelists in a list of directories.
-
-        The directory is scanned for files ending in ".whitelist".
-        Subdirectories are not scanned.
-
-        """
-
-        list = []
-        for dirname in dirnames:
-            try:
-                basenames = os.listdir(dirname)
-                whitelists = [x for x in basenames if x.endswith(".whitelist")]
-                list += [os.path.join(dirname, x) for x in whitelists]
-            except os.error:
-                pass
-
-        return list
-
-    def whitelisted_cruft(self, dirnames=None):
-        """Return list of cruft that is whitelisted."""
-
-        dirnames = dirnames or self.whitelist_dirs
-
-        list = []
-        for filename in self.whitelist_files(dirnames):
-            f = file(filename, "r")
-            for line in f.readlines():
-                line = line.strip()
-                if line and not line.startswith("#"):
-                    list.append(line)
-            f.close()
-
-        return list
-
-    def remove_whitelisted(self, crufts, dirnames=None):
-        whitelisted = self.whitelisted_cruft(dirnames=dirnames)
-        return [c for c in crufts if c.get_name() not in whitelisted]
 
=== removed file 'computerjanitorapp/app_tests.py'
--- computerjanitorapp/app_tests.py	2009-08-14 12:37:25 +0000
+++ computerjanitorapp/app_tests.py	1970-01-01 00:00:00 +0000
@@ -1,178 +0,0 @@
-# app_tests.py - unit tests for app.py
-# Copyright (C) 2008, 2009  Canonical, Ltd.
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, version 3 of the License.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-
-import os
-import shutil
-import tempfile
-import unittest
-
-import computerjanitor
-import computerjanitorapp
-
-
-class MockUI(object):
-
-    def __init__(self, testcase, app, pm):
-        self.testcase = testcase
-        
-    def run(self, options, args):
-        self.testcase.ui_ran = True
-
-
-class MockPackage(object):
-
-    def __init__(self, downloadable=False):
-        self.downloadable = downloadable
-        self.candidate = self
-
-
-class MockApt(dict):
-
-    def __init__(self):
-        self._depcache = self
-        
-    def ReadPinFile(self, filename):
-        pass
-
-    def Cache(self):
-        return self
-
-
-class MockCruft(object):
-
-    def __init__(self, name):
-        self.name = name
-
-    def get_name(self):
-        return self.name
-
-
-class ApplicationTests(unittest.TestCase):
-
-    def setUp(self):
-        self.mock_apt = MockApt()
-        self.app = computerjanitorapp.Application(apt=self.mock_apt)
-        self.app.apt_cache["dash"] = MockPackage(downloadable=True)
-        self.app.apt_cache["gzip"] = MockPackage(downloadable=True)
-
-    def testSetsUpAptAttributeCorrectly(self):
-        self.assertEqual(self.app.apt, self.mock_apt)
-        
-    def testSetsUpAndReturnsState(self):
-        self.assert_(self.app.state)
-
-    def testSetsUpAptCacheWhenRequested(self):
-        self.assertNotEqual(self.app.apt_cache, None)
-
-    def testSetsOptionDefaultsCorrectly(self):
-        options, args = self.app.parse_options(args=[])
-        self.assertEqual(args, [])
-        self.assertEqual(options.all, None)
-        self.assertEqual(options.state_file, 
-                         "/var/lib/computer-janitor/state.dat")
-        self.assertEqual(options.no_act, None)
-
-    def testAcceptsDashDashAllOption(self):
-        options, args = self.app.parse_options(args=["--all"])
-        self.assertEqual(options.all, True)
-
-    def testAcceptsDashDashStateFileOption(self):
-        options, args = self.app.parse_options(args=["--state-file=foo"])
-        self.assertEqual(options.state_file, "foo")
-
-    def testAcceptsDashDashNoActOption(self):
-        options, args = self.app.parse_options(args=["--no-act"])
-        self.assertEqual(options.no_act, True)
-
-    def testRunsUserInterface(self):
-
-        def pm_class(app, plugin_dirs):
-            self.pm_ran = True
-
-        def ui_class(app, pm):
-            return MockUI(self, app, pm)
-
-        self.pm_ran = False
-        self.ui_ran = False
-        self.app.run(ui_class=ui_class, plugin_manager_class=pm_class)
-        self.assert_(self.ui_ran)
-
-    def testAcceptsAptCacheWhenEssentialPackagesAreThere(self):
-        self.assertEqual(self.app.verify_apt_cache(), None)
-
-    def testRejectsAptCacheWhenDashIsMissing(self):
-        del self.app.apt_cache["dash"]
-        self.assertRaises(computerjanitor.Exception, 
-                          self.app.verify_apt_cache)
-
-    def testRejectsAptCacheWhenGzipIsMissing(self):
-        del self.app.apt_cache["gzip"]
-        self.assertRaises(computerjanitor.Exception, 
-                          self.app.verify_apt_cache)
-
-    def testRejectsAptCacheWhenDashIsNotDownloadable(self):
-        self.app.apt_cache["dash"].candidate.downloadable = False
-        self.assertRaises(computerjanitor.Exception, 
-                          self.app.verify_apt_cache)
-
-    def testRejectsAptCacheWhenGzipIsNotDownloadable(self):
-        self.app.apt_cache["dash"].candidate.downloadable = False
-        self.assertRaises(computerjanitor.Exception, 
-                          self.app.verify_apt_cache)
-
-    def testSetsDefaultListOfWhitelistDirectoriesCorrectly(self):
-        self.assert_("/etc/computer-janitor.d" in self.app.whitelist_dirs)
-
-    def testReturnsEmptyWhitelistByDefault(self):
-        dirname = tempfile.mkdtemp()
-        whitelist = self.app.whitelisted_cruft(dirnames=[dirname])
-        shutil.rmtree(dirname)
-        self.assertEqual(whitelist, [])
-
-    def testDoesNotMindNonExistentWhitelistDirectory(self):
-        dirname = tempfile.mkdtemp()
-        subdir = os.path.join(dirname, "foo")
-        whitelist = self.app.whitelisted_cruft(dirnames=[subdir])
-        shutil.rmtree(dirname)
-        self.assertEqual(whitelist, [])
-
-    def testReadsWhitelistFilesCorrectly(self):
-        dirname = tempfile.mkdtemp()
-        temp1 = os.path.join(dirname, "foo.whitelist")
-        temp2 = os.path.join(dirname, "foo.whitelist~")
-
-        file(temp1, "w").write("deb:foo\n")
-        file(temp2, "w").write("deb:bar\n")
-
-        whitelist = self.app.whitelisted_cruft(dirnames=[dirname])
-        shutil.rmtree(dirname)
-        self.assertEqual(whitelist, ["deb:foo"])
-
-    def testFindsCorrectWhitelistFilesInDotDDirectory(self):
-        dirname = tempfile.mkdtemp()
-        file(os.path.join(dirname, "foo.whitelist"), "w").write("deb:foo\n")
-        file(os.path.join(dirname, "foo.whitelist~"), "w").write("deb:bar\n")
-        list = self.app.whitelist_files([dirname])
-        shutil.rmtree(dirname)
-        self.assertEqual(list, [os.path.join(dirname, "foo.whitelist")])
-
-    def testRemovesWhitelistedCruftCorrectly(self):
-        crufts = [MockCruft("deb:foo"), MockCruft("deb:bar")]
-        dirname = tempfile.mkdtemp()
-        file(os.path.join(dirname, "foo.whitelist"), "w").write("deb:foo\n")
-        crufts2 = self.app.remove_whitelisted(crufts, dirnames=[dirname])
-        shutil.rmtree(dirname)
-        self.assertEqual(crufts2, crufts[1:])
 
=== added file 'computerjanitorapp/areyousure.py'
--- computerjanitorapp/areyousure.py	1970-01-01 00:00:00 +0000
+++ computerjanitorapp/areyousure.py	2010-03-10 21:40:30 +0000
@@ -0,0 +1,76 @@
+# Copyright (C) 2008, 2009, 2010  Canonical, Ltd.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, version 3 of the License.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""Confirm some actions."""
+
+from __future__ import absolute_import, unicode_literals
+
+__metaclass__ = type
+__all__ = [
+    'AreYouSure',
+    ]
+
+
+import gtk
+
+from computerjanitorapp import setup_gettext
+from computerjanitorapp.store import ListStoreColumns
+
+_ = setup_gettext()
+NL = '\n'
+
+
+class AreYouSure:
+    """Confirmation of destructive actions."""
+
+    def __init__(self, ui):
+        self._ui = ui
+
+    def verify(self):
+        """Confirm package removal."""
+        # Start by getting all the active, non-ignored cruft.  These are the
+        # candidates for removal.
+        cleanable_cruft = self._ui.get_cleanable_cruft()
+        # It would be nice if we could produce better messages than these, but
+        # that would require a richer interface to the dbus service, and
+        # probably to the cruft plugin architecture underneath that.
+        message = _('Are you sure you want to clean your system?')
+        dialog = gtk.MessageDialog(
+            parent=self._ui.widgets['window'],
+            type=gtk.MESSAGE_WARNING,
+            buttons=gtk.BUTTONS_NONE,
+            message_format=message)
+        dialog.set_title(_('Clean up'))
+        package_cruft_count = sum(1 for cruft_name, is_pkg in cleanable_cruft
+                                  if is_pkg)
+        other_cruft_count = len(cleanable_cruft) - package_cruft_count
+        messages = []
+        if package_cruft_count > 0:
+            messages = [_('<b>Software packages to remove: {packages}</b>.'),
+                        _('\nRemoving packages that are still in use can '
+                          'cause errors.')]
+            ok_button = _('Remove packages')
+        if other_cruft_count > 0:
+            messages.insert(1, _('Non-package items to remove: {others}.'))
+            ok_button = _('Clean up')
+        message = NL.join(messages).format(packages=package_cruft_count,
+                                           others=other_cruft_count)
+        dialog.format_secondary_markup(message)
+        dialog.add_button(gtk.STOCK_CANCEL, gtk.RESPONSE_CLOSE)
+        dialog.add_button(ok_button, gtk.RESPONSE_YES)
+        # Show the dialog and get the user's response.
+        dialog.show_all()
+        response = dialog.run()
+        dialog.hide()
+        return response == gtk.RESPONSE_YES
 
=== renamed file 'computerjanitorapp/ui_cli.py' => 'computerjanitorapp/maincli.py'
--- computerjanitorapp/ui_cli.py	2009-08-18 14:10:42 +0000
+++ computerjanitorapp/maincli.py	2010-03-10 21:40:30 +0000
@@ -1,5 +1,4 @@
-# ui_cli.py - command line user interface
-# Copyright (C) 2008, 2009  Canonical, Ltd.
+# Copyright (C) 2008, 2009, 2010  Canonical, Ltd.
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -13,168 +12,296 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-
-import os
-import logging
+"""Command line user interface."""
+
+from __future__ import absolute_import, unicode_literals
+
+__metaclass__ = type
+__all__ = [
+    'main',
+    ]
+
+
 import sys
+import dbus
+import gobject
+import argparse
 import textwrap
-import traceback
-
-import computerjanitor
-import computerjanitorapp
-_ = computerjanitorapp.setup_gettext()
-
-
-class UnknownCommand(computerjanitor.Exception):
-
-    def __init__(self, name):
-        self._str = _("Unknown command: %s") % name
-
-
-class UnknownCruft(computerjanitor.Exception):
-
-    def __init__(self, name):
-        self._str = _("Unknown cruft: %s") % name
-
-
-class MustBeRoot(computerjanitor.Exception):
+
+from dbus.mainloop.glib import DBusGMainLoop
+
+from computerjanitorapp import __version__, setup_gettext
+from computerjanitorapp.terminalsize import get_terminal_size
+from computerjanitorapp.utilities import format_size
+from computerjanitord.service import DBUS_INTERFACE_NAME
+_ = setup_gettext()
+
+
+class Options:
+    """Command line option parser."""
+    def __init__(self, runner):
+        """Parse the command line options.
+
+        :param runner: The class implementing the sub-commands.
+        :type runner: `Runner`
+        """
+        self.runner = runner
+        # Parse the arguments.
+        self.parser = argparse.ArgumentParser(
+            description=_("""\
+            Find and remove cruft from your system.
+
+            Cruft is anything that shouldn't be on your system, but is.
+            Stretching the definition, cruft is also things that should be on
+            your system but aren't."""),
+            version=__version__)
+        subparser = self.parser.add_subparsers(title='Commands')
+        # The 'find' subcommand.
+        command = subparser.add_parser(
+            'find', help=_('Find and display all cruft found on your system.'))
+        command.add_argument(
+            '-v', '--verbose', action='store_true',
+            help=_("""\
+            Display a detailed explanation for each piece of cruft found."""))
+        command.add_argument(
+            '-i', '--ignored', action='store_true',
+            help=_('Find and display only the ignored cruft.'))
+        command.add_argument(
+            '-r', '--removable', action='store_true',
+            help=_('Find and display only the removable cruft.'))
+        command.add_argument(
+            '-s', '--short', action='store_true',
+            help=_('Display only the package names.  Do not use with -v.'))
+        command.set_defaults(func=self.runner.find)
+        # The 'ignore' subcommand.
+        command = subparser.add_parser(
+            'ignore', help=_("""\
+            Ignore a piece of cruft so that it is not cleaned up."""))
+        command.add_argument(
+            'cruft', nargs=1,
+            help=_('The name of the cruft to ignore.'))
+        command.set_defaults(func=self.runner.ignore)
+        # The 'unignore' subcommand.
+        command = subparser.add_parser(
+            'unignore', help=_("""\
+            Unignore a piece of cruft so that it will be cleaned up."""))
+        command.add_argument(
+            'cruft', nargs=1,
+            help=_('The name of the cruft to unignore.'))
+        command.set_defaults(func=self.runner.unignore)
+        # The 'clean' subcommand.
+        command = subparser.add_parser(
+            'clean',
+            help=_('Remove the selected cruft from the system.'))
+        command.add_argument(
+            '-a', '--all', action='store_true',
+            help=_('Clean up all unignored cruft.'))
+        command.add_argument(
+            '-v', '--verbose', action='store_true',
+            help=_("Provide more details on what's being cleaned."))
+        command.add_argument(
+            'cruft', nargs='?',
+            help=_("""\
+            The name of the cruft to clean up.  Do not use if specifying
+            --all."""))
+        command.set_defaults(func=self.runner.clean)
+        # Parse the arguments and execute the subcommand.
+        self.arguments = self.parser.parse_args()
+
+
+class Runner:
+    """Implementations of subcommands."""
 
     def __init__(self):
-        self._str = _("computer-janitor must be run as root, sorry.")
-
-
-class CommandLineUserInterface(computerjanitorapp.UserInterface):
-
-    def run(self, options, args):
-        if self.mustberoot and os.getuid() != 0:
-            raise MustBeRoot()
-
-        self.app.verify_apt_cache()
-    
-        dict = {
-            "find": self.show_cruft,
-            "cleanup": self.cleanup,
-            "ignore": self.ignore,
-            "unignore": self.unignore,
-            "help": self.help,
-        }
-
-        if args:
-            cmd = args[0]
-            args = args[1:]
-        else:
-            cmd = "help"
-            args = []
-        
-        if cmd in dict:
-            app = self.app
-            app.state.load(options.state_file)
-            try:
-                dict[cmd](options, args)
-            except Exception, e: # pragma: no cover
-                logging.debug(unicode(traceback.format_exc()))
-                logging.critical(unicode(e))
-                sys.exit(1)
-        else:
-            raise UnknownCommand(cmd)
-    
-    def find_cruft(self):
-        list = []
-        for plugin in self.pm.get_plugins():
-            for cruft in plugin.get_cruft():
-                list.append(cruft)
-        return self.app.remove_whitelisted(list)
-    
-    def show_one_cruft(self, name, desc, s, width): #pragma: no cover
-        if width is None:
-            max = len(name) + len(desc or '')
-        else:
-            max = width
-            max -= 9 # state column
-            max -= 2 # two spaces
-            max -= 1 # avoid the last column, some terminals word wrap there
-
-        msg = ["%-9s  %.*s" % (s, max, name)]
-        if desc:
-            paras = desc.split("\n\n")
-            for para in paras:
-                for line in textwrap.wrap(para, max):
-                    msg.append("%9s  %s" % ("", line))
-                msg.append("")
-        print ("\n".join(msg)).encode('utf-8') # FIXME: horrible kludge
-            # the above makes it possible to write out stuff even when
-            # it's going to somewhere like a pipe, because we explicitly
-            # encode it as utf-8 first. This ignores the user's desired
-            # charset, which is bad, bad, bad, but I can't figure out a
-            # way to make Python behave in a sensible way. *sigh*
-            # --liw, 2009-08-18
-    
-    def show_cruft(self, options, args):
-        list = []
-        maxname = ""
-        state = self.app.state
-        for cruft in self.find_cruft():
-            name = cruft.get_name()
-            if options.verbose:
-                desc = cruft.get_description() # pragma: no cover
-            else:
-                desc = None
-            if state.is_enabled(name):
-                s = _("removable")
-            else:
-                s = _("ignored")
-            list.append((name, desc, s))
-            if len(name) > len(maxname):
-                maxname = name
-
-        rows, cols = computerjanitorapp.get_terminal_size()
-        for name, desc, s in sorted(list):
-            self.show_one_cruft(name, desc, s, cols)
-
-    def cleanup(self, options, args):
-        crufts = {}
-        for cruft in self.find_cruft():
-            crufts[cruft.get_name()] = cruft
-        
-        if args:
-            for arg in args:
-                if arg not in crufts:
-                    raise UnknownCruft(arg)
-        elif options.all:
-            state = self.app.state
-            args = []
-            for name in crufts.keys():
-                if state.is_enabled(name):
-                    args.append(name)
-                else:
-                    logging.info(_("Ignored: %s") % name)
-    
-        for arg in args:
-            if options.no_act:
-                logging.info(_("Pretending to remove cruft: %s") % arg)
-            else:
-                logging.info(_("Removing cruft: %s") % arg)
-                crufts[arg].cleanup()
-        for plugin in self.pm.get_plugins():
-            if options.no_act:
-                logging.info(_("Pretending to post-cleanup: %s") % plugin)
-            else:
-                logging.info(_("Post-cleanup: %s") % plugin)
-                plugin.post_cleanup()
-
-    def ignore(self, options, cruft_names):
-        state = self.app.state
-        for cruft_name in cruft_names:
-            state.disable(cruft_name)
-        if not options.no_act:
-            state.save(options.state_file)
-
-    def unignore(self, options, cruft_names):
-        state = self.app.state
-        for cruft_name in cruft_names:
-            state.enable(cruft_name)
-        if not options.no_act:
-            state.save(options.state_file)
-
-    def help(self, options, args):
-        self.app.parser.print_help()
+        # Connect to the dbus service.
+        system_bus = dbus.SystemBus()
+        proxy = system_bus.get_object(DBUS_INTERFACE_NAME, '/')
+        self.janitord = dbus.Interface(
+            proxy, dbus_interface=DBUS_INTERFACE_NAME)
+        # Connect to the signal the server will emit when cleaning up.
+        self.janitord.connect_to_signal('cleanup_status', self._clean_working)
+        # This will get backpatched by __main__.  We need it to produce error
+        # messages from the argparser.
+        self.options = None
+        # The main loop for asynchronous calls and signal reception.
+        self.loop = gobject.MainLoop()
+
+    def _error(self, message):
+        """Generate a parser error and exit.
+
+        :param message: The error message.
+        :type message: string
+        """
+        self.options.parser.error(message)
+        # No return.
+
+    def find(self, arguments):
+        """Find and display all cruft.
+
+        :param arguments: Command line options.
+        """
+        # Cruft will be prefixed by 'removable' if it is not being ignored.
+        ignored = set(self.janitord.ignored())
+        cruft_names = set(self.janitord.find())
+        # Filter names based on option flags.
+        if arguments.ignored:
+            cruft = sorted(cruft_names & ignored)
+        elif arguments.removable:
+            cruft = sorted(cruft_names - ignored)
+        else:
+            cruft = sorted(cruft_names)
+        # The prefix will either be 'ignored' or 'removable' however this
+        # string will be translated, so calculate the prefix size in the
+        # native language, then add two columns of separator, followed by the
+        # cruft name.
+        prefixi = _('ignored')
+        prefixr = _('removable')
+        prefix_width = max(len(prefixi), len(prefixr))
+        # Long, short, shorter display.
+        if arguments.verbose and arguments.short:
+            self._error('Use either -s or -v but not both.')
+        if arguments.short:
+            # This is the shorter output.
+            for name in cruft:
+                print name
+        elif not arguments.verbose:
+            # This is the short output.
+            for name in cruft:
+                prefix = (prefixi if name in ignored else prefixr)
+                # 10 spaces for the prefix
+                print '{0:{1}}  {2}'.format(prefix, prefix_width, name)
+        else:
+            # This is the verbose output.  Start by getting the terminal's
+            # size, though all we care about is the width.
+            rows, columns = get_terminal_size()
+            width = ((80 if columns in (None, 0) else columns)
+                     - prefix_width # space for prefix
+                     - 2            # separator
+                     - 1            # avoid last column, some terminals wrap
+                     )
+            margin = ' ' * (prefix_width + 2)
+            for name in cruft:
+                prefix = (prefixi if name in ignored else prefixr)
+                # 10 spaces for the prefix
+                print '{0:{1}}  {2}'.format(prefix, prefix_width, name)
+                # Print some details about the cruft.
+                cruft_type, disk_usage = self.janitord.get_details(name)
+                print '{0}{1} of type {2}'.format(
+                    margin, format_size(disk_usage), cruft_type)
+                # Get the description, wrap it to the available columns, and
+                # display it line-by-line with the proper amount of leading
+                # spaces (prefix_width + 2).
+                description = self.janitord.get_description(name)
+                if len(description) == 0:
+                    print
+                    continue
+                paragraphs = description.split('\n\n')
+                for paragraph in paragraphs:
+                    for line in textwrap.wrap(paragraph, width):
+                        # 2010-02-09 barry: The original code forced the
+                        # output to utf-8, claiming that was necessary to
+                        # "write out stuff even when it's going to somewhere
+                        # like a pipe [...] ignor[ing] the user's desired
+                        # charset, which is bad, bad, bad...".  This makes me
+                        # pretty uncomfortable, so I'd like to see a bug
+                        # report before I copy that from the previous
+                        # implementation.
+                        print '{0}{1}'.format(margin, line)
+                    # Paragraph separator.
+                    print
+
+    def ignore(self, arguments):
+        """Ignore some cruft.
+
+        :param arguments: Command line options.
+        """
+        assert len(arguments.cruft) == 1, 'Unexpected arguments'
+        self.janitord.ignore(arguments.cruft[0])
+        self.janitord.save()
+
+    def unignore(self, arguments):
+        """Unignore some cruft.
+
+        :param arguments: Command line options.
+        """
+        assert len(arguments.cruft) == 1, 'Unexpected arguments'
+        self.janitord.unignore(arguments.cruft[0])
+        self.janitord.save()
+
+    def _clean_reply(self):
+        """The 'clean' operation has completed successfully."""
+        self.loop.quit()
+        print 'done.'
+
+    def _clean_error(self, exception):
+        """The 'clean' operation has failed."""
+        self.loop.quit()
+        print 'dbus service error:', exception
+
+    def _clean_working(self, cruft):
+        """The 'clean' operation is in progress.
+
+        :param cruft: The cruft that is being cleaned up.
+        :type cruft: string
+        """
+        verbose = self.options.arguments.verbose
+        if cruft == '':
+            # We're done.
+            if not verbose:
+                sys.stdout.write(' ')
+                sys.stdout.flush()
+        else:
+            if verbose:
+                print 'Working on', cruft
+            else:
+                sys.stdout.write('.')
+                sys.stdout.flush()
+
+    def clean(self, arguments):
+        """Clean up the cruft.
+
+        :param arguments: Command line options.
+        """
+        if arguments.all:
+            # You can't specify both --all and a cruft name.
+            if arguments.cruft is not None:
+                self._error('Specify a cruft name or --all, but not both')
+                # No return.
+            all_cruft = set(self.janitord.find())
+            ignored = set(self.janitord.ignored())
+            cleanable_cruft = all_cruft - ignored
+        else:
+            if arguments.cruft is None:
+                self._error('You must specify a cruft name, or use --all')
+                # No return.
+            cleanable_cruft = (arguments.cruft,)
+        # Make the asynchronous call because this can take a long time.  We'll
+        # get status updates periodically.  Note however that even though this
+        # is asynchronous, dbus still expects a response within a certain
+        # amount of time.  We have no idea how long it will take to clean up
+        # the cruft though, so just crank the timeout up to some insanely huge
+        # number (of seconds).
+        self.janitord.clean(cleanable_cruft,
+                            reply_handler=self._clean_reply,
+                            error_handler=self._clean_error,
+                            # If it takes longer than an hour, we're screwed.
+                            timeout=3600)
+        # Start the main loop.  This will exit when the remote operation is
+        # complete.
+        if not arguments.verbose:
+            sys.stdout.write('processing')
+            sys.stdout.flush()
+        self.loop.run()
+
+
+def main():
+    # We'll need a main loop to receive status signals from the dbus service.
+    # Don't start the main loop yet though, since we only need it for 'clean'
+    # commands.
+    DBusGMainLoop(set_as_default=True)
+    runner = Runner()
+    options = Options(runner)
+    # Backpatch runner because of circular references.
+    runner.options = options
+    # Execute the subcommand.
+    options.arguments.func(options.arguments)
 
=== added file 'computerjanitorapp/maingtk.py'
--- computerjanitorapp/maingtk.py	1970-01-01 00:00:00 +0000
+++ computerjanitorapp/maingtk.py	2010-03-10 21:40:30 +0000
@@ -0,0 +1,32 @@
+# Copyright (C) 2008, 2009, 2010  Canonical, Ltd.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, version 3 of the License.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""Command line user interface."""
+
+from __future__ import absolute_import, unicode_literals
+
+__metaclass__ = type
+__all__ = [
+    'main',
+    ]
+
+
+from computerjanitorapp.uigtk import UserInterface
+from dbus.mainloop.glib import DBusGMainLoop
+
+
+def main():
+    DBusGMainLoop(set_as_default=True)
+    ui = UserInterface()
+    ui.run()
 
=== removed file 'computerjanitorapp/state.py'
--- computerjanitorapp/state.py	2009-07-13 09:48:06 +0000
+++ computerjanitorapp/state.py	1970-01-01 00:00:00 +0000
@@ -1,56 +0,0 @@
-# state.py - store persistent state of crufts
-# Copyright (C) 2008, 2009  Canonical, Ltd.
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, version 3 of the License.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-
-import ConfigParser
-
-
-class State(object):
-
-    def __init__(self):
-        self._cp = ConfigParser.ConfigParser()
-        self._previously_ignored = set()
-
-    def load(self, filename):
-        self._cp.read(filename)
-        self._previously_ignored = set()
-        for cruft_name in self._cp.sections():
-            if not self.is_enabled(cruft_name):
-                self._previously_ignored.add(cruft_name)
-    
-    def save(self, filename):
-        f = file(filename, "w")
-        self._cp.write(f)
-        f.close()
-
-    def is_enabled(self, cruft_name):
-        if self._cp.has_section(cruft_name):
-            return self._cp.getboolean(cruft_name, "enabled")
-        else:
-            return True
-    
-    def enable(self, cruft_name):
-        if not self._cp.has_section(cruft_name):
-            self._cp.add_section(cruft_name)
-        self._cp.set(cruft_name, "enabled", "true")
-
-    def disable(self, cruft_name):
-        if not self._cp.has_section(cruft_name):
-            self._cp.add_section(cruft_name)
-        self._cp.set(cruft_name, "enabled", "false")
-        
-    def was_previously_ignored(self, cruft_name):
-        return cruft_name in self._previously_ignored
-
 
=== removed file 'computerjanitorapp/state_tests.py'
--- computerjanitorapp/state_tests.py	2009-07-13 09:48:06 +0000
+++ computerjanitorapp/state_tests.py	1970-01-01 00:00:00 +0000
@@ -1,77 +0,0 @@
-# state_tests.py - unit tests for store.py
-# Copyright (C) 2008, 2009  Canonical, Ltd.
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, version 3 of the License.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-
-import os
-import tempfile
-import unittest
-
-import computerjanitorapp
-
-
-class StateTests(unittest.TestCase):
-
-    def setUp(self):
-        self.state = computerjanitorapp.State()
-
-    def testInitiallyEverythingIsEnabled(self):
-        self.assert_(self.state.is_enabled("foo"))
-
-    def testDisablesWhenAsked(self):
-        self.state.disable("foo")
-        self.assertFalse(self.state.is_enabled("foo"))
-
-    def testEnablesDisabledCruft(self):
-        self.state.disable("foo")
-        self.state.enable("foo")
-        self.assert_(self.state.is_enabled("foo"))
-
-    def testEnablesEnabledCruft(self):
-        self.state.enable("foo")
-        self.assert_(self.state.is_enabled("foo"))
-
-    def testSavesAndLoadsFiles(self):
-        fd, filename = tempfile.mkstemp()
-        os.close(fd)
-        self.state.enable("foo")
-        self.state.disable("bar")
-        self.state.save(filename)
-        self.state.disable("foo")
-        self.state.enable("bar")
-        self.state.load(filename)
-        self.assert_(self.state.is_enabled("foo"))
-        self.assertFalse(self.state.is_enabled("bar"))
-        os.remove(filename)
-
-    def testInitallyNothingIsPreviouslyIgnored(self):
-        self.assertFalse(self.state.was_previously_ignored("foo"))
-
-    def testRemembersWhatWasPreviouslyIgnored(self):
-        fd, filename = tempfile.mkstemp()
-        os.close(fd)
-
-        # Set a state to disabled.
-        state1 = computerjanitorapp.State()
-        state1.disable("foo")
-        state1.save(filename)
-
-        # Load new state.        
-        state2 = computerjanitorapp.State()
-        state2.load(filename)
-
-        self.assert_(state2.was_previously_ignored("foo"))
-
-        os.remove(filename)
-
 
=== added file 'computerjanitorapp/store.py'
--- computerjanitorapp/store.py	1970-01-01 00:00:00 +0000
+++ computerjanitorapp/store.py	2010-03-10 21:40:30 +0000
@@ -0,0 +1,147 @@
+# Copyright (C) 2008, 2009, 2010  Canonical, Ltd.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, version 3 of the License.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""Gtk ListStore model for backing the TreeViews of cruft."""
+
+from __future__ import absolute_import, unicode_literals
+
+__metaclass__ = type
+__all__ = [
+    'Store',
+    'optimize',
+    'unused',
+    ]
+
+
+import gtk
+import gobject
+
+
+# XXX 2010-03-04 barry: Use a munepy enum.
+class ListStoreColumns:
+    # The cruft name as known by the dbus service.
+    name = 0
+    # The short name of the cruft.
+    short_name = 1
+    # The text displayed in the cell.
+    text = 2
+    # Should the cruft be shown?
+    show = 3
+    # Is the cruft active locally (i.e. toggle button is set)?
+    active = 4
+    # Is the cruft being ignored in the dbus service?
+    server_ignored = 5
+    # Is the cruft's description expanded?
+    expanded = 6
+    # Is this cruft package cruft or some other kind of cruft?
+    is_package_cruft = 7
+
+
+class Store:
+    """The higher level wrapper around the gtk.ListStore."""
+
+    def __init__(self, janitord):
+        """Create the Store.
+
+        :param janitord: The `dbus.Interface` for talking to the Computer
+            Janitor dbus service.
+        """
+        self.janitord = janitord
+        # This ListStore is the backing data structure for the TreeViews in
+        # the main window.  It holds information about the individual pieces
+        # of cruft.  See ListStoreColumns for details.
+        #
+        # XXX 2010-03-04 barry: pygtk does not like 'unicode'.
+        self.store = gtk.ListStore(str, str, str, bool, bool, bool, bool, bool)
+
+    def find_cruft(self):
+        """Find cruft and populate the backing store."""
+        ignored_cruft = set(self.janitord.ignored())
+        all_cruft_names = set(self.janitord.find())
+        pkg_cruft_names = set(
+            cruft_name for cruft_name in all_cruft_names
+            if self.janitord.get_details(cruft_name)[0].lower()
+            == 'packagecruft')
+        self.store.clear()
+        # Cruft always starts out in the active, not-expanded state.  Package
+        # cruft goes in the 'unused' column while non-package cruft goes in
+        # the 'optimize' column.
+        for cruft_name in all_cruft_names:
+            cruft_shortname = self.janitord.get_shortname(cruft_name)
+            self.store.append((
+                cruft_name, cruft_shortname,
+                # What is being displayed in the cell.
+                gobject.markup_escape_text(cruft_shortname),
+                # Show the cruft be shown?
+                cruft_name not in ignored_cruft,
+                # Is the cruft active locally?
+                cruft_name not in ignored_cruft,
+                # Is the cruft ignored in the dbus service?
+                cruft_name in ignored_cruft,
+                # Is the cruft's description expanded?
+                False,
+                # Is this package cruft?
+                cruft_name in pkg_cruft_names,
+                ))
+
+    # Forwards to the underlying store, for convenience.  Really, these should
+    # use generic delegates, or clients should just use self.store.store.
+
+    def get_value(self, *args, **kws):
+        return self.store.get_value(*args, **kws)
+
+    def set_value(self, *args, **kws):
+        return self.store.set_value(*args, **kws)
+
+    def filter_new(self, *args, **kws):
+        return self.store.filter_new(*args, **kws)
+
+    def foreach(self, *args, **kws):
+        return self.store.foreach(*args, **kws)
+
+    def reorder(self, *args, **kws):
+        return self.store.reorder(*args, **kws)
+
+    def get_iter_first(self, *args, **kws):
+        return self.store.get_iter_first(*args, **kws)
+
+    def iter_next(self, *args, **kws):
+        return self.store.iter_next(*args, **kws)
+
+    def clear(self, *args, **kws):
+        return self.store.clear(*args, **kws)
+
+
+# Filter functions for use with TreeView column display.
+
+def unused(store, iter):
+    """True if the cruft is not being ignored and is package cruft.
+
+    :param store: The ListStore instance.
+    :param iter: The TreeIter instance.
+    """
+    show = store.get_value(iter, ListStoreColumns.show)
+    is_package_cruft = store.get_value(iter, ListStoreColumns.is_package_cruft)
+    return show and is_package_cruft
+
+
+def optimize(store, iter):
+    """True if the cruft is not package cruft.
+
+    :param store: The ListStore instance.
+    :param iter: The TreeIter instance.
+    """
+    show = store.get_value(iter, ListStoreColumns.show)
+    is_package_cruft = store.get_value(iter, ListStoreColumns.is_package_cruft)
+    return show and not is_package_cruft
 
=== modified file 'computerjanitorapp/terminalsize.py'
--- computerjanitorapp/terminalsize.py	2008-09-22 21:39:57 +0000
+++ computerjanitorapp/terminalsize.py	2010-03-10 21:40:30 +0000
@@ -26,44 +26,39 @@
 
 def get_terminal_size(fd=1):
     """Return size of terminal attached to the standard output.
-    
-    Use ioctl(2) to query a terminal for its size, given a file
-    descriptor attached to the terminal. Return (None, None) if this
-    fails, otherwise a tuple (columns, rows).
-    
-    (The optional 'fd' argument can be set to whatever file
-    descriptor you want to use. This is useful for unit tests.)
-    
+
+    Use ioctl(2) to query a terminal for its size, given a file descriptor
+    attached to the terminal.
+
+    :param fd: Use the given file descriptor.
+    :type fd: int
+    :return: The columns and rows representing the size of the terminal.  If
+        this cannot be determined, None is returned for both values.
+    :rtype: 2-tuple
     """
 
     try:
-        # Do the ioctl call. termios.TIOCGWINSZ is the code to query
-        # terminal size (see tty_ioctl(4), at least on Linux). We need
-        # to give it a string of suitable size to use as the input
-        # buffer for ioctl. Ioctl modifies the buffer and returns the
-        # modified buffer as its return value.
+        # Do the ioctl call. termios.TIOCGWINSZ is the code to query terminal
+        # size (see tty_ioctl(4), at least on Linux).  We need to give it a
+        # string of suitable size to use as the input buffer for ioctl.
+        # ioctl() modifies the buffer and returns the modified buffer as its
+        # return value.
         #
         # The manual page specifies a struct winsize to be used, which
-        # consists of four unsigned shorts. We use struct.calcsize to
+        # consists of four unsigned shorts.  We use struct.calcsize() to
         # compute the size of that.
-        # 
-        # Note that Blake's original code assumes only the first two 
-        # shorts in the struct are used, and that two shorts fit into
-        # four bytes, which is probably true for all the relevant
-        # platforms, but is cramped enough that it makes me feel icky.
-        # Thus, I assume less. This will still break if the contents
-        # of the struct change, but since that would change the system
-        # call API, that's unlikely.
-        
+        #
+        # Note that Blake's original code assumes only the first two shorts in
+        # the struct are used, and that two shorts fit into four bytes, which
+        # is probably true for all the relevant platforms, but is cramped
+        # enough that it makes me feel icky.  Thus, I assume less.  This will
+        # still break if the contents of the struct change, but since that
+        # would change the system call API, that's unlikely.
         buflen = struct.calcsize('hhhh')
         buf = fcntl.ioctl(fd, termios.TIOCGWINSZ, '\0' * buflen)
-        
         # ioctl returns a binary buffer that represents the struct
         # at the C level. We unpack it with struct.unpack.
-        
-        tuple = struct.unpack('hhhh', buf)
-    except:
+        return tuple(struct.unpack('hhhh', buf)[:2])
+    except Exception:
         # If anything went wrong, we give up and claim we don't know.
         return None, None
-
-    return tuple[0], tuple[1]
 
=== added directory 'computerjanitorapp/tests'
=== added file 'computerjanitorapp/tests/__init__.py'
=== added file 'computerjanitorapp/tests/test_all.py'
--- computerjanitorapp/tests/test_all.py	1970-01-01 00:00:00 +0000
+++ computerjanitorapp/tests/test_all.py	2010-03-10 21:40:30 +0000
@@ -0,0 +1,29 @@
+# Copyright (C) 2008, 2009, 2010  Canonical, Ltd.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, version 3 of the License.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""Test suite for Computer Janitor."""
+
+import unittest
+
+from computerjanitorapp.tests import test_terminalsize
+from computerjanitorapp.tests import test_utilities
+from computerjanitord.tests.test_all import test_suite as cjd_suite
+
+
+def test_suite():
+    suite = unittest.TestSuite()
+    suite.addTests(test_terminalsize.test_suite())
+    suite.addTests(test_utilities.test_suite())
+    suite.addTests(cjd_suite())
+    return suite
 
=== renamed file 'computerjanitorapp/terminalsize_tests.py' => 'computerjanitorapp/tests/test_terminalsize.py'
--- computerjanitorapp/terminalsize_tests.py	2008-09-22 21:39:57 +0000
+++ computerjanitorapp/tests/test_terminalsize.py	2010-03-10 21:40:30 +0000
@@ -1,5 +1,4 @@
-# terminalsize_tests.py - unit tests for terminalsize.py
-# Copyright (C) 2008  Canonical, Ltd.
+# Copyright (C) 2008, 2009, 2010  Canonical, Ltd.
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -13,23 +12,33 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
+"""Test calculation of terminal sizes."""
+
+from __future__ import absolute_import, unicode_literals
+
+__metaclass__ = type
+__all__ = [
+    'test_suite',
+    ]
+
 
 import os
 import unittest
 
-import terminalsize
-
-
-class GetTerminalSizeTests(unittest.TestCase):
-
-    def testReturnsUnknownWhenQueryingDevNull(self):
+from computerjanitorapp import terminalsize
+
+
+class TestTerminalSize(unittest.TestCase):
+    """Test calculation of terminal sizes."""
+
+    def test_returns_unknown_when_querying_dev_null(self):
         fd = os.open("/dev/null", os.O_RDONLY)
         rows, cols = terminalsize.get_terminal_size(fd)
         os.close(fd)
         self.assertEqual(rows, None)
         self.assertEqual(cols, None)
 
-    def testReturnsTwoIntegersWhenStdoutIsATerminal(self):
+    def test_returns_two_integers_when_stdout_is_a_terminal(self):
         # We only run this check if stdout is a terminal.
         # Unfortunately, there is no sensible way of checking the values.
         # But that's OK, they're lumberjacks.
@@ -37,3 +46,9 @@
             rows, cols = terminalsize.get_terminal_size(1)
             self.assertEqual(type(rows), int)
             self.assertEqual(type(cols), int)
+
+
+def test_suite():
+    suite = unittest.TestSuite()
+    suite.addTests(unittest.makeSuite(TestTerminalSize))
+    return suite
 
=== added file 'computerjanitorapp/tests/test_utilities.py'
--- computerjanitorapp/tests/test_utilities.py	1970-01-01 00:00:00 +0000
+++ computerjanitorapp/tests/test_utilities.py	2010-03-10 21:40:30 +0000
@@ -0,0 +1,71 @@
+# Copyright (C) 2010  Canonical, Ltd.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, version 3 of the License.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""Test common utilities."""
+
+from __future__ import absolute_import, unicode_literals
+
+__metaclass__ = type
+__all__ = [
+    'test_suite',
+    ]
+
+
+import os
+import unittest
+
+from computerjanitorapp.utilities import format_size
+
+
+class TestUtilities(unittest.TestCase):
+    """Test common utilities."""
+
+    def test_format_negative(self):
+        self.assertRaises(AssertionError, format_size, -1)
+
+    def test_format_zero(self):
+        self.assertEqual(format_size(0), '0B')
+
+    def test_format_small(self):
+        self.assertEqual(format_size(500), '500B')
+
+    def test_format_1k(self):
+        self.assertEqual(format_size(1000), '1kB')
+
+    def test_format_smallish(self):
+        self.assertEqual(format_size(500000), '500kB')
+
+    def test_format_1M(self):
+        self.assertEqual(format_size(1000000), '1MB')
+
+    def test_format_mediumish(self):
+        self.assertEqual(format_size(500000000), '500MB')
+
+    def test_format_1G(self):
+        self.assertEqual(format_size(1000000000), '1GB')
+
+    def test_format_bigish(self):
+        self.assertEqual(format_size(500000000000), '500GB')
+
+    def test_format_1T(self):
+        self.assertEqual(format_size(1000000000000), '1TB')
+
+    def test_format_hugish(self):
+        self.assertEqual(format_size(500000000000000), '>1TB')
+
+
+def test_suite():
+    suite = unittest.TestSuite()
+    suite.addTests(unittest.makeSuite(TestUtilities))
+    return suite
 
=== removed file 'computerjanitorapp/ui.py'
--- computerjanitorapp/ui.py	2009-02-11 16:25:03 +0000
+++ computerjanitorapp/ui.py	1970-01-01 00:00:00 +0000
@@ -1,39 +0,0 @@
-# ui.py - user interface interface class
-# Copyright (C) 2008, 2009  Canonical, Ltd.
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, version 3 of the License.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-
-import computerjanitor
-
-
-class UserInterface(object):
-
-    """This is the base class for user interfaces.
-    
-    The user interface is in charge of obeying command line arguments,
-    and interacting with the user.
-    
-    The app and pm given to the constructor are stored in the app and
-    pm attributes.
-        
-    """
-
-    def __init__(self, app, pm, mustberoot=True):
-        self.pm = pm
-        self.app = app
-        self.mustberoot = mustberoot
-
-    def run(self, options, args):
-        """Obey command line arguments in ARGS, and options in OPTIONS."""
-        raise computerjanitor.UnimplementedMethod(self.run)
 
=== removed file 'computerjanitorapp/ui_cli_tests.py'
--- computerjanitorapp/ui_cli_tests.py	2009-02-11 16:25:03 +0000
+++ computerjanitorapp/ui_cli_tests.py	1970-01-01 00:00:00 +0000
@@ -1,246 +0,0 @@
-# ui_cli_tests.py - unit tests for ui_cli.py
-# Copyright (C) 2008, 2009  Canonical, Ltd.
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, version 3 of the License.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-
-import unittest
-
-import computerjanitor
-import computerjanitorapp
-
-
-class MockCruft(object):
-
-    def __init__(self, name):
-        self._name = name
-        self.cleaned = False
-        self.post_cleaned = False
-        
-    def get_name(self):
-        return self._name
-
-    def cleanup(self):
-        self.cleaned = True
-
-
-class MockPlugin(object):
-
-    def __init__(self, crufts):
-        self._crufts = crufts
-        self.post_cleaned = False
-        
-    def get_cruft(self):
-        for cruft in self._crufts:
-            yield cruft
-        
-    def post_cleanup(self):
-        self.post_cleaned = True
-            
-
-class MockPluginManager(object):
-
-    def __init__(self, plugins):
-        self._plugins = plugins
-        
-    def get_plugins(self):
-        return self._plugins
-
-
-class MockState(object):
-
-    def __init__(self, enabled):
-        self._enabled = set(enabled)
-
-    def is_enabled(self, name):
-        return name in self._enabled
-
-    def enable(self, name):
-        if name not in self._enabled:
-            self._enabled.add(name)
-
-    def disable(self, name):
-        if name in self._enabled:
-            self._enabled.remove(name)
-
-    def load(self, filename):
-        self.load_filename = filename
-
-    def save(self, filename):
-        self.save_filename = filename
-
-
-class MockOptionParser(object):
-
-    def __init__(self):
-        self.help_printed = False
-        
-    def print_help(self):
-        self.help_printed = True
-
-
-class MockApplication(object):
-
-    def __init__(self, enabled):
-        self.state = MockState(enabled)
-        self.parser = MockOptionParser()
-
-    def verify_apt_cache(self):
-        pass
-
-    def remove_whitelisted(self, crufts):
-        return crufts
-
-
-class MockOptions(object):
-
-    def __init__(self):
-        self.all = None
-        self.state_file = "foo"
-        self.no_act = None
-        self.verbose = None
-
-
-class CommandLineUserInterfaceTests(unittest.TestCase):
-
-    def setUp(self):
-        self.app = MockApplication(["foo"])
-        self.cruft_names = ["foo", "bar"]
-        self.crufts = [MockCruft(name) for name in self.cruft_names]
-        self.cruftdict = dict((c.get_name(), c) for c in self.crufts)
-        self.plugin = MockPlugin(self.crufts)
-        self.pm = MockPluginManager([self.plugin])
-        self.ui = computerjanitorapp.CommandLineUserInterface(self.app, 
-                                          self.pm, mustberoot=False)
-
-        self.options = MockOptions()
-
-    def testInsistsOnBeingRoot(self):
-        self.ui.mustberoot = True
-        self.assertRaises(computerjanitor.Exception, self.ui.run, None, 
-                          None)
-
-    def testFindsTheRightCruft(self):
-        self.assertEqual(self.ui.find_cruft(), self.crufts)
-
-    def testShowsTheRightCruftTheRightWay(self):
-
-        def mock_find_cruft():
-            return self.crufts
-
-        def mock_show_one_cruft(name, desc, state, width):
-            output.append((name, state))
-
-        output = []
-        self.ui.find_cruft = mock_find_cruft
-        self.ui.show_one_cruft = mock_show_one_cruft
-        self.ui.show_cruft(MockOptions(), None)
-        self.assertEqual(output, 
-                         sorted([("foo", "removable"), ("bar", "ignored")]))
-
-    def testIgnoresCruftCorrectly(self):
-        self.ui.ignore(self.options, ["foo"])
-        self.assertFalse(self.app.state.is_enabled("foo"))
-
-    def testUnignoresCruftCorrectly(self):
-        self.ui.unignore(self.options, ["bar"])
-        self.assert_(self.app.state.is_enabled("bar"))
-
-    def testCleansUpEnabledCruftWithDashDashAll(self):
-        self.options.all = True
-        self.ui.cleanup(self.options, [])
-        self.assert_(self.cruftdict["foo"].cleaned)
-
-    def testDoesNotCleanUpEnabledCruftWithDashDashAllWhenNoActIsSet(self):
-        self.options.all = True
-        self.options.no_act = True
-        self.ui.cleanup(self.options, [])
-        self.assertFalse(self.cruftdict["foo"].cleaned)
-
-    def testCleansUpRequestedEnabledCruft(self):
-        self.ui.cleanup(self.options, ["foo"])
-        self.assert_(self.cruftdict["foo"].cleaned)
-
-    def testDoesNotCleanUpDisaabledCruftWithDashDashAll(self):
-        self.options.all = True
-        self.ui.cleanup(self.options, [])
-        self.assertFalse(self.cruftdict["bar"].cleaned)
-
-    def testCleansUpRequestedDisabledCruft(self):
-        self.ui.cleanup(self.options, ["bar"])
-        self.assert_(self.cruftdict["bar"].cleaned)
-
-    def testRunsPostCleanup(self):
-        self.ui.cleanup(self.options, [])
-        self.assert_(self.plugin.post_cleaned)
-
-    def testDoesNotRunPostCleanupWhenNoActIsSet(self):
-        self.options.no_act = True
-        self.ui.cleanup(self.options, [])
-        self.assertFalse(self.plugin.post_cleaned)
-
-    def testRaisesExceptionForUnknownCruft(self):
-        self.assertRaises(computerjanitor.Exception, self.ui.cleanup,
-                          self.options, ["unknown"])
-
-    def testHelpCallsParserPrintHelp(self):
-        self.ui.help(None, None)
-        self.assert_(self.app.parser.help_printed)
-
-    def setup_run(self):
-        names = ["show_cruft", "cleanup", "ignore", "unignore", "help"]
-        for name in names:
-            method = getattr(self.ui, name)
-            wrapper = lambda options, args, name=name: \
-                        setattr(self, "operation", name)
-            setattr(self.ui, name, wrapper)
-
-    def testRunCallsShowCruft(self):
-        self.setup_run()
-        self.ui.run(self.options, ["find"])
-        self.assertEqual(self.operation, "show_cruft")
-
-    def testRunCallsCleanup(self):
-        self.setup_run()
-        self.ui.run(self.options, ["cleanup"])
-        self.assertEqual(self.operation, "cleanup")
-
-    def testRunCallsIgnore(self):
-        self.setup_run()
-        self.ui.run(self.options, ["ignore"])
-        self.assertEqual(self.operation, "ignore")
-
-    def testRunCallsUnignore(self):
-        self.setup_run()
-        self.ui.run(self.options, ["unignore"])
-        self.assertEqual(self.operation, "unignore")
-
-    def testRunCallsHelp(self):
-        self.setup_run()
-        self.ui.run(self.options, ["help"])
-        self.assertEqual(self.operation, "help")
-
-    def testRunCallsHelpWhenThereAreNoArguments(self):
-        self.setup_run()
-        self.ui.run(self.options, [])
-        self.assertEqual(self.operation, "help")
-
-    def testRaisesExceptionForUnknownCommand(self):
-        self.assertRaises(computerjanitor.Exception, self.ui.run, 
-                          self.options, ["yikes"])
-
-    def testRunLoadsStateFromRightFile(self):
-        self.setup_run()
-        self.ui.run(self.options, ["ignore"])
-        self.assertEqual(self.app.state.load_filename, 
-                         self.options.state_file)
 
=== removed file 'computerjanitorapp/ui_gtk.py'
--- computerjanitorapp/ui_gtk.py	2010-01-21 13:54:34 +0000
+++ computerjanitorapp/ui_gtk.py	1970-01-01 00:00:00 +0000
@@ -1,714 +0,0 @@
-# ui_gtk.py - graphical user interface implemented using GTK+
-# Copyright (C) 2008, 2009  Canonical, Ltd.
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, version 3 of the License.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-
-import logging
-import os
-import sys
-import threading
-import time
-import traceback
-
-import computerjanitor
-import computerjanitorapp
-_ = computerjanitorapp.setup_gettext()
-
-# We can't import gtk here, since that would mean it gets imported
-# even when we run in command line mode. Thus, we do the imports in
-# the class, when we know we need them.
-
-
-import os
-GLADE = os.environ.get('COMPUTER_JANITOR_GLADE', 
-                       '/usr/share/computer-janitor/ComputerJanitor.ui')
-
-
-STATE_COL = 0
-NAME_COL = 1
-CRUFT_COL = 2
-EXPANDED_COL = 3
-SHOW_COL = 4
-
-
-def ui(method):
-    """Decorator function for UI methods.
-    
-    Use @ui to decorate all methods in the controller class that
-    call GTK stuff, to ensure correct locking.
-    
-    """
-    
-    def new(self, *args, **kwargs):
-        self.gtk.gdk.threads_enter()
-        ret = method(self, *args, **kwargs)
-        self.gtk.gdk.threads_leave()
-        return ret
-        
-    return new
-    
-    
-class ListUpdater(threading.Thread):
-
-    """Find cruft in the background, update user interface when done."""
-
-    def __init__(self, ui):
-        threading.Thread.__init__(self)
-        self.ui = ui
-
-    def run(self):
-        self.ui.finding = True
-        self.ui.set_sensitive()
-        status = self.ui.widgets['statusbar']
-        context_id = status.get_context_id('ListUpdater')
-        status.push(context_id, _('Analyzing system...'))
-        for plugin in self.ui.pm.get_plugins():
-            for cruft in self.ui.app.remove_whitelisted(plugin.get_cruft()):
-                self.ui.add_cruft(cruft)
-        status.pop(context_id)
-        self.ui.finding = False
-        self.ui.set_sensitive()
-        self.ui.done_updating_list()
-
-
-class Cleaner(threading.Thread):
-
-    """Actually clean up the cruft."""
-    
-    def __init__(self, ui):
-        threading.Thread.__init__(self)
-        self.ui = ui
-        self.gtk = self.ui.gtk
-        self.crufts = ui.get_crufts()
-        self.plugins = ui.pm.get_plugins()
-        # progress reporting dialog/bar
-        # FIXME: the progress bar is a bit silly, it takes
-        #        items like fix-fstab (0.1s) and deb_package (5min)
-        #        and assigns them the same slice - use a pulsing one 
-        #        instead?
-        self.dialog = ui.widgets['cleanup_dialog']
-        self.pbar = ui.widgets['cleanup_progressbar']
-        # add status bar context
-        self.status = self.ui.widgets['statusbar']
-        self.context_id = self.status.get_context_id('ListUpdater')
-        self.status.push(self.context_id, _('Cleaning up...'))
-        # cancel button
-        button = ui.widgets['cleanup_cancel']
-        button.connect('clicked', self.cancel)
-        self.cancel_event = threading.Event()
-
-    def cancel(self, *args):
-        self.cancel_event.set()
-        
-    @ui
-    def inc_done(self):
-        self.done_work += 1.0
-        self.pbar.set_fraction(self.done_work / self.total_work)
-
-    @ui
-    def start_reporting(self):
-        self.total_work = len(self.crufts) + len(self.plugins)
-        self.done_work = 0.0
-        self.pbar.set_fraction(0.0)
-
-        self.dialog.show()
-    
-    @ui
-    def end_reporting(self):
-        self.pbar.set_fraction(1.0)
-        self.dialog.hide()
-        self.status.pop(self.context_id)
-
-    def run(self):
-        self.ui.cleaning = True
-        self.ui.set_sensitive()
-
-        self.start_reporting()
-        
-        for cruft in self.crufts:
-            if self.cancel_event.isSet():
-                break
-            name = cruft.get_name()
-            if self.ui.app.state.is_enabled(name):
-                if self.ui.options.no_act:
-                    time.sleep(0.1)
-                    logging.info(_("Pretending to remove cruft: %s") % name)
-                else:
-                    logging.info(_("Removing cruft: %s") % name)
-                    cruft.cleanup()
-            self.inc_done()
-
-        for plugin in self.plugins:
-            if self.cancel_event.isSet():
-                break
-            if self.ui.options.no_act:
-                logging.info(_("Pretending to post-cleanup: %s") % plugin)
-            else:
-                logging.info(_("Post-cleanup: %s") % plugin)
-                error = None
-                try:
-                    plugin.post_cleanup()
-                except Exception, e:
-                    logging.debug(unicode(traceback.format_exc()))
-                    self.ui.show_error(_("Could not clean up properly"),
-                                       unicode(e))
-                    break
-            self.inc_done()
-                
-        # do not run it directly (thread deadlocks), register for running
-        # in the gtk main thread instead
-        self.ui.glib.timeout_add(100, self.ui.show_cruft)
-        self.ui.cleaning = False
-
-        self.end_reporting()
-
-
-class GtkUserInterface(computerjanitorapp.UserInterface):
-
-    """The GTK+ user interface of Computer Janitor."""
-    
-    # This acts as the controller in MVC. To simplify binding of callbacks
-    # to GTK signals, we follow a strict convention: any method named
-    # on_WIDGETNAME_SIGNALNAME is a callback and will be bound automatically. 
-    # This way, we don't need do add each binding by hand, either in the 
-    # code or in the .glade file. See the find_and_bind_widgets method
-    # for details.
-
-    def run(self, options, args):
-        # This is where UI execution starts.
-        
-        import gtk
-        self.gtk = gtk
-        
-        import gobject
-        self.gobject = gobject
-
-        import glib
-        self.glib = glib
-
-        self.options = options
-        self.app.state.load(options.state_file)
-
-        builder = gtk.Builder()
-        builder.set_translation_domain('computerjanitor')
-        builder.add_from_file(GLADE)
-        self.find_and_bind_widgets(builder)
-        
-        self.store = self.create_cruft_store()
-        self.name_cols = set()
-        self.popup_menus = dict()
-        self.create_column('unused_treeview', self.unused_filter)
-        self.create_column('recommended_treeview', self.recommended_filter)
-        self.create_column('optimize_treeview', self.optimize_filter)
-        
-        self.show_previously_ignored = False
-        
-        self.first_map = True
-        
-        self.set_default_window_size()
-        self.widgets['window'].show()
-        
-        self.sort_crufts_by_current_order = self.sort_crufts_by_name
-        
-        self.finding = False
-        self.cleaning = False
-
-        # set thread switches interval to make it more UI friendly
-        sys.setcheckinterval(0)
-        gtk.gdk.threads_init()
-        gtk.main()
-
-    def find_and_bind_widgets(self, builder):
-        """Bind widgets and callbacks."""
-        import gtk
-        self.widgets = {}
-        for o in builder.get_objects():
-            if issubclass(type(o), gtk.Buildable):
-                name = gtk.Buildable.get_name(o)
-                self.widgets[name] = o
-                for attr in dir(self):
-                    prefix = 'on_%s_' % name
-                    if attr.startswith(prefix):
-                        signal_name = attr[len(prefix):]
-                        method = getattr(self, attr)
-                        o.connect(signal_name, method)
-                        
-    
-    def set_default_window_size(self):
-        w = self.widgets['window']
-        width = 900
-        height = 700
-        self.widgets['window'].set_default_size(width, height)
-    
-    def create_cruft_store(self):
-        """Create a gtk.ListStore for holding all the cruft."""
-        pairs = ((NAME_COL, self.gobject.TYPE_STRING),
-                 (STATE_COL, self.gobject.TYPE_BOOLEAN),
-                 (CRUFT_COL, self.gobject.TYPE_PYOBJECT),
-                 (EXPANDED_COL, self.gobject.TYPE_BOOLEAN),
-                 (SHOW_COL, self.gobject.TYPE_BOOLEAN))
-        column_types = [pair[1] for pair in sorted(pairs)]
-        store = self.gtk.ListStore(*column_types)
-
-        return store
-
-    def get_crufts(self):
-        def get(model, path, iter, crufts):
-            cruft = model.get_value(iter, CRUFT_COL)
-            crufts.append(cruft)
-        crufts = []
-        self.store.foreach(get, crufts)
-        return crufts
-
-    def sort_crufts(self, get_key):
-        crufts = self.get_crufts()
-        crufts = [(get_key(c), i, c) for i, c in enumerate(crufts)]
-        crufts.sort()
-        crufts = [i for key, i, c in crufts]
-        self.store.reorder(crufts)
-        
-    def sort_crufts_by_name(self):
-        def get_key(cruft):
-            return cruft.get_name()
-        self.sort_crufts(get_key)
-        
-    def sort_crufts_by_size(self):
-        def get_key(cruft):
-            return -cruft.get_disk_usage()
-        self.sort_crufts(get_key)
-
-    def create_column(self, widget_name, filterfunc):
-        """Add gtk.TreeViewColumn to the desired widget."""
-        treeview = self.widgets[widget_name]
-        treeview.set_rules_hint(True)
-        
-        toggle_cr = self.gtk.CellRendererToggle()
-        toggle_cr.connect('toggled', self.toggled, treeview)
-        toggle_cr.set_property("yalign", 0)
-        toggle_col = self.gtk.TreeViewColumn()
-        toggle_col.pack_start(toggle_cr)
-        toggle_col.add_attribute(toggle_cr, 'active', STATE_COL)
-        treeview.append_column(toggle_col)
-
-        name_cr = self.gtk.CellRendererText()
-        name_cr.set_property("yalign", 0)
-        import pango
-        name_cr.set_property("wrap-mode", pango.WRAP_WORD)
-        name_col = self.gtk.TreeViewColumn()
-        name_col.pack_start(name_cr)
-        name_col.add_attribute(name_cr, 'markup', NAME_COL)
-        treeview.append_column(name_col)
-        self.name_cols.add(name_col)
-        
-        filter_store = self.store.filter_new()
-        filter_store.set_visible_func(filterfunc)
-        treeview.set_model(filter_store)
-        
-        self.create_popup_menu_for_treeview(treeview)
-
-    def create_popup_menu_for_treeview(self, treeview):
-        select_all = self.gtk.MenuItem(label='Select all')
-        select_all.connect('activate', self.popup_menu_select_all, treeview)
-
-        unselect_all = self.gtk.MenuItem(label='Unselect all')
-        unselect_all.connect('activate', self.popup_menu_unselect_all, treeview)
-
-        menu = self.gtk.Menu()
-        menu.append(select_all)
-        menu.append(unselect_all)
-        menu.show_all()
-        
-        self.popup_menus[treeview] = menu
-
-    def unused_filter(self, store, iter):
-        cruft = store.get_value(iter, CRUFT_COL)
-        shown = store.get_value(iter, SHOW_COL)
-        return shown and isinstance(cruft, computerjanitor.PackageCruft)
-
-    def recommended_filter(self, store, iter):
-        return False
-        
-    def optimize_filter(self, store, iter): 
-        shown = store.get_value(iter, SHOW_COL)
-        return (shown and
-                not self.unused_filter(store, iter) and
-                not self.recommended_filter(store, iter))
-
-    def error_dialog(self, msg, secondary_msg=None):
-        dialog = self.gtk.MessageDialog(parent=self.widgets["window"],
-                                        type=self.gtk.MESSAGE_ERROR,
-                                        buttons=self.gtk.BUTTONS_OK,
-                                        message_format=msg)
-        if secondary_msg:
-            dialog.format_secondary_text(secondary_msg)
-
-        return dialog
-
-    @ui
-    def show_error(self, msg, secondary_msg=None):
-        dialog = self.error_dialog(msg, secondary_msg)
-        dialog.show()
-        dialog.run()
-        dialog.hide()
-
-    def require_root(self):
-        if os.getuid() != 0:
-            dialog = self.error_dialog(_("Root access required."), 
-                                       _("You must run computer-janitor-gtk "
-                                         "as root. Sorry."))
-            dialog.show()
-            dialog.run()
-            sys.exit(1)
-
-    def require_working_apt_cache(self):
-        """ensure that the apt cache is in good state and error/exit 
-           otherwise
-        """
-        try:
-            self.app.verify_apt_cache()
-        except computerjanitor.Exception, e:
-            logging.error(unicode(traceback.format_exc()))
-            dialog = self.error_dialog(str(e))
-            dialog.show()
-            dialog.run()
-            sys.exit(1)
-
-    def pulse(self):
-        """pulse callback that shows a progress pulse until finding is False"""
-        progress = self.widgets['progressbar_status']
-        if self.finding or self.cleaning:
-            progress.show()
-            progress.pulse()
-            return True
-        else:
-            progress.hide()
-            return False
-
-    def show_cruft(self):
-        """clear the cruft store and update it again via a thread """
-        self.store.clear()
-        # run as "daemon" thread to ensure that the main app exist
-        # if the user presses "quit" before the ListUpdater thread 
-        # has finished
-        t = ListUpdater(self)
-        t.daemon = True
-        t.start()
-        # run a glib handler to shows a pulse progress
-        self.glib.timeout_add(150, self.pulse)
-
-    @ui
-    def add_cruft(self, cruft):
-        state = self.app.state.is_enabled(cruft.get_name())
-        shown = (self.show_previously_ignored or
-                 not self.app.state.was_previously_ignored(cruft.get_name()))
-        sort_index = 0
-        values = ((CRUFT_COL, cruft),
-                  (NAME_COL, cruft.get_shortname()),
-                  (STATE_COL, state),
-                  (EXPANDED_COL, False),
-                  (SHOW_COL, shown))
-        values = [pair[1] for pair in sorted(values)]
-        self.store.append(values)
-        self.sort_crufts_by_current_order()
-
-    @ui
-    def done_updating_list(self):
-        if not self.find_visible_cruft():
-            dialog = self.widgets['borednow_messagedialog']
-            dialog.show()
-            dialog.run()
-            dialog.hide()
-            
-    def foreach_set_state(self, treeview, enabled):
-        def set_state(model, path, iter, user_data):
-            iter2 = model.convert_iter_to_child_iter(iter)
-            cruft = self.store.get_value(iter2, CRUFT_COL)
-            cruft_name = cruft.get_name()
-            if enabled:
-                self.app.state.enable(cruft_name)
-            else:
-                self.app.state.disable(cruft_name)
-            self.store.set_value(iter2, STATE_COL, enabled)
-        treeview.get_model().foreach(set_state, None)
-        self.app.state.save(self.options.state_file)
-        self.set_sensitive_unlocked()
-
-    def format_name(self, cruft):
-        return self.gobject.markup_escape_text(cruft.get_shortname())
-
-    def format_size(self, bytes):
-        table = ((1000**3, "GB"),
-                 (1000**2, "MB"),
-                 (1000**1, "kB"),
-                 (      1, "B"))
-        for factor, unit in table:
-            if bytes >= factor or factor == 1:
-                return '%d %s' % (bytes / factor, unit)
-        
-    def format_description(self, cruft):
-        esc = self.gobject.markup_escape_text
-
-        lines = [esc(cruft.get_shortname())]
-        
-        # FIXME: The action verbs should come from the crufts themselves.
-        action_verbs = {
-            computerjanitor.PackageCruft: 'uninstall',
-            computerjanitor.FileCruft: 'remove',
-            computerjanitor.MissingPackageCruft: 'install',
-        }
-        action_descriptions = {
-            'uninstall': _('Package will be <b>removed</b>.'),
-            'install': _('Package will be <b>installed</b>.'),
-            'remove': _('File will be <b>removed</b>.'),
-        }
-        action_verb = action_verbs.get(type(cruft))
-        if action_verb:
-            lines += [action_descriptions[action_verb]]
-            
-        size = cruft.get_disk_usage()
-        if size is not None:
-            lines += [_('Size: %s.') % self.format_size(size)]
-
-        desc = cruft.get_description()
-        if desc:
-            lines += ['', esc(desc)]
-        
-        return '\n'.join(lines)
-
-    def toggle_long_description(self, treeview):
-        """Toggle the showing of the long description of some cruft."""
-        
-        selection = treeview.get_selection()
-        filtermodel, selected = selection.get_selected()
-        if not selected:
-            return
-        model = filtermodel.get_model()
-        iter = filtermodel.convert_iter_to_child_iter(selected)
-        cruft = model.get_value(iter, CRUFT_COL)
-        expanded = model.get_value(iter, EXPANDED_COL)
-        expanded = not expanded
-        model.set_value(iter, EXPANDED_COL, expanded)
-        if expanded:
-            value = self.format_description(cruft)
-        else:
-            value = self.format_name(cruft)
-        model.set_value(iter, NAME_COL, value)
-
-    @ui
-    def set_sensitive(self):
-        self.set_sensitive_unlocked()
-        
-    def set_sensitive_unlocked(self):
-        do = self.widgets['do_button']
-        
-        names = ['unused_treeview', 'recommended_treeview', 
-                 'optimize_treeview']
-        cleanable_cruft = self.find_visible_cruft()
-        do.set_sensitive(not self.finding and
-                         not self.cleaning and 
-                         len(cleanable_cruft) > 0)
-
-    def find_visible_cruft(self):
-        names = ['unused_treeview', 'recommended_treeview', 
-                 'optimize_treeview']
-        cleanable_cruft = []
-        for name in names:
-            w = self.widgets[name]
-            model = w.get_model()
-            it = model.get_iter_first()
-            while it is not None:
-                cruft = model.get_value(it, CRUFT_COL)
-                if self.app.state.is_enabled(cruft.get_name()):
-                    cleanable_cruft.append(cruft)
-                it = model.iter_next(it)
-        return cleanable_cruft
-
-    def really_cleanup(self):
-        """Ask user if they really mean to clean up.
-        
-        Be especially insistent (in wording) if they are removing
-        packages.
-        
-        """
-        
-        crufts = self.get_crufts()
-        crufts = [c 
-                  for c in crufts 
-                  if self.app.state.is_enabled(c.get_name())]
-        packages = [c 
-                    for c in crufts 
-                    if isinstance(c, computerjanitor.PackageCruft)]
-        others = [c for c in crufts if c not in packages]
-
-        # The following messages are a bit vague, since we need to handle
-        # cases where we remove packages, and don't remove packages, and
-        # so on, given that "clean up cruft" is such a general concept.
-        # My apologies to anyone who thinks this is confusing. Please
-        # provide a patch that a) works b) is not specific to removing
-        # packages.
-
-        msg = _('Are you sure you want to clean up?')
-        dialog = self.gtk.MessageDialog(parent=self.widgets['window'],
-                                        type=self.gtk.MESSAGE_WARNING,
-                                        buttons=self.gtk.BUTTONS_NONE,
-                                        message_format=msg)
-        dialog.set_title(_('Clean up'))                                        
-
-        if packages:
-            msg = (_('You have chosen to <b>remove %d software packages.</b> '
-                     'Removing packages that are still needed can cause '
-                     'errors.') % 
-                   len(packages))
-        else:
-            msg = _('Do you want to continue?')
-        dialog.format_secondary_markup(msg)
-
-        dialog.add_button(self.gtk.STOCK_CANCEL, self.gtk.RESPONSE_CLOSE)
-        if others:
-            dialog.add_button(_('Clean up'), self.gtk.RESPONSE_YES)
-        else:
-            dialog.add_button(_('Remove packages'), self.gtk.RESPONSE_YES)
-
-        dialog.show_all()
-        response = dialog.run()
-        dialog.hide()
-
-        return response == self.gtk.RESPONSE_YES
-
-    # The rest of this class is callbacks for GTK signals.
-
-    def on_about_menuitem_activate(self, *args):
-        w = self.widgets['about_dialog']
-        w.set_name(_('Computer Janitor'))
-        w.set_version(computerjanitorapp.VERSION)
-        w.show()
-        w.run()
-        w.hide()
-
-    def on_do_button_clicked(self, *args):
-        if self.really_cleanup():
-            Cleaner(self).start()
-            self.glib.timeout_add(150, self.pulse)
-
-    def on_show_previously_ignored_toggled(self, menuitem):
-        self.show_previously_ignored = menuitem.get_active()
-        iter = self.store.get_iter_first()
-        while iter:
-            cruft = self.store.get_value(iter, CRUFT_COL)
-            name = cruft.get_name()
-            shown = (self.show_previously_ignored or
-                     not self.app.state.was_previously_ignored(name))
-            self.store.set_value(iter, SHOW_COL, shown)
-            iter = self.store.iter_next(iter)
-    
-    def treeview_size_allocate(self, treeview, *args):
-        column = treeview.get_column(NAME_COL)
-        name_cr = column.get_cell_renderers()[0]
-        x, y, width, height = name_cr.get_size(treeview, None)
-        width = column.get_width()
-        name_cr.set_property("wrap-width", width)
-        
-    on_unused_treeview_size_allocate = treeview_size_allocate
-    on_recommended_treeview_size_allocate = treeview_size_allocate
-    on_optimize_treeview_size_allocate = treeview_size_allocate
-
-    def on_quit_menuitem_activate(self, *args):
-        self.gtk.main_quit()
-
-    on_window_delete_event = on_quit_menuitem_activate
-
-    def on_window_map_event(self, *args):
-        if self.first_map:
-            self.first_map = False
-            self.require_root()
-            self.require_working_apt_cache()
-            self.show_cruft()
-
-    def treeview_button_press_event(self, treeview, event):
-        # We handle mouse button presses ourselves so that we can either
-        # toggle the long description (button 1, typically left) or 
-        # pop up a menu (button 3, typically right).
-        #
-        # This is slightly tricky and probably a source of bugs.
-        # Oh well.
-        
-        if event.button == 1:
-            # Select row being clicked on. Also show/hide its long 
-            # description. But only if click is on the name
-            # portion of the column, not the toggle button.
-            x = int(event.x)
-            y = int(event.y)
-            time = event.time
-            pathinfo = treeview.get_path_at_pos(x, y)
-            if pathinfo:
-                path, col, cellx, celly = pathinfo
-                if col in self.name_cols:
-                    treeview.set_cursor(path, col, False)
-                    self.toggle_long_description(treeview)
-                else:
-                    return False
-            return True
-        if event.button == 3:
-            # Popup a menu
-            x = int(event.x)
-            y = int(event.y)
-            time = event.time
-            pathinfo = treeview.get_path_at_pos(x, y)
-            if pathinfo:
-                path, col, cellx, celly = pathinfo
-                treeview.grab_focus()
-                treeview.set_cursor(path, col, False)
-                menu = self.popup_menus[treeview]
-                menu.popup(None, None, None, event.button, time)
-            return True
-
-    on_unused_treeview_button_press_event = treeview_button_press_event
-    on_recommended_treeview_button_press_event = treeview_button_press_event
-    on_optimize_treeview_button_press_event = treeview_button_press_event
-
-    def popup_menu_select_all(self, menuitem, treeview):
-        self.foreach_set_state(treeview, True)
-
-    def popup_menu_unselect_all(self, menuitem, treeview):
-        self.foreach_set_state(treeview, False)
-
-    def toggled(self, cr, path, treeview):
-        model = treeview.get_model()
-        filter_iter = model.get_iter(path)
-        iter = model.convert_iter_to_child_iter(filter_iter)
-        cruft = self.store.get_value(iter, CRUFT_COL)
-        cruft_name = cruft.get_name()
-        enabled = self.app.state.is_enabled(cruft.get_name())
-        enabled = not enabled
-        if enabled:
-            self.app.state.enable(cruft_name)
-        else:
-            self.app.state.disable(cruft_name)
-        self.app.state.save(self.options.state_file)
-        self.store.set_value(iter, STATE_COL, enabled)
-        self.set_sensitive_unlocked()
-
-    def on_sort_by_name_toggled(self, menuitem):
-        if menuitem.get_active():
-            self.sort_crufts_by_current_order = self.sort_crufts_by_name
-        else:
-            self.sort_crufts_by_current_order = self.sort_crufts_by_size
-        self.sort_crufts_by_current_order()
-
-    def on_borednow_messagedialog_close(self, dialog):
-        dialog.hide()
-
-    def on_borednow_messagedialog_response(self, dialog, response):
-        dialog.hide()
-
 
=== removed file 'computerjanitorapp/ui_tests.py'
--- computerjanitorapp/ui_tests.py	2009-02-11 16:25:03 +0000
+++ computerjanitorapp/ui_tests.py	1970-01-01 00:00:00 +0000
@@ -1,36 +0,0 @@
-# ui_tests.py - unit tests for ui.py
-# Copyright (C) 2008, 2009  Canonical, Ltd.
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, version 3 of the License.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-
-import unittest
-
-import computerjanitor
-import computerjanitorapp
-
-
-class UserInterfaceTests(unittest.TestCase):
-
-    def setUp(self):
-        self.ui = computerjanitorapp.UserInterface("app", "pm")
-        
-    def testReturnsCorrectApp(self):
-        self.assertEqual(self.ui.app, "app")
-    
-    def testReturnsCorrectPluginManager(self):
-        self.assertEqual(self.ui.pm, "pm")
-    
-    def testRunRaisesUnimplemented(self):
-        self.assertRaises(computerjanitor.UnimplementedMethod, 
-                          self.ui.run, None, None)
 
=== added file 'computerjanitorapp/uigtk.py'
--- computerjanitorapp/uigtk.py	1970-01-01 00:00:00 +0000
+++ computerjanitorapp/uigtk.py	2010-03-10 21:40:30 +0000
@@ -0,0 +1,515 @@
+# Copyright (C) 2008, 2009, 2010  Canonical, Ltd.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, version 3 of the License.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""Gtk user interface for computer janitor."""
+
+from __future__ import absolute_import, unicode_literals
+
+__metaclass__ = type
+__all__ = [
+    'UserInterface',
+    ]
+
+
+import os
+import gtk
+import dbus
+import glib
+import pango
+import gobject
+
+from computerjanitorapp import __version__, setup_gettext
+from computerjanitorapp.areyousure import AreYouSure
+from computerjanitorapp.store import (
+    ListStoreColumns, Store, optimize, unused)
+from computerjanitorapp.utilities import format_size
+from computerjanitord.service import DBUS_INTERFACE_NAME
+
+_ = setup_gettext()
+
+GLADE = '/usr/share/computer-janitor/ComputerJanitor.ui'
+ROOT_WIDTH = 900
+ROOT_HEIGHT = 500
+NL = '\n'
+
+# Keys are lower-cased cruft types, i.e. class name of cruft instances.
+ACTIONS = dict(
+    packagecruft=_('Package will be <b>removed</b>.'),
+    filecruft=_('Package will be <b>installed</b>.'),
+    missingpackagecruft=_('File will be <b>removed</b>.'),
+    )
+
+SENSITIVE_WIDGETS = (
+    'do_button',
+    'optimize_treeview',
+    'quit_menuitem',
+    'show_previously_ignored',
+    'sort_by_name',
+    'sort_by_size',
+    'unused_treeview',
+    )
+
+
+class UserInterface:
+    """Implementation of the Gtk user interface."""
+
+    def __init__(self):
+        # Connect to the dbus service.
+        system_bus = dbus.SystemBus()
+        proxy = system_bus.get_object(DBUS_INTERFACE_NAME, '/')
+        self.janitord = dbus.Interface(
+            proxy, dbus_interface=DBUS_INTERFACE_NAME)
+        # Create the model on which the TreeViews will be based.
+        self.store = Store(self.janitord)
+        self.popup_menus = {}
+        self.cruft_name_columns = set()
+        # Sort by name by default.
+        self._sort_key = self._by_name
+        # Work is happening asynchronously on the dbus service.
+        self.working = False
+        # Connect to the signal the server will emit when cleaning up.
+        self.janitord.connect_to_signal('cleanup_status', self._clean_working)
+
+    def run(self):
+        """Set up the widgets and run the main loop."""
+        builder = gtk.Builder()
+        builder.set_translation_domain('computerjanitor')
+        # Load the glade ui file, which can be overridden from the environment
+        # for testing purposes.
+        glade_file = os.environ.get('COMPUTER_JANITOR_GLADE', GLADE)
+        builder.add_from_file(glade_file)
+        # Bind widgets to callbacks.
+        self.find_and_bind_widgets(builder)
+        # Do the initial search for cruft and set up the TreeView model.
+        self.store.find_cruft()
+        self.sort_cruft()
+        # Now hook the TreeViews up to there view of the model.
+        self.create_column('unused_treeview', unused)
+        self.create_column('optimize_treeview', optimize)
+        # Set the dimensions of the root window.
+        root = self.widgets['window']
+        root.set_default_size(ROOT_WIDTH, ROOT_HEIGHT)
+        # Map the root window and go!
+        root.show()
+        gtk.main()
+
+    def find_and_bind_widgets(self, builder):
+        """Bind widgets and callbacks."""
+        # Start by extracting all the bindable widgets from the ui builder,
+        # keeping track of them as mapped to their name.
+        self.widgets = {}
+        for ui_object in builder.get_objects():
+            if issubclass(type(ui_object), gtk.Buildable):
+                widget_name = gtk.Buildable.get_name(ui_object)
+                self.widgets[widget_name] = ui_object
+                # Search through the attributes of this instance looking for
+                # callbacks for this widget.  We use the naming convention
+                # 'on_<widget>_<signal>' for such methods.  Both the widget
+                # name and signal (or event) can contain underscores.  Connect
+                # the widget to the callback.
+                prefix = 'on_{0}_'.format(widget_name)
+                for method_name in dir(self):
+                    if method_name.startswith(prefix):
+                        signal_name = method_name[len(prefix):]
+                        ui_object.connect(
+                            signal_name, getattr(self, method_name))
+
+    def create_column(self, widget_name, filter_func):
+        """Set up a column in the named TreeView."""
+        treeview = self.widgets[widget_name]
+        # XXX 2010-03-04 barry: This is a bit of an abuse because it's
+        # supposed to specify whether users are to read across the rows.  As a
+        # side effect it renders the columns with alternating row colors, but
+        # that's not it's primary function.
+        treeview.set_rules_hint(True)
+        # Each TreeView contains two columns.  The leftmost one is a toggle
+        # that when select tells c-j to act on that cruft.  Deselecting the
+        # toggle ignores the package for next time.
+        toggle_cr = gtk.CellRendererToggle()
+        toggle_cr.connect('toggled', self._toggled, treeview)
+        toggle_cr.set_property('yalign', 0)
+        toggle_col = gtk.TreeViewColumn()
+        toggle_col.pack_start(toggle_cr)
+        toggle_col.add_attribute(toggle_cr, 'active', ListStoreColumns.active)
+        treeview.append_column(toggle_col)
+        # The rightmost column contains the details of the cruft.  It will
+        # always contain the cruft name and can be expanded to display cruft
+        # details.  Tell the column to get its toggle's active state from the
+        # model.
+        name_cr = gtk.CellRendererText()
+        name_cr.set_property('yalign', 0)
+        name_cr.set_property('wrap-mode', pango.WRAP_WORD)
+        name_col = gtk.TreeViewColumn()
+        name_col.pack_start(name_cr)
+        name_col.add_attribute(name_cr, 'markup', ListStoreColumns.text)
+        treeview.append_column(name_col)
+        self.cruft_name_columns.add(name_col)
+        # The individual crufts may or may not be visible in this TreeView.
+        # It's the filter function that controls this, so set that now.
+        filter_store = self.store.filter_new()
+        filter_store.set_visible_func(filter_func)
+        treeview.set_model(filter_store)
+        # Each TreeView has a popup menu for select or deselecting all visible
+        # cruft.
+        self.create_popup_menu_for_treeview(treeview)
+
+    def create_popup_menu_for_treeview(self, treeview):
+        """The tree views have a popup menu to select/deselect everything.
+
+        :param treeview: The `TreeView` to attach the menu to.
+        """
+        select_all = gtk.MenuItem(label='Select all')
+        select_all.connect('activate', self.popup_menu_select_all, treeview)
+        unselect_all = gtk.MenuItem(label='Unselect all')
+        unselect_all.connect('activate',
+                             self.popup_menu_unselect_all, treeview)
+        menu = gtk.Menu()
+        menu.append(select_all)
+        menu.append(unselect_all)
+        menu.show_all()
+        self.popup_menus[treeview] = menu
+
+    def _by_name(self, cruft_name):
+        """Sort by cruft name."""
+        return cruft_name
+
+    def _by_size(self, cruft_name):
+        """Sort by cruft size, from largest to smallest."""
+        # Return negative size to sort from largest to smallest.
+        return -self.janitord.get_details(cruft_name)[1]
+
+    def sort_cruft(self):
+        """Sort the cruft displays, either by name or size."""
+        # The way reordering (not technically 'sorting') works in gtk is that
+        # you give a list of integer indexes to the the ListStore.  These
+        # indexes are in sorted order, and refer to the pre-sort indexes of
+        # the items in the store.  IOW, the ListStore knows that if the first
+        # integer in the list is 7, it will move the 7th item to the top.
+        #
+        # Start by getting the indexes and names of the currenly sorted cruft.
+        # We'll fill this list with 2-tuples of the format:
+        # (sort-key, current-index).
+        cruft_data = []
+        def get(model, path, iter, crufts):
+            cruft_name = model.get_value(iter, ListStoreColumns.name)
+            crufts.append((self._sort_key(cruft_name), len(crufts)))
+            # Continue iterating.
+            return False
+        self.store.foreach(get, cruft_data)
+        cruft_data.sort()
+        cruft_indexes = [index for key, index in cruft_data]
+        self.store.reorder(cruft_indexes)
+
+    def get_cleanable_cruft(self):
+        """Return the list of cleanable cruft candidates.
+
+        :return: List of cleanable cruft.
+        :rtype: list of 2-tuples of (cruft_name, is_package_cruft)
+        """
+        cleanable_cruft = []
+        def collect(model, path, iter, crufts):
+            # Only clean up active cruft, i.e. those that are specifically
+            # checked as ready for cleaning.
+            cruft_active = model.get_value(iter, ListStoreColumns.active)
+            if cruft_active:
+                cruft_name = model.get_value(iter, ListStoreColumns.name)
+                cruft_is_package_cruft = model.get_value(
+                    iter, ListStoreColumns.is_package_cruft)
+                crufts.append((cruft_name, cruft_is_package_cruft))
+            # Continue iterating.
+            return False
+        self.store.foreach(collect, cleanable_cruft)
+        return cleanable_cruft
+
+    def toggle_long_description(self, treeview):
+        """Toggle the currently selected cruft's long description.
+
+        :param treeview: The TreeView
+        """
+        selection = treeview.get_selection()
+        filter_model, selected = selection.get_selected()
+        if not selected:
+            return
+        model = filter_model.get_model()
+        iter = filter_model.convert_iter_to_child_iter(selected)
+        cruft_name = model.get_value(iter, ListStoreColumns.name)
+        expanded = model.get_value(iter, ListStoreColumns.expanded)
+        shortname = model.get_value(iter, ListStoreColumns.short_name)
+        if expanded:
+            # Collapse it.
+            value = gobject.markup_escape_text(shortname)
+        else:
+            cruft_type, size = self.janitord.get_details(cruft_name)
+            lines = [gobject.markup_escape_text(shortname)]
+            action = ACTIONS.get(cruft_type.lower())
+            if action is not None:
+                lines.append(action)
+            lines.append('Size: {0}'.format(format_size(size)))
+            lines.append('')
+            description = self.janitord.get_description(cruft_name)
+            lines.append(gobject.markup_escape_text(description))
+            value = NL.join(lines)
+        model.set_value(iter, ListStoreColumns.text, value)
+        model.set_value(iter, ListStoreColumns.expanded, not expanded)
+
+    def desensitize(self):
+        """Make certain ui elements insensitive during work."""
+        for widget in SENSITIVE_WIDGETS:
+            self.widgets[widget].set_sensitive(False)
+
+    def sensitize(self):
+        """Make certain ui elements sensitive after work."""
+        for widget in SENSITIVE_WIDGETS:
+            self.widgets[widget].set_sensitive(True)
+
+    # Popup menu support.
+
+    def popup_menu_foreach_set_state(self, treeview, enabled):
+        """Set the state of the cruft 'active' flag for all cruft.
+
+        :param treeview: The `TreeView` to set cruft state on.
+        :param enabled: The new state flag for all cruft.  True means enabled.
+        :type enabled: bool
+        """
+        def set_state(model, path, iter, user_data):
+            # Set the state on an individual piece of cruft.  Start by
+            # changing the state of the cruft on the dbus service.
+            child_iter = model.convert_iter_to_child_iter(iter)
+            cruft_name = self.store.get_value(
+                child_iter, ListStoreColumns.name)
+            if enabled:
+                self.janitord.unignore(cruft_name)
+            else:
+                self.janitord.ignore(cruft_name)
+            # Now set the active state in the model.
+            self.store.set_value(child_iter, ListStoreColumns.active, enabled)
+        treeview.get_model().foreach(set_state, None)
+        # Save the updated state on the dbus service.
+        self.janitord.save()
+
+    def popup_menu_select_all(self, menuitem, treeview):
+        self.popup_menu_foreach_set_state(treeview, True)
+
+    def popup_menu_unselect_all(self, menuitem, treeview):
+        self.popup_menu_foreach_set_state(treeview, False)
+
+    # Progress bar
+
+    def pulse(self):
+        """Progress bar callback, showing that something is happening."""
+        progress = self.widgets['progressbar_status']
+        if self.working:
+            progress.show()
+            progress.pulse()
+            return True
+        else:
+            # All done.  Hide the progress bar, make the ui elements sensitive
+            # again, update the store, and kill the timer.
+            progress.hide()
+            self.store.clear()
+            self.store.find_cruft()
+            self.sensitize()
+            return False
+
+    def _clean_working(self, cruft):
+        """dbus signal handler; the 'clean' operation is in progress.
+
+        :param done: The cruft that is being cleaned up.
+        :type done: string
+        """
+        # Just mark the status here.  The progress bar pulsar will handle
+        # doing the actual work.
+        self.working = (cruft != '')
+        if self.working:
+            self.widgets['progressbar_status'].set_text(
+                _('Processing {0}').format(cruft))
+
+    # Callbacks
+
+    def _toggled(self, widget, path, treeview):
+        """Handle the toggle button in a TreeView cell.
+
+        :param widget: The CellRendererToggle
+        :param path: The cell's path.
+        :param treeview: The TreeView
+        """
+        # Find out which cruft's toggle was clicked.
+        model = treeview.get_model()
+        filter_iter = model.get_iter(path)
+        child_iter = model.convert_iter_to_child_iter(filter_iter)
+        cruft_name = self.store.get_value(child_iter, ListStoreColumns.name)
+        state = self.store.get_value(child_iter, ListStoreColumns.active)
+        # Toggle the current state.
+        new_state = not state
+        if new_state:
+            self.janitord.unignore(cruft_name)
+        else:
+            self.janitord.ignore(cruft_name)
+        self.store.set_value(child_iter, ListStoreColumns.active, new_state)
+        self.store.set_value(
+            child_iter, ListStoreColumns.server_ignored, not new_state)
+        # Save the new ignored state on the dbus service.
+        self.janitord.save()
+
+    # Signal and event handlers.
+
+    def on_quit_menuitem_activate(self, *args):
+        """Signal and event handlers for quitting.
+
+        Since we just want things to go away, we don't really care about the
+        arguments.  Just tell the main loop to exit.
+        """
+        # Don't quit while we're working.
+        if self.working:
+            return True
+        gtk.main_quit()
+
+    on_window_delete_event = on_quit_menuitem_activate
+
+    def treeview_button_press_event(self, treeview, event):
+        """Handle mouse button press events on the TreeView ourselves.
+
+        We handle mouse button presses ourselves so that we can either
+        toggle the long description (button 1, typically left) or
+        pop up a menu (button 3, typically right).
+        """
+        # Original comment: This is slightly tricky and probably a source of
+        # bugs.  Oh well.
+        if event.button == 1:
+            # Left button event.  Select the row being clicked on.  If the
+            # click is on the cruft name, show or hide its long description.
+            # If the click the click is elsewhere do not handle it.  This
+            # allows the toggle button event to be handled separately.
+            x = int(event.x)
+            y = int(event.y)
+            time = event.time
+            pathinfo = treeview.get_path_at_pos(x, y)
+            if pathinfo is None:
+                # The click was not in a cell, but we've handled it anyway.
+                return True
+            path, column, cell_x, cell_y = pathinfo
+            if column in self.cruft_name_columns:
+                treeview.set_cursor(path, column, False)
+                self.toggle_long_description(treeview)
+                return True
+            else:
+                # We are not handling this event so that the toggle button
+                # handling can occur.
+                return False
+        elif event.button == 3:
+            # Right button event.  Pop up the select/deselect all menu.
+            treeview.grab_focus()
+            x = int(event.x)
+            y = int(event.y)
+            time = event.time
+            pathinfo = treeview.get_path_at_pos(x, y)
+            if pathinfo is not None:
+                path, column, cell_x, cell_y = pathinfo
+                treeview.set_cursor(path, column, False)
+            menu = self.popup_menus[treeview]
+            menu.popup(None, None, None, event.button, time)
+            return True
+        else:
+            # No other events are handled by us.
+            return False
+
+    # The actual event handler is totally generic.  Alias it to names
+    # recognized by the automatic event binding scheme.
+    on_unused_treeview_button_press_event = treeview_button_press_event
+    on_optimize_treeview_button_press_event = treeview_button_press_event
+
+    def treeview_size_allocate(self, treeview, *args):
+        """Allocate space for the tree view and set wrap width.
+
+        :param treeview: The TreeView
+        :param args: Additional ignored positional arguments
+        """
+        # Get the rightmost of the two columns in the TreeView, i.e. the one
+        # containing the text.
+        column = treeview.get_column(1)
+        name_cr = column.get_cell_renderers()[0]
+        # Wrap to the entire width of the column.
+        width = column.get_width()
+        name_cr.set_property('wrap-width', width)
+
+    on_unused_treeview_size_allocate = treeview_size_allocate
+    on_optimize_treeview_size_allocate = treeview_size_allocate
+
+    def on_sort_by_name_toggled(self, menuitem):
+        """Reorder the crufts to be sorted by name or size."""
+        if menuitem.get_active():
+            self._sort_key = self._by_name
+        else:
+            self._sort_key = self._by_size
+        self.sort_cruft()
+
+    def on_about_menuitem_activate(self, *args):
+        dialog = self.widgets['about_dialog']
+        dialog.set_name(_('Computer Janitor'))
+        dialog.set_version(__version__)
+        dialog.show()
+        dialog.run()
+        dialog.hide()
+
+    def on_show_previously_ignored_toggled(self, menuitem):
+        """Show all cruft, even those being ignored.
+
+        Normally, we only show cruft that wasn't explicitly ignored.  By
+        toggling this menu item, the janitor can also display cruft that is
+        marked as ignored on the dbus service.
+        """
+        show_ignored_cruft = menuitem.get_active()
+        iter = self.store.get_iter_first()
+        while iter:
+            cruft_name = self.store.get_value(iter, ListStoreColumns.name)
+            server_ignored = self.store.get_value(
+                iter, ListStoreColumns.server_ignored)
+            show = (show_ignored_cruft or not server_ignored)
+            self.store.set_value(iter, ListStoreColumns.show, show)
+            iter = self.store.iter_next(iter)
+
+    def on_do_button_clicked(self, *args):
+        """JFDI, well almost."""
+        self.count = 0
+        response = AreYouSure(self).verify()
+        if not response:
+            return
+        # This can take a long time.  Make an asynchronous call to the dbus
+        # service and arrange for it to occasionally provide us with status.
+        # This isn't great ui, but OTOH, the package cruft cleaners themselves
+        # don't provide much granularity, so there's little we can do anyway
+        # without a major rewrite of the plugin architecture.
+        self.working = True
+        glib.timeout_add(150, self.pulse)
+        # Make various ui elements insensitive.
+        self.desensitize()
+        cleanable = [cruft for cruft, ispkg in self.get_cleanable_cruft()]
+        # XXX 2010-03-08 barry: Do better than this.
+        def error(exception):
+            print exception
+            self.working = False
+        def reply():
+            pass
+        # Make the asynchronous call because this can take a long time.  We'll
+        # get status updates periodically.  Note however that even though this
+        # is asynchronous, dbus still expects a response within a certain
+        # amount of time.  We have no idea how long it will take to clean up
+        # the cruft though, so just crank the timeout up to some insanely huge
+        # number (of seconds).
+        self.widgets['progressbar_status'].set_text('Authenticating...')
+        self.janitord.clean(cleanable,
+                            reply_handler=reply,
+                            error_handler=error,
+                            # If it takes longer than an hour, we're screwed.
+                            timeout=3600)
 
=== added file 'computerjanitorapp/utilities.py'
--- computerjanitorapp/utilities.py	1970-01-01 00:00:00 +0000
+++ computerjanitorapp/utilities.py	2010-03-10 21:40:30 +0000
@@ -0,0 +1,51 @@
+# Copyright (C) 2008, 2009, 2010  Canonical, Ltd.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, version 3 of the License.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""Common utilities."""
+
+from __future__ import absolute_import, unicode_literals
+
+__metaclass__ = type
+__all__ = [
+    'format_size',
+    ]
+
+
+from math import log10
+
+
+TABLE = (
+    'B',
+    'kB',
+    'MB',
+    'GB',
+    'TB',
+    )
+
+
+def format_size(bytes):
+    """Format size in bytes.
+
+    :param bytes: Integer size in bytes.
+    :type bytes: integer
+    :return: Formatted size
+    :rtype: string
+    """
+    assert bytes >= 0, 'Cannot have negative sizes'
+    if bytes == 0:
+        return '0B'
+    if bytes > 10**12:
+        return '>1TB'
+    key = divmod(int(log10(bytes)), 3)[0]
+    return '{0}{1}'.format(bytes // 10**(key * 3), TABLE[key])
 
=== added directory 'computerjanitord'
=== added file 'computerjanitord/__init__.py'
=== added file 'computerjanitord/application.py'
--- computerjanitord/application.py	1970-01-01 00:00:00 +0000
+++ computerjanitord/application.py	2010-03-10 21:40:30 +0000
@@ -0,0 +1,111 @@
+# Copyright (C) 2008, 2009, 2010  Canonical, Ltd.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, version 3 of the License.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""Application interface for use by plugins.
+
+This primarily makes certain apt functionality available to the plugin.
+"""
+
+from __future__ import absolute_import, unicode_literals
+
+__metaclass__ = type
+__all__ = [
+    'Application',
+    'SourcesListError',
+    ]
+
+
+import apt
+
+import computerjanitor
+import computerjanitorapp
+
+_ = computerjanitorapp.setup_gettext()
+
+SYNTAPTIC_PREFERENCES_FILE = '/var/lib/synaptic/preferences'
+# There really isn't anything special about these packages.  These really just
+# represent landmarks in the package namespace that we look for to try to
+# judge the sanity of the apt cache.  If these are missing, things are really
+# messed up and we can't actually figure out how to continue.
+LANDMARK_PACKAGES = [
+    'dash',
+    'gzip',
+    ]
+
+
+class LandmarkPackageError(computerjanitor.Exception):
+    """Base class for problems with the landmark packages."""
+
+    _errmsg = None
+
+    def __init__(self, package):
+        self.package = package
+
+    def __str__(self):
+        # gettext translation needs to be called at run time.
+        return _(self._errmsg).format(self)
+
+
+class MissingLandmarkError(LandmarkPackageError):
+    """A landmark package could not be found."""
+
+    _errmsg = _('Landmark package {0.package} is missing')
+
+
+class NonDownloadableError(LandmarkPackageError):
+    """A landmark package is not downloadable."""
+
+    _errmsg = _('Landmark package {0.package} is not downloadable')
+
+
+class Application:
+    """Interface for plugins requesting apt actions."""
+
+    def __init__(self, apt_cache=None):
+        """Create the application interface.
+
+        :param apt_cache: Alternative apt cache for testing purposes.  When
+            `None` use the default apt cache.
+        """
+        if apt_cache is None:
+            # Use the real apt cache.
+            self.apt_cache = apt.Cache()
+        else:
+            self.apt_cache = apt_cache
+        self.refresh_apt_cache()
+
+    def refresh_apt_cache(self):
+        """Refresh the apt cache.
+
+        This API is used by plugins.
+        """
+        self.apt_cache.open()
+        # For historical purposes, Synaptic has a different way of pinning
+        # packages than apt, so we have to load its preferences file in order
+        # to know what it's pinning.
+        self.apt_cache._depcache.ReadPinFile(SYNTAPTIC_PREFERENCES_FILE)
+
+    def verify_apt_cache(self):
+        """Verify that essential packages are available in the apt cache.
+
+        This API is used by plugins.
+
+        :raises SourcesListProblem: when an essential package is not
+            available.
+        """
+        for name in LANDMARK_PACKAGES:
+            if name not in self.apt_cache:
+                raise MissingLandmarkError(name)
+            if not any(v.downloadable for v in self.apt_cache[name].versions):
+                raise NonDownloadableError(name)
 
=== added file 'computerjanitord/authenticator.py'
--- computerjanitord/authenticator.py	1970-01-01 00:00:00 +0000
+++ computerjanitord/authenticator.py	2010-03-10 21:40:30 +0000
@@ -0,0 +1,85 @@
+# Copyright (C) 2008, 2009, 2010  Canonical, Ltd.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, version 3 of the License.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""Authentication for Computer Janitor backend services."""
+
+from __future__ import absolute_import, unicode_literals
+
+__metaclass__ = type
+__all__ = [
+    'Authenticator',
+    ]
+
+
+import dbus
+
+
+PK_AUTHORITY_BUS_NAME = 'org.freedesktop.PolicyKit1'
+PK_AUTHORITY_OBJECT_PATH = '/org/freedesktop/PolicyKit1/Authority'
+PK_AUTHORITY_INTERFACE = 'org.freedesktop.PolicyKit1.Authority'
+# From the PolicyKit API.
+# http://hal.freedesktop.org/docs/polkit/
+# eggdbus-interface-org.freedesktop.PolicyKit1.Authority.html
+AllowUserInteraction = 0x00000001
+
+
+class Authenticator:
+    """PolicyKit authenticator."""
+
+    def authenticate(self, sender, connection, privilege):
+        """Authenticate with PolicyKit.
+
+        :param sender: The initiator of the action.
+        :param connection: The dbus connection that initiated the action.
+        :param privilege: The privilege being requested.
+        :return: Whether the subject is authorized or not.
+        :rtype: bool
+        """
+        policykit = self._get_policykit_proxy()
+        sender_pid = self._get_sender_pid(connection, sender)
+        # This is the CheckAuthorization() 'subject' structure.
+        subject = (
+            'unix-process', {
+                'pid': sender_pid,
+                'start-time': 0,
+                })
+        # No details or cancellation_id needed.
+        details = {'': ''}
+        cancellation_id = ''
+        flags = AllowUserInteraction
+        # CheckAuthorization returns an AuthorizationResult structure, modeled
+        # as a 3-tuple.  The only thing we care about though is the boolean
+        # describing whether we got authorized or not.
+        is_authorized, is_challenge, details = policykit.CheckAuthorization(
+            subject, privilege, details, flags, cancellation_id)
+        return is_authorized
+
+    def _get_policykit_proxy(self):
+        """Contact the system bus to get a PolicyKit proxy."""
+        system_bus = dbus.SystemBus()
+        pk_proxy = system_bus.get_object(
+            PK_AUTHORITY_BUS_NAME, PK_AUTHORITY_OBJECT_PATH)
+        return dbus.Interface(pk_proxy, PK_AUTHORITY_INTERFACE)
+
+    def _get_sender_pid(self, connection, sender):
+        """Contact the system bus to get the sender connection PID."""
+        # Since we're going to authorize a Unix process, we need to get the
+        # sender's process id.  This is available on the dbus.  The
+        # CheckAuthorization() method also requires us to have a start-time,
+        # but it's not clear what the semantics are for that, so we'll just
+        # put a zero there.
+        db_proxy = connection.get_object(
+            dbus.BUS_DAEMON_NAME, dbus.BUS_DAEMON_PATH, introspect=False)
+        info = dbus.Interface(db_proxy, dbus.BUS_DAEMON_IFACE)
+        return info.GetConnectionUnixProcessID(sender)
 
=== added file 'computerjanitord/collector.py'
--- computerjanitord/collector.py	1970-01-01 00:00:00 +0000
+++ computerjanitord/collector.py	2010-03-10 21:40:30 +0000
@@ -0,0 +1,149 @@
+# Copyright (C) 2008, 2009, 2010  Canonical, Ltd.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, version 3 of the License.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""A cruft collector."""
+
+from __future__ import absolute_import, unicode_literals
+
+__metaclass__ = type
+__all__ = [
+    'Collector',
+    ]
+
+
+import os
+import time
+import logging
+
+from computerjanitor import PluginManager
+from computerjanitord.errors import DuplicateCruftError
+from computerjanitord.whitelist import Whitelist
+
+
+log = logging.getLogger('computerjanitor')
+MISSING = object()
+DEFAULT_PLUGINS_DIRS = "/usr/share/computerjanitor/plugins"
+
+# For testing purposes.
+SLEEPY_TIME = float(os.environ.get('COMPUTER_JANITOR_SLEEPY_TIME', '1.0'))
+
+
+class Collector:
+    """A cruft collector."""
+
+    def __init__(self, application, plugin_manager_class=None,
+                 whitelist_dirs=None, service=None):
+        """Create a cruft collector.
+
+        :param application: The `Application` class.
+        :type application: This object is used by plugins to access the apt
+            database.  It must have an attribute named `apt_cache` and a
+            method named `refresh_apt_cache()`.
+        :param plugin_manager_class: The plugin manager class.  If None (the
+            default), then `computerjanitor.PluginManager` is used.
+        :type plugin_manager_class: callable accepting a single argument,
+            which is a sequence of plugin directories.
+        :param whitelist_dirs: Sequence of directories to search for
+            '.whitelist' files.  Passed directly to
+            `computerjanitord.whitelist.Whitelist`.
+        :param service: The dbus service; when doing plugin post-cleanup, this
+            will be used to emit a progress signal.
+        """
+        self.application = application
+        self.service = service
+        self.whitelist = Whitelist(whitelist_dirs)
+        # Keep track of cruft and map between the cruft's name and its Cruft
+        # instance.  We'll use the latter when cruft cleanup is requested
+        # through the dbus API.
+        self.cruft = None
+        self.cruft_by_name = None
+        # Set up the plugin manager.
+        plugin_path = os.environ.get('COMPUTER_JANITOR_PLUGINS',
+                                     DEFAULT_PLUGINS_DIRS)
+        plugin_dirs = plugin_path.split(':')
+        if plugin_manager_class is None:
+            plugin_manager_class = PluginManager
+        self.plugin_manager = plugin_manager_class(application, plugin_dirs)
+        self.load()
+
+    def load(self):
+        """Reload all cruft."""
+        self.cruft = []
+        self.cruft_by_name = {}
+        # Ask all the plugins to find their cruft, filtering out whitelisted
+        # cruft.
+        for plugin in self.plugin_manager.get_plugins():
+            for cruft in plugin.get_cruft():
+                if not self.whitelist.is_whitelisted(cruft):
+                    # Different plugins can give us duplicate cruft names,
+                    # however the Cruft class better be the same, otherwise we
+                    # won't actually know how to map the name back to a cruft
+                    # instance for proper cleanup.
+                    if cruft.get_name() in self.cruft_by_name:
+                        my_cruft = self.cruft_by_name[cruft.get_name()]
+                        if cruft.__class__ is my_cruft.__class__:
+                            # We only need one instance of this cruft.
+                            continue
+                        else:
+                            raise DuplicateCruftError(cruft.get_name())
+                    #print '    ', cruft.get_name()
+                    self.cruft.append(cruft)
+                    self.cruft_by_name[cruft.get_name()] = cruft
+
+    def clean(self, names, dry_run=False):
+        """Clean up the named cruft.
+
+        :param names: The names of the cruft to clean up.
+        :type names: list of strings
+        :param dry_run: Flag indicating whether to do permanent changes.
+        :type dry_run: bool
+        """
+        # Ensure that all named cruft is known.
+        for name in names:
+            cruft = self.cruft_by_name.get(name, MISSING)
+            if cruft is MISSING:
+                log.error('No such cruft: {0}'.format(name))
+                raise NoSuchCruftError(name)
+            log.info('cleaning cruft: {0}'.format(cruft.get_name()))
+            if not dry_run:
+                cruft.cleanup()
+        # Do plugin-specific post-cleanup.
+        for plugin in self.plugin_manager.get_plugins():
+            logging.info('post-cleanup: {0}'.format(plugin))
+            if self.service is not None:
+                # Notify the client that we're not done yet.
+                #
+                # 2010-02-09 barry: this actually kind of sucks because the
+                # granularity is too coarse.  Some plugins will post_cleanup()
+                # very quickly, others will take a long time.  Unfortunately,
+                # the computerjanitor.Plugin API doesn't support a more
+                # granular feedback.  Plugin.get_plugin(..., callback=foo)
+                # doesn't really cut it because that only gets called during
+                # get_plugins().
+                self.service.cleanup_status(plugin.__class__.__name__)
+            if dry_run:
+                # For testing purposes.
+                time.sleep(SLEEPY_TIME)
+            else:
+                try:
+                    plugin.post_cleanup()
+                except Exception:
+                    logging.exception('plugin: {0}'.format(plugin))
+                    # Keep going.
+        # Now we're done.
+        if self.service is not None:
+            self.service.cleanup_status('')
+        # Reload list of crufts.
+        self.application.refresh_apt_cache()
+        self.load()
 
=== added directory 'computerjanitord/data'
=== added file 'computerjanitord/data/com.ubuntu.ComputerJanitor.conf'
--- computerjanitord/data/com.ubuntu.ComputerJanitor.conf	1970-01-01 00:00:00 +0000
+++ computerjanitord/data/com.ubuntu.ComputerJanitor.conf	2010-03-10 21:40:30 +0000
@@ -0,0 +1,15 @@
+<!DOCTYPE busconfig PUBLIC
+ "-//freedesktop//DTD D-BUS Bus Configuration 1.0//EN"
+ "http://www.freedesktop.org/standards/dbus/1.0/busconfig.dtd">
+<busconfig>
+        <policy user="root">
+                <allow own="com.ubuntu.ComputerJanitor"/>
+        </policy>
+
+        <policy context="default">
+                <allow send_interface="com.ubuntu.ComputerJanitor"/>
+                <allow receive_interface="com.ubuntu.ComputerJanitor"
+                       receive_sender="com.ubuntu.ComputerJanitor"/>
+        </policy>
+
+</busconfig>
 
=== added file 'computerjanitord/data/com.ubuntu.computerjanitor.policy'
--- computerjanitord/data/com.ubuntu.computerjanitor.policy	1970-01-01 00:00:00 +0000
+++ computerjanitord/data/com.ubuntu.computerjanitor.policy	2010-03-10 21:40:30 +0000
@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE policyconfig PUBLIC
+ "-//freedesktop//DTD PolicyKit Policy Configuration 1.0//EN"
+ "http://www.freedesktop.org/standards/PolicyKit/1.0/policyconfig.dtd">
+<policyconfig>
+
+  <vendor>ComputerJanitor</vendor>
+  <vendor_url>https://launchpad.net/computer-janitor</vendor_url>
+
+  <action id="com.ubuntu.computerjanitor.updatesystem">
+    <description>Clean up packages that are no longer necessary</description>
+    <message>Removing unused packages requires authentication</message>
+    <defaults>
+      <allow_inactive>no</allow_inactive>
+      <allow_active>auth_admin_keep</allow_active>
+    </defaults>
+  </action>
+
+</policyconfig>
 
=== added file 'computerjanitord/errors.py'
--- computerjanitord/errors.py	1970-01-01 00:00:00 +0000
+++ computerjanitord/errors.py	2010-03-10 21:40:30 +0000
@@ -0,0 +1,57 @@
+# Copyright (C) 2008, 2009, 2010  Canonical, Ltd.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, version 3 of the License.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""Exceptions for the Computer Janitor daemon."""
+
+
+from __future__ import absolute_import, unicode_literals
+
+__metaclass__ = type
+__all__ = [
+    'DuplicateCruftError',
+    'NoSuchCruftError',
+    'PermissionDeniedError',
+    ]
+
+
+import dbus
+
+from computerjanitorapp import setup_gettext
+_ = setup_gettext()
+
+
+class PermissionDeniedError(dbus.DBusException):
+    """Permission denied by policy"""
+
+
+class CruftError(dbus.DBusException):
+    MSG = None
+
+    def __init__(self, cruft_name):
+        self.cruft_name = cruft_name
+
+    def __str__(self):
+        return _(self.MSG).format(self)
+
+
+class DuplicateCruftError(CruftError):
+    """Duplicate cruft name with different cleanup."""
+
+    MSG = _('Duplicate cruft with different cleanup: {0.cruft_name}')
+
+
+class NoSuchCruftError(CruftError):
+    """There is no cruft by the given name."""
+
+    MSG = _('No such cruft: {0.cruft_name}')
 
=== added file 'computerjanitord/main.py'
--- computerjanitord/main.py	1970-01-01 00:00:00 +0000
+++ computerjanitord/main.py	2010-03-10 21:40:30 +0000
@@ -0,0 +1,97 @@
+# Copyright (C) 2008, 2009, 2010  Canonical, Ltd.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, version 3 of the License.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""Main entry point for Computer Janitor dbus daemon."""
+
+from __future__ import absolute_import, unicode_literals
+
+__metaclass__ = type
+__all__ = [
+    'main',
+    ]
+
+
+import os
+import gobject
+import logging
+import argparse
+import warnings
+import dbus.mainloop.glib
+import logging.handlers
+
+from computerjanitorapp import __version__, setup_gettext
+from computerjanitord.service import Service
+
+_ = setup_gettext()
+
+
+# 2010-02-09 barry: computerjanitor.package_cruft has a DeprecationWarning,
+# but that really needs to be fixed in that package, which in turn needs to be
+# ripped out of update-manager.
+warnings.filterwarnings('ignore', category=DeprecationWarning,
+                        module='computerjanitor.package_cruft')
+
+
+class Options:
+    """Command line options."""
+
+    def __init__(self):
+        self.parser = argparse.ArgumentParser(
+            description=_('Computer janitor dbus daemon'),
+            version=__version__)
+        self.parser.add_argument(
+            '-n', '--dry-run', action='store_true',
+            help=_("""\
+            Only pretend to do anything permanent.  This is useful for testing
+            and debugging."""))
+        self.parser.add_argument(
+            '-f', '--state-file', metavar='FILE',
+            help=_('Store ignored state in FILE instead of the default.'))
+        self.arguments = self.parser.parse_args()
+
+
+class ASCIIFormatter(logging.Formatter):
+    """Force the log messages to ASCII."""
+    def format(self, record):
+        message = logging.Formatter.format(self, record)
+        return message.encode('ascii', 'replace')
+
+
+def main():
+    """Main entry point."""
+    # Set up logging.
+    if os.environ.get('COMPUTER_JANITOR_DEBUG') is not None:
+        level = logging.DEBUG
+    else:
+        level = logging.INFO
+    logging.basicConfig(level=level, format='%(levelname)s: %(message)s')
+    log = logging.getLogger('computerjanitor')
+    # SysLogHandler does not recognize unicode arguments.
+    syslog = logging.handlers.SysLogHandler(str('/dev/log'))
+    # syslog will provide a timestamp.
+    formatter = ASCIIFormatter('computerjanitord:%(levelname)s: %(message)s')
+    syslog.setFormatter(formatter)
+    syslog.setLevel(level)
+    log.addHandler(syslog)
+    options = Options()
+    dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
+    server = Service(options)
+    try:
+        gobject.MainLoop().run()
+    except KeyboardInterrupt:
+        pass
+
+
+if __name__ == '__main__':
+    main()
 
=== added file 'computerjanitord/service.py'
--- computerjanitord/service.py	1970-01-01 00:00:00 +0000
+++ computerjanitord/service.py	2010-03-10 21:40:30 +0000
@@ -0,0 +1,260 @@
+# Copyright (C) 2008, 2009, 2010  Canonical, Ltd.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, version 3 of the License.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""dbus service for cleaning up crufty packages that are no longer needed."""
+
+
+from __future__ import absolute_import, unicode_literals
+
+__metaclass__ = type
+__all__ = [
+    'Service',
+    ]
+
+
+import atexit
+import logging
+
+import dbus.service
+
+from computerjanitor import PackageCruft
+from computerjanitord.application import Application
+from computerjanitord.authenticator import Authenticator
+from computerjanitord.collector import Collector
+from computerjanitord.errors import NoSuchCruftError, PermissionDeniedError
+from computerjanitord.state import State, DEFAULT_STATE_FILE
+
+
+log = logging.getLogger('computerjanitor')
+MISSING = object()
+
+DBUS_INTERFACE_NAME = 'com.ubuntu.ComputerJanitor'
+PRIVILEGE = 'com.ubuntu.computerjanitor.updatesystem'
+
+
+class Service(dbus.service.Object):
+    """Backend dbus service that handles removing crufty packages."""
+
+    def __init__(self, options):
+        """Create the dbus service.
+
+        :param options: The command line options class.
+        :type options: `Options`
+        """
+        self.dry_run = options.arguments.dry_run
+        self.state_file = (DEFAULT_STATE_FILE
+                           if options.arguments.state_file is None
+                           else options.arguments.state_file)
+        self.application = Application()
+        self.state = State()
+        self.state.load(self.state_file)
+        self.collector = Collector(self.application, service=self)
+        self.authenticator = Authenticator()
+        bus_name = dbus.service.BusName(
+            DBUS_INTERFACE_NAME, bus=dbus.SystemBus())
+        dbus.service.Object.__init__(self, bus_name, '/')
+        # We can't use the decorator because that doesn't work with methods;
+        # self doesn't get passed to the handler.
+        atexit.register(self._exit_handler)
+
+    def _exit_handler(self):
+        """Ensure that the state file is saved at exit."""
+        if not self.dry_run:
+            self.state.save(self.state_file)
+
+    def _authenticate(self, sender, connection):
+        """Authenticate via PolicyKit.
+
+        :param sender: The dbus client sender.
+        :param connection: The dbus client connection.
+        :raises PermissionDeniedError: when the authentication fails.
+        """
+        if not self.authenticator.authenticate(sender, connection, PRIVILEGE):
+            log.error('Permission denied: {0} for {1} on {2}'.format(
+                PRIVILEGE, sender, connection))
+            raise PermissionDeniedError(PRIVILEGE)
+        log.debug('Permission granted: {0} for {1} on {2}'.format(
+            PRIVILEGE, sender, connection))
+
+    @dbus.service.method(DBUS_INTERFACE_NAME,
+                         out_signature='as')
+    def find(self):
+        """Find all the non-whitelisted cruft on the system.
+
+        Because this is a read-only interface it does not need authorization
+        to be called.
+
+        :return: A list of matching cruft names.
+        """
+        return list(cruft.get_name() for cruft in self.collector.cruft)
+
+    @dbus.service.method(DBUS_INTERFACE_NAME,
+                         out_signature='as',
+                         # Must wrap these in str() because Python < 2.6.5
+                         # does not like unicode keyword arguments.
+                         sender_keyword=str('sender'),
+                         connection_keyword=str('connection'))
+    def load(self, sender=None, connection=None):
+        """Load the state file."""
+        self._authenticate(sender, connection)
+        self.state.load(self.state_file)
+        return list(self.state.ignore)
+
+    @dbus.service.method(DBUS_INTERFACE_NAME,
+                         # Must wrap these in str() because Python < 2.6.5
+                         # does not like unicode keyword arguments.
+                         sender_keyword=str('sender'),
+                         connection_keyword=str('connection'))
+    def save(self, sender=None, connection=None):
+        """Save the state file."""
+        self._authenticate(sender, connection)
+        if not self.dry_run:
+            self.state.save(self.state_file)
+
+    @dbus.service.method(DBUS_INTERFACE_NAME,
+                         in_signature='s',
+                         # Must wrap these in str() because Python < 2.6.5
+                         # does not like unicode keyword arguments.
+                         sender_keyword=str('sender'),
+                         connection_keyword=str('connection'))
+    def ignore(self, name, sender=None, connection=None):
+        """Ignore the named cruft.
+
+        :param name: The name of the cruft to ignore.
+        :type filename: string
+        """
+        # Make sure this is known cruft first.
+        cruft = self.collector.cruft_by_name.get(name, MISSING)
+        if cruft is MISSING:
+            log.error('ignore(): No such cruft: {0}'.format(name))
+            raise NoSuchCruftError(name)
+        self._authenticate(sender, connection)
+        if not self.dry_run:
+            self.state.ignore.add(name)
+
+    @dbus.service.method(DBUS_INTERFACE_NAME,
+                         in_signature='s',
+                         # Must wrap these in str() because Python < 2.6.5
+                         # does not like unicode keyword arguments.
+                         sender_keyword=str('sender'),
+                         connection_keyword=str('connection'))
+    def unignore(self, name, sender=None, connection=None):
+        """Unignore the named cruft.
+
+        :param name: The name of the cruft to unignore.
+        :type filename: string
+        """
+        cruft = self.collector.cruft_by_name.get(name, MISSING)
+        if cruft is MISSING:
+            log.error('ignore(): No such cruft: {0}'.format(name))
+            raise NoSuchCruftError(name)
+        self._authenticate(sender, connection)
+        if not self.dry_run:
+            # Don't worry if we're already not ignoring the cruft (i.e. don't
+            # raise a KeyError here if 'name' is not in the set).
+            self.state.ignore.discard(name)
+
+    @dbus.service.method(DBUS_INTERFACE_NAME,
+                         out_signature='as')
+    def ignored(self):
+        """Return the list of ignored cruft.
+
+        :return: The names of the ignored cruft.
+        :rtype: list of strings
+        """
+        return list(self.state.ignore)
+
+    @dbus.service.method(DBUS_INTERFACE_NAME,
+                         in_signature='s',
+                         out_signature='s')
+    def get_description(self, name):
+        """Return the description of the named cruft.
+
+        :param name: The cruft name.
+        :type name: string
+        :return: The description of the cruft.
+        :rtype: string
+        """
+        cruft = self.collector.cruft_by_name.get(name, MISSING)
+        if cruft is MISSING:
+            log.error('get_description(): No such cruft: {0}'.format(name))
+            raise NoSuchCruftError(name)
+        return cruft.get_description()
+
+    @dbus.service.method(DBUS_INTERFACE_NAME,
+                         in_signature='s',
+                         out_signature='s')
+    def get_shortname(self, name):
+        """Return the short name of the named cruft.
+
+        :param name: The cruft name.
+        :type name: string
+        :return: The short nameof the cruft.
+        :rtype: string
+        """
+        cruft = self.collector.cruft_by_name.get(name, MISSING)
+        if cruft is MISSING:
+            log.error('get_shortname(): No such cruft: {0}'.format(name))
+            raise NoSuchCruftError(name)
+        return cruft.get_shortname()
+
+    @dbus.service.method(DBUS_INTERFACE_NAME,
+                         in_signature='s',
+                         out_signature='st')
+    def get_details(self, name):
+        """Return some extra details about the named cruft.
+
+        :param name: The cruft name.
+        :type name: string
+        :return: Some extra details about the named cruft, specifically its
+            'type' and the amount of disk space it consumes.  The type is
+            simply the name of the cruft instance's class.
+        :rtype: string, uint64
+        """
+        cruft = self.collector.cruft_by_name.get(name, MISSING)
+        if cruft is MISSING:
+            log.error('get_shortname(): No such cruft: {0}'.format(name))
+            raise NoSuchCruftError(name)
+        return cruft.__class__.__name__, cruft.get_disk_usage()
+
+    @dbus.service.method(DBUS_INTERFACE_NAME,
+                         in_signature='as', # array of strings
+                         # Must wrap these in str() because Python < 2.6.5
+                         # does not like unicode keyword arguments.
+                         sender_keyword=str('sender'),
+                         connection_keyword=str('connection'))
+    def clean(self, names, sender=None, connection=None):
+        """Clean the named crufts.
+
+        :param names: The names of the cruft to clean.
+        :type names: list of strings
+        """
+        self._authenticate(sender, connection)
+        self.collector.clean(names, self.dry_run)
+
+    @dbus.service.signal(DBUS_INTERFACE_NAME,
+                         signature='s')
+    def cleanup_status(self, cruft):
+        """Signal cleanup status.
+
+        This signal is used to incrementally inform clients that some cleanup
+        work is being done.  It is called at the beginning of the cleanup
+        process and after each plugin has completed its `post_cleanup()`
+        method.
+
+        :param done: The name of the next piece of cruft to be cleaned up, or
+            the empty string when there's nothing left to do.
+        :type done: string
+        """
+        log.debug('cleanup_status: {0}'.format(cruft))
 
=== added file 'computerjanitord/state.py'
--- computerjanitord/state.py	1970-01-01 00:00:00 +0000
+++ computerjanitord/state.py	2010-03-10 21:40:30 +0000
@@ -0,0 +1,92 @@
+# Copyright (C) 2008, 2009, 2010  Canonical, Ltd.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, version 3 of the License.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""Maintaining package ignored state."""
+
+from __future__ import absolute_import, unicode_literals
+
+__metaclass__ = type
+__all__ = [
+    'DEFAULT_STATE_FILE',
+    'State',
+    ]
+
+
+import ConfigParser
+import textwrap
+
+
+DEFAULT_STATE_FILE = '/var/lib/computer-janitor/state.dat'
+
+
+class State:
+    """Maintain the state of cruft which should be ignored.
+
+    The file's format is a `ConfigParser` style .ini file.  Each section is a
+    cruft's `.get_name()` value and contains a single boolean setting
+    `ignore`.  If true, then the cruft is ignored.
+
+    For backward compatibility purposes, the setting `enabled` is also
+    recognized (on read only).  If `enabled` is false then the cruft is
+    ignored.
+    """
+
+    def __init__(self):
+        self.ignore = set()
+
+    def load(self, filename):
+        """Load ignored state from a file.
+
+        This reset any previously determined state and re-initializes it with
+        the state stored in the file.
+
+        :param filename: The file to load.
+        :type filename: string
+        """
+        parser = ConfigParser.ConfigParser()
+        parser.read(filename)
+        # Reset the set of ignored packages.
+        self.ignore = set()
+        for cruft_name in parser.sections():
+            # For backwards compatibility, recognize both the 'ignore' setting
+            # and the 'enabled' setting.  We only write the former.
+            try:
+                ignore = parser.getboolean(cruft_name, 'ignore')
+            except ConfigParser.NoOptionError:
+                try:
+                    ignore = not parser.getboolean(cruft_name, 'enabled')
+                except ConfigParser.NoOptionError:
+                    # No other settings are recognized.
+                    ignore = False
+            if ignore:
+                self.ignore.add(cruft_name)
+
+    def save(self, filename):
+        """Save the ignored state to a file.
+
+        Only the packages being ignored are stored to the file, and writing
+        overwrites the previous contents of the file.
+        
+        :param filename: The file to load.
+        :type filename: string
+        """
+        # It's easier just to write the .ini file directly instead of using
+        # the ConfigParser interface.  This way we can guarantee sort order
+        # and can automatically cull unignored packages from the file.
+        with open(filename, 'w') as fp:
+            for cruft_name in self.ignore:
+                print >> fp, textwrap.dedent("""\
+                [{0}]
+                ignore: true
+                """.format(cruft_name))
 
=== added directory 'computerjanitord/tests'
=== added file 'computerjanitord/tests/__init__.py'
=== added directory 'computerjanitord/tests/data'
=== added file 'computerjanitord/tests/data/empty'
=== added directory 'computerjanitord/tests/data/etc'
=== added directory 'computerjanitord/tests/data/etc/apt'
=== added file 'computerjanitord/tests/data/etc/apt/sources.list'
--- computerjanitord/tests/data/etc/apt/sources.list	1970-01-01 00:00:00 +0000
+++ computerjanitord/tests/data/etc/apt/sources.list	2010-03-10 21:40:30 +0000
@@ -0,0 +1,1 @@
+deb http://archive.ubuntu.com/ubuntu intrepid main restricted
 
=== added directory 'computerjanitord/tests/data/var'
=== added directory 'computerjanitord/tests/data/var/cache'
=== added directory 'computerjanitord/tests/data/var/cache/apt'
=== added directory 'computerjanitord/tests/data/var/cache/apt/archives'
=== added directory 'computerjanitord/tests/data/var/cache/apt/archives/partial'
=== added directory 'computerjanitord/tests/data/var/lib'
=== added directory 'computerjanitord/tests/data/var/lib/apt'
=== added directory 'computerjanitord/tests/data/var/lib/apt/lists'
=== added file 'computerjanitord/tests/data/var/lib/apt/lists/archive.ubuntu.com_ubuntu_dists_intrepid_restricted_binary-i386_Packages'
--- computerjanitord/tests/data/var/lib/apt/lists/archive.ubuntu.com_ubuntu_dists_intrepid_restricted_binary-i386_Packages	1970-01-01 00:00:00 +0000
+++ computerjanitord/tests/data/var/lib/apt/lists/archive.ubuntu.com_ubuntu_dists_intrepid_restricted_binary-i386_Packages	2010-03-10 21:40:30 +0000
@@ -0,0 +1,54 @@
+Package: dash
+Priority: required
+Section: shells
+Installed-Size: 236
+Maintainer: Ubuntu Core Developers <[e-mail]>
+Original-Maintainer: Gerrit Pape <[e-mail]>
+Architecture: all
+Version: 0.5.5.1-3ubuntu1
+Depends: debianutils (>= 2.15), dpkg (>= 1.15.0)
+Pre-Depends: libc6 (>= 2.11~20100104-0ubuntu2)
+Filename: pool/main/d/dash/dash_0.5.5.1-3ubuntu1_all.deb
+Size: 104190
+MD5sum: a7f08fe3ee941d06c0d98e5e99c02190
+SHA1: d2dda78f9a6f82c58c01d34f18b94aebfcb33f19
+SHA256: 69709747f854ac1bd671dff37b47c18e589b095ecb8f3116beaed7fc0eeb657e
+Description: POSIX-compliant shell
+ The Debian Almquist Shell (dash) is a POSIX-compliant shell derived
+ from ash.
+ .
+ Since it executes scripts faster than bash, and has fewer library
+ dependencies (making it more robust against software or hardware
+ failures), it is used as the default system shell on Debian systems.
+Homepage: http://gondor.apana.org.au/~herbert/dash/
+Bugs: https://bugs.launchpad.net/ubuntu/+filebug
+Origin: Ubuntu
+Supported: 5y
+Task: minimal
+
+Package: gzip
+Essential: yes
+Priority: required
+Section: utils
+Installed-Size: 284
+Maintainer: Ubuntu Core Developers <[e-mail]>
+Original-Maintainer: Bdale Garbee <[e-mail]>
+Architecture: all
+Version: 1.3.12-9ubuntu1
+Pre-Depends: libc6 (>= 2.4)
+Suggests: less
+Filename: pool/main/g/gzip/gzip_1.3.12-9ubuntu1_all.deb
+Size: 107030
+MD5sum: f64beb93d2d1a3348cfc47f1fd176ee1
+SHA1: 3dd3e56f551fb85ba2ad385df463adeff1fff2d9
+SHA256: 2545f0a28514535006adf9ee8576ca3be2aa6da3d890047f92eeda18c0e3aa57
+Description: GNU compression utilities
+ This package provides the standard GNU file compression utilities, which
+ are also the default compression tools for Debian.  They typically operate
+ on files with names ending in '.gz', but can also decompress files ending
+ in '.Z' created with 'compress'.
+Bugs: https://bugs.launchpad.net/ubuntu/+filebug
+Origin: Ubuntu
+Supported: 5y
+Task: minimal
+
 
=== added directory 'computerjanitord/tests/data/var/lib/apt/lists/partial'
=== added directory 'computerjanitord/tests/data/var/lib/dpkg'
=== added file 'computerjanitord/tests/data/var/lib/dpkg/status'
--- computerjanitord/tests/data/var/lib/dpkg/status	1970-01-01 00:00:00 +0000
+++ computerjanitord/tests/data/var/lib/dpkg/status	2010-03-10 21:40:30 +0000
@@ -0,0 +1,28 @@
+Package: dash-nodownload
+Priority: required
+Section: shells
+Installed-Size: 236
+Maintainer: Ubuntu Core Developers <[e-mail]>
+Original-Maintainer: Gerrit Pape <[e-mail]>
+Architecture: all
+Version: 0.5.5.1-3ubuntu1
+Depends: debianutils (>= 2.15), dpkg (>= 1.15.0)
+Pre-Depends: libc6 (>= 2.11~20100104-0ubuntu2)
+Filename: pool/main/d/dash/dash_0.5.5.1-3ubuntu1_all.deb
+Size: 104190
+MD5sum: a7f08fe3ee941d06c0d98e5e99c02190
+SHA1: d2dda78f9a6f82c58c01d34f18b94aebfcb33f19
+SHA256: 69709747f854ac1bd671dff37b47c18e589b095ecb8f3116beaed7fc0eeb657e
+Description: POSIX-compliant shell
+ The Debian Almquist Shell (dash) is a POSIX-compliant shell derived
+ from ash.
+ .
+ Since it executes scripts faster than bash, and has fewer library
+ dependencies (making it more robust against software or hardware
+ failures), it is used as the default system shell on Debian systems.
+Homepage: http://gondor.apana.org.au/~herbert/dash/
+Bugs: https://bugs.launchpad.net/ubuntu/+filebug
+Origin: Ubuntu
+Supported: 5y
+Task: minimal
+
 
=== added file 'computerjanitord/tests/test_all.py'
--- computerjanitord/tests/test_all.py	1970-01-01 00:00:00 +0000
+++ computerjanitord/tests/test_all.py	2010-03-10 21:40:30 +0000
@@ -0,0 +1,41 @@
+# Copyright (C) 2008, 2009, 2010  Canonical, Ltd.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, version 3 of the License.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""Test suite for Computer Janitor daemon (dbus backend)."""
+
+from __future__ import absolute_import, unicode_literals
+
+__metaclass__ = type
+__all__ = [
+    'test_suite',
+    ]
+
+
+import unittest
+
+from computerjanitord.tests import test_application
+from computerjanitord.tests import test_authenticator
+from computerjanitord.tests import test_collector
+from computerjanitord.tests import test_state
+from computerjanitord.tests import test_whitelist
+
+
+def test_suite():
+    suite = unittest.TestSuite()
+    suite.addTests(test_application.test_suite())
+    suite.addTests(test_authenticator.test_suite())
+    suite.addTests(test_collector.test_suite())
+    suite.addTests(test_state.test_suite())
+    suite.addTests(test_whitelist.test_suite())
+    return suite
 
=== added file 'computerjanitord/tests/test_application.py'
--- computerjanitord/tests/test_application.py	1970-01-01 00:00:00 +0000
+++ computerjanitord/tests/test_application.py	2010-03-10 21:40:30 +0000
@@ -0,0 +1,106 @@
+# Copyright (C) 2008, 2009, 2010  Canonical, Ltd.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, version 3 of the License.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""Test the plugin application interfaces."""
+
+from __future__ import absolute_import, unicode_literals
+
+__metaclass__ = type
+__all__ = [
+    'ApplicationTestSetupMixin',
+    'test_suite',
+    ]
+
+
+import os
+import apt
+import apt_pkg
+import unittest
+import warnings
+import pkg_resources
+
+from contextlib import contextmanager
+
+import computerjanitor
+import computerjanitord.application
+
+from computerjanitord.application import (
+    Application, MissingLandmarkError, NonDownloadableError)
+
+
+@contextmanager
+def landmarks(*packages):
+    # Hack the module global list of known landmark packages.
+    old_landmarks = computerjanitord.application.LANDMARK_PACKAGES[:]
+    computerjanitord.application.LANDMARK_PACKAGES[:] = packages
+    yield
+    computerjanitord.application.LANDMARK_PACKAGES[:] = old_landmarks
+
+
+class MockCruft:
+    def __init__(self, name):
+        self.name = name
+
+    def get_name(self):
+        warnings.warn('.get_name() is deprecated; use .name',
+                      DeprecationWarning)
+        return self.name
+
+
+class ApplicationTestSetupMixin:
+    """Set up an `Application` instance with test data in its apt_cache."""
+
+    def setUp(self):
+        self.data_dir = os.path.abspath(
+            pkg_resources.resource_filename('computerjanitord.tests', 'data'))
+        # Make the test insensitive to the platform's architecture.
+        apt_pkg.Config.Set('APT::Architecture', 'i386')
+        self.cache = apt.Cache(rootdir=self.data_dir)
+        self.app = Application(self.cache)
+
+    def tearDown(self):
+        # Clear the cache.
+        cache_dir = os.path.join(self.data_dir, 'var', 'cache', 'apt')
+        for filename in os.listdir(cache_dir):
+            if filename.endswith('.bin'):
+                os.remove(os.path.join(cache_dir, filename))
+
+
+class TestApplication(unittest.TestCase, ApplicationTestSetupMixin):
+    """Test the `Application` interface."""
+
+    def setUp(self):
+        ApplicationTestSetupMixin.setUp(self)
+
+    def tearDown(self):
+        ApplicationTestSetupMixin.tearDown(self)
+
+    def test_verify_apt_cache_good_path(self):
+        # All essential packages are in the cache by default.
+        self.assertEqual(self.app.verify_apt_cache(), None)
+
+    def test_verify_apt_cache_with_nondownloadable_landmark(self):
+        # Test that a missing landmark file causes an exception.
+        with landmarks('gzip', 'dash-nodownload'):
+            self.assertRaises(NonDownloadableError, self.app.verify_apt_cache)
+
+    def test_verify_apt_cache_with_missing_landmark(self):
+        with landmarks('gzip', 'dash', 'i-am-not-here'):
+            self.assertRaises(MissingLandmarkError, self.app.verify_apt_cache)
+
+
+def test_suite():
+    suite = unittest.TestSuite()
+    suite.addTests(unittest.makeSuite(TestApplication))
+    return suite
 
=== added file 'computerjanitord/tests/test_authenticator.py'
--- computerjanitord/tests/test_authenticator.py	1970-01-01 00:00:00 +0000
+++ computerjanitord/tests/test_authenticator.py	2010-03-10 21:40:30 +0000
@@ -0,0 +1,97 @@
+# Copyright (C) 2008, 2009, 2010  Canonical, Ltd.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, version 3 of the License.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""Test the authenticator."""
+
+import unittest
+
+from computerjanitord.authenticator import Authenticator
+
+SUCCESS_PID = 801
+FAILURE_PID = 999
+
+AUTHENTICATED_USER = 'desktop-user'
+IMPOSTER_USER = 'imposter'
+EXPECTED_PRIVILEGE = 'com.ubuntu.computerjanitor.cleanpackages'
+BOGUS_PRIVILEGE = 'com.example.evil-corp.killsystem'
+
+
+class MockPolicyKit(object):
+    """Mock the PolicyKit's CheckAuthorization() method."""
+
+    def CheckAuthorization(self, subject, privilege, details, flags,
+                           cancellation_id):
+        """See `policykit.CheckAuthorization()`.
+
+        :return: (is_authorized, is_challenge, details)
+        """
+        if privilege == BOGUS_PRIVILEGE:
+            return False, False, ''
+        assert isinstance(subject, tuple) and len(subject) == 2, (
+            'subject is not a 2-tuple')
+        assert subject[0] == 'unix-process', 'Badly formed subject'
+        assert isinstance(subject[1], dict), 'Badly formed subject details'
+        assert subject[1]['start-time'] == 0, 'subject missing start-time'
+        if subject[1]['pid'] == SUCCESS_PID:
+            return True, False, ''
+        else:
+            return False, False, ''
+
+
+class TestableAuthenticator(Authenticator):
+    """See `Authenticator`."""
+
+    def _get_policykit_proxy(self):
+        """See `Authenticator`."""
+        return MockPolicyKit()
+
+    def _get_sender_pid(self, connection, sender):
+        """See `Authenticator`."""
+        if sender == AUTHENTICATED_USER:
+            return SUCCESS_PID
+        else:
+            return FAILURE_PID
+
+
+class TestAuthenticator(unittest.TestCase):
+    """Tests of the PolicyKit authenticator."""
+
+    def setUp(self):
+        """See `unittest.TestCase`."""
+        self.authenticator = TestableAuthenticator()
+        self.connection = object()
+
+    def tearDown(self):
+        """See `unittest.TestCase`."""
+
+    def test_good_path(self):
+        # Test for successful authentication.
+        self.assertTrue(self.authenticator.authenticate(
+            AUTHENTICATED_USER, self.connection, EXPECTED_PRIVILEGE))
+
+    def test_bogus_privilege(self):
+        # Test for bogus privilege fails.
+        self.assertFalse(self.authenticator.authenticate(
+            AUTHENTICATED_USER, self.connection, BOGUS_PRIVILEGE))
+
+    def test_unauthorized(self):
+        # Test for some imposter not being able to authenticate.
+        self.assertFalse(self.authenticator.authenticate(
+            IMPOSTER_USER, self.connection, EXPECTED_PRIVILEGE))
+
+
+def test_suite():
+    suite = unittest.TestSuite()
+    suite.addTests(unittest.makeSuite(TestAuthenticator))
+    return suite
 
=== added file 'computerjanitord/tests/test_collector.py'
--- computerjanitord/tests/test_collector.py	1970-01-01 00:00:00 +0000
+++ computerjanitord/tests/test_collector.py	2010-03-10 21:40:30 +0000
@@ -0,0 +1,187 @@
+# Copyright (C) 2008, 2009, 2010  Canonical, Ltd.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, version 3 of the License.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""Test the cruft collector."""
+
+from __future__ import absolute_import, unicode_literals
+
+__metaclass__ = type
+__all__ = [
+    'test_suite',
+    ]
+
+
+import os
+import shutil
+import tempfile
+import unittest
+
+from computerjanitor.plugin import Plugin
+from computerjanitord.collector import Collector
+from computerjanitord.errors import DuplicateCruftError
+from computerjanitord.tests.test_application import ApplicationTestSetupMixin
+
+
+class MockCruft:
+    """Mock cruft that supports the required `get_name()` interface."""
+
+    def __init__(self, name):
+        self.name = name
+
+    def get_name(self):
+        return self.name
+
+
+class MockPlugin(Plugin):
+    cruft_class = MockCruft
+
+    def __init__(self, prefix, shortnames):
+        super(MockPlugin, self).__init__()
+        self.prefix = prefix
+        self.shortnames = shortnames
+
+    def get_cruft(self):
+        for shortname in self.shortnames:
+            yield self.cruft_class('{0}:{1}'.format(self.prefix, shortname))
+
+
+class SawAppPlugin(Plugin):
+    """All this plugin does is set a marker attribute on the `Application`.
+
+    This proves that access to the application through the plugin works.
+    """
+    def get_cruft(self):
+        self.app.saw_app_plugin = True
+        return []
+
+
+class MockPluginManager:
+    def __init__(self, app, plugin_dirs):
+        self.app = app
+        # Ignore plugin_dirs
+
+    def get_plugins(self):
+        shortnames = ('one', 'two', 'three')
+        for prefix in ('foo', 'bar', 'baz'):
+            plugin = MockPlugin(prefix, shortnames)
+            plugin.set_application(self.app)
+            yield plugin
+        plugin = SawAppPlugin()
+        plugin.set_application(self.app)
+        yield plugin
+
+
+class MockCruftExtra(MockCruft):
+    """Cruft with a different class."""
+
+
+class MockPluginExtra(MockPlugin):
+    """A mock plugin that returns cruft with a different class."""
+
+    cruft_class = MockCruftExtra
+
+
+class IgnoredDuplicateCruftPluginManager(MockPluginManager):
+    """Add an additional piece of ignorable duplication cruft."""
+    
+    def __init__(self, app, plugin_dirs):
+        self.app = app
+        # Ignore plugin_dirs
+
+    def get_plugins(self):
+        yield MockPlugin('one', ('foo', 'bar'))
+        yield MockPlugin('one', ('baz', 'foo'))
+
+
+class BadDuplicateCruftPluginManager(MockPluginManager):
+    """Add an additional piece of bad duplicate cruft."""
+    def __init__(self, app, plugin_dirs):
+        self.app = app
+        # Ignore plugin_dirs
+
+    def get_plugins(self):
+        yield MockPlugin('one', ('foo', 'bar'))
+        yield MockPluginExtra('one', ('baz', 'foo'))
+
+
+class TestCollector(unittest.TestCase, ApplicationTestSetupMixin):
+    """Test the cruft collector."""
+
+    def setUp(self):
+        # Set up the test data Application.
+        ApplicationTestSetupMixin.setUp(self)
+        self.tempdir = tempfile.mkdtemp()
+        whitelist_dirs = (self.tempdir,)
+        with open(os.path.join(self.tempdir, 'one.whitelist'), 'w') as fp:
+            print >> fp, 'foo:two'
+            print >> fp, 'bar:one'
+            print >> fp, 'baz:three'
+        self.collector = Collector(self.app, MockPluginManager, whitelist_dirs)
+
+    def tearDown(self):
+        shutil.rmtree(self.tempdir)
+        ApplicationTestSetupMixin.tearDown(self)
+
+    def test_cruft_collector(self):
+        cruft_names = set(cruft.get_name() for cruft in self.collector.cruft)
+        self.assertEqual(cruft_names, set(('foo:one', 'foo:three',
+                                           'bar:two', 'bar:three',
+                                           'baz:one', 'baz:two')))
+
+    def test_plugin_needs_application(self):
+        # SawAppPlugin returned by the MockPluginManager sets this attribute
+        # on the Application.
+        self.assertTrue(self.app.saw_app_plugin)
+
+    def test_collector_name_mapping(self):
+        cruft_keys = set(self.collector.cruft_by_name)
+        cruft_names = set(cruft.get_name() for cruft in self.collector.cruft)
+        self.assertEqual(cruft_keys, cruft_names)
+
+
+class TestDuplicateCruftCollector(
+    unittest.TestCase, ApplicationTestSetupMixin):
+
+    def setUp(self):
+        # Set up the test data Application.
+        ApplicationTestSetupMixin.setUp(self)
+
+    def tearDown(self):
+        ApplicationTestSetupMixin.tearDown(self)
+
+    def test_duplicate_cruft_error(self):
+        self.assertRaises(DuplicateCruftError, Collector,
+                          self.app, BadDuplicateCruftPluginManager, [])
+
+    def test_duplicate_cruft_error_message(self):
+        try:
+            Collector(self.app, BadDuplicateCruftPluginManager, [])
+        except DuplicateCruftError as error:
+            self.assertEqual(
+                str(error),
+                'Duplicate cruft with different cleanup: one:foo')
+        else:
+            raise AssertionError('DuplicateCruftError expected')
+
+    def test_ignored_duplicate_cruft(self):
+        collector = Collector(self.app, IgnoredDuplicateCruftPluginManager, [])
+        self.assertEqual(list(cruft.get_name() for cruft in collector.cruft),
+                         ['one:foo', 'one:bar', 'one:baz'])
+
+
+def test_suite():
+    suite = unittest.TestSuite()
+    suite.addTests(unittest.makeSuite(TestCollector))
+    suite.addTests(unittest.makeSuite(TestDuplicateCruftCollector))
+    return suite
 
=== added file 'computerjanitord/tests/test_state.py'
--- computerjanitord/tests/test_state.py	1970-01-01 00:00:00 +0000
+++ computerjanitord/tests/test_state.py	2010-03-10 21:40:30 +0000
@@ -0,0 +1,141 @@
+# Copyright (C) 2008, 2009, 2010  Canonical, Ltd.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, version 3 of the License.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""Test the package state."""
+
+from __future__ import absolute_import, unicode_literals
+
+__metaclass__ = type
+__all__ = [
+    'test_suite',
+    ]
+
+
+import os
+import difflib
+import tempfile
+import textwrap
+import unittest
+
+from computerjanitord.state import State
+
+NL = '\n'
+
+
+class TestState(unittest.TestCase):
+    """Test the `State` class."""
+
+    def setUp(self):
+        self.state = State()
+        # Create a temporary file with some enabled and disabled packages.
+        fd, self._state_file = tempfile.mkstemp()
+        os.close(fd)
+        with open(self._state_file, 'w') as fp:
+            print >> fp, textwrap.dedent("""\
+            [deb:foo]
+            ignore: false
+            [deb:bar]
+            ignore: true
+            [deb:baz]
+            ignore: true
+            """)
+        fd, self._state_file_old = tempfile.mkstemp()
+        os.close(fd)
+        with open(self._state_file_old, 'w') as fp:
+            print >> fp, textwrap.dedent("""\
+            [deb:qux]
+            enabled: false
+            [deb:fno]
+            enabled: true
+            [deb:bla]
+            enabled: true
+            """)
+        fd, self._write_file = tempfile.mkstemp()
+        os.close(fd)
+
+    def tearDown(self):
+        os.remove(self._state_file)
+        os.remove(self._state_file_old)
+        os.remove(self._write_file)
+
+    def assertEqualNdiff(self, expected, got):
+        expected_lines = expected.splitlines()
+        got_lines = got.splitlines()
+        self.assertEqual(
+            expected, got,
+            '\n' + NL.join(difflib.ndiff(expected_lines, got_lines)))
+
+    def test_initially_no_previously_ignored(self):
+        self.assertEqual(self.state.ignore, set())
+
+    def test_load_state(self):
+        self.state.load(self._state_file)
+        self.assertEqual(self.state.ignore, set(('deb:bar', 'deb:baz')))
+
+    def test_backward_compatibility_file_format(self):
+        # Here, enabled:false means to ignore the package.
+        self.state.load(self._state_file_old)
+        self.assertEqual(self.state.ignore, set(('deb:qux',)))
+
+    def test_ignore(self):
+        self.state.ignore.add('deb:buz')
+        self.state.ignore.add('deb:baz')
+        self.assertEqual(self.state.ignore, set(('deb:buz', 'deb:baz')))
+
+    def test_more_ignores(self):
+        self.state.load(self._state_file)
+        self.state.ignore.add('deb:buz')
+        self.state.ignore.add('deb:baz')
+        self.assertEqual(self.state.ignore,
+                         set(('deb:bar', 'deb:buz', 'deb:baz')))
+
+    def test_unignore(self):
+        self.state.load(self._state_file)
+        self.state.ignore.remove('deb:bar')
+        self.assertEqual(self.state.ignore, set(('deb:baz',)))
+
+    def test_write(self):
+        self.state.load(self._state_file)
+        self.state.ignore.add('deb:buz')
+        self.state.ignore.remove('deb:baz')
+        self.state.save(self._write_file)
+        with open(self._write_file) as fp:
+            got = fp.read()
+        expected = textwrap.dedent("""\
+        [deb:bar]
+        ignore: true
+
+        [deb:buz]
+        ignore: true
+
+        """)
+        self.assertEqualNdiff(expected, got)
+
+    def test_write_new_format(self):
+        self.state.load(self._state_file_old)
+        self.state.save(self._write_file)
+        with open(self._write_file) as fp:
+            got = fp.read()
+        expected = textwrap.dedent("""\
+        [deb:qux]
+        ignore: true
+
+        """)
+        self.assertEqualNdiff(expected, got)
+
+
+def test_suite():
+    suite = unittest.TestSuite()
+    suite.addTests(unittest.makeSuite(TestState))
+    return suite
 
=== added file 'computerjanitord/tests/test_whitelist.py'
--- computerjanitord/tests/test_whitelist.py	1970-01-01 00:00:00 +0000
+++ computerjanitord/tests/test_whitelist.py	2010-03-10 21:40:30 +0000
@@ -0,0 +1,119 @@
+# Copyright (C) 2008, 2009, 2010  Canonical, Ltd.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, version 3 of the License.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""Test the whitelister."""
+
+from __future__ import absolute_import, unicode_literals
+
+__metaclass__ = type
+__all__ = [
+    'test_suite',
+    ]
+
+
+import os
+import shutil
+import tempfile
+import unittest
+
+from computerjanitord.whitelist import Whitelist
+
+
+class MockCruft:
+    """Mock cruft that supports the required `get_name()` interface."""
+
+    def __init__(self, shortname):
+        self.name = 'foo:' + shortname
+