Merge pull request #547 from posit-dev/worktree-matrix-strip-patch-tags

Tag matrix latest-patch rows with minor-only tags

Author: ianpittwood

posit-bakery/posit_bakery/config/dependencies/version.py

@@ -1,13 +1,52 @@
+import re
 from typing import Annotated, Self, Any
 
-from packaging.version import Version
+from packaging.version import InvalidVersion, Version
 from pydantic import Field, model_validator, field_validator
 from ruamel.yaml.scalarfloat import ScalarFloat
 from ruamel.yaml.scalarint import ScalarInt
 
 from posit_bakery.config.shared import BakeryYAMLModel
 
 
+_STRIP_PATCH_RE = re.compile(r"(\d+\.\d+)(?:\.\d+)+")
+_VERSION_SUBSTRING_RE = re.compile(r"\d+(?:\.\d+)+")
+
+
+def strip_patch(s: str) -> str:
+    """Collapse dotted numeric runs in a string to their first two segments.
+
+    Any ``\\d+(\\.\\d+)+`` substring with three or more components reduces to
+    ``MAJOR.MINOR``; 4+ component versions (e.g. ``1.2.3.4``) collapse the
+    same way, not partially (which the old ``(\\d+\\.\\d+)\\.\\d+`` regex did,
+    producing ``1.2.4``).
+
+    Shared between the ``stripPatch`` Jinja filter and matrix latest-patch
+    grouping so the two stay consistent — anything that would render the
+    same after the filter must land in the same group, otherwise rows
+    collide on the rendered tag.
+    """
+    return _STRIP_PATCH_RE.sub(r"\1", s)
+
+
+def extract_versions(s: str) -> tuple["DependencyVersion", ...]:
+    """Return every ``\\d+(\\.\\d+)+`` substring in ``s`` parsed as a
+    ``DependencyVersion``.
+
+    Returning a tuple (rather than the first match) is load-bearing: it lets
+    values with several version segments (e.g. ``"go1.24-lib2.3.1"``) sort on
+    the later segment when the earlier one ties. Unparseable substrings are
+    skipped; the empty tuple means no version was found.
+    """
+    parsed: list[DependencyVersion] = []
+    for match in _VERSION_SUBSTRING_RE.finditer(s):
+        try:
+            parsed.append(DependencyVersion(match.group()))
+        except InvalidVersion:
+            continue
+    return tuple(parsed)
+
+
 class DependencyVersion(Version):
     """A version class for dependencies that extends packaging's Version.
 

posit-bakery/posit_bakery/config/image/matrix.py

@@ -19,7 +19,7 @@
 )
 from packaging.version import InvalidVersion
 
-from posit_bakery.config.dependencies.version import DependencyVersion
+from posit_bakery.config.dependencies.version import DependencyVersion, extract_versions, strip_patch
 from posit_bakery.config.image.build_os import TargetPlatform, DEFAULT_PLATFORMS
 from posit_bakery.config.registry import BaseRegistry, Registry
 from posit_bakery.config.shared import BakeryPathMixin, BakeryYAMLModel
@@ -742,8 +742,12 @@ def to_image_versions(self) -> list[ImageVersion]:
         resolved_deps = self.resolved_dependencies
         latest_pick = self._compute_latest_combination(resolved_deps)
         products = self._cartesian_product(resolved_deps, self.values)
+        latest_patch_signatures = self._compute_latest_patch_signatures(products)
         for product in products:
             is_latest = latest_pick is not None and self._matches_latest(product, latest_pick)
+            is_latest_patch = (
+                latest_patch_signatures is not None and self._row_signature(product) in latest_patch_signatures
+            )
             image_version = ImageVersion(
                 parent=self.parent,
                 name=self._render_name_pattern(self.namePattern, product["dependencies"], product["values"]),
@@ -755,6 +759,7 @@ def to_image_versions(self) -> list[ImageVersion]:
                 values=product["values"],
                 isMatrixVersion=True,
                 latest=is_latest,
+                isLatestPatchCombination=is_latest_patch,
                 buildTarget=self.buildTarget,
             )
             image_versions.append(image_version)
@@ -779,3 +784,119 @@ def _matches_latest(product: dict[str, list | dict], latest_pick: dict[str, str]
             if axis_key in latest_pick and str(value) != latest_pick[axis_key]:
                 return False
         return True
+
+    @staticmethod
+    def _row_signature(product: dict[str, list | dict]) -> tuple:
+        """Hashable signature for a cartesian-product row, used for set membership checks."""
+        dep_parts = tuple(sorted((d.dependency, d.versions[0]) for d in product["dependencies"]))
+        value_parts = tuple(sorted((k, str(v)) for k, v in product["values"].items()))
+        return dep_parts, value_parts
+
+    def _compute_latest_patch_signatures(self, products: list[dict[str, list | dict]]) -> set[tuple] | None:
+        """Identify cartesian-product rows that are the latest patch for their stripped group.
+
+        Validate all dependency versions upfront, then group every row by the result of
+        applying :func:`strip_patch` to each of its axis values. Within each group, the
+        row whose ``_patch_sort_key`` ranks highest is the "latest patch" row.
+
+        Grouping by the stripped form keeps the selection consistent with what
+        ``stripPatch`` would render: any two rows that would produce the same stripped
+        tag share a group, so only one of them is flagged and no ``LATEST_PATCH``
+        targets collide on push.
+
+        :param products: All cartesian-product rows.
+
+        :return: A set of row signatures (see :pymeth:`_row_signature`) identifying
+            latest-patch rows. Returns ``None`` if any dependency version is unparseable;
+            in that case no ``LATEST_PATCH``-family tags are emitted for the matrix.
+        """
+        if not products:
+            return set()
+
+        # Validate dependency versions in a single explicit pass so the rest of the
+        # function can treat them as parseable. Mirrors `_compute_latest_combination`'s
+        # behaviour: bad dep input aborts emission of the family, and an unexpected
+        # internal error from the version constructor is caught and treated the same way
+        # rather than killing the whole build.
+        for product in products:
+            for dep in product["dependencies"]:
+                try:
+                    DependencyVersion(dep.versions[0])
+                except InvalidVersion as e:
+                    log.warning(
+                        f"Image matrix '{self.namePattern}': cannot determine latest patch combinations "
+                        f"because dependency '{dep.dependency}' version '{dep.versions[0]}' is unparseable "
+                        f"({e}). No 'latestPatch'-family tags will be emitted for this matrix."
+                    )
+                    return None
+                except Exception as e:
+                    log.warning(
+                        f"Image matrix '{self.namePattern}': cannot determine latest patch combinations "
+                        f"because dependency '{dep.dependency}' raised an unexpected error processing "
+                        f"'{dep.versions[0]}' ({type(e).__name__}: {e}). "
+                        f"No 'latestPatch'-family tags will be emitted for this matrix."
+                    )
+                    return None
+
+        groups: dict[tuple, list[dict[str, list | dict]]] = {}
+        for product in products:
+            groups.setdefault(self._minor_group_key(product), []).append(product)
+
+        latest_signatures: set[tuple] = set()
+        for group_rows in groups.values():
+            try:
+                max_row = max(group_rows, key=self._patch_sort_key)
+            except Exception as e:
+                # _patch_sort_key parses value substrings as ``DependencyVersion``,
+                # which the dep pre-validation pass above doesn't cover. An
+                # unexpected error there shouldn't kill the build — drop
+                # latestPatch tags for the matrix instead.
+                log.warning(
+                    f"Image matrix '{self.namePattern}': cannot determine latest patch combinations "
+                    f"because computing the patch sort key raised an unexpected error "
+                    f"({type(e).__name__}: {e}). "
+                    f"No 'latestPatch'-family tags will be emitted for this matrix."
+                )
+                return None
+            latest_signatures.add(self._row_signature(max_row))
+        return latest_signatures
+
+    @staticmethod
+    def _minor_group_key(product: dict[str, list | dict]) -> tuple:
+        """Group key derived from :func:`strip_patch` applied to every axis value.
+
+        Two rows that would render to the same stripped tag share the same group key,
+        regardless of whether the value is a plain version (``3.12.3``), a prefixed
+        version (``go1.24.3``), or a non-version label (``alpha``).
+
+        Pure function — assumes dependency versions are already validated by the
+        caller; this method does not raise.
+        """
+        dep_parts = tuple(
+            (dep.dependency, strip_patch(dep.versions[0]))
+            for dep in sorted(product["dependencies"], key=lambda d: d.dependency)
+        )
+        value_parts = tuple((k, strip_patch(str(val))) for k, val in sorted(product["values"].items()))
+        return dep_parts, value_parts
+
+    @staticmethod
+    def _patch_sort_key(product: dict[str, list | dict]) -> tuple:
+        """Sort key for finding the highest-patch row within a group.
+
+        Extract *every* numeric ``MAJOR.MINOR[.PATCH...]`` substring from each value
+        and use the tuple of parsed versions as the sort key, so multi-version strings
+        (e.g. ``"go1.24-lib2.3.1"`` vs ``"go1.24-lib2.3.2"``) cascade comparison to
+        the later segment that actually differs.
+
+        Within a group all rows share the same stripped form, which forces the same
+        set of version-bearing positions, so every row produces the same shape of
+        tuple (empty when no version is present and the group has a single row, or
+        non-empty in lockstep otherwise). That invariant prevents mixed-type
+        comparisons during ``max()``.
+        """
+        sort_keys = []
+        for dep in sorted(product["dependencies"], key=lambda d: d.dependency):
+            sort_keys.append(DependencyVersion(dep.versions[0]))
+        for k, val in sorted(product["values"].items()):
+            sort_keys.append(extract_versions(str(val)))
+        return tuple(sort_keys)

posit-bakery/posit_bakery/config/image/version.py

@@ -85,6 +85,15 @@ class ImageVersion(BakeryPathMixin, BakeryYAMLModel):
             description="Flag to indicate if this is a matrix version.",
         ),
     ]
+    isLatestPatchCombination: Annotated[
+        bool,
+        Field(
+            exclude=True,
+            default=False,
+            description="Flag set on matrix versions whose dependency versions are the latest patch for their "
+            "(major.minor, ...) group. Used to gate ``LATEST_PATCH``-filtered tag patterns.",
+        ),
+    ]
     os: Annotated[
         list[ImageVersionOS],
         Field(

posit-bakery/posit_bakery/config/tag.py

@@ -15,6 +15,7 @@ class TagPatternFilter(str, Enum):
 
     ALL = "all"  # Matches all image targets.
     LATEST = "latest"  # Matches the image targets at the latest image version.
+    LATEST_PATCH = "latestPatch"  # Matches matrix rows that are the latest patch for their minor combination.
     PRIMARY_OS = "primaryOS"  # Matches image targets using the primary OS.
     PRIMARY_VARIANT = "primaryVariant"  # Matches image targets of the primary variant.
 
@@ -153,24 +154,44 @@ def default_matrix_tag_patterns() -> list[TagPattern]:
     hyphen onward. This set excludes stripMetadata patterns to avoid tag collisions across
     matrix combinations.
 
+    The ``stripPatch`` variants emit additional minor-only tags (e.g., "R4.3-python3.11")
+    for rows that represent the latest patch in their (minor, ...) group, gated by the
+    ``LATEST_PATCH`` filter so non-latest rows do not collide on the stripped tag.
+
     :return: A list of TagPattern objects representing the default matrix tag patterns.
     """
     return [
         TagPattern(
             patterns=["{{ Version }}-{{ OS }}-{{ Variant }}"],
             only=[TagPatternFilter.ALL],
         ),
+        TagPattern(
+            patterns=["{{ Version | stripPatch }}-{{ OS }}-{{ Variant }}"],
+            only=[TagPatternFilter.LATEST_PATCH],
+        ),
         TagPattern(
             patterns=["{{ Version }}-{{ Variant }}"],
             only=[TagPatternFilter.PRIMARY_OS],
         ),
+        TagPattern(
+            patterns=["{{ Version | stripPatch }}-{{ Variant }}"],
+            only=[TagPatternFilter.LATEST_PATCH, TagPatternFilter.PRIMARY_OS],
+        ),
         TagPattern(
             patterns=["{{ Version }}-{{ OS }}"],
             only=[TagPatternFilter.PRIMARY_VARIANT],
         ),
+        TagPattern(
+            patterns=["{{ Version | stripPatch }}-{{ OS }}"],
+            only=[TagPatternFilter.LATEST_PATCH, TagPatternFilter.PRIMARY_VARIANT],
+        ),
         TagPattern(
             patterns=["{{ Version }}"],
             only=[TagPatternFilter.PRIMARY_OS, TagPatternFilter.PRIMARY_VARIANT],
         ),
+        TagPattern(
+            patterns=["{{ Version | stripPatch }}"],
+            only=[TagPatternFilter.LATEST_PATCH, TagPatternFilter.PRIMARY_OS, TagPatternFilter.PRIMARY_VARIANT],
+        ),
         *_shared_latest_tag_patterns(),
     ]

