Adjust conan code according to univers #101

Signed-off-by: John M. Horan <johnmhoran@gmail.com>

Author: johnmhoran

src/univers/conan/version.py

@@ -47,7 +47,7 @@ def __lt__(self, other):
 
 
 @total_ordering
-class Version:
+class ConanVersion:
     """
     This is NOT an implementation of semver, as users may use any pattern in their versions.
     It is just a helper to parse "." or "-" and compare taking into account integers when possible
@@ -60,15 +60,15 @@ def __init__(self, value):
         items = value.rsplit("+", 1)  # split for build
         if len(items) == 2:
             value, build = items
-            self._build = Version(build)  # This is a nested version by itself
+            self._build = ConanVersion(build)  # This is a nested version by itself
         else:
             value = items[0]
             self._build = None
 
         items = value.rsplit("-", 1)  # split for pre-release
         if len(items) == 2:
             value, pre = items
-            self._pre = Version(pre)  # This is a nested version by itself
+            self._pre = ConanVersion(pre)  # This is a nested version by itself
         else:
             value = items[0]
             self._pre = None
@@ -101,7 +101,7 @@ def bump(self, index):
         items.extend([0] * (len(items) - index - 1))
         v = ".".join(str(i) for i in items)
         # prerelease and build are dropped while bumping digits
-        result = Version(v)
+        result = ConanVersion(v)
         return result
 
     def upper_bound(self, index):
@@ -113,7 +113,7 @@ def upper_bound(self, index):
         items.extend([0] * (len(items) - index - 1))
         v = ".".join(str(i) for i in items)
         v += "-"  # Exclude prereleases
-        result = Version(v)
+        result = ConanVersion(v)
         return result
 
     @property
@@ -165,8 +165,8 @@ def __repr__(self):
     def __eq__(self, other):
         if other is None:
             return False
-        if not isinstance(other, Version):
-            other = Version(other)
+        if not isinstance(other, ConanVersion):
+            other = ConanVersion(other)
 
         return (self._nonzero_items, self._pre, self._build) == (
             other._nonzero_items,
@@ -180,8 +180,8 @@ def __hash__(self):
     def __lt__(self, other):
         if other is None:
             return False
-        if not isinstance(other, Version):
-            other = Version(other)
+        if not isinstance(other, ConanVersion):
+            other = ConanVersion(other)
 
         if self._pre:
             if other._pre:  # both are pre-releases

src/univers/conan/version_range.py

@@ -1,7 +1,7 @@
 from collections import namedtuple
 
 from univers.conan.errors import ConanException
-from univers.conan.version import Version
+from univers.conan.version import ConanVersion
 
 _Condition = namedtuple("_Condition", ["operator", "version"])
 
@@ -21,7 +21,7 @@ def __init__(self, expression, prerelease):
     @staticmethod
     def _parse_expression(expression):
         if expression == "" or expression == "*":
-            return [_Condition(">=", Version("0.0.0"))]
+            return [_Condition(">=", ConanVersion("0.0.0"))]
 
         operator = expression[0]
         if operator not in (">", "<", "^", "~", "="):
@@ -37,11 +37,11 @@ def _parse_expression(expression):
         if version == "":
             raise ConanException(f"Error parsing version range {expression}")
         if operator == "~":  # tilde minor
-            v = Version(version)
+            v = ConanVersion(version)
             index = 1 if len(v.main) > 1 else 0
             return [_Condition(">=", v), _Condition("<", v.upper_bound(index))]
         elif operator == "^":  # caret major
-            v = Version(version)
+            v = ConanVersion(version)
 
             def first_non_zero(main):
                 for i, m in enumerate(main):
@@ -52,7 +52,7 @@ def first_non_zero(main):
             initial_index = first_non_zero(v.main)
             return [_Condition(">=", v), _Condition("<", v.upper_bound(initial_index))]
         else:
-            return [_Condition(operator, Version(version))]
+            return [_Condition(operator, ConanVersion(version))]
 
     def valid(self, version):
         if version.pre:
@@ -95,7 +95,7 @@ def __str__(self):
         return self._expression
 
     def __contains__(self, version):
-        assert isinstance(version, Version), type(version)
+        assert isinstance(version, ConanVersion), type(version)
         for condition_set in self.condition_sets:
             if condition_set.valid(version):
                 return True

src/univers/versions.py

@@ -18,6 +18,7 @@
 from univers import maven
 from univers import nuget
 from univers import rpm
+from univers.conan.version import ConanVersion as conan_version
 from univers.utils import remove_spaces
 
 """
@@ -139,6 +140,7 @@ def __eq__(self, other):
 
     def __lt__(self, other):
         if not isinstance(other, self.__class__):
+            print('Hello!')
             return NotImplemented
         return self.value.__lt__(other.value)
 
@@ -650,3 +652,96 @@ def __ge__(self, other):
             return self.value.__ge__(other.value)
         # version value are of diff type, then semver one is always ahead of legacy
         return isinstance(self.value, SemverVersion)
