Tidy up the parser to return a Term | None, instead of tuple[Term, ...] (which was sometimes empty

Author: pelson

simple_repository_browser/_search.py

@@ -122,25 +122,20 @@ class SearchCompiler:
     """
 
     @classmethod
-    def compile(cls, terms: Term | tuple[Term, ...]) -> SQLBuilder:
+    def compile(cls, term: Term | None) -> SQLBuilder:
         """Compile search terms into SQL WHERE and ORDER BY clauses."""
-        # Normalise to tuple of terms
-        if not isinstance(terms, tuple):
-            terms = (terms,) if terms else ()
-
-        if len(terms) == 0:
+        if term is None:
             return SQLBuilder(
                 where_clause="",
                 where_params=(),
                 order_clause="",
                 order_params=(),
                 search_context=SearchContext(),
             )
-        assert len(terms) == 1
 
         # Build WHERE clause and collect context
         context = SearchContext()
-        where_clause, where_params, final_context = cls._visit_term(terms[0], context)
+        where_clause, where_params, final_context = cls._visit_term(term, context)
 
         # Build ORDER BY clause based on collected context
         order_clause, order_params = cls._build_ordering_from_context(final_context)
@@ -338,14 +333,14 @@ def _build_ordering_from_context(
         return order_clause, tuple(all_params)
 
 
-def build_sql(terms: Term | tuple[Term, ...]) -> SQLBuilder:
+def build_sql(term: Term | None) -> SQLBuilder:
     """Build SQL WHERE and ORDER BY clauses from search terms."""
-    return SearchCompiler.compile(terms)
+    return SearchCompiler.compile(term)
 
 
 def query_to_sql(query) -> SQLBuilder:
-    terms = parse(query)
-    return build_sql(terms)
+    term = parse(query)
+    return build_sql(term)
 
 
 grammar = parsley.makeGrammar(
@@ -376,8 +371,8 @@ def query_to_sql(query) -> SQLBuilder:
             |filter:filter -> filter
             |'-' filters:filters -> Not(filters)
     )
-    search_terms = (filters+:filters -> tuple(filters)
-                   | -> ())
+    search_terms = (filters:filters -> filters
+                   | -> None)
     """),
     {
         "And": And,
@@ -389,7 +384,7 @@ def query_to_sql(query) -> SQLBuilder:
 )
 
 
-def parse(query: str) -> typing.Tuple[Term, ...]:
+def parse(query: str) -> Term | None:
     return grammar(query.strip()).search_terms()
 
 

simple_repository_browser/model.py

@@ -114,14 +114,14 @@ async def project_query(
         self, query: str, page_size: int, page: int
     ) -> QueryResultModel:
         try:
-            search_terms = _search.parse(query)
+            search_term = _search.parse(query)
         except _search.ParseError:
             raise errors.InvalidSearchQuery("Invalid search pattern")
 
-        if not search_terms:
+        if search_term is None:
             raise errors.InvalidSearchQuery("Please specify a search query")
         try:
-            sql_builder = _search.build_sql(search_terms)
+            sql_builder = _search.build_sql(search_term)
         except ValueError as err:
             raise errors.InvalidSearchQuery(f"Search query invalid ({str(err)})")
 

simple_repository_browser/tests/test_search.py

