refactor: do not use object oriented style

Author: aignas

python/private/py_wheel.bzl

@@ -17,7 +17,7 @@
 load(":py_info.bzl", "PyInfo")
 load(":py_package.bzl", "py_package_lib")
 load(":stamp.bzl", "is_stamping_enabled")
-load(":version.bzl", "normalize_pep440")
+load(":version.bzl", "version")
 
 PyWheelInfo = provider(
     doc = "Information about a wheel produced by `py_wheel`",
@@ -310,7 +310,7 @@ def _py_wheel_impl(ctx):
 
     filename_segments = [
         _escape_filename_distribution_name(ctx.attr.distribution),
-        normalize_pep440(version),
+        version.normalize(version),
         _escape_filename_segment(python_tag),
         _escape_filename_segment(abi),
         _escape_filename_segment(ctx.attr.platform),

python/private/pypi/pep508_evaluate.bzl

@@ -345,31 +345,30 @@ def _env_expr(left, op, right):
 
 def _version_expr(left, op, right):
     """Evaluate a version comparison expression"""
-    _left = version(left)
-    _right = version(right)
+    _left = version.parse(left)
+    _right = version.parse(right)
     if _left == None or _right == None:
         # Per spec, if either can't be normalized to a version, then
         # fallback to simple string comparison. Usually this is `platform_version`
         # or `platform_release`, which vary depending on platform.
         return _env_expr(left, op, right)
 
     if op == "===":
-        return _left.eqq(_right)
+        return version.is_eeq(_left, _right)
     elif op == "!=":
-        return _left.ne(_right)
+        return version.is_ne(_left, _right)
     elif op == "==":
-        # Matching of major, minor, patch only
-        return _left.eq(_right)
+        return version.is_eq(_left, _right)
     elif op == "<":
-        return _left.lt(_right)
+        return version.is_lt(_left, _right)
     elif op == ">":
-        return _left.gt(_right)
+        return version.is_gt(_left, _right)
     elif op == "<=":
-        return _left.le(_right)
+        return version.is_le(_left, _right)
     elif op == ">=":
-        return _left.ge(_right)
+        return version.is_ge(_left, _right)
     elif op == "~=":
-        return _left.compatible(_right)
+        return version.is_compatible(_left, _right)
     else:
         return False  # Let's just ignore the invalid ops
 

python/private/version.bzl

@@ -563,7 +563,7 @@ def _parse(version_str, strict = True):
 
     return parts
 
-def version(version_str, strict = False):
+def parse(version_str, strict = False):
     """Parse a PEP4408 compliant version
 
     See https://packaging.python.org/en/latest/specifications/binary-distribution-format/#escaping-and-unicode
@@ -581,7 +581,7 @@ def version(version_str, strict = False):
     if not parts:
         return None
 
-    return _new_version(
+    return struct(
         epoch = _parse_epoch(parts["epoch"]),
         release = _parse_release(parts["release"]),
         pre = _parse_pre(parts["pre"]),
@@ -644,25 +644,6 @@ def _parse_post(value):
     # it. Use `ord` and `chr` functions to find a good value.
     return ("~", post)
 
-def _new_version(**kwargs):
-    self = struct(**kwargs)
-
-    return struct(
-        # methods, keep sorted
-        compatible = mkmethod(self, _version_compatible),
-        eq = mkmethod(self, _version_eq),
-        eqq = mkmethod(self, _version_eqq),
-        ge = mkmethod(self, _version_ge),
-        gt = mkmethod(self, _version_gt),
-        key = mkmethod(self, _version_key),
-        le = mkmethod(self, _version_le),
-        lt = mkmethod(self, _version_lt),
-        ne = mkmethod(self, _version_ne),
-
-        # attrs are the same as self
-        **kwargs
-    )
-
 def _pad_zeros(release, n):
     padding = n - len(release)
     if padding <= 0:
@@ -846,3 +827,18 @@ def _version_key(self, *, local = True):
         # PEP440 - post release ordering: .devN, <no suffix>
         self.dev or release_key,
     )
+
+version = struct(
+    normalize = normalize_pep440,
+    parse = parse,
+    # methods, keep sorted
+    key = _version_key,
+    is_compatible = _version_compatible,
+    is_eq = _version_eq,
+    is_eeq = _version_eqq,
+    is_ge = _version_ge,
+    is_gt = _version_gt,
+    is_le = _version_le,
+    is_lt = _version_lt,
+    is_ne = _version_ne,
+)

tests/py_wheel/py_wheel_tests.bzl

@@ -17,7 +17,7 @@ load("@rules_testing//lib:analysis_test.bzl", "analysis_test", "test_suite")
 load("@rules_testing//lib:truth.bzl", "matching")
 load("@rules_testing//lib:util.bzl", rt_util = "util")
 load("//python:packaging.bzl", "py_wheel")
-load("//python/private:version.bzl", "normalize_pep440")  # buildifier: disable=bzl-visibility
+load("//python/private:version.bzl", "version")  # buildifier: disable=bzl-visibility
 
 _basic_tests = []
 _tests = []
@@ -257,7 +257,7 @@ def _test_pep440_normalization(env):
                         prefix = prefixes[i % len(prefixes)]
                         postfix = postfixes[(i // len(prefixes)) % len(postfixes)]
                         env.expect.that_str(
-                            normalize_pep440(
+                            version.normalize(
                                 prefix + iepoch + irelease + iprepost +
                                 idev + ilocal + postfix,
                             ),

tests/pypi/pep508/evaluate_tests.bzl

@@ -341,15 +341,18 @@ def _test_ordering(env):
     ]
 
     for lower, higher in zip(want[:-1], want[1:]):
-        lower = version(lower, strict = True)
-        higher = version(higher, strict = True)
+        lower = version.parse(lower, strict = True)
+        higher = version.parse(higher, strict = True)
 
-        if not lower.key() < higher.key():
+        lower_key = version.key(lower)
+        higher_key = version.key(higher)
+
+        if not lower_key < higher_key:
             env.fail("Expected '{}'.key() to be smaller than '{}'.key(), but got otherwise: {} > {}".format(
-                lower.str(),
-                higher.str(),
-                lower.key(),
-                higher.key(),
+                lower.string,
+                higher.string,
+                lower_key,
+                higher_key,
             ))
 
 _tests.append(_test_ordering)