cleanerbackend.py

BleachBit 删除了不必要的文件（例如缓存器

    def other_cleanup(self, really_delete):
        if self.options["clipboard"][1]:
            if really_delete:
                gtk.gdk.threads_enter()
                clipboard = gtk.clipboard_get()
                clipboard.set_text("")
                gtk.gdk.threads_leave()
                return (0, _("Clipboard"))
            return _("Clipboard")


    def whitelisted(self, pathname):
        """Return boolean whether file is whitelisted"""
        regexes = ['/tmp/pulse-[^/]+/pid',
            '/tmp/gconfd-[^/]+/lock/ior',
            '/tmp/orbit-[^/]+/bonobo-activation-register[a-z0-9-]*.lock',
            '/tmp/orbit-[^/]+/bonobo-activation-server-[a-z0-9-]*ior',
            '/tmp/.X0-lock' ]
        for regex in regexes:
            if None != re.match(regex, pathname):
                return True
        return False


class Java(Cleaner):
    """Delete the Java cache"""

    def get_description(self):
        return _("Delete Java's cache")

    def get_id(self):
        return 'java'

    def get_name(self):
        return "Java"

    def list_files(self):
        dirname = os.path.expanduser("~/.java/deployment/cache")
        for filename in children_in_directory(dirname, False):
            yield filename


class KDE(Cleaner):
    """KDE"""

    def __init__(self):
        Cleaner.__init__(self)
        self.add_option('cache', _('Cache'), _('KDE cache including Konqueror.  Often contains sparse files where the apparent file size does not match the actual disk usage.'))
        self.add_option('tmp', _('Temporary files'), _('Temporary files stored by KDE under the home directory'))

    def get_description(self):
        return _("KDE desktop environment")

    def get_id(self):
        return 'kde'

    def get_name(self):
        return "KDE"

    def list_files(self):
        # cache
        if self.options["cache"][1]:
            dirs = glob.glob(os.path.expanduser("~/.kde/cache-*/"))
            for dirname in dirs:
                for filename in children_in_directory(dirname, False):
                    yield filename
        # temporary
        if self.options["tmp"][1]:
            dirs = glob.glob(os.path.expanduser("~/.kde/tmp-*/"))
            for dirname in dirs:
                for path in children_in_directory(dirname, False):
                    yield path

class OpenOfficeOrg(Cleaner):
    """Delete OpenOffice.org cache"""

    def __init__(self):
        Cleaner.__init__(self)
        self.options = {}
        self.add_option('cache', _('Cache'), _('Cached registry and package data'))
        self.add_option('recent_documents', _('Recent documents list'), _("OpenOffice.org's list of recently used documents."))

        # reference: http://katana.oooninja.com/w/editions_of_openoffice.org
        self.prefixes = [ "~/.ooo-2.0", "~/.openoffice.org2", "~/.openoffice.org2.0", "~/.openoffice.org/3" ]
        self.prefixes += [ "~/.ooo-dev3" ]

    def get_description(self):
        return _("OpenOffice.org office suite")

    def get_id(self):
        return 'openofficeorg'

    def get_name(self):
        return "OpenOffice.org"

    def list_files(self):
        if self.options["recent_documents"][1] and not self.options["cache"][1]:
            for prefix in self.prefixes:
                path = os.path.join(os.path.expanduser(prefix), "user/registry/cache/org.openoffice.Office.Common.dat")
                if os.path.lexists(path):
                    yield path

        if not self.options["cache"][1]:
            return
        dirs = []
        for prefix in self.prefixes:
            dirs.append(os.path.join(os.path.expanduser(prefix), "user/uno_packages/cache/"))
            dirs.append(os.path.join(os.path.expanduser(prefix), "user/registry/cache/"))
        for dirname in dirs:
            for filename in children_in_directory(dirname, False):
                yield filename

    def erase_history(self, path):
        """Erase the history node (most recently used documents)"""
        dom1 = xml.dom.minidom.parse(path)
        for node in dom1.getElementsByTagName("node"):
            if node.hasAttribute("oor:name"):
                if "History" == node.getAttribute("oor:name"):
                    node.parentNode.removeChild(node)
                    node.unlink()
                    break
        dom1.writexml(open(path, "w"))

    def other_cleanup(self, really_delete = False):
        if not self.options["recent_documents"][1]:
            return
        for prefix in self.prefixes:
            path = os.path.join(os.path.expanduser(prefix), "user/registry/data/org/openoffice/Office/Common.xcu")
            if os.path.lexists(path):
                if really_delete:
                    oldsize = os.path.getsize(path)
                    self.erase_history(path)
                    newsize = os.path.getsize(path)
                    return (oldsize - newsize, path)
                else:
                    return path


class Opera(Cleaner):
    """Opera"""

    def __init__(self):
        Cleaner.__init__(self)
        self.add_option('cache', _('Cache'), _('Web cache reduces time to display revisited pages'))
        self.add_option('cookies', _('Cookies'), _('HTTP cookies contain information such as web site prefereneces, authentication, and tracking identification'))
        self.profile_dir = "~/.opera/"

    def get_description(self):
        return _("Opera web browser")

    def get_id(self):
        return 'opera'

    def get_name(self):
        return "Opera"

    def list_files(self):
        # browser cache
        if self.options["cache"][1]:
            dirs = [ os.path.expanduser(self.profile_dir + "cache4/"), \
                os.path.expanduser(self.profile_dir + "opcache/") ]
            for dirname in dirs:
                for filename in children_in_directory(dirname, False):
                    yield filename
 
        files = []

        # cookies
        if self.options["cookies"][1]:
            files += [os.path.expanduser(self.profile_dir + "cookies4.dat")]

        for path in files:
            if os.path.lexists(path):
                yield path


