Simplify and fix ibm-semeru version handling

Instead of allowing version components to be strings, remove the
specific strings. The only strings that actually appear are '_openj9-'
and '-m2'. I don't know what -m2 means but openj9 is definitely not a
version element.

Normalize to all numbers, taking into account that '.' binds more
strongly than '+' (presumably) -- so zero-pad to 4 elements before the
'+'.

Version strings containing _openj9- but not containing '+' are skipped
as invalid.

(Assisted by Claude Code; any errors are mine.)

Author: marktsuchida

src/cjdk/_index.py

@@ -196,9 +196,10 @@ def _normalize_version(
     ver: str, *, remove_prefix_1: bool = False
 ) -> tuple[int | str, ...]:
     # Normalize requested version and candidates:
-    # - Split at dots and dashes (so we don't distinguish between '.' and '-')
-    # - Try to convert elements to integers (so that we can compare elements
-    #   numerically where feasible)
+    # - Handle _openj9- as a plain separator (for ibm-semeru-openj9-java*
+    #   versions); also handle -m2 suffix
+    # - Split at dots, dashes, plus signs, and underscores
+    # - Convert elements to integers (raise ValueError if not possible)
     # - If remove_prefix_1 and first element is 1, remove it (so JDK 1.8 == 8)
     # - Return as a tuple (so that we compare element by element)
     # - Trailing zero elements are NOT removed, so, e.g., 11 < 11.0 (for the
@@ -208,24 +209,38 @@ def _normalize_version(
     is_plus = ver.endswith("+")
     if is_plus:
         ver = ver[:-1]
+    plus = ("+",) if is_plus else ()
+
+    if "_openj9-" in ver:
+        # ibm-semeru-openj9-java* version numbers have a variable number of
+        # '.'-separated numbers before the '+'. Pad so that comparisons work.
+        first, second = ver.split("+", 1)
+        nfirst = _normalize_version(first, remove_prefix_1=remove_prefix_1)
+        while len(nfirst) < 4:
+            nfirst = nfirst + (0,)
+        nsecond = _normalize_version(
+            second.replace("-m", "-").replace("_openj9-", "-")
+        )
+        return nfirst + nsecond + plus
+
     if ver:
-        norm = tuple(re.split(_VER_SEPS, ver))
-        norm = tuple(_intify(e) for e in norm)
+        parts = re.split(_VER_SEPS, ver)
+        norm = []
+        for part in parts:
+            try:
+                norm.append(int(part))
+            except ValueError:
+                raise ValueError(
+                    f"Non-integer element '{part}' in version"
+                ) from None
+        norm = tuple(norm)
     else:
         norm = ()
-    plus = ("+",) if is_plus else ()
     if remove_prefix_1 and len(norm) and norm[0] == 1:
         return norm[1:] + plus
     return norm + plus
 
 
-def _intify(s: str) -> int | str:
-    try:
-        return int(s)
-    except ValueError:
-        return s
-
-
 def _is_version_compatible_with_spec(
     version: tuple[int | str, ...], spec: tuple[int | str, ...]
 ) -> bool:
@@ -243,25 +258,6 @@ def _is_version_compatible_with_spec(
     return len(version) >= len(spec) and version[: len(spec)] == spec
 
 
-class _VersionElement:
-    """Wrapper for version tuple elements enabling mixed int/str comparison."""
-
-    def __init__(self, value: int | str) -> None:
-        self.value = value
-
-    def __eq__(self, other: object) -> bool:
-        if not isinstance(other, _VersionElement):
-            return NotImplemented
-        if isinstance(self.value, int) and isinstance(other.value, int):
-            return self.value == other.value
-        return str(self.value) == str(other.value)
-
-    def __lt__(self, other: _VersionElement) -> bool:
-        if isinstance(self.value, int) and isinstance(other.value, int):
-            return self.value < other.value
-        return str(self.value) < str(other.value)
-
-
 def matching_jdk_versions(index: Index, conf: Configuration) -> list[str]:
     """
     Return all version strings matching the configuration, sorted by version.
@@ -274,10 +270,4 @@ def matching_jdk_versions(index: Index, conf: Configuration) -> list[str]:
     if not versions:
         return []
     matched = _match_versions(conf.vendor, versions, conf.version)
-
-    def version_sort_key(
-        item: tuple[tuple[int | str, ...], str],
-    ) -> tuple[_VersionElement, ...]:
-        return tuple(_VersionElement(e) for e in item[0])
-
-    return [v for _, v in sorted(matched.items(), key=version_sort_key)]
+    return [v for _, v in sorted(matched.items())]

tests/test_index.py

@@ -210,8 +210,14 @@ def test_normalize_version():
     assert f("1", remove_prefix_1=True) == ()
     assert f("1.8", remove_prefix_1=True) == (8,)
     assert f("1.8.0", remove_prefix_1=True) == (8, 0)
-    assert f("1.8u300", remove_prefix_1=True) == ("8u300",)
-    assert f("21.0.1+12_openj9-0.42.0") == (21, 0, 1, 12, "openj9", 0, 42, 0)
+    assert f("17.0.4.1+1_openj9-0.33.1") == (17, 0, 4, 1, 1, 0, 33, 1)
+    assert f("21.0.1+12_openj9-0.42.0") == (21, 0, 1, 0, 12, 0, 42, 0)
+    assert f("23+37_openj9-0.47.0.0.0") == (23, 0, 0, 0, 37, 0, 47, 0, 0, 0)
+    assert f("23.0.1+11_openj9-0.49.0-m2") == (23, 0, 1, 0, 11, 0, 49, 0, 2)
+    with pytest.raises(ValueError):
+        f("23.4.5_openj9-42")  # No '+' despite having _openj9-
+    with pytest.raises(ValueError):
+        f("1.8u300")  # No longer seen in index
 
 
 def test_is_version_compatible_with_spec():