+
+class ConanVersion(Version):
+    @classmethod
+    def build_value(cls, string):
+        return conan_version(string)
+
+    # def __eq__(self, other):
+        # if not isinstance(other, self.__class__):
+        #     return NotImplemented
+        # return conan_version.vercmp(self.value, other.value) == 0
+
+    def __eq__(self, other):
+        if other is None:
+            return False
+        if not isinstance(other, conan_version):
+            other = conan_version(other)
+
+    @classmethod
+    def is_valid(cls, string):
+        try:
+            cls.build_value(string)
+            return True
+        except ValueError:
+            return False
+
+    @property
+    def major(self):
+        return self.value and self.value.major
+
+    @property
+    def minor(self):
+        return self.value and self.value.minor
+
+    @property
+    def patch(self):
+        return self.value and self.value.patch
+
+    @property
+    def prerelease(self):
+        return self.value and self.value.prerelease
+
+    @property
+    def build(self):
+        return self.value and self.value.build
+
+    def next_major(self):
+        return self.value and self.value.next_major()
+
+    def next_minor(self):
+        return self.value and self.value.next_minor()
+
+    def next_patch(self):
+        return self.value and self.value.next_patch()
+
+    @property
+    def micro(self):
+        # self.value()
+        return self.value and self.value.micro
+
+    @property
+    def pre(self):
+        return self.value and self.value._pre
+
+    def __lt__(self, other):
+        if other is None:
+            return False
+        if not isinstance(other, conan_version):
+            other = conan_version(other)
+
+        if self.value._pre:
+            if other._pre:  # both are pre-releases
+                return (self.value._nonzero_items, self.value._pre, self.value._build) < (
+                    other._nonzero_items,
+                    other._pre,
+                    other._build,
+                )
+            else:  # Left hand is pre-release, right side is regular
+                if (
+                    self.value._nonzero_items == other._nonzero_items
+                ):  # Problem only happens if both equal
+                    return True
+                else:
+                    return self.value._nonzero_items < other._nonzero_items
+        else:
+            if other._pre:  # Left hand is regular, right side is pre-release
+                if (
+                    self.value._nonzero_items == other._nonzero_items
+                ):  # Problem only happens if both equal
+                    return False
+                else:
+                    return self.value._nonzero_items < other._nonzero_items
+            else:  # None of them is pre-release
+                return (self.value._nonzero_items, self.value._build) < (other._nonzero_items, other._build)

tests/test_conan_version_bump.py

@@ -1,6 +1,6 @@
 import pytest
 
-from univers.conan.version import Version
+from univers.conan.version import ConanVersion
 
 values = [
     ["1.0.0", 0, "2.0.0"],
@@ -13,6 +13,6 @@
 
 @pytest.mark.parametrize("version, index, result", values)
 def test_version_bump(version, index, result):
-    r = Version(version)
+    r = ConanVersion(version)
     bumped = r.bump(index)
     assert bumped == result

tests/test_conan_version_comparison.py

@@ -1,6 +1,6 @@
 import pytest
 
-from univers.conan.version import Version
+from univers.versions import ConanVersion
 
 v = [
     ("1", "2"),
@@ -45,8 +45,8 @@
 
 @pytest.mark.parametrize("v1, v2", v)
 def test_comparison(v1, v2):
-    v1 = Version(v1)
-    v2 = Version(v2)
+    v1 = ConanVersion(v1)
+    v2 = ConanVersion(v2)
     assert v1 < v2
     assert v2 > v1
     assert v1 != v2
@@ -55,7 +55,7 @@ def test_comparison(v1, v2):
 
 
 def test_comparison_with_integer():
-    v1 = Version("13.0")
+    v1 = ConanVersion("13.0")
     # Issue: https://github.com/conan-io/conan/issues/12907
     assert v1 > 5
     assert v1 >= 5
@@ -86,14 +86,14 @@ def test_comparison_with_integer():
 
 @pytest.mark.parametrize("v1, v2", e)
 def test_equality(v1, v2):
-    v1 = Version(v1)
-    v2 = Version(v2)
+    v1 = ConanVersion(v1)
+    v2 = ConanVersion(v2)
     assert v1 == v2
     assert not v1 != v2
 
 
 def test_elem_comparison():
-    v1 = Version("1.2.3b.4-pre.1.2b+build.1.1b")
+    v1 = ConanVersion("1.2.3b.4-pre.1.2b+build.1.1b")
     major = v1.major
     assert major < 2
     assert major < "2"

tests/test_conan_version_range.py

@@ -1,7 +1,7 @@
 import pytest
 
 from univers.conan.errors import ConanException
-from univers.conan.version import Version
+from univers.conan.version import ConanVersion
 from univers.conan.version_range import VersionRange
 
 values = [
@@ -55,10 +55,10 @@ def test_range(version_range, conditions, versions_in, versions_out):
             assert condition.version == expected_condition[1]
 
     for v in versions_in:
-        assert Version(v) in r
+        assert ConanVersion(v) in r
 
     for v in versions_out:
-        assert Version(v) not in r
+        assert ConanVersion(v) not in r
 
 
 def test_wrong_range_syntax():