remove config option, correct libversion algorithm

Author: immqu

README.rst

@@ -127,19 +127,16 @@ common case but may not work correctly when a task that demand precise version
 comparisons such as for dependency resolution and vulnerability lookup where
 a "good enough" comparison accuracy is not acceptable. ``libversion`` does not
 handle version range notations.
-For this reason, univers adds support for libversion using a configuration option which allows users to use libversion as a fallback, i.e., in case the native version comparison fails. Usage: 
+For this reason, univers provides a dedicated libversion scheme for users who
+explicitly choose that behavior. Usage:
 
 .. code:: python
 
-    from univers.config import config
-    from univers.versions import PypiVersion
-    
-    v3 = PypiVersion("1.2.3-invalid")
-    v4 = PypiVersion("1.2.4-invalid")
-    result = v3 < v4 # Error without fallback
+    from univers.versions import LibversionVersion
 
-    config.use_libversion_fallback = True
-    result = v3 < v4 # result == True
+    v3 = LibversionVersion("1.2.3-invalid")
+    v4 = LibversionVersion("1.2.4-invalid")
+    result = v3 < v4
 
 Installation
 ============

src/univers/config.py

@@ -12,13 +12,15 @@
 KEYWORD_POST_RELEASE = 2
 
 METAORDER_LOWER_BOUND = 0
-METAORDER_ZERO = 1
-METAORDER_NONZERO = 2
-METAORDER_PRE_RELEASE = 3
-METAORDER_POST_RELEASE = 4
+METAORDER_PRE_RELEASE = 1
+METAORDER_ZERO = 2
+METAORDER_POST_RELEASE = 3
+METAORDER_NONZERO = 4
 METAORDER_LETTER_SUFFIX = 5
 METAORDER_UPPER_BOUND = 6
 
+_TOKEN_RE = re.compile(r"[A-Za-z]+|[0-9]+")
+
 
 class LibversionVersion:
     def __init__(self, version_string):
@@ -52,22 +54,61 @@ def classify_keyword(s):
         else:
             return KEYWORD_UNKNOWN
 
-    @staticmethod
-    def parse_token_to_component(s):
-        if s.isalpha():
-            keyword_type = LibversionVersion.classify_keyword(s)
-            metaorder = METAORDER_PRE_RELEASE if keyword_type == KEYWORD_PRE_RELEASE else METAORDER_POST_RELEASE
-            return s, metaorder
-        else:
-            s = s.lstrip("0")
-            metaorder = METAORDER_ZERO if s == "" else METAORDER_NONZERO
-            return s, metaorder
-
     @staticmethod
     def get_next_version_component(s):
-        components = re.split(r"[^a-zA-Z0-9]+", s)
-        for component in components:
-            yield LibversionVersion.parse_token_to_component(component)
+        tokens = list(_TOKEN_RE.finditer(s))
+        token_count = len(tokens)
+        parsed_tokens = []
+
+        prev_end = None
+        for token in tokens:
+            start, end = token.span()
+            delim_before = prev_end is not None and start > prev_end
+            parsed_tokens.append(
+                {
+                    "value": token.group(0),
+                    "is_alpha": token.group(0).isalpha(),
+                    "delim_before": delim_before,
+                    "start": start,
+                    "end": end,
+                }
+            )
+            prev_end = end
+
+        for i, token in enumerate(parsed_tokens):
+            next_token = parsed_tokens[i + 1] if i + 1 < token_count else None
+            delim_after = next_token is not None and next_token["start"] > token["end"]
+
+            if token["is_alpha"]:
+                raw_value = token["value"]
+                value = raw_value.lower()
+                keyword_type = LibversionVersion.classify_keyword(value)
+
+                is_letter_suffix = False
+                if i > 0 and not token["delim_before"]:
+                    prev_token = parsed_tokens[i - 1]
+                    if not prev_token["is_alpha"]:
+                        next_is_numeric_no_delim = (
+                            next_token is not None
+                            and not next_token["is_alpha"]
+                            and not delim_after
+                        )
+                        if not next_is_numeric_no_delim:
+                            is_letter_suffix = True
+
+                if is_letter_suffix:
+                    metaorder = METAORDER_LETTER_SUFFIX
+                elif keyword_type == KEYWORD_POST_RELEASE:
+                    metaorder = METAORDER_POST_RELEASE
+                else:
+                    metaorder = METAORDER_PRE_RELEASE
+
+                yield value, metaorder
+                continue
+
+            value = token["value"].lstrip("0")
+            metaorder = METAORDER_ZERO if value == "" else METAORDER_NONZERO
+            yield value, metaorder
 
     def compare_components(self, other):
         max_len = max(len(self.components), len(other.components))
