drupal-scout 3.0.2__tar.gz → 3.0.3__tar.gz

{drupal_scout-3.0.2/drupal_scout.egg-info → drupal_scout-3.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drupal-scout
-Version: 3.0.2
+Version: 3.0.3
 Summary: Scout out for transitive versions of Drupal modules for the upgrade of the core.
 Author-email: "Andrew [R-Tech] Tsyhaniuk" <in0mad91@gmail.com>
 License: MIT License

{drupal_scout-3.0.2 → drupal_scout-3.0.3}/drupal_scout/tests/test_worker.py

@@ -161,6 +161,46 @@ class TestWorker(TestCase):
         # Should find no entries for Drupal 11
         self.assertEqual(len(suitable), 0)
 
+    def test_find_suitable_entries_complex_specifiers(self):
+        """
+        Test finding suitable entries with complex requirements like ^10.2 || <10.5, 10.2<10.5, >=9.5 <11.
+        """
+        module = Module(name='drupal/test_module')
+        worker = Worker(module=module, current_core='10.6.3')
+        
+        transitive_entries = [
+            {'version': '1.0.0', 'requirement': '10.2<10.5', 'requirement_parts': ['10.2<10.5']},
+            {'version': '2.0.0', 'requirement': '^10.2 || <10.5', 'requirement_parts': ['^10.2', '<10.5']},
+            {'version': '3.0.0', 'requirement': '>=9.5 <11', 'requirement_parts': ['>=9.5 <11']},
+        ]
+        
+        suitable = worker.find_suitable_entries(transitive_entries)
+        
+        # 10.6.3 satisfies ^10.2 (>=10.2) and >=9.5 <11, but not 10.2<10.5 (<10.5)
+        self.assertEqual(len(suitable), 2)
+        self.assertEqual(suitable[0]['version'], '2.0.0')
+        self.assertEqual(suitable[1]['version'], '3.0.0')
+
+    def test_find_suitable_entries_unparseable_requirement_fallback(self):
+        """
+        Test that unparseable or malformed requirement strings log warnings and do not crash the worker.
+        """
+        module = Module(name='drupal/test_module')
+        worker = Worker(module=module, current_core='10.6.3')
+        
+        transitive_entries = [
+            {'version': '1.0.0', 'requirement': 'invalid_specifier_!@#', 'requirement_parts': ['invalid_specifier_!@#']},
+            {'version': '2.0.0', 'requirement': '10.x.x', 'requirement_parts': ['10.x.x']},
+        ]
+        
+        suitable = worker.find_suitable_entries(transitive_entries)
+        # Should gracefully evaluate without raising an exception
+        self.assertTrue(isinstance(suitable, list))
+        # '10.x.x' should match via major-version fallback (major 10 == current core major 10)
+        # 'invalid_specifier_!@#' has no digits to extract, so it should not match
+        self.assertEqual(len(suitable), 1)
+        self.assertEqual(suitable[0]['version'], '2.0.0')
+
 
 @pytest.mark.asyncio
 async def test_get_retries_on_connection_error():

{drupal_scout-3.0.2 → drupal_scout-3.0.3}/drupal_scout/worker.py

@@ -1,9 +1,12 @@
 import asyncio
 import logging
+import re
 
 import aiohttp
 import jq
 from packaging import version
+from packaging.specifiers import SpecifierSet, InvalidSpecifier
+from packaging.version import InvalidVersion
 from .exceptions import ModuleNotFoundException
 from .module import Module
 
@@ -123,13 +126,74 @@ class Worker:
             '.packages."' + self.module.name + '" | .[] | select(.require != null) | {"version", '
                                                '"requirement":.require."drupal/core"}').input(response_contents).all()
         for entry in entries:
-            if "|" in entry['requirement']:
-                entry['requirement'] = entry['requirement'].replace("^", "").replace(" ", "")
-                entry["requirement_parts"] = [p for p in entry['requirement'].split("|") if p]
-                entry['requirement'] = " || ".join(entry['requirement_parts'])
+            req_str = entry.get('requirement', '')
+            if req_str and "|" in req_str:
+                req_clean = req_str.replace("^", "").replace(" ", "")
+                parts = [p.strip() for p in re.split(r'\|+', req_clean) if p.strip()]
+                entry["requirement_parts"] = parts
+                entry['requirement'] = " || ".join(parts)
                 transitive_entries.append(entry)
         return transitive_entries
 
