Added more dynamic report of pitfalls from multiple sources issue #86

Author: Anas-Elhounsri

src/rsmetacheck/scripts/pitfalls/p001.py

@@ -1,5 +1,5 @@
 import re
-from typing import Dict, Optional, List, Union
+from typing import Dict, Optional, List
 from rsmetacheck.utils.pitfall_utils import normalize_version
 from rsmetacheck.utils.pitfall_utils import extract_metadata_source_filename
 
@@ -95,15 +95,15 @@ def extract_latest_release_version(somef_data: Dict) -> Optional[str]:
 
     return None
 
+
 def detect_version_mismatch(somef_data: Dict, file_name: str) -> list:
     """
     Detect version mismatches between metadata files and the latest release.
-    Checks all metadata files and returns one result dict per metadata source
-    that has an inconsistency.
+    Returns a single result with all mismatched sources merged into one evidence message.
 
     - Metadata version > release by >= 2 in any component: pitfall
-    - Metadata version > release by < 2: note (best practice to prepare ahead)
-    - Metadata version < release: pitfall (metadata was not updated)
+    - Metadata version > release by < 2: note
+    - Metadata version < release: pitfall
     - Metadata version == release: no issue
     """
     metadata_versions = extract_version_from_metadata(somef_data)
@@ -113,7 +113,10 @@ def detect_version_mismatch(somef_data: Dict, file_name: str) -> list:
         return []
 
     normalized_release_version = normalize_version(release_version)
-    results = []
+
+    pitfall_sources = []
+    note_sources = []
+    all_mismatches = []
 
     for md_info in metadata_versions:
         metadata_version = normalize_version(md_info["version"])
@@ -122,48 +125,56 @@ def detect_version_mismatch(somef_data: Dict, file_name: str) -> list:
         if metadata_version == normalized_release_version:
             continue
 
+        all_mismatches.append({
+            "source_file": metadata_source_file,
+            "source": md_info["source"],
+            "metadata_version": metadata_version,
+        })
+
         if _metadata_ahead_of_release(metadata_version, normalized_release_version):
             if _version_diff_significant(metadata_version, normalized_release_version):
-                results.append({
-                    "has_pitfall": True,
-                    "has_note": False,
-                    "file_name": file_name,
-                    "metadata_version": metadata_version,
-                    "release_version": normalized_release_version,
-                    "metadata_source": md_info["source"],
-                    "metadata_source_file": metadata_source_file,
-                    "note_text": None,
-                    "notes": []
-                })
+                pitfall_sources.append(metadata_source_file)
             else:
-                note_text = f"Version discrepancy: {metadata_source_file} version '{metadata_version}' is ahead of release version '{normalized_release_version}'"
-                results.append({
-                    "has_pitfall": False,
-                    "has_note": True,
-                    "file_name": file_name,
-                    "metadata_version": metadata_version,
-                    "release_version": normalized_release_version,
-                    "metadata_source": md_info["source"],
-                    "metadata_source_file": metadata_source_file,
-                    "note_text": note_text,
-                    "notes": [{
-                        "metadata_source_file": metadata_source_file,
-                        "metadata_version": metadata_version,
-                        "release_version": normalized_release_version,
-                        "note_text": note_text
-                    }]
-                })
+                note_sources.append(metadata_source_file)
         else:
