Patches for P013, P016, W001, W003 and W005. Updated path of tests and all pass. Bumped SoMEF version to 0.10.3

Author: Anas-Elhounsri

poetry.lock

@@ -7,9 +7,9 @@ readme = "README.md"
 packages = [{include = "rsmetacheck", from = "src"}]
 
 [tool.poetry.dependencies]
-python = ">=3.11,<3.13"
-requests = "*"
-somef = "0.10.1"
+    python = ">=3.11,<3.13"
+    requests = "*"
+    somef = "0.10.3"
 
 [tool.poetry.scripts]
 rsmetacheck = "rsmetacheck.cli:cli"

pyproject.toml

@@ -26,11 +26,11 @@ def detect_license_no_version_pitfall(somef_data: Dict, file_name: str) -> Dict:
                         "requirements.txt", "setup.py"]
 
     versioned_patterns = {
-        "GPL": r"\bGPL[-\s]?\d+(\.\d+)?",
-        "LGPL": r"\bLGPL[-\s]?\d+(\.\d+)?",
-        "AGPL": r"\bAGPL[-\s]?\d+(\.\d+)?",
-        "Apache": r"\bApache[-\s]?\d+(\.\d+)?",
-        "CC": r"\bCC[- ]BY[-\s]?\d+(\.\d+)?",
+        "GPL": r"\bGPL[-\s]?\(?\s*(?:>=?|<=?|>|<|=)?\s*\d+(\.\d+)?\)?",
+        "LGPL": r"\bLGPL[-\s]?\(?\s*(?:>=?|<=?|>|<|=)?\s*\d+(\.\d+)?\)?",
+        "AGPL": r"\bAGPL[-\s]?\(?\s*(?:>=?|<=?|>|<|=)?\s*\d+(\.\d+)?\)?",
+        "Apache": r"\bApache[-\s]?\(?\s*(?:>=?|<=?|>|<|=)?\s*\d+(\.\d+)?\)?",
+        "CC": r"\bCC[- ]BY[-\s]?\(?\s*(?:>=?|<=?|>|<|=)?\s*\d+(\.\d+)?\)?",
         "BSD": r"\bBSD[-\s]\d+[-\s]Clause"
     }
 

src/rsmetacheck/scripts/pitfalls/p013.py

@@ -11,9 +11,12 @@ def normalize_repository_url(url: str) -> str:
     url = url.lower().strip()
 
     url = re.sub(r'^git\+', '', url)  # Remove git+ prefix
+    url = re.sub(r'^http://', 'https://', url)  # Normalize http to https
+    url = url.replace('www.github.com', 'github.com')
 
     url = re.sub(r'/$', '', url)  # Remove trailing slash
     url = re.sub(r'\.git$', '', url)  # Remove .git suffix
+    url = re.sub(r'/$', '', url)  # Remove trailing slash again if it was .git/
 
     if url.startswith('git@'):
         url = re.sub(r'^git@([^:]+):', r'https://\1/', url)

src/rsmetacheck/scripts/pitfalls/p016.py

@@ -1,4 +1,5 @@
 from typing import Dict, List, Tuple, Optional
+import re
 from rsmetacheck.utils.pitfall_utils import extract_metadata_source_filename
 
 
@@ -31,25 +32,14 @@ def extract_requirements_from_metadata(somef_data: Dict) -> List[Dict]:
     return results
 
 
-def check_requirement_has_version(requirement: Dict) -> bool:
+def check_requirement_has_version(req_name: str) -> bool:
     """
     Check if a single requirement has version information.
     Returns True if version is present and non-empty, False otherwise.
     """
-    if "version" in requirement:
-        version = requirement["version"]
-        # Version should be non-empty string
-        if isinstance(version, str) and version.strip():
-            return True
-
-    if "value" in requirement:
-        value = requirement["value"]
-        if isinstance(value, str):
-
-            version_operators = ["==", ">=", "<=", ">", "<", "~=", "!=", "^", "~"]
-            if any(op in value for op in version_operators):
-                return True
-
+    version_operators = ["==", ">=", "<=", ">", "<", "~=", "!=", "^", "~"]
+    if any(op in req_name for op in version_operators) or re.search(r'\bv?\d+(\.\d+)+\b', req_name):
+        return True
     return False
 
 
@@ -67,17 +57,30 @@ def analyze_requirements_versions(requirements_data: Dict) -> Tuple[int, int, Li
     else:
         return 0, 0, []
 
-    total_requirements = len(requirements_list)
+    total_requirements = 0
     unversioned_count = 0
     unversioned_names = []
 
     for req in requirements_list:
         if isinstance(req, dict):
-            has_version = check_requirement_has_version(req)
-            if not has_version:
-                unversioned_count += 1
-                req_name = req.get("name", req.get("value", "unknown"))
-                unversioned_names.append(req_name)
+            req_name = req.get("name", req.get("value", "unknown"))
+            if isinstance(req_name, str) and bool(re.search(r'\b(npm|bash|cd|pip|install)\b', req_name.lower())):
+                continue
+            
+            if isinstance(req_name, str) and ',' in req_name:
+                parts = [p.strip() for p in req_name.split(',')]
+            else:
+                parts = [req_name]
+                
+            for part in parts:
+                if not part: continue
+                total_requirements += 1
+                has_version_field = "version" in req and bool(req["version"])
+                has_version_str = isinstance(part, str) and check_requirement_has_version(part)
+                
+                if not (has_version_field or has_version_str):
+                    unversioned_count += 1
+                    unversioned_names.append(part)
 
     return total_requirements, unversioned_count, unversioned_names
 

src/rsmetacheck/scripts/warnings/w001.py

@@ -25,13 +25,13 @@ def detect_dual_license_missing_codemeta_pitfall(somef_data: Dict, file_name: st
         r"dual[\s-]?licen[cs]ed?",
         r"dually[\s-]?licen[cs]ed?",
         r"multiple[\s-]?licen[cs]es?",
-        r"(?:is|are)\s+licen[cs]ed?\s+under.*(?:and|or).*licen[cs]e", 
-        r"choose.*(?:between|from|your).*licen[cs]e",  
-        r"either.*or.*licen[cs]e",  
+        r"(?:is|are)\s+licen[cs]ed?\s+under.*\b(?:and|or)\b.*licen[cs]e", 
+        r"choose.*\b(?:between|from|your)\b.*licen[cs]e",  
+        r"\beither\b.*\bor\b.*licen[cs]e",  
         r"\d+\..*licen[cs]e.*\n.*\d+\..*licen[cs]e",
         r"licen[cs]e.*options?",
-        r"available\s+under.*(?:two|multiple|either).*licen[cs]es?",
-        r"licen[cs]ed? under.*(?:and|or)"
+        r"available\s+under.*\b(?:two|multiple|either)\b.*licen[cs]es?",
+        r"licen[cs]ed?\s+under.*\b(?:and|or)\b"
     ]
 
     has_dual_license_indicator = False

src/rsmetacheck/scripts/warnings/w003.py

@@ -15,27 +15,28 @@ def detect_multiple_requirements_in_string(requirement_string: str) -> List[str]
     req_str = requirement_string.strip()
 
     # Patterns that might indicate multiple requirements
-    # Split by common separators but be careful not to split version specifiers
-    potential_separators = [
-        r'\s{2,}',  # Multiple spaces
-        r'\s+(?=[A-Za-z])',  # Space followed by letter (new requirement)
-        r',\s*',  # Comma separation
-        r';\s*',  # Semicolon separation
-    ]
+    if bool(re.search(r'\b(npm|bash|cd|pip|install)\b', req_str.lower())):
+        return []
 
     detected_requirements = []
 
-    if re.search(r'\s{2,}', req_str):
+    if re.search(r',\s*', req_str):
+        parts = re.split(r',\s*', req_str)
+        if len(parts) > 1:
+            detected_requirements = [part.strip() for part in parts if part.strip()]
+    elif re.search(r';\s*', req_str):
+        parts = re.split(r';\s*', req_str)
+        if len(parts) > 1:
+            detected_requirements = [part.strip() for part in parts if part.strip()]
+    elif re.match(r'^([A-Z][a-zA-Z0-9]*(\s+|$)){2,}$', req_str):
+        parts = re.split(r'\s+', req_str)
+        if len(parts) > 1:
+            detected_requirements = [part.strip() for part in parts if part.strip()]
+    elif re.search(r'\s{2,}', req_str):
         parts = re.split(r'\s{2,}', req_str)
         if len(parts) > 1:
             detected_requirements = [part.strip() for part in parts if part.strip()]
 
-    if not detected_requirements:
-        if re.search(r'\s+[A-Z][A-Za-z]', req_str):
-            parts = re.split(r'\s+(?=[A-Z])', req_str)
-            if len(parts) > 1:
-                detected_requirements = [part.strip() for part in parts if part.strip()]
-
     return detected_requirements if len(detected_requirements) > 1 else []
 
 

src/rsmetacheck/scripts/warnings/w005.py

@@ -328,9 +328,11 @@ def format_evidence_text(pitfall_code: str, pitfall_result: Dict) -> str:
             if different_urls and isinstance(different_urls, list) and len(different_urls) > 0:
                 source_path = different_urls[0].get("source", "")
                 metadata_source = extract_metadata_source_filename(source_path)
+                mismatched_url = different_urls[0].get("url", "unknown URL")
+                return f"{evidence_base}the correct URL is {github_api_url}, and the one found in {metadata_source} is {mismatched_url}"
             elif "source" in pitfall_result:
                 metadata_source = extract_metadata_source(pitfall_result)
-            return f"{evidence_base}{metadata_source} codeRepository points to different repository: {github_api_url}"
+            return f"{evidence_base}the correct URL is {github_api_url}, and the one found in {metadata_source} is unknown"
 
     elif pitfall_code == "P017":
         if "codemeta_version" in pitfall_result: