gha-utils 4.17.9__tar.gz → 4.18.1__tar.gz

{gha_utils-4.17.9 → gha_utils-4.18.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gha-utils
-Version: 4.17.9
+Version: 4.18.1
 Summary: ⚙️ CLI helpers for GitHub Actions + reuseable workflows
 Author-email: Kevin Deldycke <kevin@deldycke.com>
 Project-URL: Homepage, https://github.com/kdeldycke/workflows
@@ -48,13 +48,14 @@ Requires-Dist: boltons>=24.0.0
 Requires-Dist: bump-my-version<1.1.1,>=0.32.2
 Requires-Dist: click-extra~=5.0.2
 Requires-Dist: extra-platforms~=3.2.0
+Requires-Dist: gitignore-parser~=0.1.12
 Requires-Dist: packaging~=25.0
 Requires-Dist: PyDriller~=2.6
 Requires-Dist: pyproject-metadata~=0.9.0
 Requires-Dist: pyyaml~=6.0.0
 Requires-Dist: wcmatch>=8.5
 Provides-Extra: test
-Requires-Dist: coverage[toml]~=7.9.1; extra == "test"
+Requires-Dist: coverage[toml]~=7.10.0; extra == "test"
 Requires-Dist: pytest~=8.4.0; extra == "test"
 Requires-Dist: pytest-cases~=3.9.1; extra == "test"
 Requires-Dist: pytest-cov~=6.2.1; extra == "test"

{gha_utils-4.17.9 → gha_utils-4.18.1}/gha_utils/__init__.py

@@ -17,4 +17,4 @@
 
 from __future__ import annotations
 
-__version__ = "4.17.9"
+__version__ = "4.18.1"

{gha_utils-4.17.9 → gha_utils-4.18.1}/gha_utils/cli.py

@@ -116,8 +116,8 @@ def gha_utils():
 )
 @option(
     "--format",
-    type=Choice(tuple(item.value for item in Dialects), case_sensitive=False),
-    default="github",
+    type=Choice(Dialects, case_sensitive=False),  # type: ignore[arg-type]
+    default=Dialects.github,
     help="Rendering format of the metadata.",
 )
 @option(

{gha_utils-4.17.9 → gha_utils-4.18.1}/gha_utils/matrix.py

@@ -27,7 +27,7 @@ from boltons.iterutils import unique
 RESERVED_MATRIX_KEYWORDS = ["include", "exclude"]
 
 
-class Matrix(FrozenDict):
+class Matrix:
     """A matrix as defined by GitHub's actions workflows.
 
     See GitHub official documentation on `how-to implement variations of jobs in a
@@ -47,35 +47,43 @@ class Matrix(FrozenDict):
     matrix.
     """
 
-    # Tuples are used to keep track of the insertion order and force immutability.
-    include: tuple[dict[str, str], ...] = tuple()
-    exclude: tuple[dict[str, str], ...] = tuple()
+    def __init__(self, *args, **kwargs):
+        self.variations: dict[str, tuple[str, ...]] = {}
+
+        # Tuples are used to keep track of the insertion order and force immutability.
+        self.include: tuple[dict[str, str], ...] = tuple()
+        self.exclude: tuple[dict[str, str], ...] = tuple()
+
+        self._job_counter = None
 
     def matrix(
         self, ignore_includes: bool = False, ignore_excludes: bool = False
-    ) -> dict[str, str]:
+    ) -> FrozenDict[str, str]:
         """Returns a copy of the matrix.
 
         The special ``include`` and ``excludes`` directives will be added by default.
         You can selectively ignore them by passing the corresponding boolean parameters.
         """
-        dict_copy = dict(self)
+        dict_copy = self.variations.copy()
         if not ignore_includes and self.include:
-            dict_copy["include"] = self.include
+            dict_copy["include"] = self.include  # type: ignore[assignment]
         if not ignore_excludes and self.exclude:
-            dict_copy["exclude"] = self.exclude
-        return dict_copy
+            dict_copy["exclude"] = self.exclude  # type: ignore[assignment]
+        return FrozenDict(dict_copy)
 
     def __repr__(self) -> str:
-        return (
-            f"<{self.__class__.__name__}: {super(FrozenDict, self).__repr__()}; "
-            f"include={self.include}; exclude={self.exclude}>"
-        )
+        return f"<{self.__class__.__name__}: {self.matrix()}>"
 
     def __str__(self) -> str:
         """Render matrix as a JSON string."""
         return json.dumps(self.matrix())
 
+    def __getitem__(self, key: str) -> tuple[str, ...]:
+        """Returns the values of a variation by its ID."""
+        if key in self.variations:
+            return self.variations[key]
+        raise KeyError(f"Variation {key} not found in matrix")
+
     @staticmethod
     def _check_ids(*var_ids: str) -> None:
         for var_id in var_ids:
@@ -89,8 +97,8 @@ class Matrix(FrozenDict):
         if any(type(v) is not str for v in values):
             raise ValueError(f"Only strings are accepted in {values}")
         # Extend variation with values, and deduplicate them along the way.
