def find_indices_by_href(self, query):
for item in self.all_items:
q = (item.href or '')
if item.fragment:
q += '#' + item.fragment
if primary_contains(query, q):
yield self.indexFromItem(item)
def do_filter(self, text):
text = unicode(text)
self.filtered_searches = []
for i, search in enumerate(self.searches):
if primary_contains(text, search['name']):
self.filtered_searches.append(i)
self.reset()
def filterAcceptsRow(self, row, parent):
if not self._filter_text:
return True
sm = self.sourceModel()
entry = sm.index_to_entry(sm.index(row, 0, parent))
if not isinstance(entry, CSSEntry):
return True
return primary_contains(self._filter_text, entry.rule.selector)
def do_filter(self, text):
text = unicode(text)
self.beginResetModel()
self.filtered_searches = []
for i, search in enumerate(self.searches):
if primary_contains(text, search['name']):
self.filtered_searches.append(i)
self.endResetModel()
def filterAcceptsRow(self, row, parent):
if not self._filter_text:
return True
sm = self.sourceModel()
for item in (sm.data(sm.index(row, c, parent)) or '' for c in xrange(sm.columnCount())):
if item and primary_contains(self._filter_text, item):
return True
return False
def find_items(self, query):
for item in self.all_items:
text = item.text()
if query and isinstance(query, str):
if text and isinstance(text, str) and primary_contains(
query, text):
yield item
else:
yield item
def display_filtered_categories(self, idx):
idx = idx if idx is not None else self.category_filter_box.currentIndex()
self.available_items_box.clear()
self.applied_items_box.clear()
item_filter = self.item_filter_box.text()
for item in self.all_items_sorted:
if idx == 0 or item.label == self.category_labels[idx]:
if item.index not in self.applied_items and item.exists:
if primary_contains(item_filter, item.name):
self.available_items_box.addItem(self.make_list_widget(item))
for index in self.applied_items:
self.applied_items_box.addItem(self.make_list_widget(self.all_items[index]))
def _match(query,
value,
matchkind,
use_primary_find_in_search=True,
case_sensitive=False):
if query.startswith('..'):
query = query[1:]
sq = query[1:]
internal_match_ok = True
else:
internal_match_ok = False
for t in value:
try: # ignore regexp exceptions, required because search-ahead tries before typing is finished
if not case_sensitive:
t = icu_lower(t)
if (matchkind == EQUALS_MATCH):
if internal_match_ok:
if query == t:
return True
comps = [c.strip() for c in t.split('.') if c.strip()]
for comp in comps:
if sq == comp:
return True
elif query[0] == '.':
if t.startswith(query[1:]):
ql = len(query) - 1
if (len(t) == ql) or (t[ql:ql + 1] == '.'):
return True
elif query == t:
return True
elif matchkind == REGEXP_MATCH:
if re.search(
query, t,
re.UNICODE if case_sensitive else re.I | re.UNICODE):
return True
elif matchkind == CONTAINS_MATCH:
if not case_sensitive and use_primary_find_in_search:
if primary_contains(query, t):
return True
elif query in t:
return True
except re.error:
pass
return False
def _match(query,
value,
matchkind,
use_primary_find_in_search=True,
case_sensitive=False):
if query.startswith('..'):
query = query[1:]
sq = query[1:]
internal_match_ok = True
else:
internal_match_ok = False
for t in value:
try: # ignore regexp exceptions, required because search-ahead tries before typing is finished
if not case_sensitive:
t = icu_lower(t)
if (matchkind == EQUALS_MATCH):
if internal_match_ok:
if query == t:
return True
return sq in [c.strip() for c in t.split('.') if c.strip()]
elif query[0] == '.':
if t.startswith(query[1:]):
ql = len(query) - 1
if (len(t) == ql) or (t[ql:ql + 1] == '.'):
return True
elif query == t:
return True
elif matchkind == REGEXP_MATCH:
flags = regex.UNICODE | regex.VERSION1 | regex.FULLCASE | (
0 if case_sensitive else regex.IGNORECASE)
if regex.search(query, t, flags) is not None:
return True
elif matchkind == ACCENT_MATCH:
if primary_contains(query, t):
return True
elif matchkind == CONTAINS_MATCH:
if not case_sensitive and use_primary_find_in_search:
if primary_no_punc_contains(query, t):
return True
elif query in t:
return True
except regex.error:
pass
return False
def test_find(self):
' Test searching for substrings '
self.ae((1, 1), icu.find(b'a', b'1ab'))
self.ae((1, 1 if sys.maxunicode >= 0x10ffff else 2), icu.find('\U0001f431', 'x\U0001f431x'))
self.ae((1 if sys.maxunicode >= 0x10ffff else 2, 1), icu.find('y', '\U0001f431y'))
self.ae((0, 4), icu.primary_find('pena', 'peña'))
for k, v in {u'pèché': u'peche', u'flüße':u'Flusse', u'Štepánek':u'ŠtepaneK'}.iteritems():
self.ae((1, len(k)), icu.primary_find(v, ' ' + k), 'Failed to find %s in %s' % (v, k))
self.assertTrue(icu.startswith(b'abc', b'ab'))
self.assertTrue(icu.startswith('abc', 'abc'))
self.assertFalse(icu.startswith('xyz', 'a'))
self.assertTrue(icu.startswith('xxx', ''))
self.assertTrue(icu.primary_startswith('pena', 'peña'))
self.assertTrue(icu.contains('\U0001f431', '\U0001f431'))
self.assertTrue(icu.contains('something', 'some other something else'))
self.assertTrue(icu.contains('', 'a'))
self.assertTrue(icu.contains('', ''))
self.assertFalse(icu.contains('xxx', 'xx'))
self.assertTrue(icu.primary_contains('pena', 'peña'))
def test_find(self):
" Test searching for substrings "
self.ae((1, 1), icu.find(b"a", b"1ab"))
self.ae((1, 1 if sys.maxunicode >= 0x10FFFF else 2), icu.find("\U0001f431", "x\U0001f431x"))
self.ae((1 if sys.maxunicode >= 0x10FFFF else 2, 1), icu.find("y", "\U0001f431y"))
self.ae((0, 4), icu.primary_find("pena", "peña"))
for k, v in {"pèché": "peche", "flüße": "Flusse", "Štepánek": "ŠtepaneK"}.iteritems():
self.ae((1, len(k)), icu.primary_find(v, " " + k), "Failed to find %s in %s" % (v, k))
self.assertTrue(icu.startswith(b"abc", b"ab"))
self.assertTrue(icu.startswith("abc", "abc"))
self.assertFalse(icu.startswith("xyz", "a"))
self.assertTrue(icu.startswith("xxx", ""))
self.assertTrue(icu.primary_startswith("pena", "peña"))
self.assertTrue(icu.contains("\U0001f431", "\U0001f431"))
self.assertTrue(icu.contains("something", "some other something else"))
self.assertTrue(icu.contains("", "a"))
self.assertTrue(icu.contains("", ""))
self.assertFalse(icu.contains("xxx", "xx"))
self.assertTrue(icu.primary_contains("pena", "peña"))
def test_find(self):
' Test searching for substrings '
self.ae((1, 1), icu.find(b'a', b'1ab'))
self.ae((1, 1 if sys.maxunicode >= 0x10ffff else 2), icu.find('\U0001f431', 'x\U0001f431x'))
self.ae((1 if sys.maxunicode >= 0x10ffff else 2, 1), icu.find('y', '\U0001f431y'))
self.ae((0, 4), icu.primary_find('pena', 'peña'))
for k, v in iteritems({u'pèché': u'peche', u'flüße':u'Flusse', u'Štepánek':u'ŠtepaneK'}):
self.ae((1, len(k)), icu.primary_find(v, ' ' + k), 'Failed to find %s in %s' % (v, k))
self.assertTrue(icu.startswith(b'abc', b'ab'))
self.assertTrue(icu.startswith('abc', 'abc'))
self.assertFalse(icu.startswith('xyz', 'a'))
self.assertTrue(icu.startswith('xxx', ''))
self.assertTrue(icu.primary_startswith('pena', 'peña'))
self.assertTrue(icu.contains('\U0001f431', '\U0001f431'))
self.assertTrue(icu.contains('something', 'some other something else'))
self.assertTrue(icu.contains('', 'a'))
self.assertTrue(icu.contains('', ''))
self.assertFalse(icu.contains('xxx', 'xx'))
self.assertTrue(icu.primary_contains('pena', 'peña'))
def _match(query, value, matchkind, use_primary_find_in_search=True, case_sensitive=False):
if query.startswith('..'):
query = query[1:]
sq = query[1:]
internal_match_ok = True
else:
internal_match_ok = False
for t in value:
try: # ignore regexp exceptions, required because search-ahead tries before typing is finished
if not case_sensitive:
t = icu_lower(t)
if (matchkind == EQUALS_MATCH):
if internal_match_ok:
if query == t:
return True
comps = [c.strip() for c in t.split('.') if c.strip()]
for comp in comps:
if sq == comp:
return True
elif query[0] == '.':
if t.startswith(query[1:]):
ql = len(query) - 1
if (len(t) == ql) or (t[ql:ql+1] == '.'):
return True
elif query == t:
return True
elif matchkind == REGEXP_MATCH:
if re.search(query, t, re.UNICODE if case_sensitive else re.I|re.UNICODE):
return True
elif matchkind == CONTAINS_MATCH:
if not case_sensitive and use_primary_find_in_search:
if primary_contains(query, t):
return True
elif query in t:
return True
except re.error:
pass
return False
def test_find(self):
' Test searching for substrings '
self.ae((1, 1), icu.find(b'a', b'1ab'))
self.ae((1, 1), icu.find('\U0001f431', 'x\U0001f431x'))
self.ae((1, 1), icu.find('y', '\U0001f431y'))
self.ae((0, 4), icu.primary_find('pena', 'peña'))
for k, v in iteritems({
'pèché': 'peche',
'flüße': 'Flusse',
'Štepánek': 'ŠtepaneK'
}):
self.ae((1, len(k)), icu.primary_find(v, ' ' + k),
f'Failed to find {v} in {k}')
self.assertTrue(icu.startswith(b'abc', b'ab'))
self.assertTrue(icu.startswith('abc', 'abc'))
self.assertFalse(icu.startswith('xyz', 'a'))
self.assertTrue(icu.startswith('xxx', ''))
self.assertTrue(icu.primary_startswith('pena', 'peña'))
self.assertTrue(icu.contains('\U0001f431', '\U0001f431'))
self.assertTrue(icu.contains('something', 'some other something else'))
self.assertTrue(icu.contains('', 'a'))
self.assertTrue(icu.contains('', ''))
self.assertFalse(icu.contains('xxx', 'xx'))
self.assertTrue(icu.primary_contains('pena', 'peña'))
def containsq(x, prefix):
return primary_contains(prefix, x)
def find_items(self, query):
for item in self.all_items:
if primary_contains(query, item.text()):
yield item
def find_items(self, query):
for item in self.all_items:
if primary_contains(query, item.text()):
yield item
def filter_tags(self, filter_value, which='available_tags'):
collection = getattr(self, which)
q = icu_lower(unicode_type(filter_value))
for i in range(collection.count()): # on every available tag
item = collection.item(i)
item.setHidden(bool(q and not primary_contains(q, unicode_type(item.text()))))
def find_items(self, query):
for item in self.all_items:
text = item.text()
if not query or (text and primary_contains(query, text)):
yield item
def case_insensitive_compare(self, l, r):
if prefs['use_primary_find_in_search']:
return primary_contains(l, r)
return contains(l.lower(), r.lower())
def filter(self, query):
query = unicode(query or '')
self.beginResetModel()
self.items = [x for x in self.names if primary_contains(query, x[0]) or primary_contains(query, x[1])]
self.endResetModel()
self.filtered.emit(not bool(query))
def filter_tags(self, filter_value, which='available_tags'):
collection = getattr(self, which)
q = icu_lower(unicode(filter_value))
for i in xrange(collection.count()): # on every available tag
item = collection.item(i)
item.setHidden(bool(q and not primary_contains(q, unicode(item.text()))))
def containsq(x, prefix):
return primary_contains(prefix, x)
def filter_item(self, x):
if self.show_only_misspelt and self.spell_map[x]:
return False
if self.filter_expression is not None and not primary_contains(self.filter_expression, x[0]):
return False
return True
