wip: finish PEP508/PEP440 impl for version matching

Author: aignas

python/private/py_wheel_normalize_pep440.bzl

@@ -517,3 +517,128 @@ def normalize_pep440(version):
             "Parse error at '%s'" % parser.input[parser.context()["start"]:],
         )
     return parser.context()["norm"]
+
+def _upper(*, epoch = 0, release, pre = "", post = "", dev = "", local = ""):
+    epoch = epoch
+    _release = list(release[:-1])
+    pre = pre
+    post = post
+    dev = dev
+    local = local
+
+    if pre or dev or local:
+        return _new_version(
+            epoch = epoch,
+            release = release,
+        )
+
+    _release[-1] = _release[-1] + 1
+    release = ".".join([str(d) for d in _release])
+
+    return _new_version(
+        epoch = epoch,
+        release = release,
+    )
+
+def _version_eq(left, right):
+    if left.epoch != right.epoch:
+        return False
+
+    # Check at most 3 terms and check the same number of terms
+    check_len = min(min(len(left.release), len(right.release)), 3)
+
+    return left.release[:check_len] == right.release[:check_len]
+
+def _version_lt(left, right):
+    if left.epoch < right.epoch:
+        return True
+    elif left.epoch > right.epoch:
+        return False
+
+    return left.release < right.release
+
+def _version_gt(left, right):
+    if left.epoch > right.epoch:
+        return True
+    elif left.epoch < right.epoch:
+        return False
+
+    return left.release > right.release
+
+def _new_version(*, epoch = 0, release, pre = "", post = "", dev = "", local = ""):
+    epoch = epoch or 0
+    _release = tuple([int(d) for d in release.split(".")])
+    pre = pre or ""
+    post = post or ""
+    dev = dev or ""
+    local = local or ""
+
+    self = struct(
+        epoch = epoch,
+        release = _release,
+        pre = pre,
+        post = post,
+        dev = dev,
+        local = local,
+        upper = lambda: _upper(
+            epoch = epoch,
+            release = _release,
+            pre = pre,
+            post = post,
+            dev = dev,
+            local = local,
+        ),
+        key = lambda: (
+            epoch,
+            _release,
+            pre,
+            post,
+            dev,
+            local,
+        ),
+        eq = lambda x: _version_eq(self, x),  # buildifier: disable=uninitialized
+        ne = lambda x: not _version_eq(self, x),  # buildifier: disable=uninitialized
+        lt = lambda x: _version_lt(self, x),  # buildifier: disable=uninitialized
+        gt = lambda x: _version_gt(self, x),  # buildifier: disable=uninitialized
+        le = lambda x: not _version_gt(self, x),  # buildifier: disable=uninitialized
+        ge = lambda x: not _version_lt(self, x),  # buildifier: disable=uninitialized
+        eqq = lambda x: _version_eqq(self, x),  # buildifier: disable=uninitialized
+    )
+
+    return self
+
+def parse_version(version):
+    """Escape the version component of a filename.
+
+    See https://packaging.python.org/en/latest/specifications/binary-distribution-format/#escaping-and-unicode
+    and https://peps.python.org/pep-0440/
+
+    Args:
+      version: version string to be normalized according to PEP 440.
+
+    Returns:
+      string containing the normalized version.
+    """
+    parser = _new(version.strip())  # PEP 440: Leading and Trailing Whitespace
+    accept(parser, _is("v"), "")  # PEP 440: Preceding v character
+
+    parts = {}
+    fns = [
+        ("epoch", accept_epoch),
+        ("release", accept_release),
+        ("pre", accept_prerelease),
+        ("post", accept_postrelease),
+        ("dev", accept_devrelease),
+        ("local", accept_local),
+    ]
+
+    for p, fn in fns:
+        fn(parser)
+        parts[p] = parser.context()["norm"]
+        parser.context()["norm"] = ""
+
+    if parser.input[parser.context()["start"]:]:
+        # If we fail to parse the version return None
+        return None
+
+    return _new_version(**parts)

python/private/pypi/pep508_evaluate.bzl