@@ -76,8 +117,8 @@ def compare_components(self, other):
             """
             Get current components or pad with zero
             """
-            c1 = self.components[i] if i < len(self.components) else ("0", METAORDER_ZERO)
-            c2 = other.components[i] if i < len(other.components) else ("0", METAORDER_ZERO)
+            c1 = self.components[i] if i < len(self.components) else ("", METAORDER_ZERO)
+            c2 = other.components[i] if i < len(other.components) else ("", METAORDER_ZERO)
 
             """
             Compare based on metaorder
@@ -107,10 +148,13 @@ def compare_components(self, other):
             c2_is_alpha = c2[0].isalpha()
 
             if c1_is_alpha and c2_is_alpha:
-                if c1[0].lower() < c2[0].lower():
+                c1_letter = c1[0][0].lower() if c1[0] else ""
+                c2_letter = c2[0][0].lower() if c2[0] else ""
+                if c1_letter < c2_letter:
                     return -1
-                elif c1[0].lower() > c2[0].lower():
+                elif c1_letter > c2_letter:
                     return 1
+                continue
             elif c1_is_alpha:
                 return -1
             elif c2_is_alpha:

src/univers/libversion.py

@@ -9,7 +9,6 @@
 from packaging import version as packaging_version
 
 from univers import arch
-from univers.config import config
 from univers import debian
 from univers import gem
 from univers import gentoo
@@ -86,85 +85,16 @@ class Version:
 
     def __attrs_post_init__(self):
         normalized_string = self.normalize(self.string)
-        
-        # Skip validation if fallback is enabled
-        if not config.use_libversion_fallback:
-            if not self.is_valid(normalized_string):
-                print("Validation - config id:", id(config), "value:", config.use_libversion_fallback)
-                raise InvalidVersion(f"{self.string!r} is not a valid {self.__class__!r}")
+        if not self.is_valid(normalized_string):
+            raise InvalidVersion(f"{self.string!r} is not a valid {self.__class__!r}")
 
         # Set the normalized string as default value
         # Notes: setattr is used because this is an immutable frozen instance.
         # See https://www.attrs.org/en/stable/init.html?#post-init
         object.__setattr__(self, "normalized_string", normalized_string)
-        
-        # Try to build value, but allow it to fail if fallback is enabled
-        try:
-            value = self.build_value(normalized_string)
-        except Exception as e:
-            if config.use_libversion_fallback:
-                # Store the normalized string as value if building fails
-                value = normalized_string
-            else:
-                raise
-        
-        object.__setattr__(self, "value", value)
 
-    def __init_subclass__(cls, **kwargs):
-        """
-        Automatically wrap comparison methods in subclasses with fallback logic.
-        """
-        super().__init_subclass__(**kwargs)
-        
-        comparison_methods = ['__lt__', '__le__', '__gt__', '__ge__', '__eq__', '__ne__']
-        
-        for method_name in comparison_methods:
-            # Only wrap if the method is defined in THIS specific class
-            if method_name in cls.__dict__:
-                original_method = cls.__dict__[method_name]
-                wrapped = cls._wrap_comparison_method(original_method, method_name)
-                setattr(cls, method_name, wrapped)
-
-    @staticmethod
-    def _wrap_comparison_method(original_method, method_name):
-        """
-        Wrap a comparison method with fallback logic.
-        
-        Uses only standard library features (no external dependencies).
-        """
-        def wrapper(self, other):
-            try:
-                # Try the original comparison method
-                return original_method(self, other)
-            except (ValueError, TypeError, AttributeError) as e:
-                # If it fails and fallback is enabled, use libversion
-                if config.use_libversion_fallback:
-                    try:
-                        import libversion
-                        result = libversion.version_compare2(str(self), str(other))
-                        
-                        # Map libversion result to the appropriate comparison
-                        if method_name == '__lt__':
-                            return result < 0
-                        elif method_name == '__le__':
-                            return result <= 0
-                        elif method_name == '__gt__':
-                            return result > 0
-                        elif method_name == '__ge__':
-                            return result >= 0
-                        elif method_name == '__eq__':
-                            return result == 0
-                        elif method_name == '__ne__':
-                            return result != 0
-                    except Exception:
-                        # If fallback also fails, re-raise the original exception
-                        raise e
-                # If fallback is disabled, re-raise the original exception
-                raise
-
-        # Preserve method name
-        wrapper.__name__ = original_method.__name__
-        return wrapper
+        value = self.build_value(normalized_string)
+        object.__setattr__(self, "value", value)
 
     @classmethod
     def is_valid(cls, string):

src/univers/versions.py

@@ -23,7 +23,6 @@
 from univers.versions import RubygemsVersion
 from univers.versions import SemverVersion
 from univers.versions import Version
-from univers.config import config
 
 
 def test_version():
@@ -249,33 +248,16 @@ def test_libversion_version():
     assert LibversionVersion("1.2.3") == LibversionVersion("1.2.3")
     assert LibversionVersion("1.2.3") != LibversionVersion("1.2.4")
     assert LibversionVersion.is_valid("1.2.3")
-    assert not LibversionVersion.is_valid("1.2.3a-1-a")
     assert LibversionVersion.normalize("v1.2.3") == "1.2.3"
     assert LibversionVersion("1.2.3") > LibversionVersion("1.2.2")
     assert LibversionVersion("1.2.3") < LibversionVersion("1.3.0")
     assert LibversionVersion("1.2.3") >= LibversionVersion("1.2.3")
     assert LibversionVersion("1.2.3") <= LibversionVersion("1.2.3")
     assert LibversionVersion("1.2.3-alpha") < LibversionVersion("1.2.3")
     assert LibversionVersion("1.2.3-alpha") != LibversionVersion("1.2.3-beta")
+    assert LibversionVersion("1.0custom1") < LibversionVersion("1.0")
+    assert LibversionVersion("1.0alpha1") == LibversionVersion("1.0a1")
+    assert LibversionVersion("1.0") < LibversionVersion("1.0a")
+    assert LibversionVersion("1.0.1") < LibversionVersion("1.0a")
+    assert LibversionVersion("1.0a1") < LibversionVersion("1.0")
     assert LibversionVersion("1.0") == LibversionVersion("1.0.0")
-
-
-def test_libversion_fallback_config():
-    # Default: fallback disabled
-    v1 = PypiVersion("1.2.3")
-    v2 = PypiVersion("1.2.4")
-    assert v1 < v2
-
-    # Enable globally
-    config.use_libversion_fallback = True
-    v3 = PypiVersion("1.2.3-invalid")
-    v4 = PypiVersion("1.2.4-invalid")
-    assert v3 < v4  # Uses fallback if needed
-
-    # Temporarily enable fallback
-    config.use_libversion_fallback = False
-    with config.libversion_fallback(enabled=True):
-        v5 = PypiVersion("custom-1")
-        v6 = PypiVersion("custom-2")
-        assert v5 < v6  # Uses fallback if needed
-