Add function to invert constraints and ranges #91

CHANGELOG.rst

@@ -2,6 +2,12 @@ Changelog
 =========
 
 
+Version v30.9.1
+----------------
+
+- Add inverse function to VersionRange.
+
+
 Version v30.9.0
 ----------------
 

src/univers/version_constraint.py

@@ -39,6 +39,14 @@ def operator_star(a, b):
     return True
 
 
+def operator_null(a, b):
+    """
+    Comparison operator for the star "^" constraint comparator. Since it does not matches
+    any version, it is always False.
+    """
+    return False
+
+
 # note: ORDER MATTER here: we tests startswith(key) for each key in sequence
 COMPARATORS = {
     ">=": operator.ge,
@@ -48,6 +56,7 @@ def operator_star(a, b):
     ">": operator.gt,
     "=": operator.eq,
     "*": operator_star,
+    "^": operator_null,
 }
 
 
@@ -150,10 +159,10 @@ def from_string(cls, string, version_class):
         if comparator not in COMPARATORS:
             raise ValueError(f"Unknown comparator: {comparator!r}")
 
-        if not version and comparator != "*":
+        if not version and comparator not in ["*", "^"]:
             raise ValueError("Empty version")
 
-        if comparator == "*":
+        if comparator in ["*", "^"]:
             version = None
         else:
             version = version_class(version)

src/univers/version_range.py

@@ -25,6 +25,18 @@ class InvalidVersionRange(Exception):
     """
 
 
+INVERTED_COMPARATORS = {
+    ">=": "<",
+    "<=": ">",
+    "!=": "=",
+    "<": ">=",
+    ">": "<=",
+    "=": "!=",
+    "*": "^",
+    "^": "*",
+}
+
+
 @attr.s(frozen=True, order=False, eq=True, hash=True)
 class VersionRange:
     """
@@ -164,6 +176,33 @@ def from_versions(cls, sequence):
             constraints.append(constraint)
         return cls(constraints=constraints)
 
+    def inverse(self):
+        """
+        Return the inverse of this VersionRange. For example, if this range is
+        ">=1.0.0", the inverse is "<1.0.0".
+        >>> VersionRange.from_string("vers:npm/>=1.0.0").inverse()
+        NpmVersionRange(constraints=(VersionConstraint(comparator='<', version=SemverVersion(string='1.0.0')),))
+        """
+        inverted_constraints = []
+        for constraint in self.constraints:
+            if constraint.comparator in INVERTED_COMPARATORS:
+                inverted_comparator = INVERTED_COMPARATORS[constraint.comparator]
+            else:
+                raise NotImplementedError(
+                    f"Cannot invert a range with a {constraint.comparator!r} comparator."
+                )
+            if inverted_comparator == "*" or inverted_comparator == "^":
+                inverted_constraint = VersionConstraint.from_string(
+                    string=inverted_comparator, version_class=self.version_class
+                )
+            else:
+                inverted_constraint = VersionConstraint(
+                    comparator=inverted_comparator,
+                    version=constraint.version,
+                )
+            inverted_constraints.append(inverted_constraint)
+        return self.__class__(constraints=inverted_constraints)
+
     def __str__(self):
         constraints = "|".join(str(c) for c in sorted(self.constraints))
         return f"vers:{self.scheme}/{constraints}"

tests/test_version_range.py

@@ -393,3 +393,12 @@ def test_npm_advisory_version_range_parse(test_case):
         string=test_case["npm_native"],
     )
     assert str(result) == test_case["expected_vers"]
+
+
+@pytest.mark.parametrize("test_case", json.load(open("./tests/data/npm_advisory.json")))
+def test_npm_advisory_inverse_version_range_parse(test_case):
+    result = NpmVersionRange.from_native(
+        string=test_case["npm_native"],
+    ).inverse()
+    result = result.inverse()
+    assert str(result) == test_case["expected_vers"]