Use jinja expression parser to match conditions

Author: mgorny

conda_forge_tick/migrators/recipe_v1.py

@@ -3,6 +3,10 @@
 from pathlib import Path
 from typing import Any
 
+from jinja2 import Environment
+from jinja2.nodes import Compare, Node, Not
+from jinja2.parser import Parser
+
 from conda_forge_tick.migrators.core import MiniMigrator
 from conda_forge_tick.recipe_parser._parser import _get_yaml_parser
 
@@ -12,38 +16,49 @@
 logger = logging.getLogger(__name__)
 
 
-def get_condition(node: Any) -> str | None:
+def get_condition(node: Any) -> Node | None:
     if isinstance(node, dict) and "if" in node:
-        return node["if"].strip()
+        return Parser(
+            Environment(), node["if"].strip(), state="variable"
+        ).parse_expression()
     return None
 
 
-def is_same_condition(a: str, b: str) -> bool:
+def is_same_condition(a: Node, b: Node) -> bool:
     return a == b
 
 
-def is_single_expression(condition: str) -> bool:
-    return not any(f" {x} " in condition for x in ("and", "or", "if"))
-
+INVERSE_OPS = {
+    "eq": "ne",
+    "ne": "eq",
+    "gt": "lteq",
+    "gteq": "lt",
+    "lt": "gteq",
+    "lteq": "gt",
+    "in": "notin",
+    "notin": "in",
+}
 
-def is_negated_condition(a: str, b: str) -> bool:
-    # we only handle negating trivial expressions
-    if not all(map(is_single_expression, (a, b))):
-        return False
 
+def is_negated_condition(a: Node, b: Node) -> bool:
     # X <-> not X
-    a_not = a.startswith("not")
-    b_not = b.startswith("not")
-    if (
-        a_not != b_not
-        and a.removeprefix("not").lstrip() == b.removeprefix("not").lstrip()
-    ):
+    if Not(a) == b or a == Not(b):
         return True
 
+    # unwrap (not X) <-> (not Y)
+    if isinstance(a, Not) and isinstance(b, Not):
+        a = a.node
+        b = b.node
+
     # A == B <-> A != B
-    if "==" in b and a == b.replace("==", "!=", 1):
-        return True
-    if "!=" in b and a == b.replace("!=", "==", 1):
+    if (
+        isinstance(a, Compare)
+        and isinstance(b, Compare)
+        and len(a.ops) == len(b.ops) == 1
+        and a.expr == b.expr
+        and a.ops[0].expr == b.ops[0].expr
+        and a.ops[0].op == INVERSE_OPS[b.ops[0].op]
+    ):
         return True
 
     return False

tests/test_recipe_v1.py

@@ -9,8 +9,8 @@
     Version,
 )
 from conda_forge_tick.migrators.recipe_v1 import (
+    get_condition,
     is_negated_condition,
-    is_single_expression,
 )
 
 YAML_PATH = Path(__file__).parent / "test_v1_yaml"
@@ -21,44 +21,31 @@
 )
 
 
-@pytest.mark.parametrize(
-    "x",
-    [
-        "win",
-        "not unix",
-        'cuda_compiler_version == "None"',
-        "build_platform != target_platform",
-    ],
-)
-def test_is_single_expression(x):
-    assert is_single_expression(x)
-
-
-@pytest.mark.parametrize(
-    "x",
-    [
-        'cuda_compiler_version != "None" and linux"',
-        'unix and blas_impl != "mkl"',
-        "linux or osx",
-        "foo if bar else baz",
-    ],
-)
-def test_not_is_single_expression(x):
-    assert not is_single_expression(x)
-
-
 @pytest.mark.parametrize(
     "a,b",
     [
         ("unix", "not unix"),
         ('cuda_compiler_version == "None"', 'not cuda_compiler_version == "None"'),
         ('cuda_compiler_version == "None"', 'cuda_compiler_version != "None"'),
         ('not cuda_compiler_version == "None"', 'not cuda_compiler_version != "None"'),
+        (
+            'cuda_compiler_version != "None" and linux',
+            'not (cuda_compiler_version != "None" and linux)',
+        ),
+        ("linux or osx", "not (linux or osx)"),
+        ("a >= 14", "a < 14"),
+        ("a >= 14", "not (a >= 14)"),
+        ("a in [1, 2, 3]", "a not in [1, 2, 3]"),
+        ("a in [1, 2, 3]", "not a in [1, 2, 3]"),
+        ("a + b < 10", "a + b >= 10"),
+        ("a == b == c", "not (a == b == c)"),
     ],
 )
 def test_is_negated_condition(a, b):
-    assert is_negated_condition(a, b)
-    assert is_negated_condition(b, a)
+    a_cond = get_condition({"if": a})
+    b_cond = get_condition({"if": b})
+    assert is_negated_condition(a_cond, b_cond)
+    assert is_negated_condition(b_cond, a_cond)
 
 
 @pytest.mark.parametrize(
@@ -69,11 +56,16 @@ def test_is_negated_condition(a, b):
         ('cuda_compiler_version != "None"', 'not cuda_compiler_version == "None"'),
         ("a or b", "not a or b"),
         ("a and b", "not a and b"),
+        ("a == b == c", "a != b != c"),
+        ("a > 4", "a < 4"),
+        ("a == b == c", "not (a == b) == c"),
     ],
 )
 def test_not_is_negated_condition(a, b):
-    assert not is_negated_condition(a, b)
-    assert not is_negated_condition(b, a)
+    a_cond = get_condition({"if": a})
+    b_cond = get_condition({"if": b})
+    assert not is_negated_condition(a_cond, b_cond)
+    assert not is_negated_condition(b_cond, a_cond)
 
 
 @flaky