Improve the error message when erlang_package deps conflict

non sem-ver versions (common for git deps) now produce a more readable
message when there is a conflict

Author: HoloRin

bzlmod/extensions.bzl

@@ -1,7 +1,6 @@
 load(
     ":hex_pm.bzl",
     "hex_package_info",
-    "newest",
     "satisfies",
 )
 load(
@@ -12,6 +11,11 @@ load(
     "log",
     "without_requirement",
 )
+load(
+    ":semver.bzl",
+    "lt",
+    "version_from_string",
+)
 load(
     "//:rules_erlang.bzl",
     "xref_runner_sources",
@@ -76,6 +80,23 @@ def _resolve_hex_pm(ctx, packages):
             return resolved
     fail("Dependencies were not resolved after {} passes.".format(_RESOLVE_MAX_PASSES))
 
+def _newest(a, b):
+    if a.version == b.version:
+        return a
+
+    a_version = version_from_string(a.version)
+    b_version = version_from_string(b.version)
+    if a_version == None or b_version == None:
+        fail("A version of {} & {} for {} cannot be resolved".format(
+            a.version,
+            b.version,
+            a.name,
+        ))
+    elif lt(a_version, b_version):
+        return b
+    else:
+        return a
+
 def _resolve_local(packages):
     deduped = []
     packages_by_name = {}
@@ -87,7 +108,7 @@ def _resolve_local(packages):
     for (_, dupes) in packages_by_name.items():
         p = dupes[0]
         for dupe in dupes[1:]:
-            p = newest(p, dupe)
+            p = _newest(p, dupe)
         deduped.append(p)
     return deduped
 

bzlmod/hex_pm.bzl

@@ -1,3 +1,12 @@
+load(
+    ":semver.bzl",
+    "Version",
+    "eq",
+    "gte",
+    "lt",
+    "version_from_string",
+)
+
 def hex_package_info(ctx, name):
     curl = ctx.which("curl")
     endpoint = "https://hex.pm/api/packages/{}".format(name)
@@ -20,68 +29,19 @@ def hex_release_info(ctx, name, version):
         fail("hex.pm api returned {} for {}".format(response.return_code, endpoint))
     return json.decode(response.stdout)
 
-Version = provider(fields = ["major", "minor", "patch"])
-
-def _version(version):
-    [major, minor, patch] = version.split(".", 2)
-    if not patch.isdigit():
-        return None
-    return Version(
-        major = int(major),
-        minor = int(minor),
-        patch = int(patch),
-    )
-
-def _gte(a, b):
-    if a.major > b.major:
-        return True
-    elif a.major == b.major:
-        if a.minor > b.minor:
-            return True
-        elif a.minor == b.minor:
-            return a.patch >= b.patch
-        else:
-            return False
-    else:
-        return False
-
-def _lt(a, b):
-    if a.major < b.major:
-        return True
-    elif a.major == b.major:
-        if a.minor < b.minor:
-            return True
-        elif a.minor == b.minor:
-            return a.patch < b.patch
-        else:
-            return False
-    else:
-        return False
-
-def _eq(a, b):
-    return a.major == b.major and a.minor == b.minor and a.patch == b.patch
-
-def newest(a, b):
-    if a.version == b.version:
-        return a
-    if _lt(_version(a.version), _version(b.version)):
-        return b
-    else:
-        return a
-
 def satisfies(version, requirement):
-    v = _version(version)
+    v = version_from_string(version)
     if v == None:
         # print("Ignoring version", version)
         return False
     if requirement.startswith("~>"):
-        min = _version(requirement.removeprefix("~>").lstrip())
+        min = version_from_string(requirement.removeprefix("~>").lstrip())
         if min == None:
             print("Ignoring requirement", requirement)
             return False
         max = Version(major = min.major, minor = min.minor + 1, patch = 0)
-        return _gte(v, min) and _lt(v, max)
-    elif _version(requirement) != None:
-        return _eq(v, _version(requirement))
+        return gte(v, min) and lt(v, max)
+    elif version_from_string(requirement) != None:
+        return eq(v, version_from_string(requirement))
     else:
         fail(requirement)

bzlmod/semver.bzl

@@ -0,0 +1,47 @@
+Version = provider(fields = ["major", "minor", "patch"])
+
+def version_from_string(version):
+    parts = version.split(".", 2)
+    if len(parts) != 3:
+        return None
+    [major, minor, patch] = parts
+    if not major.isdigit():
+        return None
+    if not minor.isdigit():
+        return None
+    if not patch.isdigit():
+        return None
+    return Version(
+        major = int(major),
+        minor = int(minor),
+        patch = int(patch),
+    )
+
+def gte(a, b):
+    if a.major > b.major:
+        return True
+    elif a.major == b.major:
+        if a.minor > b.minor:
+            return True
+        elif a.minor == b.minor:
+            return a.patch >= b.patch
+        else:
+            return False
+    else:
+        return False
+
+def lt(a, b):
+    if a.major < b.major:
+        return True
+    elif a.major == b.major:
+        if a.minor < b.minor:
+            return True
+        elif a.minor == b.minor:
+            return a.patch < b.patch
+        else:
+            return False
+    else:
+        return False
+
+def eq(a, b):
+    return a.major == b.major and a.minor == b.minor and a.patch == b.patch