commitizen 4.19.0__tar.gz → 4.19.2__tar.gz

{commitizen-4.19.0 → commitizen-4.19.2}/PKG-INFO

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

commitizen-4.19.2/commitizen/__version__.py

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

{commitizen-4.19.0 → commitizen-4.19.2}/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.19.0 → commitizen-4.19.2}/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,11 +159,18 @@ class Bump:
             raise NoPatternMapError(
                 f"'{self.config.settings['name']}' rule does not support bump"
             )
-        return bump.find_increment(
-            self.cz.filter_commits_before_bump(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.19.0 → commitizen-4.19.2}/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,11 +180,20 @@ class Version:
             raise NoPatternMapError(
                 f"'{self.config.settings['name']}' rule does not support bump"
             )
-        increment = bump.find_increment(
-            self.cz.filter_commits_before_bump(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.19.0 → commitizen-4.19.2}/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"),

{commitizen-4.19.0 → commitizen-4.19.2}/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.19.0 → commitizen-4.19.2}/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.19.0 → commitizen-4.19.2}/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.0 → commitizen-4.19.2}/commitizen/tags.py

@@ -127,15 +127,18 @@ class TagRules:
         if `warn` is `True`, it will print a warning message if the tag is not a version tag.
         """
         tag = tag.name if isinstance(tag, GitTag) else tag
+        if self.is_ignored_tag(tag):
+            return False
+
         is_legit = any(regex.fullmatch(tag) for regex in self.version_regexes)
-        if warn and not is_legit and not self.is_ignored_tag(tag):
+        if warn and not is_legit:
             out.warn(self._version_tag_error(tag))
         return is_legit
 
     def is_ignored_tag(self, tag: str | GitTag) -> bool:
         """True if a given tag can be ignored"""
         tag = tag.name if isinstance(tag, GitTag) else tag
-        return any(regex.match(tag) for regex in self.ignored_regexes)
+        return any(regex.fullmatch(tag) for regex in self.ignored_regexes)
 
     def get_version_tags(
         self, tags: Iterable[GitTag], warn: bool = False

commitizen-4.19.2/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.19.0 → commitizen-4.19.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "commitizen"
-version = "4.19.0"
+version = "4.19.2"
 description = "Python commitizen client tool"
 license = "MIT"
 license-files = ["LICENSE"]

{commitizen-4.19.0 → commitizen-4.19.2}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "commitizen"
-version = "4.19.0"
+version = "4.19.2"
 description = "Python commitizen client tool"
 authors = [{ name = "Santiago Fraire", email = "santiwilly@gmail.com" }]
 maintainers = [

commitizen-4.19.0/commitizen/__version__.py

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

commitizen-4.19.0/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