chore: apply same sanitizing logic to both AHB and Condition expression (#573)

* chore: apply same sanitizing logic to both AHB and Condition expression

* the tests are right.

---------

Co-authored-by: Konstantin <[email protected]>

Author: hf-kklein

src/ahbicht/expressions/ahb_expression_parser.py

@@ -12,6 +12,7 @@
 
 # pylint: disable=anomalous-backslash-in-string
 from ahbicht.expressions import parsing_logger
+from ahbicht.expressions.sanitizer import sanitize_expression
 from ahbicht.utility_functions import tree_copy
 
 GRAMMAR = """
@@ -31,12 +32,6 @@
 # and CTRL+F for "Mus[2]" in the unittest that fails if you remove the lookahead.
 _parser = Lark(GRAMMAR, start="ahb_expression")
 
-_replacements: dict[str, str] = {
-    "\u00a0": " ",  # no-break space,
-    "V": "∨",  # Vogel-V != logical OR
-    "v": "∨",
-}
-
 
 @tree_copy
 @lru_cache(maxsize=1024)
@@ -51,9 +46,7 @@ def parse_ahb_expression_to_single_requirement_indicator_expressions(ahb_express
     :return parsed_tree:
     """
     try:
-        if ahb_expression is not None:
-            for key, value in _replacements.items():
-                ahb_expression = ahb_expression.replace(key, value)
+        ahb_expression = sanitize_expression(ahb_expression)
         parsed_tree = _parser.parse(ahb_expression)
         parsing_logger.debug("Successfully parsed '%s' as AHB expression", ahb_expression)
     except (UnexpectedEOF, UnexpectedCharacters, TypeError) as eof:

src/ahbicht/expressions/condition_expression_parser.py

@@ -14,13 +14,15 @@
 
 from ahbicht.condition_node_distinction import derive_condition_node_type
 from ahbicht.expressions import parsing_logger
+from ahbicht.expressions.sanitizer import sanitize_expression
 from ahbicht.models.categorized_key_extract import CategorizedKeyExtract
 from ahbicht.models.condition_node_type import ConditionNodeType
 from ahbicht.utility_functions import tree_copy
 
 GRAMMAR = r"""
 ?expression: expression "O"i expression -> or_composition
-            | expression "∨" expression -> or_composition
+            | expression "∨" expression -> or_composition // the logical or
+            | expression "V"i expression -> or_composition // a 'v' for those who first chose to introduce logical symbols but now can't find them on their keyboard  
             | expression "X"i expression -> xor_composition
             | expression "⊻" expression -> xor_composition
             | expression "U"i expression -> and_composition
@@ -59,6 +61,7 @@ def parse_condition_expression_to_tree(condition_expression: str) -> Tree[Token]
     :return parsed_tree: Tree
     """
     try:
+        condition_expression = sanitize_expression(condition_expression)
         parsed_tree = _parser.parse(condition_expression)
         parsing_logger.debug("Successfully parsed '%s' as condition expression", condition_expression)
     except (UnexpectedEOF, UnexpectedCharacters, TypeError) as eof:

src/ahbicht/expressions/sanitizer.py

@@ -0,0 +1,29 @@
+"""contains a function to sanitize user input/expressions from the AHBs"""
+
+from typing import Literal, Optional, overload
+
+_replacements: dict[str, str] = {
+    "\u00a0": " ",  # no-break space,
+    "V": "∨",  # Vogel-V != logical OR
+    "v": "∨",
+}
+
+
+@overload
+def sanitize_expression(expression: Literal[None]) -> Literal[None]: ...
+@overload
+def sanitize_expression(expression: str) -> str: ...
+
+
+def sanitize_expression(expression: Optional[str]) -> Optional[str]:
+    """
+    fixes some common issues with expressions from the AHBs
+    """
+    if expression is None:
+        return None
+    for key, value in _replacements.items():
+        expression = expression.replace(key, value)
+    return expression.strip()
+
+
+__all__ = ["sanitize_expression"]