@@ -16,7 +16,8 @@
 """
 
 load("//python/private:enum.bzl", "enum")
-load("//python/private:semver.bzl", "semver")
+load("//python/private:py_wheel_normalize_pep440.bzl", "parse_version")
+
 
 # The expression parsing and resolution for the PEP508 is below
 #
@@ -353,36 +354,37 @@ def _env_expr(left, op, right):
     elif op == ">=":
         return left >= right
     else:
-        return fail("TODO: op unsupported: '{}'".format(op))
+        return fail("unsupported op: '{}' {} '{}'".format(left, op, right))
 
 def _version_expr(left, op, right):
     """Evaluate a version comparison expression"""
-    left = semver(left)
-    right = semver(right)
-    _left = left.key()
-    _right = right.key()
+    if op == "===":
+        # https://peps.python.org/pep-0440/#arbitrary-equality
+        # > simple string equality operations
+        return _env_expr(left, "==", right)
+
+    _left = parse_version(left)
+    _right = parse_version(right)
+    if _left == None or _right == None:
+        # Sometimes `platform_version` is not a true PEP440 version,
+        # so then we fallback to a simple string expression evaluation
+        return _env_expr(left, op, right)
+
     if op == "<":
-        return _left < _right
+        return _left.lt(_right)
     elif op == ">":
-        return _left > _right
+        return _left.gt(_right)
     elif op == "<=":
-        return _left <= _right
+        return _left.le(_right)
     elif op == ">=":
-        return _left >= _right
+        return _left.ge(_right)
     elif op == "!=":
-        return _left != _right
+        return _left.ne(_right)
     elif op == "==":
         # Matching of major, minor, patch only
-        return _left[:3] == _right[:3]
+        return _left.eq(_right)
     elif op == "~=":
-        right_plus = right.upper()
-        _right_plus = right_plus.key()
-        return _left >= _right and _left < _right_plus
-    elif op == "===":
-        # Strict matching
-        return _left == _right
-    elif op in _VERSION_CMP:
-        fail("TODO: op unsupported: '{}'".format(op))
+        return _left.ge(_right) and _left.lt(_right.upper())
     else:
         return False  # Let's just ignore the invalid ops
 

python/private/semver.bzl

@@ -43,32 +43,6 @@ def _to_dict(self):
         "pre_release": self.pre_release,
     }
 
-def _upper(self):
-    major = self.major
-    minor = self.minor
-    patch = self.patch
-    build = ""
-    pre_release = ""
-    version = self.str()
-
-    if patch != None:
-        minor = minor + 1
-        patch = 0
-    elif minor != None:
-        major = major + 1
-        minor = 0
-    elif minor == None:
-        major = major + 1
-
-    return _new(
-        major = major,
-        minor = minor,
-        patch = patch,
-        build = build,
-        pre_release = pre_release,
-        version = "~" + version,
-    )
-
 def _new(*, major, minor, patch, pre_release, build, version = None):
     # buildifier: disable=uninitialized
     self = struct(
@@ -82,7 +56,6 @@ def _new(*, major, minor, patch, pre_release, build, version = None):
         key = lambda: _key(self),
         str = lambda: version,
         to_dict = lambda: _to_dict(self),
-        upper = lambda: _upper(self),
     )
     return self
 

tests/pypi/pep508/evaluate_tests.bzl

@@ -123,6 +123,7 @@ def _evaluate_version_env_tests(env):
             "{} <= '3.7.10'".format(var_name): True,
             "{} <= '3.7.8'".format(var_name): False,
             "{} == '3.7.9'".format(var_name): True,
+            "{} == '3.7.*'".format(var_name): True,
             "{} != '3.7.9'".format(var_name): False,
             "{} ~= '3.7.1'".format(var_name): True,
             "{} ~= '3.7.10'".format(var_name): False,
@@ -148,6 +149,38 @@ def _evaluate_version_env_tests(env):
 
 _tests.append(_evaluate_version_env_tests)
 
+def _evaluate_platform_version_is_special(env):
+    # Given
+    marker_env = {"platform_version": "FooBar Linux v1.2.3"}
+
+    # When the platform version is not
+    input = "platform_version == '0'"
+    got = evaluate(
+        input,
+        env = marker_env,
+    )
+    env.expect.that_collection((input, got)).contains_exactly((input, False))
+
+    # And when I compare it as string
+    input = "'FooBar' in platform_version"
+    got = evaluate(
+        input,
+        env = marker_env,
+    )
+    env.expect.that_collection((input, got)).contains_exactly((input, True))
+
+
+    # Check that the non-strict eval gives us back the input when no
+    # env is supplied.
+    got = evaluate(
+        input,
+        env = {},
+        strict = False,
+    )
+    env.expect.that_bool(got).equals(input.replace("'", '"'))
+
+_tests.append(_evaluate_platform_version_is_special)
+
 def _logical_expression_tests(env):
     for input, want in {
         # Basic

tests/semver/semver_test.bzl

@@ -104,24 +104,6 @@ def _test_semver_sort(env):
 
 _tests.append(_test_semver_sort)
 
-def _test_upper(env):
-    for input, want in {
-        # Depending on how many version numbers are specified we will increase
-        # the upper bound differently. See https://packaging.python.org/en/latest/specifications/version-specifiers/#compatible-release for docs
-        "0.0.1": "0.1.0",
-        "0.1": "1.0",
-        "0.1.0": "0.2.0",
-        "1": "2",
-        "1.0.0-pre": "1.1.0",  # pre-release info is dropped
-        "1.2.0": "1.3.0",
-        "2.0.0+build0": "2.1.0",  # build info is dropped
-    }.items():
-        actual = semver(input).upper().key()
-        want = semver(want).key()
-        env.expect.that_collection(actual).contains_exactly(want).in_order()
-
-_tests.append(_test_upper)
-
 def semver_test_suite(name):
     """Create the test suite.