Implement new search: support multiple words

Previously, a search would only return results with exact matches, that is if
the search string is a substring of the text in the window buffer.  With this
new edition, we support searching for multiple words. A result would only be
shown if *all* of those words appear at least once in the text.

Author: RJ722

rednotebook/data.py

@@ -178,14 +178,14 @@ def get_words(self, with_special_chars=False):
     def get_number_of_words(self):
         return len(self.get_words(with_special_chars=True))
 
-    def search(self, text, tags):
+    def search(self, queries, tags):
         """
         This method is only called for days that have all given tags.
         Search in date first, then in the text, then in the tags.
         Uses case-insensitive search.
         """
         results = []
-        if not text:
+        if not queries:
             # Only add text result once for all tags.
             add_text_to_results = False
             for day_tag, entries in self.get_category_content_pairs().items():
@@ -200,41 +200,46 @@ def search(self, text, tags):
                         add_text_to_results = True
             if add_text_to_results:
                 results.append(get_text_with_dots(self.text, 0, TEXT_RESULT_LENGTH))
-        elif text in str(self):
-            # Date contains searched text.
+        elif any(text in str(self) for text in queries):
+            # Any of the query matches with the date.
             results.append(get_text_with_dots(self.text, 0, TEXT_RESULT_LENGTH))
         else:
-            text_result = self.search_in_text(text)
+            text_result = self.search_in_text(queries)
             if text_result:
                 results.append(text_result)
-            results.extend(self.search_in_categories(text))
+            results.extend(self.search_in_categories(queries))
         return str(self), results
 
