Commit before merge

src/calibre/gui2/dialogs/tag_categories.py

@@ -9,7 +9,7 @@ from PyQt4.QtGui import QDialog, QIcon, QListWidgetItem
 from calibre.gui2.dialogs.tag_categories_ui import Ui_TagCategories
 from calibre.gui2.dialogs.confirm_delete import confirm
 from calibre.constants import islinux
-from calibre.utils.icu import sort_key
+from calibre.utils.icu import sort_key, strcmp
 
 class Item:
     def __init__(self, name, label, index, icon, exists):
@@ -160,15 +160,17 @@ class TagCategories(QDialog, Ui_TagCategories):
         cat_name = unicode(self.input_box.text()).strip()
         if cat_name == '':
             return False
+        for c in self.categories:
+            if strcmp(c, cat_name) == 0:
+                cat_name = c
         if cat_name not in self.categories:
             self.category_box.clear()
             self.current_cat_name = cat_name
             self.categories[cat_name] = []
             self.applied_items = []
             self.populate_category_list()
-            self.category_box.setCurrentIndex(self.category_box.findText(cat_name))
+        self.input_box.clear()
-        else:
+        self.category_box.setCurrentIndex(self.category_box.findText(cat_name))
-            self.select_category(self.category_box.findText(cat_name))
         return True
 
     def del_category(self):
@@ -196,7 +198,6 @@ class TagCategories(QDialog, Ui_TagCategories):
 
     def accept(self):
         self.save_category()
-        self.db.prefs['user_categories'] = self.categories
         QDialog.accept(self)
 
     def save_category(self):

src/calibre/gui2/tag_view.py

@@ -1187,9 +1187,19 @@ class TagBrowserMixin(object): # {{{
                 self.do_user_categories_edit())
 
     def do_user_categories_edit(self, on_category=None):
-        d = TagCategories(self, self.library_view.model().db, on_category)
+        db = self.library_view.model().db
+        d = TagCategories(self, db, on_category)
         d.exec_()
         if d.result() == d.Accepted:
+            db.prefs.set('user_categories', d.categories)
+            st = db.field_metadata.get_search_terms()
+            for k in d.categories:
+                key = '@' + k
+                if key in st:
+                    continue
+                db.field_metadata.add_user_category(key, k)
+            db.data.sqp_initialize(db.field_metadata.get_search_terms(),
+                                        optimize=True)
             self.tags_view.set_new_model()
             self.tags_view.recount()
 

src/calibre/library/caches.py

@@ -197,15 +197,15 @@ class ResultCache(SearchQueryParser): # {{{
         self.first_sort = True
         self.search_restriction = ''
         self.field_metadata = field_metadata
-        self.all_search_locations = field_metadata.get_search_terms()
+        all_search_locations = field_metadata.get_search_terms()
-        SearchQueryParser.__init__(self, self.all_search_locations, optimize=True)
+        SearchQueryParser.__init__(self, all_search_locations, optimize=True)
         self.build_date_relop_dict()
         self.build_numeric_relop_dict()
 
     def break_cycles(self):
         self._data = self.field_metadata = self.FIELD_MAP = \
             self.numeric_search_relops = self.date_search_relops = \
-            self.all_search_locations = self.db_prefs = None
+            self.db_prefs = None
 
 
     def __getitem__(self, row):
@@ -424,11 +424,6 @@ class ResultCache(SearchQueryParser): # {{{
         if self.db_prefs is None:
             return  res
         user_cats = self.db_prefs.get('user_categories', [])
-        # translate the case of the location
-        for loc in user_cats:
-            if location == icu_lower(loc):
-                location = loc
-                break
         if location not in user_cats:
             return res
         c = set(candidates)

src/calibre/library/field_metadata.py

@@ -474,11 +474,10 @@ class FieldMetadata(dict):
         for key in list(self._tb_cats.keys()):
             val = self._tb_cats[key]
             if val['is_category'] and val['kind'] in ('user', 'search'):
+                for k in self._tb_cats[key]['search_terms']:
+                    if k in self._search_term_map:
+                        del self._search_term_map[k]
                 del self._tb_cats[key]
-                if key in self._search_term_map:
-                    del self._search_term_map[key]
-                if key in self._search_term_map:
-                    del self._search_term_map[key]
 
     def cc_series_index_column_for(self, key):
         return self._tb_cats[key]['rec_index'] + 1
@@ -486,12 +485,15 @@ class FieldMetadata(dict):
     def add_user_category(self, label, name):
         if label in self._tb_cats:
             raise ValueError('Duplicate user field [%s]'%(label))
+        st = [label]
+        if icu_lower(label) != label:
+            st.append(icu_lower(label))
         self._tb_cats[label] = {'table':None,          'column':None,
                                 'datatype':None,       'is_multiple':None,
                                 'kind':'user',         'name':name,
-                                'search_terms':[label],'is_custom':False,
+                                'search_terms':st,     'is_custom':False,
                                 'is_category':True}
-        self._add_search_terms_to_map(label, [label])
+        self._add_search_terms_to_map(label, st)
 
     def add_search_category(self, label, name):
         if label in self._tb_cats:
@@ -524,6 +526,7 @@ class FieldMetadata(dict):
         if terms is not None:
             for t in terms:
                 if t in self._search_term_map:
+                    print self._search_term_map
                     raise ValueError('Attempt to add duplicate search term "%s"'%t)
                 self._search_term_map[t] = key
 

src/calibre/utils/search_query_parser.py

@@ -119,6 +119,9 @@ class SearchQueryParser(object):
         return failed
 
     def __init__(self, locations, test=False, optimize=False):
+        self.sqp_initialize(locations, test=test, optimize=optimize)
+
+    def sqp_initialize(self, locations, test=False, optimize=False):
         self._tests_failed = False
         self.optimize = optimize
         # Define a token