-        var_values = list(self.get(variation_id, [])) + list(values)
-        super(FrozenDict, self).__setitem__(variation_id, tuple(unique(var_values)))
+        var_values = list(self.variations.get(variation_id, [])) + list(values)
+        self.variations[variation_id] = tuple(unique(var_values))
 
     def _add_and_dedup_dicts(
         self, *new_dicts: dict[str, str]
@@ -123,9 +131,9 @@ class Matrix(FrozenDict):
         passing the corresponding ``with_matrix``, ``with_includes`` and
         ``with_excludes`` boolean filter parameters.
         """
-        variations = {}
+        all_variations = {}
         if with_matrix:
-            variations = {k: list(v) for k, v in self.items()}
+            all_variations = {k: list(v) for k, v in self.variations.items()}
 
         for expand, directives in (
             (with_includes, self.include),
@@ -134,9 +142,9 @@ class Matrix(FrozenDict):
             if expand:
                 for value in directives:
                     for k, v in value.items():
-                        variations.setdefault(k, []).append(v)
+                        all_variations.setdefault(k, []).append(v)
 
-        return {k: tuple(unique(v)) for k, v in variations.items()}
+        return {k: tuple(unique(v)) for k, v in all_variations.items()}
 
     def product(
         self, with_includes: bool = False, with_excludes: bool = False
@@ -148,17 +156,17 @@ class Matrix(FrozenDict):
 
         Respects the order of variations and their values.
         """
-        variations = self.all_variations(
+        all_variations = self.all_variations(
             with_includes=with_includes, with_excludes=with_excludes
         )
-        if not variations:
+        if not all_variations:
             return
         yield from map(
             dict,
             itertools.product(
                 *(
                     tuple((variant_id, v) for v in variations)
-                    for variant_id, variations in variations.items()
+                    for variant_id, variations in all_variations.items()
                 )
             ),
         )
@@ -187,11 +195,11 @@ class Matrix(FrozenDict):
                 self.all_variations(
                     with_matrix=False, with_includes=True, with_excludes=True
                 )
-            ).difference(self)
+            ).difference(self.variations)
             if unreferenced_keys:
                 raise ValueError(
                     f"Matrix exclude keys {list(unreferenced_keys)} does not match any "
-                    f"{list(self)} key within the matrix"
+                    f"{self.variations.keys()} key within the matrix"
                 )
 
         # Reset the number of combinations.
@@ -202,7 +210,7 @@ class Matrix(FrozenDict):
 
         # The matrix is empty, none of the include directive will match, so condider all
         # directives as un-applicable.
-        if not self:
+        if not self.variations:
             leftover_includes = list(self.include)
 
         # Search for include directives that matches the original matrix variations

{gha_utils-4.17.9 → gha_utils-4.18.1}/gha_utils/metadata.py

@@ -156,6 +156,7 @@ import json
 import logging
 import os
 import re
+import sys
 import tomllib
 from collections.abc import Iterable
 from enum import StrEnum
@@ -164,8 +165,9 @@ from operator import itemgetter
 from pathlib import Path
 from random import randint
 from re import escape
-from typing import Any, Final, Iterator, cast
+from typing import Any, Final, cast
 
+import gitignore_parser
 from bumpversion.config import get_configuration  # type: ignore[import-untyped]
 from bumpversion.config.files import find_config_file  # type: ignore[import-untyped]
 from bumpversion.show import resolve_name  # type: ignore[import-untyped]
@@ -196,6 +198,7 @@ SHORT_SHA_LENGTH = 7
     depends on the size of the repository.
 """
 
+GITIGNORE_PATH = Path(".gitignore")
 
 NUITKA_BUILD_TARGETS = {
     "linux-arm64": {
@@ -315,7 +318,7 @@ WorkflowEvent = StrEnum(
 """
 
 
-Dialects = StrEnum("Dialects", ("github", "plain"))
+Dialects = StrEnum("Dialects", ("github", "json"))
 """Dialects in which metadata can be formatted to."""
 
 
@@ -347,6 +350,75 @@ MYPY_VERSION_MIN: Final = (3, 8)
 """
 
 
+# XXX Patch gitignore-parser to support Windows paths. Refs:
+# https://github.com/mherrmann/gitignore_parser/issues/60
+# https://github.com/mherrmann/gitignore_parser/pull/61
+# XXX In the future, replace this with wcmatch once it supports gitignore files:
+# https://github.com/facelessuser/wcmatch/issues/226
+
+
+_OriginalIgnoreRule = gitignore_parser.IgnoreRule
+
+
+class PatchedIgnoreRule(_OriginalIgnoreRule):  # type: ignore[misc,valid-type]
+    """Patch version of ``IgnoreRule`` to support Windows paths.
+
+    Taken from: https://github.com/mherrmann/gitignore_parser/pull/61/files
+    """
+
+    @staticmethod
+    def _count_trailing_symbol(symbol: str, text: str) -> int:
+        """Count the number of trailing characters in a string."""
+        count = 0
+        for char in reversed(str(text)):
+            if char == symbol:
+                count += 1
+            else:
+                break
+        return count
+
+    def match(self, abs_path: str | Path) -> bool:
+        matched = False
+        if self.base_path:
+            rel_path = (
+                gitignore_parser._normalize_path(abs_path)
+                .relative_to(self.base_path)
+                .as_posix()
+            )
+        else:
+            rel_path = gitignore_parser._normalize_path(abs_path).as_posix()
+        # Path() strips the trailing following symbols on windows, so we need to
+        # preserve it: ' ', '.'
+        if sys.platform.startswith("win"):
+            rel_path += " " * self._count_trailing_symbol(" ", abs_path)
+            rel_path += "." * self._count_trailing_symbol(".", abs_path)
+        # Path() strips the trailing slash, so we need to preserve it
+        # in case of directory-only negation
+        if self.negation and type(abs_path) is str and abs_path[-1] == "/":
+            rel_path += "/"
+        if rel_path.startswith("./"):
+            rel_path = rel_path[2:]
+        if re.search(self.regex, rel_path):
+            matched = True
+        return matched
+
+
+gitignore_parser.IgnoreRule = PatchedIgnoreRule
+
+
+class JSONMetadata(json.JSONEncoder):
+    """Custom JSON encoder for metadata serialization."""
+
+    def default(self, o: Any) -> Any:
+        if isinstance(o, Matrix):
+            return o.matrix()
+
+        if isinstance(o, Path):
+            return str(o)
+
+        return super().default(o)
+
+
 class Metadata:
     """Metadata class."""
 
@@ -577,11 +649,15 @@ class Metadata:
         events.
 
         .. seealso::
-
             - https://stackoverflow.com/a/67204539
             - https://stackoverflow.com/a/62953566
             - https://stackoverflow.com/a/61861763
 
+        .. seealso::
+            Pull request events on GitHub are a bit complex, see: `The Many SHAs of a
+            GitHub Pull Request
+            <https://www.kenmuse.com/blog/the-many-shas-of-a-github-pull-request/>`_.
+
         .. todo::
             Refactor so we can get rid of ``self.github_context``. Maybe there's enough
             metadata lying around in the environment variables that we can inspect the
@@ -642,11 +718,7 @@ class Metadata:
     @cached_property
     def new_commits_hash(self) -> tuple[str, ...] | None:
         """List all hashes of new commits."""
-        return (
-            cast(tuple[str, ...], self.new_commits_matrix["commit"])
-            if self.new_commits_matrix
-            else None
-        )
+        return self.new_commits_matrix["commit"] if self.new_commits_matrix else None
 
     @cached_property
     def release_commits(self) -> tuple[Commit, ...] | None:
@@ -680,13 +752,16 @@ class Metadata:
     def release_commits_hash(self) -> tuple[str, ...] | None:
         """List all hashes of release commits."""
         return (
-            cast(tuple[str, ...], self.release_commits_matrix["commit"])
+            self.release_commits_matrix["commit"]
             if self.release_commits_matrix
             else None
         )
 
-    @staticmethod
-    def glob_files(*patterns: str) -> Iterator[Path]:
+    @cached_property
+    def gitignore_exists(self) -> bool:
+        return GITIGNORE_PATH.is_file()
+
+    def glob_files(self, *patterns: str) -> list[Path]:
         """Return all file path matching the ``patterns``.
 
         Patterns are glob patterns supporting ``**`` for recursive search, and ``!``