posit-bakery/posit_bakery/config/templating/render.py

@@ -2,6 +2,7 @@
 
 import jinja2
 
+from posit_bakery.config.dependencies.version import strip_patch
 from posit_bakery.const import REGEX_IMAGE_TAG_SUFFIX_ALLOWED_CHARACTERS_PATTERN
 from posit_bakery.error import BakeryTemplateError
 
@@ -25,6 +26,7 @@ def jinja2_env(**kwargs) -> jinja2.Environment:
     env = jinja2.Environment(**kwargs)
     env.filters["tagSafe"] = lambda s: re.sub(REGEX_IMAGE_TAG_SUFFIX_ALLOWED_CHARACTERS_PATTERN, "-", s).strip("-._")
     env.filters["stripMetadata"] = lambda s: re.sub(r"[+-](?=[^+-]*$).*", "", s)
+    env.filters["stripPatch"] = strip_patch
     env.filters["condense"] = lambda s: re.sub(r"[ .-]", "", s)
     env.filters["regexReplace"] = lambda s, find, replace: re.sub(find, replace, s)
     env.filters["quote"] = lambda s: '"' + s + '"'

posit-bakery/posit_bakery/image/image_target.py

@@ -324,6 +324,11 @@ def is_latest(self) -> bool:
         """Check if the image version is marked as latest."""
         return self.image_version.latest
 
+    @property
+    def is_latest_patch_combination(self) -> bool:
+        """Check if the image version is the latest patch for its matrix (minor, ...) group."""
+        return self.image_version.isLatestPatchCombination
+
     @property
     def is_primary_os(self) -> bool:
         """Check if the image OS is marked as primary."""
@@ -410,6 +415,9 @@ def tag_patterns(self) -> list[TagPattern]:
                 # Skip pattern marked as latest if not latest version.
                 if TagPatternFilter.LATEST in tag_pattern.only and not self.is_latest:
                     continue
+                # Skip pattern for latest patch if this row is not the latest patch in its group.
+                if TagPatternFilter.LATEST_PATCH in tag_pattern.only and not self.is_latest_patch_combination:
+                    continue
                 # Skip pattern for primary OS if not primary OS.
                 if TagPatternFilter.PRIMARY_OS in tag_pattern.only and not self.is_primary_os:
                     continue