+    def _is_clause_satisfied(self, clause: str) -> bool:
+        """
+        Check if a single requirement clause is satisfied by self.current_core.
+        """
+        try:
+            core_ver = version.parse(self.current_core)
+        except InvalidVersion:
+            try:
+                core_ver = version.parse(f"{self.current_core}.0.0")
+            except InvalidVersion:
+                return False
+
+        raw_clause = clause.strip()
+        if not raw_clause:
+            return False
+
+        # Fast path for simple numbers or caret major versions e.g. '8', '^8', '9', '10'
+        if re.match(r'^[\^~]?\d+$', raw_clause):
+            try:
+                major = int(re.sub(r'[^\d]', '', raw_clause))
+                return core_ver.major == major
+            except ValueError:
+                pass
+
+        # Normalize specifiers for SpecifierSet
+        spec_str = raw_clause
+        def _expand_caret(m: re.Match) -> str:
+            ver_str = m.group(1)
+            major = int(ver_str.split('.')[0])
+            return f">={ver_str}, <{major + 1}.0.0"
+        spec_str = re.sub(r'\^(\d+(?:\.\d+)*)', _expand_caret, spec_str)
+        spec_str = re.sub(r'(\d+(?:\.\d+)*)\s*([<>=!~])', r'\1, \2', spec_str)
+        parts = [p.strip() for p in spec_str.split(',') if p.strip()]
+        norm_parts = []
+        for p in parts:
+            if re.match(r'^\d+\.x$', p):
+                norm_parts.append(f"=={p.split('.')[0]}.*")
+            elif re.match(r'^\d+$', p):
+                norm_parts.append(f"=={p}.*")
+            elif re.match(r'^\d+(\.\d+)+$', p):
+                norm_parts.append(f">={p}")
+            else:
+                norm_parts.append(p)
+        norm_spec_str = ", ".join(norm_parts)
+
+        try:
+            spec_set = SpecifierSet(norm_spec_str)
+            return core_ver in spec_set
+        except (InvalidSpecifier, InvalidVersion) as exc:
+            logger.warning("Failed to evaluate requirement clause %r as SpecifierSet: %s", clause, exc)
+            matches = re.findall(r'\b\d+\b', raw_clause)
+            if matches:
+                try:
+                    majors = [int(m) for m in matches]
+                    return core_ver.major in majors
+                except ValueError:
+                    pass
+            return False
+
     def find_suitable_entries(self, transitive_entries: list) -> list:
         """
         Get the suitable transitive versions of the module.
@@ -139,20 +203,24 @@ class Worker:
         :rtype:     list
         """
         suitable_entries = []
-        current_major_version = version.parse(self.current_core).major
         for entry in transitive_entries:
-            # Parse all requirement parts to extract major versions
-            requirement_major_versions = [version.parse(req_part).major for req_part in entry['requirement_parts']]
-            
-            # Check if the current major version is in the list of supported major versions
-            # The requirement uses || to indicate OR, so the module supports any of these versions
-            if current_major_version in requirement_major_versions:
+            req_parts = entry.get('requirement_parts', [])
+            if not req_parts and 'requirement' in entry:
+                req_parts = [p.strip() for p in re.split(r'\|+', entry['requirement']) if p.strip()]
+
+            if any(self._is_clause_satisfied(part) for part in req_parts):
                 suitable_entries.append(entry)
 
         # apply post-filtering if the lock version is used and the module version is specified
         if self.use_lock_version and self.module.version:
-            suitable_entries = [
-                entry for entry in suitable_entries
-                if version.parse(entry['version']) >= version.parse(self.module.version)
-            ]
+            filtered = []
+            for entry in suitable_entries:
+                try:
+                    if version.parse(entry['version']) >= version.parse(self.module.version):
+                        filtered.append(entry)
+                except Exception:
+                    filtered.append(entry)
+            suitable_entries = filtered
+
         return suitable_entries
+

{drupal_scout-3.0.2 → drupal_scout-3.0.3/drupal_scout.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drupal-scout
-Version: 3.0.2
+Version: 3.0.3
 Summary: Scout out for transitive versions of Drupal modules for the upgrade of the core.
 Author-email: "Andrew [R-Tech] Tsyhaniuk" <in0mad91@gmail.com>
 License: MIT License

{drupal_scout-3.0.2 → drupal_scout-3.0.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "drupal-scout"
-version = "3.0.2"
+version = "3.0.3"
 description = "Scout out for transitive versions of Drupal modules for the upgrade of the core."
 readme = "README.md"
 license = { file = "LICENSE.txt" }