Use conan 2.0 as default conan version

Signed-off-by: Tushar Goel <tushar.goel.dav@gmail.com>

Author: TG1999

src/univers/conan/errors.py

@@ -41,13 +41,6 @@ def conanfile_exception_formatter(conanfile_name, func_name):
     """
 
     def _raise_conanfile_exc(e):
-        from conan.api.output import LEVEL_DEBUG
-        from conan.api.output import conan_output_level
-
-        if conan_output_level <= LEVEL_DEBUG:
-            import traceback
-
-            raise ConanExceptionInUserConanfileMethod(traceback.format_exc())
         m = _format_conanfile_exception(conanfile_name, func_name, e)
         raise ConanExceptionInUserConanfileMethod(m)
 
@@ -132,13 +125,18 @@ def remote_message(self):
         return ""
 
     def __str__(self):
-        from conans.util.files import exception_message_safe
 
         msg = super(ConanException, self).__str__()
+
+        try:
+            msg = str(msg)
+        except Exception:
+            msg = repr(msg)
+
         if self.remote:
-            return "{}.{}".format(exception_message_safe(msg), self.remote_message())
+            return "{}.{}".format(msg, self.remote_message())
 
-        return exception_message_safe(msg)
+        return msg
 
 
 class ConanReferenceDoesNotExistInDB(ConanException):
@@ -230,36 +228,6 @@ def __init__(self, *args, **kwargs):
         super(NotFoundException, self).__init__(*args, **kwargs)
 
 
-class RecipeNotFoundException(NotFoundException):
-    def __init__(self, ref, remote=None):
-        from conans.model.recipe_ref import RecipeReference
-
-        assert isinstance(
-            ref, RecipeReference
-        ), "RecipeNotFoundException requires a RecipeReference"
-        self.ref = ref
-        super(RecipeNotFoundException, self).__init__(remote=remote)
-
-    def __str__(self):
-        tmp = repr(self.ref)
-        return "Recipe not found: '{}'".format(tmp, self.remote_message())
-
-
-class PackageNotFoundException(NotFoundException):
-    def __init__(self, pref, remote=None):
-        from conans.model.package_ref import PkgReference
-
-        assert isinstance(pref, PkgReference), "PackageNotFoundException requires a PkgReference"
-        self.pref = pref
-
-        super(PackageNotFoundException, self).__init__(remote=remote)
-
-    def __str__(self):
-        return "Binary package not found: '{}'{}".format(
-            self.pref.repr_notime(), self.remote_message()
-        )
-
-
 class UserInterfaceErrorException(RequestErrorException):
     """
     420 error
@@ -274,7 +242,5 @@ class UserInterfaceErrorException(RequestErrorException):
     AuthenticationException: 401,
     ForbiddenException: 403,
     NotFoundException: 404,
-    RecipeNotFoundException: 404,
-    PackageNotFoundException: 404,
     UserInterfaceErrorException: 420,
 }

src/univers/conan/version.py

@@ -47,7 +47,7 @@ def __lt__(self, other):
 
 
 @total_ordering
-class ConanVersion:
+class Version:
     """
     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 = ConanVersion(build)  # This is a nested version by itself
+            self._build = Version(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 = ConanVersion(pre)  # This is a nested version by itself
+            self._pre = Version(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 = ConanVersion(v)
+        result = Version(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 = ConanVersion(v)
+        result = Version(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, ConanVersion):
-            other = ConanVersion(other)
+        if not isinstance(other, Version):
+            other = Version(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, ConanVersion):
-            other = ConanVersion(other)
+        if not isinstance(other, Version):
+            other = Version(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 ConanVersion
+from univers.versions import ConanVersion
 
 _Condition = namedtuple("_Condition", ["operator", "version"])
 

src/univers/version_range.py

@@ -14,6 +14,7 @@
 from univers import gem
 from univers import maven
 from univers import versions
+from univers.conan.version_range import VersionRange as conan_version_range
 from univers.utils import remove_spaces
 from univers.version_constraint import VersionConstraint
 from univers.version_constraint import contains_version
@@ -377,9 +378,27 @@ def from_native(cls, string):
         return cls(constraints=constraints)
 
 
-class ConanVersionRange(NpmVersionRange):
+class ConanVersionRange(VersionRange):
     scheme = "conan"
-    version_class = versions.SemverVersion
+    version_class = versions.ConanVersion
+
+    @classmethod
+    def from_native(cls, string):
+        """
+        Return a VersionRange built from a conan range ``string``.
+        """
+        condition_sets = conan_version_range(string).condition_sets
+        constraints = []
+        for conditions in condition_sets:
+            for condition in conditions.conditions:
+                comparator = condition.operator
+                version = condition.version
+                constraints.append(
+                    VersionConstraint(
+                        comparator=comparator, version=cls.version_class(str(version))
+                    )
+                )
+        return cls(constraints=constraints)
 
 
 class GemVersionRange(VersionRange):

src/univers/versions.py

@@ -18,7 +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.conan.version import Version as conan_version
 from univers.utils import remove_spaces
 
 """
@@ -140,7 +140,6 @@ def __eq__(self, other):
 
     def __lt__(self, other):
         if not isinstance(other, self.__class__):
-            print('Hello!')
             return NotImplemented
         return self.value.__lt__(other.value)
 
@@ -653,22 +652,14 @@ def __ge__(self, other):
         # version value are of diff type, then semver one is always ahead of legacy
         return isinstance(self.value, SemverVersion)
 
+
+@attr.s(frozen=True, order=False, eq=False, hash=True)
+@total_ordering
 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:
@@ -697,6 +688,46 @@ def prerelease(self):
     def build(self):
         return self.value and self.value.build
 
+    @property
+    def micro(self):
+        return self.value and self.value.micro
+
+    @property
+    def pre(self):
+        return self.value and self.value._pre
+
+    @property
+    def nonzero_items(self):
+        return self.value and self.value._nonzero_items
+
+    @property
+    def main(self):
+        return self.value._items
+
+    @property
+    def major(self):
+        try:
+            return self.value.main[0]
+        except IndexError:
+            return None
+
+    @property
+    def minor(self):
+        try:
+            return self.value.main[1]
+        except IndexError:
+            return None
+
+    @property
+    def patch(self):
+        try:
+            return self.value.main[2]
+        except IndexError:
+            return None
+
+    def upper_bound(self, index):
+        return self.value and self.value.upper_bound(index)
+
     def next_major(self):
         return self.value and self.value.next_major()
 
@@ -706,42 +737,41 @@ def next_minor(self):
     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
+    def bump(self, index):
+        return self.value and self.value.bump(index)
 
-    @property
-    def pre(self):
-        return self.value and self.value._pre
+    def __eq__(self, other):
+        if other is None:
+            return False
+        if not isinstance(other, ConanVersion):
+            other = ConanVersion.build_value(other)
+            return self.value == other
+        return self.value == other.value
 
     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)
+        if not isinstance(other, ConanVersion):
+            other = ConanVersion(str(other))
+        return self.value < other.value
+
+    def __le__(self, other):
+        if other is None:
+            return False
+        if not isinstance(other, ConanVersion):
+            other = ConanVersion(str(other))
+        return self.value <= other.value
+
+    def __gt__(self, other):
+        if other is None:
+            return False
+        if not isinstance(other, ConanVersion):
+            other = ConanVersion(str(other))
+        return self.value > other.value
+
+    def __ge__(self, other):
+        if other is None:
+            return False
+        if not isinstance(other, ConanVersion):
+            other = ConanVersion(str(other))
+        return self.value >= other.value