@@ -695,46 +770,77 @@ class Metadata:
         All directories are traversed, whether they are hidden (i.e. starting with a
         dot ``.``) or not, including symlinks.
 
-        Returns both hidden and non-hidden files, but no directories.
+        Skips:
+
+        - files which does not exists
+        - directories
+        - broken symlinks
+        - files matching patterns specified by ``.gitignore`` file
+
+        Returns both hidden and non-hidden files.
 
         All files are normalized to their absolute path, so that duplicates produced by
         symlinks are ignored.
 
-        Files that doesn't exist and broken symlinks are skipped.
+        File path are returned as relative to the current working directory if
+        possible, or as absolute path otherwise.
+
+        The resulting list of file paths is sorted.
         """
+        current_dir = Path.cwd()
         seen = set()
+
+        # If the .gitignore file exists, we parse it to filter out ignored files.
+        gitignore = None
+        if self.gitignore_exists:
+            logging.debug(f"Load {GITIGNORE_PATH} to filter out ignored files.")
+            gitignore = gitignore_parser.parse_gitignore(GITIGNORE_PATH)
+
         for file_path in iglob(
             patterns,
             flags=NODIR | GLOBSTAR | DOTGLOB | GLOBTILDE | BRACE | FOLLOW | NEGATE,
         ):
             # Normalize the path to avoid duplicates.
             try:
-                normalized_path = Path(file_path).resolve(strict=True)
-            # Skip files that do not exist or broken symlinks.
+                absolute_path = Path(file_path).resolve(strict=True)
+            # Skip files that do not exists and broken symlinks.
             except OSError:
-                logging.warning(
-                    f"Skipping non-existing file / broken symlink: {file_path}"
-                )
+                logging.warning(f"Skip non-existing file / broken symlink: {file_path}")
                 continue
+
+            # Simplify the path by trying to make it relative to the current location.
+            normalized_path = absolute_path
+            try:
+                normalized_path = absolute_path.relative_to(current_dir)
+            except ValueError:
+                # If the file is not relative to the current directory, keep its
+                # absolute path.
+                logging.debug(
+                    f"{absolute_path} is not relative to {current_dir}. "
+                    "Keeping the path absolute."
+                )
+
             if normalized_path in seen:
-                logging.debug(f"Skipping duplicate file: {normalized_path}")
+                logging.debug(f"Skip duplicate file: {normalized_path}")
                 continue
-            seen.add(normalized_path)
-            yield normalized_path
 
-    @cached_property
-    def gitignore_exists(self) -> bool:
-        return Path(".gitignore").is_file()
+            # Skip files that are ignored by .gitignore.
+            if gitignore and gitignore(file_path):
+                logging.debug(f"Skip file matching {GITIGNORE_PATH}: {file_path}")
+                continue
+
+            seen.add(normalized_path)
+        return sorted(seen)
 
     @cached_property
-    def python_files(self) -> Iterator[Path]:
+    def python_files(self) -> list[Path]:
         """Returns a list of python files."""
-        yield from self.glob_files("**/*.py", "!.venv/**")
+        return self.glob_files("**/*.py", "!.venv/**")
 
     @cached_property
-    def doc_files(self) -> Iterator[Path]:
+    def doc_files(self) -> list[Path]:
         """Returns a list of doc files."""
-        yield from self.glob_files("**/*.{md,markdown,rst,tex}", "!.venv/**")
+        return self.glob_files("**/*.{md,markdown,rst,tex}", "!.venv/**")
 
     @property
     def is_python_project(self):
@@ -844,7 +950,7 @@ class Metadata:
         return None
 
     @cached_property
-    def blacken_docs_params(self) -> tuple[str, ...] | None:
+    def blacken_docs_params(self) -> str | None:
         """Generates ``blacken-docs`` parameters.
 
         `Blacken-docs reuses Black's --target-version pyXY parameters
@@ -867,7 +973,7 @@ class Metadata:
         <https://github.com/psf/black/issues/751#issuecomment-473066811>`_.
         """
         if self.py_target_versions:
-            return tuple(
+            return " ".join(
                 f"--target-version py{version.major}{version.minor}"
                 for version in self.py_target_versions
             )
@@ -1185,7 +1291,7 @@ class Metadata:
         for variations in matrix.solve():
             # We will re-attach back this binary name to the with an include directive,
             # so we need a copy the main variants it corresponds to.
-            bin_name_include = {k: variations[k] for k in matrix}
+            bin_name_include = {k: variations[k] for k in matrix.variations}
             bin_name_include["bin_name"] = (
                 "{cli_id}-{target}-{short_sha}.{extension}"
             ).format(**variations)
@@ -1316,8 +1422,8 @@ class Metadata:
                     delimiter = f"ghadelimiter_{randint(10**8, (10**9) - 1)}"
                     content += f"{env_name}<<{delimiter}\n{env_value}\n{delimiter}\n"
         else:
-            assert dialect == Dialects.plain
-            content = repr(metadata)
+            assert dialect == Dialects.json
+            content = json.dumps(metadata, cls=JSONMetadata, indent=2)
 
         logging.debug(f"Formatted metadata:\n{content}")
 

{gha_utils-4.17.9 → gha_utils-4.18.1}/gha_utils.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gha-utils
-Version: 4.17.9
+Version: 4.18.1
 Summary: ⚙️ CLI helpers for GitHub Actions + reuseable workflows
 Author-email: Kevin Deldycke <kevin@deldycke.com>
 Project-URL: Homepage, https://github.com/kdeldycke/workflows
@@ -48,13 +48,14 @@ Requires-Dist: boltons>=24.0.0
 Requires-Dist: bump-my-version<1.1.1,>=0.32.2
 Requires-Dist: click-extra~=5.0.2
 Requires-Dist: extra-platforms~=3.2.0
+Requires-Dist: gitignore-parser~=0.1.12
 Requires-Dist: packaging~=25.0
 Requires-Dist: PyDriller~=2.6
 Requires-Dist: pyproject-metadata~=0.9.0
 Requires-Dist: pyyaml~=6.0.0
 Requires-Dist: wcmatch>=8.5
 Provides-Extra: test
-Requires-Dist: coverage[toml]~=7.9.1; extra == "test"
+Requires-Dist: coverage[toml]~=7.10.0; extra == "test"
 Requires-Dist: pytest~=8.4.0; extra == "test"
 Requires-Dist: pytest-cases~=3.9.1; extra == "test"
 Requires-Dist: pytest-cov~=6.2.1; extra == "test"

{gha_utils-4.17.9 → gha_utils-4.18.1}/gha_utils.egg-info/requires.txt

@@ -2,6 +2,7 @@ boltons>=24.0.0
 bump-my-version<1.1.1,>=0.32.2
 click-extra~=5.0.2
 extra-platforms~=3.2.0
+gitignore-parser~=0.1.12
 packaging~=25.0
 PyDriller~=2.6
 pyproject-metadata~=0.9.0
@@ -9,7 +10,7 @@ pyyaml~=6.0.0
 wcmatch>=8.5
 
 [test]
-coverage[toml]~=7.9.1
+coverage[toml]~=7.10.0
 pytest~=8.4.0
 pytest-cases~=3.9.1
 pytest-cov~=6.2.1

{gha_utils-4.17.9 → gha_utils-4.18.1}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 # Docs: https://packaging.python.org/en/latest/guides/writing-pyproject-toml/
 name = "gha-utils"
-version = "4.17.9"
+version = "4.18.1"
 # Python versions and their status: https://devguide.python.org/versions/
 requires-python = ">= 3.11"
 description = "⚙️ CLI helpers for GitHub Actions + reuseable workflows"
@@ -76,6 +76,7 @@ dependencies = [
     "bump-my-version >= 0.32.2, < 1.1.1",
     "click-extra ~= 5.0.2",
     "extra-platforms ~= 3.2.0",
+    "gitignore-parser ~= 0.1.12",
     "packaging ~= 25.0",
     "PyDriller ~= 2.6",
     "pyproject-metadata ~= 0.9.0",
@@ -86,7 +87,7 @@ dependencies = [
 
 [project.optional-dependencies]
 test = [
-    "coverage [toml] ~= 7.9.1",
+    "coverage [toml] ~= 7.10.0",
     "pytest ~= 8.4.0",
     # More pytest plugins at: https://docs.pytest.org/en/latest/reference/plugin_list.html
     "pytest-cases ~= 3.9.1",
@@ -119,7 +120,7 @@ pretty = true
 
 [[tool.mypy.overrides]]
 ignore_missing_imports = true
-module = ["boltons.*"]
+module = ["boltons.*", "gitignore_parser.*"]
 
 [tool.pytest.ini_options]
 # https://docs.pytest.org/en/latest/customize.html#pyproject-toml
@@ -137,7 +138,7 @@ addopts = [
 xfail_strict = true
 
 [tool.bumpversion]
-current_version = "4.17.9"
+current_version = "4.18.1"
 allow_dirty = true
 ignore_missing_files = true
 

{gha_utils-4.17.9 → gha_utils-4.18.1}/tests/test_matrix.py

@@ -26,7 +26,11 @@ from gha_utils.matrix import Matrix
 def test_matrix():
     matrix = Matrix()
 
-    assert matrix == dict()
+    assert isinstance(matrix, Matrix)
+    assert not isinstance(matrix, dict)
+
+    assert hasattr(matrix, "variations")
+    assert isinstance(matrix.variations, dict)
 
     assert hasattr(matrix, "include")
     assert hasattr(matrix, "exclude")
@@ -34,23 +38,20 @@ def test_matrix():
     assert matrix.exclude == tuple()
 
     matrix.add_variation("foo", ["a", "b", "c"])
-    assert matrix == {"foo": ("a", "b", "c")}
+    assert matrix.variations == {"foo": ("a", "b", "c")}
     assert not matrix.include
     assert not matrix.exclude
 
     # Natural deduplication.
     matrix.add_variation("foo", ["a", "a", "d"])
-    assert matrix == {"foo": ("a", "b", "c", "d")}
+    assert matrix.variations == {"foo": ("a", "b", "c", "d")}
     assert not matrix.include
     assert not matrix.exclude
 
     assert matrix.matrix() == {"foo": ("a", "b", "c", "d")}
 
     assert str(matrix) == '{"foo": ["a", "b", "c", "d"]}'
-    assert (
-        repr(matrix)
-        == "<Matrix: {'foo': ('a', 'b', 'c', 'd')}; include=(); exclude=()>"
-    )
+    assert repr(matrix) == "<Matrix: FrozenDict({'foo': ('a', 'b', 'c', 'd')})>"
 
     with pytest.raises(ValueError):
         matrix.add_variation("variation_1", None)
@@ -101,8 +102,8 @@ def test_includes():
         '"include": [{"foo": "a", "bar": "1"}, {"foo": "b", "bar": "2"}]}'
     )
     assert (
-        repr(matrix) == "<Matrix: {'foo': ('a', 'b', 'c')}; "
-        "include=({'foo': 'a', 'bar': '1'}, {'foo': 'b', 'bar': '2'}); exclude=()>"
+        repr(matrix) == "<Matrix: FrozenDict({'foo': ('a', 'b', 'c'), "
+        "'include': ({'foo': 'a', 'bar': '1'}, {'foo': 'b', 'bar': '2'})})>"
     )
 
     # Multiple insertions.
@@ -157,8 +158,8 @@ def test_excludes():
         '"exclude": [{"foo": "a", "bar": "1"}, {"foo": "b", "bar": "2"}]}'
     )
     assert (
-        repr(matrix) == "<Matrix: {'foo': ('a', 'b', 'c')}; "
-        "include=(); exclude=({'foo': 'a', 'bar': '1'}, {'foo': 'b', 'bar': '2'})>"
+        repr(matrix) == "<Matrix: FrozenDict({'foo': ('a', 'b', 'c'), "
+        "'exclude': ({'foo': 'a', 'bar': '1'}, {'foo': 'b', 'bar': '2'})})>"
     )
 
     # Multiple insertions.

gha_utils-4.18.1/tests/test_metadata.py

@@ -0,0 +1,333 @@
+# Copyright Kevin Deldycke <kevin@deldycke.com> and contributors.
+#
+# This program is Free Software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+from __future__ import annotations
+
+import json
+import re
+from string import ascii_lowercase, digits
+from typing import Any
+
+import pytest
+from extra_platforms import ALL_IDS, is_windows
+
+from gha_utils.metadata import NUITKA_BUILD_TARGETS, Dialects, Metadata
+
+
+@pytest.mark.parametrize("target_id, target_data", NUITKA_BUILD_TARGETS.items())
+def test_nuitka_targets(target_id: str, target_data: dict[str, str]) -> None:
+    assert isinstance(target_id, str)
+    assert isinstance(target_data, dict)
+
+    assert set(target_data) == {
+        "os",
+        "platform_id",
+        "arch",
+        "extension",
+    }, f"Unexpected keys in target data for {target_id}"
+
+    assert isinstance(target_data["os"], str)
+    assert isinstance(target_data["platform_id"], str)
+    assert isinstance(target_data["arch"], str)
+    assert isinstance(target_data["extension"], str)
+
+    assert set(target_data["os"]).issubset(ascii_lowercase + digits + "-.")
+    assert target_data["platform_id"] in ALL_IDS
+    assert target_data["arch"] in {"arm64", "x64"}
+    assert set(target_data["extension"]).issubset(ascii_lowercase)
+
+    assert target_id == target_data["platform_id"] + "-" + target_data["arch"]
+    assert set(target_id).issubset(ascii_lowercase + digits + "-")
+
+
+def regex(pattern: str) -> re.Pattern:
+    """Compile a regex pattern with DOTALL flag."""
+    return re.compile(pattern, re.DOTALL)
+
+
+def iter_checks(metadata: Any, expected: Any, context: Any) -> None:
+    """Recursively iterate over expected content and check it matches in metadata."""
+
+    if isinstance(expected, re.Pattern):
+        assert isinstance(metadata, str)
+        assert re.fullmatch(expected, metadata) is not None, (
+            f"{metadata!r} does not match {expected.pattern!r} in {context!r}"
+        )
+
+    elif isinstance(expected, dict):
+        assert isinstance(metadata, dict)
+        assert set(metadata) == set(expected)
+        for key, value in expected.items():
+            iter_checks(metadata[key], value, metadata)
+
+    elif isinstance(expected, list):
+        assert isinstance(metadata, list)
+        assert len(metadata) == len(expected)
+        for item in expected:
+            iter_checks(metadata[expected.index(item)], item, metadata)
+
+    else:
+        assert metadata == expected, (
+            f"{metadata!r} does not match {expected!r} in {context!r}"
+        )
+        assert type(metadata) is type(expected)
+
+
+expected = {
+    "new_commits": None,
+    "release_commits": None,
+    "gitignore_exists": True,
+    "python_files": [
+        "gha_utils\\__init__.py",
+        "gha_utils\\__main__.py",
+        "gha_utils\\changelog.py",
+        "gha_utils\\cli.py",
+        "gha_utils\\mailmap.py",
+        "gha_utils\\matrix.py",
+        "gha_utils\\metadata.py",
+        "gha_utils\\test_plan.py",
+        "tests\\__init__.py",
+        "tests\\test_changelog.py",
+        "tests\\test_mailmap.py",
+        "tests\\test_matrix.py",
+        "tests\\test_metadata.py",
+    ]
+    if is_windows()
+    else [
+        "gha_utils/__init__.py",
+        "gha_utils/__main__.py",
+        "gha_utils/changelog.py",
+        "gha_utils/cli.py",
+        "gha_utils/mailmap.py",
+        "gha_utils/matrix.py",
+        "gha_utils/metadata.py",
+        "gha_utils/test_plan.py",
+        "tests/__init__.py",
+        "tests/test_changelog.py",
+        "tests/test_mailmap.py",
+        "tests/test_matrix.py",
+        "tests/test_metadata.py",
+    ],
+    "doc_files": [
+        ".github\\code-of-conduct.md",
+        "changelog.md",
+        "readme.md",
+    ]
+    if is_windows()
+    else [
+        ".github/code-of-conduct.md",
+        "changelog.md",
+        "readme.md",
+    ],
+    "is_python_project": True,
+    "package_name": "gha-utils",
+    "blacken_docs_params": "--target-version py311 --target-version py312 --target-version py313",
+    "mypy_params": "--python-version 3.11",
+    "current_version": regex(r"[0-9\.]+"),
+    "released_version": None,
+    "is_sphinx": False,
+    "active_autodoc": False,
+    "release_notes": regex(
+        r"### Changes\n\n"
+        r"> \[\!IMPORTANT\]\n"
+        r"> This version is not released yet and is under active development\.\n\n"
+        r".+"
+    ),
+    "new_commits_matrix": None,
+    "release_commits_matrix": None,
+    "nuitka_matrix": {
+        "os": [
+            "ubuntu-24.04-arm",
+            "ubuntu-24.04",
+            "macos-15",
+            "macos-13",
+            "windows-11-arm",
+            "windows-2025",
+        ],
+        "entry_point": ["gha-utils"],
+        "commit": [regex(r"[a-z0-9]+")],
+        "include": [
+            {
+                "target": "linux-arm64",
+                "os": "ubuntu-24.04-arm",
+                "platform_id": "linux",
+                "arch": "arm64",
+                "extension": "bin",
+            },
+            {
+                "target": "linux-x64",
+                "os": "ubuntu-24.04",
+                "platform_id": "linux",
+                "arch": "x64",
+                "extension": "bin",
+            },
+            {
+                "target": "macos-arm64",
+                "os": "macos-15",
+                "platform_id": "macos",
+                "arch": "arm64",
+                "extension": "bin",
+            },
+            {
+                "target": "macos-x64",
+                "os": "macos-13",
+                "platform_id": "macos",
+                "arch": "x64",
+                "extension": "bin",
+            },
+            {
+                "target": "windows-arm64",
+                "os": "windows-11-arm",
+                "platform_id": "windows",
+                "arch": "arm64",
+                "extension": "exe",
+            },
+            {
+                "target": "windows-x64",
+                "os": "windows-2025",
+                "platform_id": "windows",
+                "arch": "x64",
+                "extension": "exe",
+            },
+            {
+                "entry_point": "gha-utils",
+                "cli_id": "gha-utils",
+                "module_id": "gha_utils.__main__",
+                "callable_id": "main",
+                "module_path": regex(r"gha_utils(/|\\)__main__\.py"),
+            },
+            {
+                "commit": regex(r"[a-z0-9]+"),
+                "short_sha": regex(r"[a-z0-9]+"),
+                "current_version": regex(r"[0-9\.]+"),
+            },
+            {
+                "os": "ubuntu-24.04-arm",
+                "entry_point": "gha-utils",
+                "commit": regex(r"[a-z0-9]+"),
+                "bin_name": regex(r"gha-utils-linux-arm64-[a-z0-9]+\.bin"),
+            },
+            {
+                "os": "ubuntu-24.04",
+                "entry_point": "gha-utils",
+                "commit": regex(r"[a-z0-9]+"),
+                "bin_name": regex(r"gha-utils-linux-x64-[a-z0-9]+\.bin"),
+            },
+            {
+                "os": "macos-15",
+                "entry_point": "gha-utils",
+                "commit": regex(r"[a-z0-9]+"),
+                "bin_name": regex(r"gha-utils-macos-arm64-[a-z0-9]+\.bin"),
+            },
+            {
+                "os": "macos-13",
+                "entry_point": "gha-utils",
+                "commit": regex(r"[a-z0-9]+"),
+                "bin_name": regex(r"gha-utils-macos-x64-[a-z0-9]+\.bin"),
+            },
+            {
+                "os": "windows-11-arm",
+                "entry_point": "gha-utils",
+                "commit": regex(r"[a-z0-9]+"),
+                "bin_name": regex(r"gha-utils-windows-arm64-[a-z0-9]+\.exe"),
+            },
+            {
+                "os": "windows-2025",
+                "entry_point": "gha-utils",
+                "commit": regex(r"[a-z0-9]+"),
+                "bin_name": regex(r"gha-utils-windows-x64-[a-z0-9]+\.exe"),
+            },
+            {"state": "stable"},
+        ],
+    },
+}
+
+
+def test_metadata_json_format():
+    metadata = Metadata().dump(Dialects.json)
+    assert isinstance(metadata, str)
+
+    iter_checks(json.loads(metadata), expected, metadata)
+
+
+def test_metadata_github_format():
+    raw_metadata = Metadata().dump()
+    assert isinstance(raw_metadata, str)
+
+    # Prepare metadata for checks
+    metadata = {}
+    # Accumulation states.
+    acc_key = None
+    acc_delimiter = None
+    acc_lines = []
+    for line in raw_metadata.splitlines():
+        # We are at the end of the accumulation for a key.
+        if line == acc_delimiter:
+            assert acc_delimiter
+            assert acc_key
+            assert acc_lines
+            metadata[acc_key] = "\n".join(acc_lines)
+            # Reset accumulation states.
+            acc_key = None
+            acc_delimiter = None
+            acc_lines = []
+            continue
+
+        # We are accumulating lines for a key.
+        if acc_key:
+            acc_lines.append(line)
+            continue
+
+        # We should not have any accumulation state at this point.
+        assert acc_key is None
+        assert acc_delimiter is None
+        assert acc_lines == []
+
+        # We are starting a new accumulation for a key.
+        if "<<" in line:
+            # Check the delimiter syntax.
+            assert line.count("<<") == 1
+            acc_key, acc_delimiter = line.split("<<", 1)
+            assert re.fullmatch(r"ghadelimiter_[0-9]+", acc_delimiter)
+            continue
+
+        # We are at a simple key-value pair.
+        if "=" in line:
+            key, value = line.split("=", 1)
+            # Convert dict-like JSON string into Python dict.
+            if value.startswith("{"):
+                value = json.loads(value)
+            metadata[key] = value
+            continue
+
+        raise ValueError(
+            f"Unexpected line format in metadata: {line!r}. "
+            "Expecting a key-value pair or a delimited block."
+        )
+
+    # Adapt expected values to match GitHub Actions format.
+    github_format_expected = {}
+    for key, value in expected.items():
+        new_value = value
+        if value is None:
+            new_value = ""
+        elif isinstance(value, bool):
+            new_value = str(value).lower()
+        elif isinstance(value, list):
+            new_value = " ".join(f'"{i}"' for i in value)
+        github_format_expected[key] = new_value
+
+    iter_checks(metadata, github_format_expected, raw_metadata)

gha_utils-4.17.9/tests/test_metadata.py

@@ -1,214 +0,0 @@
-# Copyright Kevin Deldycke <kevin@deldycke.com> and contributors.
-#
-# This program is Free Software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
-
-from __future__ import annotations
-
-import re
-from string import ascii_lowercase, digits
-
-from extra_platforms import ALL_IDS
-
-from gha_utils.metadata import NUITKA_BUILD_TARGETS, Dialects, Metadata
-
-
-def test_nuitka_targets():
-    for target_id, target_data in NUITKA_BUILD_TARGETS.items():
-        assert isinstance(target_id, str)
-        assert isinstance(target_data, dict)
-
-        assert set(target_data) == {
-            "os",
-            "platform_id",
-            "arch",
-            "extension",
-        }, f"Unexpected keys in target data for {target_id}"
-
-        assert isinstance(target_data["os"], str)
-        assert isinstance(target_data["platform_id"], str)
-        assert isinstance(target_data["arch"], str)
-        assert isinstance(target_data["extension"], str)
-
-        assert set(target_data["os"]).issubset(ascii_lowercase + digits + "-.")
-        assert target_data["platform_id"] in ALL_IDS
-        assert target_data["arch"] in {"arm64", "x64"}
-        assert set(target_data["extension"]).issubset(ascii_lowercase)
-
-        assert target_id == target_data["platform_id"] + "-" + target_data["arch"]
-        assert set(target_id).issubset(ascii_lowercase + digits + "-")
-
-
-def test_metadata_github_format():
-    metadata = Metadata()
-
-    assert re.fullmatch(
-        (
-            r"new_commits=\n"
-            r"release_commits=\n"
-            r"gitignore_exists=true\n"
-            r"python_files=[\S ]*\n"
-            r"doc_files=[\S ]*\n"
-            r"is_python_project=true\n"
-            r"package_name=gha-utils\n"
-            r"blacken_docs_params=--target-version py311 "
-            r"--target-version py312 --target-version py313\n"
-            r"mypy_params=--python-version 3\.11\n"
-            r"current_version=[0-9\.]+\n"
-            r"released_version=\n"
-            r"is_sphinx=false\n"
-            r"active_autodoc=false\n"
-            r"release_notes<<ghadelimiter_[0-9]+\n"
-            r"### Changes\n\n"
-            r"> \[\!IMPORTANT\]\n"
-            r"> This version is not released yet and is under active development.\n\n"
-            r".+\n"
-            r"ghadelimiter_[0-9]+\n"
-            r"new_commits_matrix=\n"
-            r"release_commits_matrix=\n"
-            #
-            r"nuitka_matrix=\{"
-            #
-            r'"os": \["ubuntu-24\.04-arm", "ubuntu-24\.04", '
-            r'"macos-15", "macos-13", "windows-11-arm", "windows-2025"\], '
-            #
-            r'"entry_point": \["gha-utils"\], '
-            #
-            r'"commit": \["[a-z0-9]+"\], '
-            #
-            r'"include": \['
-            #
-            r'\{"target": "linux-arm64", "os": "ubuntu-24\.04-arm", '
-            r'"platform_id": "linux", "arch": "arm64", "extension": "bin"\}, '
-            r'\{"target": "linux-x64", "os": "ubuntu-24\.04", '
-            r'"platform_id": "linux", "arch": "x64", "extension": "bin"\}, '
-            r'\{"target": "macos-arm64", "os": "macos-15", '
-            r'"platform_id": "macos", "arch": "arm64", "extension": "bin"\}, '
-            r'\{"target": "macos-x64", "os": "macos-13", '
-            r'"platform_id": "macos", "arch": "x64", '
-            r'"extension": "bin"\}, '
-            r'\{"target": "windows-arm64", "os": "windows-11-arm", '
-            r'"platform_id": "windows", "arch": "arm64", "extension": "exe"\}, '
-            r'\{"target": "windows-x64", "os": "windows-2025", '
-            r'"platform_id": "windows", "arch": "x64", "extension": "exe"\}, '
-            #
-            r'\{"entry_point": "gha-utils", '
-            r'"cli_id": "gha-utils", "module_id": "gha_utils\.__main__", '
-            r'"callable_id": "main", '
-            r'"module_path": "gha_utils(/|\\\\)__main__\.py"\}, '
-            #
-            r'\{"commit": "[a-z0-9]+", "short_sha": "[a-z0-9]+", '
-            r'"current_version": "[0-9\.]+"\}, '
-            #
-            r'\{"os": "ubuntu-24\.04-arm", "entry_point": "gha-utils", '
-            r'"commit": "[a-z0-9]+", '
-            r'"bin_name": "gha-utils-linux-arm64-[a-z0-9]+\.bin"\}, '
-            r'\{"os": "ubuntu-24\.04", "entry_point": "gha-utils", '
-            r'"commit": "[a-z0-9]+", '
-            r'"bin_name": "gha-utils-linux-x64-[a-z0-9]+\.bin"\}, '
-            r'\{"os": "macos-15", "entry_point": "gha-utils", '
-            r'"commit": "[a-z0-9]+", '
-            r'"bin_name": "gha-utils-macos-arm64-[a-z0-9]+\.bin"\}, '
-            r'\{"os": "macos-13", "entry_point": "gha-utils", '
-            r'"commit": "[a-z0-9]+", '
-            r'"bin_name": "gha-utils-macos-x64-[a-z0-9]+\.bin"\}, '
-            r'\{"os": "windows-11-arm", "entry_point": "gha-utils", '
-            r'"commit": "[a-z0-9]+", '
-            r'"bin_name": "gha-utils-windows-arm64-[a-z0-9]+\.exe"\}, '
-            r'\{"os": "windows-2025", "entry_point": "gha-utils", '
-            r'"commit": "[a-z0-9]+", '
-            r'"bin_name": "gha-utils-windows-x64-[a-z0-9]+\.exe"\}, '
-            r'\{"state": "stable"\}\]\}\n'
-        ),
-        metadata.dump(Dialects.github),
-        re.DOTALL,
-    )
-
-
-def test_metadata_plain_format():
-    metadata = Metadata()
-
-    assert re.fullmatch(
-        (
-            r"\{"
-            r"'new_commits': None, "
-            r"'release_commits': None, "
-            r"'gitignore_exists': True, "
-            r"'python_files': <generator object Metadata\.python_files at \S+>, "
-            r"'doc_files': <generator object Metadata\.doc_files at \S+>, "
-            r"'is_python_project': True, "
-            r"'package_name': 'gha-utils', "
-            r"'blacken_docs_params': \("
-            r"'--target-version py311', "
-            r"'--target-version py312', "
-            r"'--target-version py313'\), "
-            r"'mypy_params': '--python-version 3\.11', "
-            r"'current_version': '[0-9\.]+', "
-            r"'released_version': None, "
-            r"'is_sphinx': False, "
-            r"'active_autodoc': False, "
-            r"'release_notes': '### Changes\\n\\n"
-            r"> \[\!IMPORTANT\]\\n"
-            r"> This version is not released yet and is under active development.\\n\\n"
-            r".+', "
-            r"'new_commits_matrix': None, "
-            r"'release_commits_matrix': None, "
-            r"'nuitka_matrix': <Matrix: \{"
-            r"'os': \('ubuntu-24\.04-arm', 'ubuntu-24\.04', "
-            r"'macos-15', 'macos-13', 'windows-11-arm', 'windows-2025'\), "
-            r"'entry_point': \('gha-utils',\), "
-            r"'commit': \('[a-z0-9]+',\)\}; "
-            #
-            r"include=\(\{'target': 'linux-arm64', 'os': 'ubuntu-24\.04-arm', "
-            r"'platform_id': 'linux', 'arch': 'arm64', 'extension': 'bin'\}, "
-            r"\{'target': 'linux-x64', 'os': 'ubuntu-24\.04', 'platform_id': 'linux', "
-            r"'arch': 'x64', 'extension': 'bin'\}, \{'target': 'macos-arm64', 'os': 'macos-15', "
-            r"'platform_id': 'macos', 'arch': 'arm64', 'extension': 'bin'\}, "
-            r"\{'target': 'macos-x64', 'os': 'macos-13', 'platform_id': 'macos', 'arch': 'x64', "
-            r"'extension': 'bin'\}, \{'target': 'windows-arm64', 'os': 'windows-11-arm', 'platform_id': "
-            r"'windows', 'arch': 'arm64', 'extension': 'exe'\}, "
-            r"\{'target': 'windows-x64', 'os': 'windows-2025', 'platform_id': "
-            r"'windows', 'arch': 'x64', 'extension': 'exe'\}, "
-            #
-            r"\{'entry_point': 'gha-utils', 'cli_id': 'gha-utils', "
-            r"'module_id': 'gha_utils\.__main__', 'callable_id': 'main', "
-            r"'module_path': 'gha_utils(/|\\\\)__main__\.py'\}, "
-            #
-            r"\{'commit': '[a-z0-9]+', 'short_sha': '[a-z0-9]+', "
-            r"'current_version': '[0-9\.]+'\}, "
-            #
-            r"\{'os': 'ubuntu-24\.04-arm', 'entry_point': 'gha-utils', "
-            r"'commit': '[a-z0-9]+', "
-            r"'bin_name': 'gha-utils-linux-arm64-[a-z0-9]+\.bin'\}, "
-            r"\{'os': 'ubuntu-24\.04', 'entry_point': 'gha-utils', "
-            r"'commit': '[a-z0-9]+', "
-            r"'bin_name': 'gha-utils-linux-x64-[a-z0-9]+\.bin'\}, "
-            r"\{'os': 'macos-15', 'entry_point': 'gha-utils', "
-            r"'commit': '[a-z0-9]+', "
-            r"'bin_name': 'gha-utils-macos-arm64-[a-z0-9]+\.bin'\}, "
-            r"\{'os': 'macos-13', 'entry_point': 'gha-utils', "
-            r"'commit': '[a-z0-9]+', 'bin_name': "
-            r"'gha-utils-macos-x64-[a-z0-9]+\.bin'\}, "
-            r"\{'os': 'windows-11-arm', 'entry_point': 'gha-utils', "
-            r"'commit': '[a-z0-9]+', "
-            r"'bin_name': 'gha-utils-windows-arm64-[a-z0-9]+\.exe'\}, "
-            r"\{'os': 'windows-2025', 'entry_point': 'gha-utils', "
-            r"'commit': '[a-z0-9]+', "
-            r"'bin_name': 'gha-utils-windows-x64-[a-z0-9]+\.exe'\}, "
-            r"\{'state': 'stable'\}\); "
-            r"exclude=\(\)>\}"
-        ),
-        metadata.dump(Dialects.plain),
-        re.DOTALL,
-    )