Compatible difference formatter (not tested)

Author: Leon-hk

src/gardenlinux/features/reproducibility/comparator.py

@@ -262,6 +262,6 @@ def generate(
                 return {}, False
 
             with self._unpack(a) as unpacked_a, self._unpack(b) as unpacked_b:
-                return self._compare_directories(unpacked_a, unpacked_b)
+                return self._compare_directories(Path(unpacked_a), Path(unpacked_b))
         else:
             return self._compare_directories(a, b)

src/gardenlinux/features/reproducibility/diff_parser.py

@@ -9,7 +9,8 @@
 import re
 from os import PathLike
 from pathlib import Path
-from typing import Dict, Optional
+import json
+from typing import Dict, Optional, Any
 
 import networkx as nx
 
@@ -32,7 +33,7 @@ class DiffParser(object):
 
     _remove_arch = re.compile("(-arm64|-amd64)$")
     _GARDENLINUX_ROOT: str = os.getenv("GL_ROOT_DIR", ".")
-    _SUFFIX = "-diff.txt"
+    _SUFFIX = "-diff.json"
 
     def __init__(
         self,
@@ -63,6 +64,33 @@ def __init__(
         self.missing_flavors: set[str] = set()
         self.unexpected_falvors: set[str] = set()
 
+    def _map_files_to_flavors(
+        self,
+        files: Dict[str, Any],
+        flavor: str,
+        dictionary: Dict[str, set[str]],
+        prefix: str = "",
+    ) -> None:
+        """
+        Map hierarchical files to a comma-separated representation and bundle the flavors having issues with the file
+
+        :param files:                   Dictionary of the archives and files
+        :param flavor:                  The flavor of the current files
+        :param dictionary:              The dictionary in which the files have to be inserted
+        :param prefix:                  Archive prefix path of the file (comma-separated)
+
+        :since: 1.0.0
+        """
+        for file in files:
+            if files[file] == {}:
+                if prefix + file not in dictionary:
+                    dictionary[prefix + file] = set()
+                dictionary[prefix + file].add(flavor)
+            else:
+                self._map_files_to_flavors(
+                    files[file], flavor, dictionary, prefix=prefix + file + ","
+                )
+
     def sort_features(self, graph: nx.DiGraph) -> list[str]:
         """
         Forward sorting implemented in the parser
@@ -109,24 +137,23 @@ def parse(
 
                 flavor = flavor.rstrip(self._SUFFIX)
                 self.all_flavors.add(flavor)
-                if content == "":
+                if content == "{}":
                     self.reproducible_flavors.add(flavor)
                 elif content == "whitelist\n":
                     self.reproducible_flavors.add(flavor)
                     self.passed_by_whitelist.add(flavor)
                 else:
-                    non_reproducible_flavors[flavor] = content.split("\n")[:-1]
+                    non_reproducible_flavors[flavor] = json.loads(content)
 
         self.missing_flavors = self.expected_falvors - self.all_flavors
         self.unexpected_falvors = self.all_flavors - self.expected_falvors
 
         # Map files to flavors
         affected_flavors: Dict[str, set[str]] = {}  # {file: {flavors...}}
         for flavor in non_reproducible_flavors:
-            for file in non_reproducible_flavors[flavor]:
-                if file not in affected_flavors:
-                    affected_flavors[file] = set()
-                affected_flavors[file].add(flavor)
+            self._map_files_to_flavors(
+                non_reproducible_flavors[flavor], flavor, affected_flavors
+            )
 
         # Merge files affected_flavors by the same flavors by mapping flavor sets to files
         self._bundled: Dict[frozenset[str], set[str]] = {}  # {{flavors...}: {files...}}

src/gardenlinux/features/reproducibility/markdown_formatter.py

@@ -8,7 +8,7 @@
 from os import PathLike
 from pathlib import Path
 from string import Template
-from typing import Collection, Optional
+from typing import Collection, Optional, Any
 
 import networkx as nx
 from attr import dataclass
@@ -116,7 +116,7 @@ def _treeStr(
         # Remove last linebreak as the last line can contain spaces
         return s.rstrip(), found
 
-    def _dropdown(self, items: Collection[str]) -> str:
+    def _dropdown(self, items: Collection[str], sort: bool = True) -> str:
         """
         Converts the items into a markdown dropwon list if the length is 10 or more
 
@@ -127,16 +127,53 @@ def _dropdown(self, items: Collection[str]) -> str:
         """
 
         if len(items) <= self._DROPDOWN_THRESHOLD:
-            return "<br>".join([f"`{item}`" for item in sorted(items)])
+            return "<br>".join(
+                [f"`{item}`" for item in (sorted(items) if sort else items)]
+            )
         else:
-            for first in sorted(items):
+            for first in sorted(items) if sort else items:
                 return (
                     f"<details><summary>{first}...</summary>"
-                    + "<br>".join([f"`{item}`" for item in sorted(items)])
+                    + "<br>".join(
+                        [f"`{item}`" for item in (sorted(items) if sort else items)]
+                    )
                     + "</details>"
                 )
             return ""
 
+    def _format_files(self, files: Collection[str]) -> list[str]:
+        """
+        Rebuild a dictionary from the comma-separated hierarchy and return a representation with indentation
+
+        :param files:                  List of files
+
+        :return: list(str) Sorted and formatted files
+        :since:  1.0.0
+        """
+
+        dictionary: dict[str, Any] = {}
+
+        def fill_dictionary(d: dict[str, Any], parts: list[str]) -> None:
+            if parts[0] not in d:
+                d[parts[0]] = {}
+            if len(parts) > 1:
+                fill_dictionary(d[parts[0]], parts[1:])
+
+        for file in files:
+            fill_dictionary(dictionary, file.split(","))
+
+        def dict_to_strs(d: dict[str, Any], prefix: str = "") -> list[str]:
+            lines = []
+            for part in sorted(d):
+                if d[part] == {}:
+                    lines.append(prefix + part)
+                else:
+                    lines.append(prefix + part + ":")
+                    lines = lines + dict_to_strs(d[part], prefix=prefix + "  ")
+            return lines
+
+        return dict_to_strs(dictionary)
+
     def _format_nighlty_stats(self) -> str:
         """
         Parses nightly_stats file and formats a human readable result
@@ -283,7 +320,7 @@ def sorting_function(files: frozenset[str]) -> tuple[int, str]:
         for files in sorted(trees, key=sorting_function):
             flavors, tree = trees[files]
             row = "|"
-            row += self._dropdown(files)
+            row += self._dropdown(self._format_files(files), sort=False)
             row += "|"
             row += f"**{round(100 * (len(flavors) / len(self._diff_parser.expected_falvors)), 1)}%** affected<br>"
             row += self._dropdown(flavors)