class realplayer(Cleaner):
    """RealPlayer by RealNetworks"""

    def get_description(self):
        return _("Delete RealPlayer's cookies")

    def get_id(self):
        return 'realplayer'

    def get_name(self):
        return "RealPlayer"

    def list_files(self):
        path = os.path.expanduser("~/.config/real/rpcookies.txt")
        if os.path.lexists(path):
            yield path



class rpmbuild(Cleaner):
    """Delete the rpmbuild build directory"""

    def get_description(self):
        return _("Delete the files in the rpmbuild build directory")

    def get_id(self):
        return 'rpmbuild'

    def get_name(self):
        return "rpmbuild"

    def list_files(self):
        dirnames = set([ os.path.expanduser("~/rpmbuild/BUILD/") ])
        try:
            args = ["rpm", "--eval", "%_topdir"]
            dirname = subprocess.Popen(args, stdout=subprocess.PIPE).\
                communicate()[0]
        except:
            print "warning: exception '%s' running '%s'" % \
                (str(sys.exc_info()[1]), " ".join(args))
        else:
            dirnames.add(dirname + "/BUILD")
        for dirname in dirnames:
            for filename in children_in_directory(dirname, True):
                yield filename


class Thumbnails(Cleaner):
    """Delete the thumbnails folder"""

    def get_description(self):
        return _("Delete thumbnails in the thumbnails folder")

    def get_id(self):
        return 'thumbnails'

    def get_name(self):
        return _("Thumbnails")

    def list_files(self):
        dirname = os.path.expanduser("~/.thumbnails")
        for filename in children_in_directory(dirname, False):
            yield filename


class VIM(Cleaner):
    """VIM (Vi IMproved)"""

    def get_description(self):
        return _("Delete ~/.viminfo which includes VIM file history, command history, and buffers")

    def get_id(self):
        return 'vim'

    def get_name(self):
        return "VIM"

    def list_files(self):
        path = os.path.expanduser("~/.viminfo")
        if os.path.lexists(path):
            yield path


class XChat(Cleaner):
    """Delete XChat logs and scrollback"""

    def available(self):
        return True

    def get_id(self):
        return 'xchat'

    def get_description(self):
        return _("Delete XChat logs and scrollback")

    def get_name(self):
        return "XChat"

    def list_files(self):
        dirs = [ "~/.xchat2/scrollback/" ]
        dirs += [ "~/.xchat2/logs/" ] # Seen before XChat version 2.8.6
        dirs += [ "~/.xchat2/xchatlogs" ] # Seen first in XChat version 2.8.6
        for dirname in dirs:
            dirname = os.path.expanduser(dirname)
            for filename in children_in_directory(dirname, False):
                yield filename

backends = {}
backends["bash"] = Bash()
backends["beagle"] = Beagle()
backends["epiphany"] = Epiphany()
backends["firefox"] = Firefox()
backends["flash"] = Flash()
backends["java"] = Java()
backends["kde"] = KDE()
backends["openofficeorg"] = OpenOfficeOrg()
backends["opera"] = Opera()
backends["realplayer"] = realplayer()
backends["rpmbuild"] = rpmbuild()
backends["system"] = System()
backends["thumbnails"] = Thumbnails()
backends["vim"] = VIM()
backends["xchat"] = XChat()


import unittest

class TestUtilities(unittest.TestCase):
    def test_get_name(self):
        for key in sorted(backends):
            for name in backends[key].get_name():
                self.assert_ (type(name) is str)

    def test_get_descrption(self):
        for key in sorted(backends):
            for desc in backends[key].get_description():
                self.assert_ (type(desc) is str)

    def test_get_options(self):
        for key in sorted(backends):
            for (test_id, name, value) in backends[key].get_options():
                self.assert_ (type(test_id) is str)
                self.assert_ (type(name) is str)
                self.assert_ (type(value) is bool)

    def test_list_files(self):
        for key in sorted(backends):
            print "debug: test_list_files: key='%s'" % (key, )
            for (cleaner_id, __name, __value) in backends[key].get_options():
                backends[key].set_option(cleaner_id, True)
            for filename in backends[key].list_files():
                self.assert_ (type(filename) is str)
                self.assert_ (os.path.lexists(filename), \
                    "In backend '%s' path does not exist: '%s' \
                    " % (key, filename))

    def test_other_cleanup(self):
        """Test the method other_cleanup()"""
        for key in sorted(backends):
            for (cleaner_id, __name, __value) in backends[key].get_options():
                backends[key].set_option(cleaner_id, True)
            description = backends[key].other_cleanup(False)
            self.assert_ (None == description or type(description) is str)

    def test_whitelist(self):
        tests = [ \
            ('/tmp/gconfd-z/lock/ior', True), \
            ('/tmp/orbit-z/bonobo-activation-server-ior', True), \
            ('/tmp/orbit-z/bonobo-activation-register.lock', True), \
            ('/tmp/orbit-foo/bonobo-activation-server-a9cd6cc4973af098918b154c4957a93f-ior', True), \
            ('/tmp/orbit-foo/bonobo-activation-register-a9cd6cc4973af098918b154c4957a93f.lock', True), \
            ('/tmp/pulse-foo/pid', True), \
            ('/tmp/tmpsDOBFd', False) \
            ]
        for test in tests:
            self.assertEqual(backends['system'].whitelisted(test[0]), test[1], test[0])

if __name__ == '__main__':
    unittest.main()