commitizen 4.18.1__tar.gz → 4.19.1__tar.gz

{commitizen-4.18.1 → commitizen-4.19.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: commitizen
-Version: 4.18.1
+Version: 4.19.1
 Summary: Python commitizen client tool
 Keywords: commitizen,conventional,commits,git
 Author: Santiago Fraire

commitizen-4.19.1/commitizen/__version__.py

@@ -0,0 +1 @@
+__version__ = "4.19.1"

{commitizen-4.18.1 → commitizen-4.19.1}/commitizen/bump.py

@@ -2,64 +2,18 @@ from __future__ import annotations
 
 import os
 import re
-from collections import OrderedDict
 from glob import iglob
-from logging import getLogger
 from string import Template
-from typing import TYPE_CHECKING, cast
+from typing import TYPE_CHECKING
 
-from commitizen.defaults import BUMP_MESSAGE, MAJOR, MINOR, PATCH
+from commitizen.defaults import BUMP_MESSAGE
 from commitizen.exceptions import CurrentVersionNotFoundError
-from commitizen.git import GitCommit, smart_open
+from commitizen.git import smart_open
 
 if TYPE_CHECKING:
     from collections.abc import Generator, Iterable
 
-    from commitizen.version_schemes import Increment, VersionProtocol
-
-VERSION_TYPES = [None, PATCH, MINOR, MAJOR]
-
-logger = getLogger("commitizen")
-
-
-def find_increment(
-    commits: list[GitCommit], regex: str, increments_map: dict | OrderedDict
-) -> Increment | None:
-    if isinstance(increments_map, dict):
-        increments_map = OrderedDict(increments_map)
-
-    # Most important cases are major and minor.
-    # Everything else will be considered patch.
-    select_pattern = re.compile(regex)
-    increment: str | None = None
-
-    for commit in commits:
-        for message in commit.message.split("\n"):
-            result = select_pattern.search(message)
-
-            if result:
-                found_keyword = result.group(1)
-                new_increment = None
-                for match_pattern in increments_map.keys():
-                    if re.match(match_pattern, found_keyword):
-                        new_increment = increments_map[match_pattern]
-                        break
-
-                if new_increment is None:
-                    logger.debug(
-                        f"no increment needed for '{found_keyword}' in '{message}'"
-                    )
-
-                if VERSION_TYPES.index(increment) < VERSION_TYPES.index(new_increment):
-                    logger.debug(
-                        f"increment detected is '{new_increment}' due to '{found_keyword}' in '{message}'"
-                    )
-                    increment = new_increment
-
-                if increment == MAJOR:
-                    break
-
-    return cast("Increment", increment)
+    from commitizen.version_schemes import VersionProtocol
 
 
 def update_version_in_files(

{commitizen-4.18.1 → commitizen-4.19.1}/commitizen/commands/bump.py

@@ -24,6 +24,7 @@ from commitizen.exceptions import (
 )
 from commitizen.providers import get_provider
 from commitizen.tags import TagRules
+from commitizen.version_increment import VersionIncrement
 from commitizen.version_schemes import (
     Increment,
     InvalidVersion,
@@ -145,8 +146,8 @@ class Bump:
         return bool(questionary.confirm("Is this the first tag created?").ask())
 
     def _find_increment(self, commits: list[git.GitCommit]) -> Increment | None:
+        """Determine the highest configured increment across candidate commits."""
         # Update the bump map to ensure major version doesn't increment.
-        # self.cz.bump_map = defaults.bump_map_major_version_zero
         bump_map = (
             self.cz.bump_map_major_version_zero
             if self.bump_settings["major_version_zero"]
@@ -158,7 +159,18 @@ class Bump:
             raise NoPatternMapError(
                 f"'{self.config.settings['name']}' rule does not support bump"
             )
-        return bump.find_increment(commits, regex=bump_pattern, increments_map=bump_map)
+
+        commit_messages = (
+            commit.message for commit in self.cz.filter_commits_before_bump(commits)
+        )
+        increment = VersionIncrement.get_highest_by_messages(
+            commit_messages,
+            bump_pattern,
+            bump_map,
+        )
+        if increment == VersionIncrement.NONE:
+            return None
+        return cast("Increment", str(increment))
 
     def _validate_arguments(self, current_version: VersionProtocol) -> None:
         errors: list[str] = []

{commitizen-4.18.1 → commitizen-4.19.1}/commitizen/commands/changelog.py

@@ -265,6 +265,7 @@ class Changelog:
         ):
             raise NoCommitsFoundError("No commits found")
 
+        commits = self.cz.filter_commits_before_changelog(commits)
         tree = changelog.generate_tree_from_commits(
             commits,
             tags,

{commitizen-4.18.1 → commitizen-4.19.1}/commitizen/commands/version.py

@@ -4,7 +4,7 @@ from typing import TypedDict
 
 from packaging.version import InvalidVersion
 
-from commitizen import bump, factory, git, out
+from commitizen import factory, git, out
 from commitizen.__version__ import __version__
 from commitizen.config import BaseConfig
 from commitizen.exceptions import (
@@ -180,9 +180,20 @@ class Version:
             raise NoPatternMapError(
                 f"'{self.config.settings['name']}' rule does not support bump"
             )
-        increment = bump.find_increment(
-            commits, regex=bump_pattern, increments_map=bump_map
+        next_increment = VersionIncrement.get_highest_by_messages(
+            (commit.message for commit in self.cz.filter_commits_before_bump(commits)),
+            bump_pattern,
+            bump_map,
         )
+        increment: Increment | None
+        if next_increment == VersionIncrement.NONE:
+            increment = None
+        elif next_increment == VersionIncrement.PATCH:
+            increment = "PATCH"
+        elif next_increment == VersionIncrement.MINOR:
+            increment = "MINOR"
+        else:
+            increment = "MAJOR"
 
         # TODO: Consider adding all the parameters `.bump` supports:
         # prerelease, prerelease_offset,exact_increment, etc..

{commitizen-4.18.1 → commitizen-4.19.1}/commitizen/cz/base.py

@@ -37,8 +37,8 @@ class ValidationResult(NamedTuple):
 
 class BaseCommitizen(metaclass=ABCMeta):
     bump_pattern: str | None = None
-    bump_map: dict[str, str] | None = None
-    bump_map_major_version_zero: dict[str, str] | None = None
+    bump_map: Mapping[str, str | None] | None = None
+    bump_map_major_version_zero: Mapping[str, str | None] | None = None
     default_style_config: list[tuple[str, str]] = [
         ("qmark", "fg:#ff9d00 bold"),
         ("question", "bold"),
@@ -78,6 +78,52 @@ class BaseCommitizen(metaclass=ABCMeta):
         if not self.config.settings.get("style"):
             self.config.settings.update({"style": BaseCommitizen.default_style_config})
 
+    def filter_commits(self, commits: list[git.GitCommit]) -> list[git.GitCommit]:
+        """Select commits shared by bump and changelog operations.
+
+        Custom rules can override this method when both operations should use the
+        same subset of commits.
+
+        Args:
+            commits: The commits available to the current operation.
+
+        Returns:
+            The commits that the rule considers relevant.
+        """
+        return commits
+
+    def filter_commits_before_bump(
+        self, commits: list[git.GitCommit]
+    ) -> list[git.GitCommit]:
+        """Select commits before calculating a version increment.
+
+        This operation-specific hook delegates to `filter_commits` so custom rules
+        can share filtering by default or override only bump behavior.
+
+        Args:
+            commits: The commits available for bump calculation.
+
+        Returns:
+            The commits that should contribute to the version increment.
+        """
+        return self.filter_commits(commits)
+
+    def filter_commits_before_changelog(
+        self, commits: list[git.GitCommit]
+    ) -> list[git.GitCommit]:
+        """Select commits before generating a changelog.
+
+        This operation-specific hook delegates to `filter_commits` so custom rules
+        can share filtering by default or override only changelog behavior.
+
+        Args:
+            commits: The commits available for changelog generation.
+
+        Returns:
+            The commits that should contribute to the changelog.
+        """
+        return self.filter_commits(commits)
+
     @abstractmethod
     def questions(self) -> list[CzQuestion]:
         """Questions regarding the commit message."""

{commitizen-4.18.1 → commitizen-4.19.1}/commitizen/cz/conventional_commits/conventional_commits.py

@@ -8,6 +8,8 @@ from commitizen.cz.base import BaseCommitizen
 from commitizen.cz.utils import multiple_line_breaker, required_validator
 
 if TYPE_CHECKING:
+    from collections.abc import Mapping
+
     from commitizen.question import CzQuestion
 
 __all__ = ["ConventionalCommitsCz"]
@@ -32,8 +34,10 @@ class ConventionalCommitsAnswers(TypedDict):
 
 class ConventionalCommitsCz(BaseCommitizen):
     bump_pattern = defaults.BUMP_PATTERN
-    bump_map = defaults.BUMP_MAP
-    bump_map_major_version_zero = defaults.BUMP_MAP_MAJOR_VERSION_ZERO
+    bump_map: Mapping[str, str | None] = defaults.BUMP_MAP
+    bump_map_major_version_zero: Mapping[str, str | None] = (
+        defaults.BUMP_MAP_MAJOR_VERSION_ZERO
+    )
     commit_parser = r"^((?P<change_type>feat|fix|refactor|perf|BREAKING CHANGE)(?:\((?P<scope>[^()\r\n]*)\)|\()?(?P<breaking>!)?|\w+!):\s(?P<message>.*)?"
     change_type_map = {
         "feat": "Feat",

{commitizen-4.18.1 → commitizen-4.19.1}/commitizen/cz/customize/customize.py

@@ -27,8 +27,8 @@ __all__ = ["CustomizeCommitsCz"]
 
 
 def _derive_major_version_zero(
-    bump_map: Mapping[str, str],
-) -> OrderedDict[str, str]:
+    bump_map: Mapping[str, str | None],
+) -> OrderedDict[str, str | None]:
     """Derive a ``bump_map_major_version_zero`` from a user-supplied
     ``bump_map`` by demoting any ``MAJOR`` rule to ``MINOR``.
 
@@ -45,8 +45,10 @@ def _derive_major_version_zero(
 
 class CustomizeCommitsCz(BaseCommitizen):
     bump_pattern = defaults.BUMP_PATTERN
-    bump_map = defaults.BUMP_MAP
-    bump_map_major_version_zero = defaults.BUMP_MAP_MAJOR_VERSION_ZERO
+    bump_map: Mapping[str, str | None] = defaults.BUMP_MAP
+    bump_map_major_version_zero: Mapping[str, str | None] = (
+        defaults.BUMP_MAP_MAJOR_VERSION_ZERO
+    )
     change_type_order = defaults.CHANGE_TYPE_ORDER
 
     def __init__(self, config: BaseConfig) -> None:

{commitizen-4.18.1 → commitizen-4.19.1}/commitizen/defaults.py

@@ -13,8 +13,8 @@ if TYPE_CHECKING:
 
 class CzSettings(TypedDict, total=False):
     bump_pattern: str
-    bump_map: OrderedDict[str, str]
-    bump_map_major_version_zero: OrderedDict[str, str]
+    bump_map: OrderedDict[str, str | None]
+    bump_map_major_version_zero: OrderedDict[str, str | None]
     change_type_order: list[str]
 
     questions: Iterable[CzQuestion]

commitizen-4.19.1/commitizen/version_increment.py

@@ -0,0 +1,151 @@
+"""Helpers for comparing and deriving semantic-version increments.
+
+This module centralizes the conversion between external increment labels and the
+ordered enum used internally by bump-related commands. The distinction matters
+because some callers intentionally coerce unknown values to ``NONE`` while
+matched ``bump_map`` outputs must preserve the historical fail-fast behavior for
+invalid custom rule values.
+"""
+
+from __future__ import annotations
+
+import re
+from enum import IntEnum
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable, Mapping
+
+RegexPattern = str | re.Pattern[str]
+
+
+class VersionIncrement(IntEnum):
+    """Semantic versioning bump increments.
+
+    IntEnum keeps a total order compatible with NONE < PATCH < MINOR < MAJOR
+    for comparisons across the codebase.
+
+    - NONE: no bump (docs-only / style commits, etc.)
+    - PATCH: backwards-compatible bug fixes
+    - MINOR: backwards-compatible features
+    - MAJOR: incompatible API changes
+
+    Examples:
+        ```python
+        max([VersionIncrement.PATCH, VersionIncrement.MINOR])
+        # VersionIncrement.MINOR
+        ```
+    """
+
+    NONE = 0
+    PATCH = 1
+    MINOR = 2
+    MAJOR = 3
+
+    def __str__(self) -> str:
+        """Return the legacy string representation used by existing callers."""
+        return self.name
+
+    @classmethod
+    def from_value(cls, value: object) -> VersionIncrement:
+        """Convert external increment input into a known increment.
+
+        This lenient path is used for inputs such as CLI arguments where an
+        unknown string should behave like "no increment" instead of raising.
+        Matched ``bump_map`` values are validated separately so custom rules keep
+        their historical fail-fast behavior.
+        """
+        if not isinstance(value, str):
+            return VersionIncrement.NONE
+        try:
+            return cls[value]
+        except KeyError:
+            return VersionIncrement.NONE
+
+    @classmethod
+    def _compile_pattern(cls, regex: RegexPattern) -> re.Pattern[str]:
+        """Normalize a bump-pattern input into a compiled regular expression."""
+        if isinstance(regex, re.Pattern):
+            return regex
+        return re.compile(regex)
+
+    @classmethod
+    def _from_bump_map_value(cls, value: object) -> VersionIncrement:
+        """Resolve a configured bump-map value or reject invalid rule output.
+
+        This preserves the historical behavior where a matched custom bump-map
+        entry with an unsupported increment fails immediately instead of being
+        treated as a no-op.
+        """
+        if value is None:
+            return cls.NONE
+        if value == "PATCH":
+            return cls.PATCH
+        if value == "MINOR":
+            return cls.MINOR
+        if value == "MAJOR":
+            return cls.MAJOR
+        raise ValueError(f"Invalid bump increment: {value!r}")
+
+    @classmethod
+    def from_match(
+        cls, matched_text: str, increments_map: Mapping[str, object]
+    ) -> VersionIncrement:
+        """Resolve one extracted bump token against a configured bump map.
+
+        The first regular-expression key that matches wins, preserving the
+        current user-visible behavior of ``bump_map`` ordering.
+        """
+        for match_pattern, increment in increments_map.items():
+            if re.match(match_pattern, matched_text):
+                return cls._from_bump_map_value(increment)
+        return cls.NONE
+
+    @classmethod
+    def from_message(
+        cls, message: str, regex: RegexPattern, increments_map: Mapping[str, object]
+    ) -> VersionIncrement:
+        """Compute the highest increment contributed by one commit message.
+
+        Commitizen historically evaluates each line of the full commit message
+        against ``bump_pattern`` and then keeps the highest resulting bump.
+        This method preserves that behavior while returning a comparable enum.
+        """
+        select_pattern = cls._compile_pattern(regex)
+        increment = cls.NONE
+
+        for line in message.split("\n"):
+            result = select_pattern.search(line)
+            if not result:
+                continue
+
+            increment = max(
+                increment,
+                cls.from_match(result.group(1), increments_map),
+            )
+            if increment == cls.MAJOR:
+                return increment
+
+        return increment
+
+    @classmethod
+    def get_highest_by_messages(
+        cls,
+        messages: Iterable[str],
+        regex: RegexPattern,
+        increments_map: Mapping[str, object],
+    ) -> VersionIncrement:
+        """Compute the highest increment across many commit messages.
+
+        An empty iterable yields ``NONE`` so callers can preserve the existing
+        "no increment" behavior explicitly instead of relying on exceptions from
+        ``max()``.
+        """
+        select_pattern = cls._compile_pattern(regex)
+        return max(
+            (
+                cls.from_message(message, select_pattern, increments_map)
+                for message in messages
+            ),
+            default=cls.NONE,
+        )

{commitizen-4.18.1 → commitizen-4.19.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "commitizen"
-version = "4.18.1"
+version = "4.19.1"
 description = "Python commitizen client tool"
 license = "MIT"
 license-files = ["LICENSE"]
@@ -153,7 +153,6 @@ version_provider = "uv"
 version_scheme = "pep440"
 annotated_tag = true
 update_changelog_on_bump = true
-changelog_incremental = true
 
 [tool.uv.build-backend]
 module-name = "commitizen"

{commitizen-4.18.1 → commitizen-4.19.1}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "commitizen"
-version = "4.18.1"
+version = "4.19.1"
 description = "Python commitizen client tool"
 authors = [{ name = "Santiago Fraire", email = "santiwilly@gmail.com" }]
 maintainers = [
@@ -147,7 +147,6 @@ version_provider = "uv"
 version_scheme = "pep440"
 annotated_tag = true
 update_changelog_on_bump = true
-changelog_incremental = true
 
 [tool.uv.build-backend]
 module-name = "commitizen"

commitizen-4.18.1/commitizen/__version__.py

@@ -1 +0,0 @@
-__version__ = "4.18.1"

commitizen-4.18.1/commitizen/version_increment.py

@@ -1,33 +0,0 @@
-from __future__ import annotations
-
-from enum import IntEnum
-
-
-class VersionIncrement(IntEnum):
-    """Semantic versioning bump increments.
-
-    IntEnum keeps a total order compatible with NONE < PATCH < MINOR < MAJOR
-    for comparisons across the codebase.
-
-    - NONE: no bump (docs-only / style commits, etc.)
-    - PATCH: backwards-compatible bug fixes
-    - MINOR: backwards-compatible features
-    - MAJOR: incompatible API changes
-    """
-
-    NONE = 0
-    PATCH = 1
-    MINOR = 2
-    MAJOR = 3
-
-    def __str__(self) -> str:
-        return self.name
-
-    @classmethod
-    def from_value(cls, value: object) -> VersionIncrement:
-        if not isinstance(value, str):
-            return VersionIncrement.NONE
-        try:
-            return cls[value]
-        except KeyError:
-            return VersionIncrement.NONE