-            results.append({
-                "has_pitfall": True,
-                "has_note": False,
-                "file_name": file_name,
-                "metadata_version": metadata_version,
+            pitfall_sources.append(metadata_source_file)
+
+    if not all_mismatches:
+        return []
+
+    has_any_pitfall = len(pitfall_sources) > 0
+    has_any_note = len(note_sources) > 0
+
+    all_source_files = [m["source_file"] for m in all_mismatches]
+
+    # Build notes for any ahead-by-small-amount sources
+    notes = []
+    note_text = None
+    for m in all_mismatches:
+        m_version = m["metadata_version"]
+        if _metadata_ahead_of_release(m_version, normalized_release_version) and not _version_diff_significant(m_version, normalized_release_version):
+            text = f"Version discrepancy: {m['source_file']} version '{m_version}' is ahead of release version '{normalized_release_version}'"
+            notes.append({
+                "metadata_source_file": m["source_file"],
+                "metadata_version": m_version,
                 "release_version": normalized_release_version,
-                "metadata_source": md_info["source"],
-                "metadata_source_file": metadata_source_file,
-                "note_text": None,
-                "notes": []
+                "note_text": text
             })
-
-    return results
+            if note_text is None:
+                note_text = text
+
+    result = {
+        "has_pitfall": has_any_pitfall,
+        "has_note": (not has_any_pitfall and has_any_note),
+        "file_name": file_name,
+        "mismatched_sources": all_mismatches,
+        "metadata_source_files": all_source_files,
+        "release_version": normalized_release_version,
+        "note_text": note_text,
+        "notes": notes,
+        "metadata_version": all_mismatches[0]["metadata_version"] if all_mismatches else None,
+        "metadata_source_file": all_mismatches[0]["source_file"] if all_mismatches else None,
+        "metadata_source": all_mismatches[0]["source"] if all_mismatches else None,
+    }
+
+    return [result]

src/rsmetacheck/scripts/pitfalls/p003.py

@@ -32,13 +32,15 @@ def has_multiple_authors_in_single_field(author_value: str) -> bool:
 def detect_multiple_authors_single_field_pitfall(somef_data: Dict, file_name: str) -> Dict:
     """
     Detect when metadata files have multiple authors in a single field instead of a list.
+    Checks all metadata sources and collects all affected files.
     """
     result = {
         "has_pitfall": False,
         "file_name": file_name,
         "author_value": None,
         "source": None,
         "metadata_source_file": None,
+        "metadata_source_files": [],
         "multiple_authors_detected": False
     }
 
@@ -69,22 +71,26 @@ def detect_multiple_authors_single_field_pitfall(somef_data: Dict, file_name: st
                 # Handle different value formats
                 if isinstance(author_value, str):
                     if has_multiple_authors_in_single_field(author_value):
+                        source_filename = extract_metadata_source_filename(source)
+                        if result["author_value"] is None:
+                            result["author_value"] = author_value
+                            result["source"] = source
+                            result["metadata_source_file"] = source_filename
+                        result["metadata_source_files"].append(source_filename)
                         result["has_pitfall"] = True
-                        result["author_value"] = author_value
-                        result["source"] = source
-                        result["metadata_source_file"] = extract_metadata_source_filename(source)
                         result["multiple_authors_detected"] = True
-                        break
 
                 elif isinstance(author_value, dict) and "name" in author_value:
                     # Handle structured author data
                     name_value = author_value["name"]
                     if isinstance(name_value, str) and has_multiple_authors_in_single_field(name_value):
+                        source_filename = extract_metadata_source_filename(source)
+                        if result["author_value"] is None:
+                            result["author_value"] = name_value
+                            result["source"] = source
+                            result["metadata_source_file"] = source_filename
+                        result["metadata_source_files"].append(source_filename)
                         result["has_pitfall"] = True
-                        result["author_value"] = name_value
-                        result["source"] = source
-                        result["metadata_source_file"] = extract_metadata_source_filename(source)
                         result["multiple_authors_detected"] = True
-                        break
 
     return result

src/rsmetacheck/scripts/pitfalls/p006.py

@@ -40,13 +40,15 @@ def is_local_file_license(license_value: str) -> bool:
 def detect_local_file_license_pitfall(somef_data: Dict, file_name: str) -> Dict:
     """
     Detect when license in metadata files points to a local file instead of stating the name.
+    Checks all metadata sources and collects all affected files.
     """
     result = {
         "has_pitfall": False,
         "file_name": file_name,
         "license_value": None,
         "source": None,
         "metadata_source_file": None,
+        "metadata_source_files": [],
         "is_local_file": False
     }
 
@@ -68,11 +70,13 @@ def detect_local_file_license_pitfall(somef_data: Dict, file_name: str) -> Dict:
                 license_value = entry["result"]["value"]
 
                 if is_local_file_license(license_value):
+                    source_filename = extract_metadata_source_filename(source)
+                    if result["license_value"] is None:
+                        result["license_value"] = license_value
+                        result["source"] = source if source else f"technique: {technique}"
+                        result["metadata_source_file"] = source_filename
+                    result["metadata_source_files"].append(source_filename)
                     result["has_pitfall"] = True
-                    result["license_value"] = license_value
-                    result["source"] = source if source else f"technique: {technique}"
-                    result["metadata_source_file"] = extract_metadata_source_filename(source)
                     result["is_local_file"] = True
-                    break
 
     return result

src/rsmetacheck/scripts/pitfalls/p008.py

@@ -92,13 +92,15 @@ def extract_urls_from_requirements(requirement_text: str) -> list:
 def detect_invalid_software_requirement_pitfall(somef_data: Dict, file_name: str) -> Dict:
     """
     Detect when metadata files have software requirements pointing to invalid pages.
+    Checks all metadata sources and collects all affected files.
     """
     result = {
         "has_pitfall": False,
         "file_name": file_name,
         "invalid_urls": [],
         "source": None,
         "metadata_source_file": None,
+        "metadata_source_files": [],
         "requirement_text": None
     }
 
@@ -129,16 +131,18 @@ def detect_invalid_software_requirement_pitfall(somef_data: Dict, file_name: str
                     url_status = check_url_status(req_value)
 
                     if not url_status["is_accessible"]:
-                        result["has_pitfall"] = True
-                        result["invalid_urls"] = [{
+                        source_filename = extract_metadata_source_filename(source)
+                        if result["source"] is None:
+                            result["source"] = source
+                            result["metadata_source_file"] = source_filename
+                            result["requirement_text"] = req_value
+                        result["invalid_urls"].append({
                             "url": req_value,
                             "status_code": url_status["status_code"],
                             "error": url_status["error"]
-                        }]
-                        result["source"] = source
-                        result["metadata_source_file"] = extract_metadata_source_filename(source)
-                        result["requirement_text"] = req_value
-                        break
+                        })
+                        result["metadata_source_files"].append(source_filename)
+                        result["has_pitfall"] = True
                 else:
                     requirement_text = ""
                     if isinstance(req_value, str):
@@ -167,11 +171,13 @@ def detect_invalid_software_requirement_pitfall(somef_data: Dict, file_name: str
                                     })
 
                             if invalid_urls:
+                                source_filename = extract_metadata_source_filename(source)
+                                if result["source"] is None:
+                                    result["source"] = source
+                                    result["metadata_source_file"] = source_filename
+                                    result["requirement_text"] = requirement_text
+                                result["invalid_urls"].extend(invalid_urls)
+                                result["metadata_source_files"].append(source_filename)
                                 result["has_pitfall"] = True
-                                result["invalid_urls"] = invalid_urls
-                                result["source"] = source
-                                result["metadata_source_file"] = extract_metadata_source_filename(source)
-                                result["requirement_text"] = requirement_text
-                                break
 
     return result

src/rsmetacheck/scripts/pitfalls/p009.py

@@ -68,13 +68,15 @@ def is_homepage_url_repo(url: str) -> bool:
 def detect_coderepository_homepage_pitfall(somef_data: Dict, file_name: str) -> Dict:
     """
     Detect when code repository in metadata files points to homepage instead of repository.
+    Checks all metadata sources and collects all affected files.
     """
     result = {
         "has_pitfall": False,
         "file_name": file_name,
         "repository_url": None,
         "source": None,
         "metadata_source_file": None,
+        "metadata_source_files": [],
         "is_homepage": False
     }
 
@@ -103,11 +105,13 @@ def detect_coderepository_homepage_pitfall(somef_data: Dict, file_name: str) ->
                 repo_url = entry["result"]["value"]
 
                 if is_homepage_url_repo(repo_url):
+                    source_filename = extract_metadata_source_filename(source)
+                    if result["repository_url"] is None:
+                        result["repository_url"] = repo_url
+                        result["source"] = source if source else f"technique: {technique}"
+                        result["metadata_source_file"] = source_filename
+                    result["metadata_source_files"].append(source_filename)
                     result["has_pitfall"] = True
-                    result["repository_url"] = repo_url
-                    result["source"] = source if source else f"technique: {technique}"
-                    result["metadata_source_file"] = extract_metadata_source_filename(source)
                     result["is_homepage"] = True
-                    break
 
     return result

src/rsmetacheck/scripts/pitfalls/p013.py

@@ -6,12 +6,14 @@
 def detect_license_no_version_pitfall(somef_data: Dict, file_name: str) -> Dict:
     """
     Detect when license from metadata files doesn't have specific version.
+    Checks all metadata sources and collects all affected files.
     """
     result = {
         "has_pitfall": False,
         "file_name": file_name,
         "license_value": None,
         "metadata_source_file": None,
+        "metadata_source_files": [],
         "source": None
     }
 
@@ -52,17 +54,19 @@ 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 re.search(rf"\b{license_name}\b", license_upper):
                             if not re.search(version_pattern, license_upper, re.IGNORECASE):
+                                source_filename = extract_metadata_source_filename(source)
+                                if result["license_value"] is None:
+                                    result["license_value"] = license_value
+                                    result["source"] = source
+                                    result["metadata_source_file"] = source_filename
+                                result["metadata_source_files"].append(source_filename)
                                 result["has_pitfall"] = True
-                                result["license_value"] = license_value
-                                result["source"] = source
-                                result["metadata_source_file"] = extract_metadata_source_filename(source)
-                                return result
 
     return result

src/rsmetacheck/scripts/pitfalls/p016.py

@@ -33,7 +33,8 @@ def detect_different_repository_pitfall(somef_data: Dict, file_name: str) -> Dic
         "file_name": file_name,
         "github_api_url": None,
         "metadata_urls": [],
-        "different_urls": []
+        "different_urls": [],
+        "metadata_source_files": []
     }
 
     if "code_repository" not in somef_data:
@@ -79,5 +80,6 @@ def detect_different_repository_pitfall(somef_data: Dict, file_name: str) -> Dic
         result["github_api_url"] = github_api_url
         result["metadata_urls"] = metadata_urls
         result["different_urls"] = different_urls
+        result["metadata_source_files"] = ["codemeta.json"]
 
     return result