Added P019 to the output results, patched issues #37 #36 #35

Author: Anas-Elhounsri

src/metacheck/detect_pitfalls_main.py

@@ -23,6 +23,7 @@
 from metacheck.scripts.pitfalls.p016 import detect_different_repository_pitfall
 from metacheck.scripts.pitfalls.p017 import detect_codemeta_version_mismatch_pitfall
 from metacheck.scripts.pitfalls.p018 import detect_raw_swhid_pitfall
+from metacheck.scripts.pitfalls.p019 import detect_inconsistent_author_count
 
 # Warnings
 from metacheck.scripts.warnings.w001 import detect_unversioned_requirements
@@ -190,6 +191,13 @@ def detect_all_pitfalls(json_files: Iterable[Path], pitfalls_output_dir: Union[s
                 "percentage": 0.0,
                 "languages": {}
             },
+            {
+                "pitfall_code": "P019",
+                "pitfall_desc": "Inconsistent author counts found across metadata files",
+                "count": 0,
+                "percentage": 0.0,
+                "languages": {}
+            },
             {
                 "warning_code": "W001",
                 "warning_desc": "Software requirements in metadata files don't have version specifications",
@@ -268,7 +276,7 @@ def detect_all_pitfalls(json_files: Iterable[Path], pitfalls_output_dir: Union[s
     total_repos = 0
     repos_with_target_languages = 0
     jsonld_files_created = 0
-    pitfall_counts = [0] * 27
+    pitfall_counts = [0] * 29
 
     pitfall_detectors = [
         (detect_version_mismatch, "P001"),  # Index 0 -> P001
@@ -289,16 +297,17 @@ def detect_all_pitfalls(json_files: Iterable[Path], pitfalls_output_dir: Union[s
         (detect_different_repository_pitfall, "P016"),  # Index 15 -> P016
         (detect_codemeta_version_mismatch_pitfall, "P017"),  # Index 16 -> P017
         (detect_raw_swhid_pitfall, "P018"),  # Index 17 -> P018
-        (detect_unversioned_requirements, "W001"),  # Index 18 -> W001
-        (detect_outdated_datemodified, "W002"),  # Index 19 -> W002
+        (detect_inconsistent_author_count, "P019"),  # Index 18 -> P019
+        (detect_unversioned_requirements, "W001"),  # Index 19 -> W001
+        (detect_outdated_datemodified, "W002"),  # Index 20 -> W002
         (detect_dual_license_missing_codemeta_pitfall, "W003"),
-        (detect_programming_language_no_version_pitfall, "W004"),  # Index 20 -> W004
-        (detect_multiple_requirements_string_warning, "W005"),  # Index 21 -> W005
-        (detect_identifier_name_warning, "W006"),  # Index 22 -> W006
-        (detect_empty_identifier_warning, "W007"),  # Index 23 -> W007
-        (detect_author_name_list_warning, "W008"),  # Index 24 -> W008
-        (detect_development_status_url_pitfall, "W009"),  # Index 25 -> W009
-        (detect_git_remote_shorthand_pitfall, "W010"),  # Index 26 -> W010
+        (detect_programming_language_no_version_pitfall, "W004"),  # Index 21 -> W004
+        (detect_multiple_requirements_string_warning, "W005"),  # Index 22 -> W005
+        (detect_identifier_name_warning, "W006"),  # Index 23 -> W006
+        (detect_empty_identifier_warning, "W007"),  # Index 24 -> W007
+        (detect_author_name_list_warning, "W008"),  # Index 25 -> W008
+        (detect_development_status_url_pitfall, "W009"),  # Index 26 -> W009
+        (detect_git_remote_shorthand_pitfall, "W010"),  # Index 27 -> W010
     ]
 
     for json_file in json_files:

src/metacheck/scripts/pitfalls/p013.py

@@ -26,12 +26,12 @@ def detect_license_no_version_pitfall(somef_data: Dict, file_name: str) -> Dict:
                         "requirements.txt", "setup.py"]
 
     versioned_patterns = {
-        "GPL": r"GPL[-\s]?\d+(\.\d+)?",
-        "LGPL": r"LGPL[-\s]?\d+(\.\d+)?",
-        "AGPL": r"AGPL[-\s]?\d+(\.\d+)?",
-        "Apache": r"Apache[-\s]?\d+(\.\d+)?",
-        "CC": r"CC[- ]BY[-\s]?\d+(\.\d+)?",
-        "BSD": r"BSD[-\s]\d+[-\s]Clause"
+        "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+)?",
+        "BSD": r"\bBSD[-\s]\d+[-\s]Clause"
     }
 
     for entry in license_entries:
@@ -52,14 +52,17 @@ def detect_license_no_version_pitfall(somef_data: Dict, file_name: str) -> Dict:
 
                     if "0BSD" in license_value:
                         continue
+                    
+                    if "LICENSEREF-" in license_upper:
+                        continue
 
                     for license_name, version_pattern in versioned_patterns.items():
-                        if license_name in license_upper:
+                        if re.search(rf"\b{license_name}\b", license_upper):
                             if not re.search(version_pattern, license_upper, re.IGNORECASE):
                                 result["has_pitfall"] = True
                                 result["license_value"] = license_value
                                 result["source"] = source
                                 result["metadata_source_file"] = extract_metadata_source_filename(source)
-                                return result  # Stop at first match
+                                return result
 
     return result

src/metacheck/scripts/warnings/w003.py

@@ -7,7 +7,7 @@ def detect_dual_license_missing_codemeta_pitfall(somef_data: Dict, file_name: st
     Detect when repository has multiple licenses but codemeta.json only lists one.
     """
     result = {
-        "has_pitfall": False,
+        "has_warning": False,
         "file_name": file_name,
         "has_dual_license_indicator": False,
         "codemeta_license_count": 0,
@@ -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"licen[cs]ed?\s+under.*(?:and|or)",
-        r"choose.*licen[cs]e",
-        r"either.*licen[cs]e",
+        r"(?:is|are)\s+licen[cs]ed?\s+under.*(?:and|or).*licen[cs]e", 
+        r"choose.*(?:between|from).*licen[cs]e",  
+        r"either.*or.*licen[cs]e",  
         r"\d+\..*licen[cs]e.*\n.*\d+\..*licen[cs]e",
         r"licen[cs]e.*options?",
-        r"available\s+under.*licen[cs]es?"
-    ]
+        r"available\s+under.*(?:two|multiple|either).*licen[cs]es?" 
+]
 
     has_dual_license_indicator = False
     dual_license_source = None
@@ -59,6 +59,6 @@ def detect_dual_license_missing_codemeta_pitfall(somef_data: Dict, file_name: st
     result["dual_license_source"] = dual_license_source
 
     if has_dual_license_indicator and codemeta_license_count <= 1:
-        result["has_pitfall"] = True
+        result["has_warning"] = True
 
     return result

src/metacheck/utils/json_ld_utils.py

@@ -253,6 +253,16 @@ def format_evidence_text(pitfall_code: str, pitfall_result: Dict) -> str:
             identifier_value = pitfall_result.get('identifier_value') or 'unknown'
             return f"{evidence_base}codemeta.json Identifier uses raw SWHID without resolvable URL: '{identifier_value}'"
 
+    elif pitfall_code == "P019":
+        if "inconsistencies" in pitfall_result:
+            inconsistency = pitfall_result["inconsistencies"][0]
+            source_fewer = inconsistency.get('source_with_fewer', 'unknown')
+            count_fewer = inconsistency.get('fewer_count', 0)
+            source_more = inconsistency.get('source_with_more', 'unknown')
+            count_more = inconsistency.get('more_count', 0)
+            return f"{evidence_base}Author count mismatch: {source_fewer} has {count_fewer} while {source_more} has {count_more}"
+        return f"{evidence_base}Inconsistent author counts found across metadata files"
+
     # Warnings
     elif pitfall_code == "W001":
         if "unversioned_requirements" in pitfall_result:
@@ -288,9 +298,9 @@ def format_evidence_text(pitfall_code: str, pitfall_result: Dict) -> str:
         return f"{evidence_base}codemeta.json Programming languages in metadata do not have version specifications"
 
     elif pitfall_code == "W005":
-        if "requirements_string" in pitfall_result:
+        if "requirement_string" in pitfall_result:
             metadata_source = extract_metadata_source(pitfall_result)
-            requirements_string = pitfall_result.get('requirements_string') or 'unknown'
+            requirements_string = pitfall_result.get('requirement_string') or 'unknown'
             return f"{evidence_base}{metadata_source} Multiple requirements written as single string: '{requirements_string}'"
 
     elif pitfall_code == "W006":
@@ -348,6 +358,7 @@ def get_pitfall_category(pitfall_code: str) -> str:
         "P016": "metadatafile",  # metadata file codeRepository different repo
         "P017": "codemeta",  # codemeta.json version mismatch
         "P018": "codemeta",  # codemeta.json raw SWHIDs
+        "P019": "metadatafile",  # inconsistent author counts
 
         # Warnings
         "W001": "metadatafile",  # metadata file requirements
@@ -389,6 +400,7 @@ def get_suggestion_text(pitfall_code: str) -> str:
         "P016": "Make sure that the codeRepository URL in your metadata exactly matches the repository hosting your source code.",
         "P017": "You need to synchronize all version references across metadata and build configuration files.",
         "P018": "Always use the full resolvable SWHID URL (e.g., https://archive.softwareheritage.org/swh:1:dir:abcd.../). This will ensure that both humans and machines can access the archived software snapshot directly",
+        "P019": "Ensure that the number of authors is consistent across all metadata files. Inconsistencies may signal that some contributors are missing in certain files.",
 
         # Warnings
         "W001": "Add version numbers to your dependencies. This provides stability for users and allows reproducibility across different environments.",
@@ -491,7 +503,6 @@ def save_individual_pitfall_jsonld(jsonld_data: Dict, output_dir: Path, file_nam
     output_file = output_dir / f"{base_name}_pitfalls.jsonld"
 
     try:
-        # Convert any sets to lists before JSON serialization
         serializable_data = convert_sets_to_lists(jsonld_data)
 
         with open(output_file, 'w', encoding='utf-8') as f: