Make SearchItems a class hierarchy and an object tree

First support of menu items and comps groups

1 files changed, 136 insertions, 60 deletions

diff --git a/gui.py b/gui.py
index 6a5ed86..9fefecd 100755
--- a/gui.py
+++ b/gui.py
@@ -9,33 +9,62 @@ import yum
 import yum.comps
 from utils import YumUtilBase
 import cPickle as pickle
+
+class GenericItem(object):
+    def __init__(self, ui_name):
+        self.ui_name = ui_name
+        self.children = []
+
+    def append(self, child):
+        self.children.append(child)
     
-class SearchItem:
+    def isEmpty(self):
+        return False
+
+class GenericSearchItem(GenericItem):
 
-    def __init__(self, pattern, result, _type="search"):
+    def __init__(self, pattern, result):
+        GenericItem.__init__(self, pattern)
         self.pattern = pattern
         self.result = result
-        self.type = _type
 
     def __str__(self):
         return "<%s %s>(%s)" % (self.__class__.__name__,
                                 self.type, self.pattern)
 
+class SearchItem(GenericSearchItem):
+    pass
+
+class RepositoryItem(GenericSearchItem):
+    pass
+
+class PackageTagItem(GenericSearchItem):
+    pass
+
+class MenuEntryItem(GenericItem):
+    pass
+
+class MenuTagItem(PackageTagItem):
+    pass
+
+class CompsCategoryItem(GenericItem):
+    pass
+
+class CompsGroupItem(GenericSearchItem):
+    pass
+
 class PackagesUI:
 
     def __init__(self):
         self.yum = YumUtilBase("", "", "")
-        self.yum.setCacheDir()
+        #self.yum.setCacheDir()
+        self.yum.conf.cache = 1
 
-        self.searchItems = {
-            "search" : [],
-            "tag" : [],
-            "menu" : [],
-            "group" : []
-            }
+        self.searchItems = GenericItem("Invisible Toplevel")
+        self.searchItem = GenericItem("Searches")
+        self.searchItems.append(self.searchItem)
 
         self.activeSearchItems = []
-        self.treeItems = {}
 
         self.mainwindow = m = uic.loadUi("packages.ui")
 
@@ -62,12 +91,28 @@ class PackagesUI:
         self.packageDescription = m.findChild(QtGui.QTextBrowser, "packageDescription")
         self.packageProperties = m.findChild(QtGui.QTextBrowser, "packageProperties")
 
-        self.allPkgs = set(self.yum.pkgSack.returnPackages())
+        pkglists = self.yum.doPackageLists("available", showdups=0)
+        self.allPkgs = set(pkglists.available)
+        #self.allPkgs.update(pkglists.installed)
         self.result = self.allPkgs.copy()
         self.allPackagesByName = dict(((p.name, p) for p in self.allPkgs))
 
-        # tags
+        #self._getPackageTags()
+        self._getMenuTags()
+        self._getMenuEntries()
+        self._getCompsGroups()
+        self._getRepositories()
+
+        self.fillTags()
+
+        self.mainwindow.show()
+
+
+    def _getPackageTags(self):
+        item = GenericItem("PackageDB Tags")
+        self.searchItems.append(item)
         self.tag2pkgs = {}
+
         for name, tags in self.yum.pkgtags.search_tags('').iteritems():
             if name not in self.allPackagesByName: continue
             for tag in tags:
@@ -75,29 +120,57 @@ class PackagesUI:
         for tag, pkgs in self.tag2pkgs.iteritems():
             if len(pkgs) <= 1: # or tag.startswith("X-"):
                 continue
-            self.searchItems["tag"].append(SearchItem(tag, pkgs, "tag"))
+            item.append(PackageTagItem(tag, pkgs))
+
+    def _getMenuTags(self):
+        item = GenericItem("Menu Tags")
+        self.searchItems.append(item)
 
-        # menu tags
-        self.menu2packages = pickle.load(open("categories.pickle"))
+        self.menutag2packages = pickle.load(open("categories.pickle"))
 
-        for name, pkgnames in self.menu2packages.iteritems():
+        for name, pkgnames in self.menutag2packages.iteritems():
             pkgs = self._names2pkgs(pkgnames)
             if len(pkgs) <= 1:
                 continue
-            self.searchItems["menu"].append(SearchItem(name, pkgs, "menu"))
+            item.append(MenuTagItem(name, pkgs))
+
+    def _getMenuEntries(self):
+        item = GenericItem("Menu Entries")
+        self.searchItems.append(item)
+
+        self.menu2packages = pickle.load(open("menu2packages.pickle"))
+
+        for name, pkgnames in self.menutag2packages.iteritems():
+            pkgs = self._names2pkgs(pkgnames)
+            if len(pkgs) <= 1:
+                continue
+            item.append(MenuTagItem(name, pkgs))
+
+    def _getCompsGroups(self):
+        item = GenericItem("Comps Groups")
+        self.searchItems.append(item)
+
+        self.categories = {}
+        for cat in self.yum.comps.get_categories():
+            self.categories[cat.ui_name] = []
 
-        # groups
         for group in self.yum.comps.groups:
             pkgs = self._names2pkgs(group.packages)
             if not group.user_visible or not pkgs:
                 continue
-            self.searchItems["group"].append(
-                SearchItem(group.name, pkgs, "group"))
+            item.append(SearchItem(group.name, pkgs))
 
-        
-        self.fillTags()
+    def _getRepositories(self):
+        item = GenericItem("Repositories")
+        self.searchItems.append(item)
 
-        self.mainwindow.show()
+        repos = {}
+        for pkg in self.allPkgs:
+            repos.setdefault(pkg.repo,set()).add(pkg)
+        for repo, pkgs in repos.iteritems():
+            item.append(RepositoryItem(repo.name, pkgs))
+
+    #########################################################
 
     def _names2pkgs(self, pkgnames):
             pkgs = set((self.allPackagesByName.get(name) for
@@ -115,7 +188,7 @@ class PackagesUI:
             l = l[:1000]
             pkgs = set((p for n, p in l))
         for pkg in pkgs:
-            item = QtGui.QListWidgetItem("%s\n\t%s" % (pkg.summary, pkg.name),
+            item = QtGui.QListWidgetItem("%s\n\t%s" % (pkg.summary, pkg.ui_nevra),
                                          self.resultList, 0)
             item.setData(1000, pkg)
         self.resultList.sortItems(0)
@@ -133,19 +206,19 @@ class PackagesUI:
 
     def search(self):
         pattern = str(self.searchBox.text())
-        for item in self.searchItems["search"]:
+        for item in self.searchItem.children:
             if item.pattern == pattern:
                 self._addActiveSearchItem(item)
                 return
         
-        # XXX do a real search!
+        # XXX allow different searches via combobox
         searchlist = ['name', 'summary', 'description', 'url']
         result = set(self.yum.searchPackages(searchlist, [pattern], False))
         l = len(result)
-        item = SearchItem(pattern, result, 'search')
-        self.searchItems["search"].append(item)
+        item = SearchItem(pattern, result)
+        self.searchItem.append(item)
         treeitem = QtGui.QTreeWidgetItem(
-            self.treeItems["search"], [pattern, "%i/%i" % (l, l), "%8i" % l], 0)
+            self.searchItem.treeItem, [pattern, "%i/%i" % (l, l), "%8i" % l], 0)
         item.treeItem = treeitem
         treeitem.setData(3, 0, item)
 
@@ -179,49 +252,52 @@ class PackagesUI:
 
     def currentSearchItemChanged(self, current, previous):
         searchItem = current.data(3, 0).toPyObject()
-        if searchItem:
+        if searchItem and isinstance(searchItem, GenericSearchItem):
             self.fillResults(searchItem.result & self.result)
         else:
             self.fillResults(self.result)
 
     def fillTags(self):
-        for _type, name in (("search", "Searches"),
-                            ("tag", "Package Tags"),
-                            ("menu", "Application Menu"),
-                            ("group", "Groups")):
-            if self.result:
-                items = [(len(item.result & self.result), item.pattern, len(item.result), item)
-                         for item in self.searchItems[_type]]
-            else:
-                items = [(len(item.result), item.pattern, len(item.result), item)
-                         for item in self.searchItems[_type]]
+        for child in self.searchItems.children:
+            self._addSearchItem(child, self.tagList)
+        self.tagList.sortItems(2, 1)
 
-            items.sort(reverse=True)
+    def _addSearchItem(self, item, parent):
+        if item.isEmpty():
+            return
 
-            parent = QtGui.QTreeWidgetItem(self.tagList, [name], 0)
-            parent.setExpanded(True)
+        if isinstance(item, GenericSearchItem):
+            hits = len(item.result)
+            treeitem = QtGui.QTreeWidgetItem(
+                parent, [item.ui_name, "%i/%i" % (hits, hits), "%8i" % hits], 0)            
+        else:
+            treeitem = QtGui.QTreeWidgetItem(parent, [item.ui_name], 0)
+            treeitem.setExpanded(True)
 
-            self.treeItems[_type] = parent
+        item.treeItem = treeitem
+        treeitem.setData(3, 0, item)
 
-            for hits, pattern, allhits, item in items:
-                treeitem = QtGui.QTreeWidgetItem(
-                    parent, [pattern, "%i/%i" % (hits, allhits), "%8i" % hits], 0)
-                item.treeItem = treeitem
-                treeitem.setData(3, 0, item)
+        for child in item.children:
+            self._addSearchItem(child, treeitem)
                 
     def updateSearchItems(self):
-        for t, l in self.searchItems.iteritems():
-            for item in l:
-                if self.result:
-                    r = len(item.result & self.result)
-                else:
-                    r = len(item.result)
-                item.treeItem.setData(1, 0, 
-                                      "%i/%i" % (r, len(item.result)))
-                item.treeItem.setData(2, 0, "%8i" % r)
-                item.treeItem.setHidden(r == 0 and t != "search")
+        self._updateSearchItem(self.searchItems)
         self.tagList.sortItems(2, 1)
 
+    def _updateSearchItem(self, item):
+        if isinstance(item, GenericSearchItem):
+            if self.result:
+                r = len(item.result & self.result)
+            else:
+                r = len(item.result)
+            item.treeItem.setData(1, 0,
+                                  "%i/%i" % (r, len(item.result)))
+            item.treeItem.setData(2, 0, "%8i" % r)
+            item.treeItem.setHidden(r == 0)
+
+        for child in item.children:
+            self._updateSearchItem(child)
+
     def packageSelected(self, current, previous):
         if not current: return
         pkg = current.data(1000).toPyObject()