-    def search_in_text(self, search_text):
-        occurence = self.text.upper().find(search_text.upper())
-
-        # Check if search_text is in text
-        if occurence < 0:
-            return None
-
-        found_text = self.text[occurence : occurence + len(search_text)]
-        result_text = get_text_with_dots(
-            self.text, occurence, occurence + len(search_text), found_text
+    def search_in_text(self, queries):
+        """All queries should be present in the text"""
+        matches = {}
+        for query in queries:
+            occurrence = self.text.upper().find(query.upper())
+            if occurrence < 0:
+                return
+            matches[query] = occurrence
+
+        first_query = min(matches, key=matches.get)
+        first_occurrence = matches[first_query]
+
+        found_text = self.text[first_occurrence : first_occurrence + len(first_query)]
+        return get_text_with_dots(
+            self.text, first_occurrence, first_occurrence + len(first_query), found_text
         )
-        return result_text
 
-    def search_in_categories(self, text):
+    def search_in_categories(self, queries):
         results = []
-        for category, content in self.get_category_content_pairs().items():
-            if content:
-                if text.upper() in category.upper():
-                    results.extend(content)
-                else:
-                    results.extend(
-                        entry for entry in content if text.upper() in entry.upper()
-                    )
-            elif text.upper() in category.upper():
-                results.append(category)
+        for query in queries:
+            for category, content in self.get_category_content_pairs().items():
+                if content:
+                    if query.upper() in category.upper():
+                        results.extend(content)
+                    else:
+                        results.extend(
+                            entry for entry in content if query.upper() in entry.upper()
+                        )
+                elif query.upper() in category.upper():
+                    results.append(category)
         return results
 
     def __str__(self):

rednotebook/gui/browser.py

@@ -65,12 +65,13 @@ def set_font_size(self, size):
             zoom *= 0.90
             self.set_zoom_level(zoom)
 
-        def highlight(self, search_text):
+        def highlight(self, search_queries):
             # Tell the webview which text to highlight after the html is loaded
-            self.search_text = search_text
-            self.get_find_controller().search(
-                self.search_text, WebKit2.FindOptions.CASE_INSENSITIVE, MAX_HITS
-            )
+            self.search_queries = search_queries
+            for query in search_queries:
+                self.get_find_controller().search(
+                    query, WebKit2.FindOptions.CASE_INSENSITIVE, MAX_HITS
+                )
 
         def on_load_changed(self, webview, event):
             """
@@ -82,7 +83,7 @@ def on_load_changed(self, webview, event):
             does not work.
             """
             if event == WebKit2.LoadEvent.FINISHED:
-                if self.search_text:
-                    self.highlight(self.search_text)
+                if self.search_queries:
+                    self.highlight(self.search_queries)
                 else:
                     webview.get_find_controller().search_finish()

rednotebook/gui/editor.py

@@ -121,8 +121,8 @@ def replace_selection_and_highlight(self, p1, p2, p3):
         end.backward_chars(len(p3))
         self.day_text_buffer.select_range(start, end)
 
-    def highlight(self, text):
-        self.search_text = text
+    def highlight(self, queries):
+        self.search_queries = queries
         buf = self.day_text_buffer
 
         # Clear previous highlighting
@@ -131,8 +131,8 @@ def highlight(self, text):
         buf.remove_tag_by_name("highlighter", start, end)
 
         # Highlight matches
-        if text:
-            for match_start, match_end in self.iter_search_matches(text):
+        for query in enumerate(queries):
+            for match_start, match_end in self.iter_search_matches(query):
                 buf.apply_tag_by_name("highlighter", match_start, match_end)
 
     search_flags = (

rednotebook/gui/main_window.py

@@ -169,7 +169,7 @@ def show_day(self, new_day):
                     )
                     self.load_html(html)
 
-                def highlight(self, text):
+                def highlight(self, queries):
                     pass
 
             self.html_editor = Preview(self.journal)
@@ -724,9 +724,9 @@ def set_date(self, new_month, new_date, day):
     def get_day_text(self):
         return self.day_text_field.get_text()
 
-    def highlight_text(self, search_text):
-        self.html_editor.highlight(search_text)
-        self.day_text_field.highlight(search_text)
+    def highlight_text(self, search_queries):
+        self.html_editor.highlight(search_queries)
+        self.day_text_field.highlight(search_queries)
 
     def show_message(self, title, msg, msg_type):
         if msg_type == Gtk.MessageType.ERROR:

rednotebook/gui/search.py

@@ -60,18 +60,21 @@ def search(self, search_text):
             else:
                 queries.append(part)
 
-        search_text = " ".join(queries)
-
-        # Highlight all occurences in the current day's text
-        self.main_window.highlight_text(search_text)
+        # Highlight all occurrences in the current day's text
+        self.main_window.highlight_text(queries)
 
         # Scroll to query.
-        if search_text:
-            GObject.idle_add(
-                self.main_window.day_text_field.scroll_to_text, search_text
-            )
-
-        self.main_window.search_tree_view.update_data(search_text, tags)
+        if queries:
+            # TODO: Decide where to scroll to?
+            # To scroll to the first match, we'd need to search for the first
+            # occurrence of each query, and scroll to the first one. But I am
+            # not sure if that is ideal performance-wise.
+            # Would it make sense to inspect the data returned by
+            # `self.journal.search` -- which will have information on what
+            # query matched fist, and it's index?
+            pass
+
+        self.main_window.search_tree_view.update_data(queries, tags)
 
         # Without the following, showing the search results sometimes lets the
         # search entry lose focus and search phrases are added to a day's text.
@@ -89,18 +92,18 @@ def __init__(self, main_window, always_show_results):
 
         self.connect("cursor_changed", self.on_cursor_changed)
 
-    def update_data(self, search_text, tags):
+    def update_data(self, queries, tags):
         self.tree_store.clear()
 
-        if not self.always_show_results and not tags and not search_text:
+        if not self.always_show_results and not tags and not queries:
             self.main_window.cloud.show()
             self.main_window.search_scroll.hide()
             return
 
         self.main_window.cloud.hide()
         self.main_window.search_scroll.show()
 
-        for date_string, entries in self.journal.search(search_text, tags):
+        for date_string, entries in self.journal.search(queries, tags):
             for entry in entries:
                 entry = escape(entry)
                 entry = entry.replace("STARTBOLD", "<b>").replace("ENDBOLD", "</b>")

rednotebook/journal.py

@@ -506,10 +506,10 @@ def get_entries(self, category):
             entries |= set(day.get_entries(category))
         return sorted(entries)
 
-    def search(self, text, tags):
+    def search(self, queries, tags):
         results = []
         for day in reversed(self.get_days_with_tags(tags)):
-            results.append(day.search(text, tags))
+            results.append(day.search(queries, tags))
         return results
 
     def get_days_with_tags(self, tags):