add libversion fallback

Signed-off-by: Kunz, Immanuel <immanuel.kunz@aisec.fraunhofer.de>

Author: immqu

README.rst

@@ -120,15 +120,21 @@ and support for more package types are implemented on a continuous basis.
 
 Alternative
 ============
-
 Rather than using ecosystem-specific version schemes and code, another approach
 is to use a single procedure for all the versions as implemented in `libversion
 <https://github.com/repology/libversion>`_. ``libversion`` works in the most
 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: 
+.. code:: python
+    v3 = PypiVersion("1.2.3-invalid")
+    v4 = PypiVersion("1.2.4-invalid")
+    result = v3 < v4 # Error without fallback
 
+    config.use_libversion_fallback = True
+    result = v3 < v4 # result == True
 
 Installation
 ============

src/univers/config.py

@@ -0,0 +1,66 @@
+
+# univers/config.py
+
+from contextlib import contextmanager
+
+class Config:
+    """
+    Global configuration for univers library.
+    
+    Simple configuration for single-threaded use.
+    """
+    
+    def __init__(self):
+        self._use_libversion_fallback = False
+    
+    @property
+    def use_libversion_fallback(self):
+        """
+        Get the current libversion fallback setting.
+        
+        Returns:
+            bool: True if libversion fallback is enabled, False otherwise.
+        """
+        return self._use_libversion_fallback
+    
+    @use_libversion_fallback.setter
+    def use_libversion_fallback(self, value):
+        """
+        Set the global libversion fallback setting.
+        
+        Args:
+            value: Boolean value to enable (True) or disable (False) fallback.
+        
+        Example:
+            >>> from univers import config
+            >>> config.use_libversion_fallback = True
+        """
+        self._use_libversion_fallback = bool(value)
+    
+    @contextmanager
+    def libversion_fallback(self, enabled=True):
+        """
+        Context manager for temporary fallback setting.
+        
+        Args:
+            enabled (bool): Whether to enable fallback within the context.
+        
+        Example:
+            >>> from univers import config
+            >>> from univers.versions import PypiVersion
+            >>> 
+            >>> with config.libversion_fallback(enabled=True):
+            ...     v1 = PypiVersion("1.2.3-custom")
+            ...     v2 = PypiVersion("1.2.4-custom")
+            ...     result = v1 < v2
+        """
+        old_value = self._use_libversion_fallback
+        self._use_libversion_fallback = enabled
+        try:
+            yield
+        finally:
+            self._use_libversion_fallback = old_value
+
+# Global config instance
+
+config = Config()

src/univers/versions.py

@@ -9,6 +9,7 @@
 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
@@ -85,17 +86,86 @@ class Version:
 
     def __attrs_post_init__(self):
         normalized_string = self.normalize(self.string)
-        if not self.is_valid(normalized_string):
-            raise InvalidVersion(f"{self.string!r} is not a valid {self.__class__!r}")
+        
+        # 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}")
 
         # 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)
-        value = self.build_value(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
+
     @classmethod
     def is_valid(cls, string):
         """

tests/test_versions.py

@@ -12,12 +12,9 @@
 from univers.versions import EnhancedSemanticVersion
 from univers.versions import GentooVersion
 from univers.versions import GolangVersion
-<<<<<<< HEAD
 from univers.versions import IntdotVersion
 from univers.versions import LexicographicVersion
-=======
 from univers.versions import LibversionVersion
->>>>>>> 1533a12 (first libversion draft)
 from univers.versions import MavenVersion
 from univers.versions import NginxVersion
 from univers.versions import NugetVersion
@@ -26,6 +23,7 @@
 from univers.versions import RubygemsVersion
 from univers.versions import SemverVersion
 from univers.versions import Version
+from univers.config import config
 
 
 def test_version():
@@ -260,3 +258,24 @@ def test_libversion_version():
     assert LibversionVersion("1.2.3-alpha") < LibversionVersion("1.2.3")
     assert LibversionVersion("1.2.3-alpha") != LibversionVersion("1.2.3-beta")
     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
+