@@ -13,94 +13,80 @@
 @pytest.mark.parametrize(
     ["query", "expected_expression_graph"],
     [
-        ("", ()),
-        pytest.param("some-name", (Filter(FilterOn.name_or_summary, "some-name"),)),
+        ("", None),
+        pytest.param("some-name", Filter(FilterOn.name_or_summary, "some-name")),
         pytest.param(
             "some name",
-            (
-                _search.And(
-                    Filter(FilterOn.name_or_summary, "some"),
-                    Filter(FilterOn.name_or_summary, "name"),
-                ),
+            _search.And(
+                Filter(FilterOn.name_or_summary, "some"),
+                Filter(FilterOn.name_or_summary, "name"),
             ),
         ),
-        pytest.param("som*name", (Filter(FilterOn.name_or_summary, "som*name"),)),
-        pytest.param('"some name"', (Filter(FilterOn.name_or_summary, '"some name"'),)),
-        pytest.param('"some-name"', (Filter(FilterOn.name_or_summary, '"some-name"'),)),
-        pytest.param('"CASE"', (Filter(FilterOn.name_or_summary, '"CASE"'),)),
-        pytest.param("-foo", (_search.Not(Filter(FilterOn.name_or_summary, "foo")),)),
+        pytest.param("som*name", Filter(FilterOn.name_or_summary, "som*name")),
+        pytest.param('"some name"', Filter(FilterOn.name_or_summary, '"some name"')),
+        pytest.param('"some-name"', Filter(FilterOn.name_or_summary, '"some-name"')),
+        pytest.param('"CASE"', Filter(FilterOn.name_or_summary, '"CASE"')),
+        pytest.param("-foo", _search.Not(Filter(FilterOn.name_or_summary, "foo"))),
         pytest.param(
-            '-"foo bar"', (_search.Not(Filter(FilterOn.name_or_summary, '"foo bar"')),)
+            '-"foo bar"', _search.Not(Filter(FilterOn.name_or_summary, '"foo bar"'))
         ),
         pytest.param(
-            '-name:"foo bar"', (_search.Not(Filter(FilterOn.name, '"foo bar"')),)
+            '-name:"foo bar"', _search.Not(Filter(FilterOn.name, '"foo bar"'))
         ),
-        pytest.param("name:foo", (Filter(FilterOn.name, "foo"),)),
+        pytest.param("name:foo", Filter(FilterOn.name, "foo")),
         pytest.param(
             "name:foo OR name:bar",
-            (
-                _search.Or(
-                    Filter(FilterOn.name, "foo"),
-                    Filter(FilterOn.name, "bar"),
-                ),
+            _search.Or(
+                Filter(FilterOn.name, "foo"),
+                Filter(FilterOn.name, "bar"),
             ),
         ),
         pytest.param(
             'name:foo AND "fiddle AND sticks"',
-            (
-                _search.And(
-                    Filter(FilterOn.name, "foo"),
-                    Filter(FilterOn.name_or_summary, '"fiddle AND sticks"'),
-                ),
+            _search.And(
+                Filter(FilterOn.name, "foo"),
+                Filter(FilterOn.name_or_summary, '"fiddle AND sticks"'),
             ),
         ),
-        pytest.param("summary:foo", (Filter(FilterOn.summary, "foo"),)),
+        pytest.param("summary:foo", Filter(FilterOn.summary, "foo")),
         pytest.param(
             'name:"NAME OR" AND "fiddle AND sticks"',
-            (
-                _search.And(
-                    Filter(FilterOn.name, '"NAME OR"'),
-                    Filter(FilterOn.name_or_summary, '"fiddle AND sticks"'),
-                ),
+            _search.And(
+                Filter(FilterOn.name, '"NAME OR"'),
+                Filter(FilterOn.name_or_summary, '"fiddle AND sticks"'),
             ),
         ),
-        pytest.param("(((a)))", (Filter(FilterOn.name_or_summary, "a"),)),
+        pytest.param("(((a)))", Filter(FilterOn.name_or_summary, "a")),
         pytest.param(
             "(((a) OR (b)))",
-            (
-                _search.Or(
-                    Filter(FilterOn.name_or_summary, "a"),
-                    Filter(FilterOn.name_or_summary, "b"),
-                ),
+            _search.Or(
+                Filter(FilterOn.name_or_summary, "a"),
+                Filter(FilterOn.name_or_summary, "b"),
             ),
         ),
         pytest.param(
             "(a AND b) OR (c AND d)",
-            (
-                _search.Or(
-                    _search.And(
-                        Filter(FilterOn.name_or_summary, "a"),
-                        Filter(FilterOn.name_or_summary, "b"),
-                    ),
-                    _search.And(
-                        Filter(FilterOn.name_or_summary, "c"),
-                        Filter(FilterOn.name_or_summary, "d"),
-                    ),
+            _search.Or(
+                _search.And(
+                    Filter(FilterOn.name_or_summary, "a"),
+                    Filter(FilterOn.name_or_summary, "b"),
+                ),
+                _search.And(
+                    Filter(FilterOn.name_or_summary, "c"),
+                    Filter(FilterOn.name_or_summary, "d"),
                 ),
             ),
         ),
         pytest.param(
             "((a AND b)) OR (c AND -d)",
-            (
-                _search.Or(
-                    _search.And(
-                        Filter(FilterOn.name_or_summary, "a"),
-                        Filter(FilterOn.name_or_summary, "b"),
-                    ),
-                    _search.And(
-                        Filter(FilterOn.name_or_summary, "c"),
-                        _search.Not(Filter(FilterOn.name_or_summary, "d")),
-                    ),
+            _search.Or(
+                _search.And(
+                    Filter(FilterOn.name_or_summary, "a"),
+                    Filter(FilterOn.name_or_summary, "b"),
+                ),
+                _search.And(
+                    Filter(FilterOn.name_or_summary, "c"),
+                    _search.Not(Filter(FilterOn.name_or_summary, "d")),
                 ),
             ),
         ),