refactoring and testing

Author: Gerit Wagner

.coverage

@@ -6,3 +6,18 @@ search_query/ebsco/__pycache__/*
 search_query/pubmed/__pycache__/*
 search_query/wos/__pycache__/*
 search_query/generic/__pycache__/*
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+pytestdebug.log

.gitignore

@@ -68,7 +68,7 @@ def syntax_str_to_generic_search_field_set(field_value: str) -> set:
         if field_value == key:
             return deepcopy(value)
 
-    raise ValueError(f"Field {field_value} not supported by EBSCO")
+    raise ValueError(f"Field {field_value} not supported by EBSCO")  # pragma: no cover
 
 
 def generic_search_field_to_syntax_field(generic_search_field: str) -> str:
@@ -78,6 +78,6 @@ def generic_search_field_to_syntax_field(generic_search_field: str) -> str:
         if {generic_search_field} == value:
             return key
 
-    raise ValueError(
+    raise ValueError(  # pragma: no cover
         f"Generic search field set {generic_search_field} " "not supported by EBSCO"
     )

search_query/ebsco/constants.py

@@ -22,13 +22,6 @@ class EBSCOQueryStringLinter(QueryStringLinter):
 
     UNSUPPORTED_SEARCH_FIELD_REGEX = r"\b(?!OR\b)\b(?!S\d+\b)[A-Z]{2}\b"
 
-    OPERATOR_PRECEDENCE = {
-        "NEAR": 3,
-        "WITHIN": 3,
-        "NOT": 2,
-        "AND": 1,
-        "OR": 0,
-    }
     PLATFORM: PLATFORM = PLATFORM.EBSCO
     VALID_FIELDS_REGEX = VALID_FIELDS_REGEX
 
@@ -250,7 +243,7 @@ def validate_query_tree(self, query: Query) -> None:
         This method is called after the query tree has been built.
         """
 
-        self.check_quoted_search_terms_query(query)
+        self.check_unbalanced_quotes_in_terms(query)
         self.check_operator_capitalization_query(query)
         self.check_invalid_characters_in_search_term_query(query, "@&%$^~\\<>{}()[]#")
         self.check_unsupported_search_fields_in_query(query)

search_query/ebsco/linter.py

@@ -5,15 +5,11 @@
 import re
 import typing
 
-from search_query.constants import GENERAL_ERROR_POSITION
 from search_query.constants import LinterMode
 from search_query.constants import PLATFORM
-from search_query.constants import QueryErrorCode
 from search_query.constants import Token
 from search_query.constants import TokenTypes
 from search_query.ebsco.linter import EBSCOQueryStringLinter
-from search_query.linter_base import QueryListLinter
-from search_query.parser_base import QueryListParser
 from search_query.parser_base import QueryStringParser
 from search_query.query import Query
 from search_query.query import SearchField
@@ -60,8 +56,6 @@ def __init__(
 
     def combine_subsequent_tokens(self) -> None:
         """Combine subsequent tokens based on specific conditions."""
-        if not self.tokens:
-            return
 
         combined_tokens = []
         i = 0
@@ -106,18 +100,12 @@ def combine_subsequent_tokens(self) -> None:
 
         self.tokens = combined_tokens
 
-    def convert_proximity_operators(
-        self, token: str, token_type: str
-    ) -> tuple[str, int]:
+    def _extract_proximity_distance(self, token: Token) -> int:
         """Convert proximity operator token into operator and distance components"""
-        if token_type != TokenTypes.PROXIMITY_OPERATOR:
-            raise ValueError(
-                f"Invalid token type: {token_type}. Expected 'PROXIMITY_OPERATOR'."
-            )
 
         # Extract the operator (first character) and distance (rest of the string)
-        operator = token[:1]
-        distance_string = token[1:]
+        operator = token.value[:1]
+        distance_string = token.value[1:]
 
         # Change value of operator to fit construction of operator query
         if operator == "N":
@@ -128,19 +116,17 @@ def convert_proximity_operators(
         # Validate and convert the distance
         if not distance_string.isdigit():
             raise ValueError(
-                f"Invalid proximity operator format: '{token}'. "
+                f"Invalid proximity operator format: '{token.value}'. "
                 "Expected a number after the operator."
             )
 
         distance = int(distance_string)
-        return operator, distance
+        token.value = operator
+        return distance
 
     def tokenize(self) -> None:
         """Tokenize the query_str."""
 
-        if self.query_str is None:
-            raise ValueError("No string provided to parse.")
-
         self.tokens = []
         token_type = TokenTypes.UNKNOWN
         for match in self.pattern.finditer(self.query_str):
@@ -200,7 +186,7 @@ def append_operator(
 
     def _check_for_none(self, root: typing.Optional[Query]) -> Query:
         """Check if root is none"""
-        if root is None:
+        if root is None:  # pragma: no cover
             raise ValueError("Failed to construct a valid query tree.")
         return root
 
@@ -244,9 +230,7 @@ def parse_query_tree(
 
             elif token.type == TokenTypes.PROXIMITY_OPERATOR:
                 # Split token into NEAR/WITHIN and distance
-                token.value, distance = self.convert_proximity_operators(
-                    token.value, token.type
-                )
+                distance = self._extract_proximity_distance(token)
 
                 # Create new proximity_operator from token (N3, W1, N13, ...)
                 proximity_node = Query(
@@ -323,44 +307,49 @@ def parse(self) -> Query:
         return query
 
 
-class EBSCOListParser(QueryListParser):
-    """Parser for EBSCO (list format) queries."""
-
-    def __init__(self, query_list: str, search_field_general: str, mode: str) -> None:
-        """Initialize with a query list and use EBSCOParser for parsing each query."""
-        super().__init__(
-            query_list=query_list,
-            parser_class=EBSCOParser,
-            search_field_general=search_field_general,
-            mode=mode,
-        )
-        self.linter = QueryListLinter(parser=self, string_parser_class=EBSCOParser)
-
-    def get_token_str(self, token_nr: str) -> str:
-        """Format the token string for output or processing."""
-
-        # Match string combinators such as S1 AND S2 ... ; #1 AND #2 ; ...
-        pattern = rf"(S|#){token_nr}"
-
-        match = re.search(pattern, self.query_list)
-
-        if match:
-            # Return the preceding character if found
-            return f"{match.group(1)}{token_nr}"
-
-        # Log a linter message and return the token number
-        # 1 AND 2 ... are still possible,
-        # however for standardization purposes it should be S/#
-        self.linter.add_linter_message(
-            QueryErrorCode.INVALID_LIST_REFERENCE,
-            list_position=GENERAL_ERROR_POSITION,
-            positions=[(-1, -1)],
-            details="Connecting lines possibly failed. "
-            "Please use this format for connection: "
-            "S1 OR S2 OR S3 / #1 OR #2 OR #3",
-        )
-        return token_nr
-
-    def parse(self) -> Query:
-        """Parse the query in list format."""
-        raise NotImplementedError("List parsing not implemented yet.")
+# from search_query.constants import GENERAL_ERROR_POSITION
+# from search_query.constants import QueryErrorCode
+# from search_query.linter_base import QueryListLinter
+# from search_query.parser_base import QueryListParser
+
+# class EBSCOListParser(QueryListParser):
+#     """Parser for EBSCO (list format) queries."""
+
+#     def __init__(self, query_list: str, search_field_general: str, mode: str) -> None:
+#         """Initialize with a query list and use EBSCOParser for parsing each query."""
+#         super().__init__(
+#             query_list=query_list,
+#             parser_class=EBSCOParser,
+#             search_field_general=search_field_general,
+#             mode=mode,
+#         )
+#         self.linter = QueryListLinter(parser=self, string_parser_class=EBSCOParser)
+
+#     def get_token_str(self, token_nr: str) -> str:
+#         """Format the token string for output or processing."""
+
+#         # Match string combinators such as S1 AND S2 ... ; #1 AND #2 ; ...
+#         pattern = rf"(S|#){token_nr}"
+
+#         match = re.search(pattern, self.query_list)
+
+#         if match:
+#             # Return the preceding character if found
+#             return f"{match.group(1)}{token_nr}"
+
+#         # Log a linter message and return the token number
+#         # 1 AND 2 ... are still possible,
+#         # however for standardization purposes it should be S/#
+#         self.linter.add_linter_message(
+#             QueryErrorCode.INVALID_LIST_REFERENCE,
+#             list_position=GENERAL_ERROR_POSITION,
+#             positions=[(-1, -1)],
+#             details="Connecting lines possibly failed. "
+#             "Please use this format for connection: "
+#             "S1 OR S2 OR S3 / #1 OR #2 OR #3",
+#         )
+#         return token_nr
+
+#     def parse(self) -> Query:
+#         """Parse the query in list format."""
+#         raise NotImplementedError("List parsing not implemented yet.")

search_query/ebsco/parser.py

@@ -15,13 +15,6 @@
 class GenericLinter(QueryStringLinter):
     """Linter for Generic Query Strings"""
 
-    PRECEDENCE = {
-        "NEAR": 3,
-        "WITHIN": 3,
-        "NOT": 2,
-        "AND": 1,
-        "OR": 0,
-    }
     PLATFORM: PLATFORM = PLATFORM.GENERIC
 
     # Extract unique string values
@@ -33,39 +26,6 @@ class GenericLinter(QueryStringLinter):
 
     VALID_FIELDS_REGEX = re.compile(r"\b(?:" + "|".join(sorted(field_codes)) + r")\b")
 
-    # VALID_TOKEN_SEQUENCES = {
-    #     TokenTypes.FIELD: [
-    #         TokenTypes.SEARCH_TERM,
-    #         TokenTypes.PARENTHESIS_OPEN,
-    #     ],
-    #     TokenTypes.SEARCH_TERM: [
-    #         TokenTypes.SEARCH_TERM,
-    #         TokenTypes.LOGIC_OPERATOR,
-    #         TokenTypes.PROXIMITY_OPERATOR,
-    #         TokenTypes.PARENTHESIS_CLOSED,
-    #     ],
-    #     TokenTypes.LOGIC_OPERATOR: [
-    #         TokenTypes.SEARCH_TERM,
-    #         TokenTypes.FIELD,
-    #         TokenTypes.PARENTHESIS_OPEN,
-    #     ],
-    #     TokenTypes.PROXIMITY_OPERATOR: [
-    #         TokenTypes.SEARCH_TERM,
-    #         TokenTypes.PARENTHESIS_OPEN,
-    #         TokenTypes.FIELD,
-    #     ],
-    #     TokenTypes.PARENTHESIS_OPEN: [
-    #         TokenTypes.FIELD,
-    #         TokenTypes.SEARCH_TERM,
-    #         TokenTypes.PARENTHESIS_OPEN,
-    #     ],
-    #     TokenTypes.PARENTHESIS_CLOSED: [
-    #         TokenTypes.PARENTHESIS_CLOSED,
-    #         TokenTypes.LOGIC_OPERATOR,
-    #         TokenTypes.PROXIMITY_OPERATOR,
-    #     ],
-    # }
-
     def __init__(self, query_str: str = "") -> None:
         super().__init__(query_str=query_str)
 

search_query/generic/linter.py

@@ -10,16 +10,16 @@
 
 def to_string_generic(query: Query) -> str:
     """Convert the query to a string."""
-    if not hasattr(query, "value"):
+    if not hasattr(query, "value"):  # pragma: no cover
         return " (?) "
 
     result = ""
     query_content = query.value
     if query.search_field:
         query_content += f"[{query.search_field}]"
 
-    if hasattr(query, "near_param"):
-        query_content += f"({query.near_param})"
+    if hasattr(query, "distance") and query.distance:
+        query_content += f"({query.distance})"
     result = f"{result}{query_content}"
     if query.children == []:
         return result