refactor(bump_rule): use enum on increment

Author: bearomorphism

commitizen/bump_rule.py

@@ -2,18 +2,51 @@
 
 import re
 from collections.abc import Iterable
+from enum import Enum, auto
 from functools import cached_property
-from typing import Callable, Protocol
+from typing import Any, Callable, Protocol
 
 from commitizen.exceptions import NoPatternMapError
-from commitizen.version_schemes import Increment
 
-_VERSION_ORDERING = dict(zip((None, "PATCH", "MINOR", "MAJOR"), range(4)))
+
+class SemVerIncrement(Enum):
+    MAJOR = auto()
+    MINOR = auto()
+    PATCH = auto()
+
+    def __str__(self) -> str:
+        return self.name
+
+    @classmethod
+    def safe_cast(cls, value: str | None) -> SemVerIncrement | None:
+        if value is None:
+            return None
+        try:
+            return cls[value]
+        except ValueError:
+            return None
+
+    @classmethod
+    def safe_cast_dict(cls, d: dict[str, Any]) -> dict[str, SemVerIncrement]:
+        return {
+            k: v
+            for k, v in ((k, SemVerIncrement.safe_cast(v)) for k, v in d.items())
+            if v is not None
+        }
+
+
+_VERSION_ORDERING = dict(
+    zip(
+        (None, SemVerIncrement.PATCH, SemVerIncrement.MINOR, SemVerIncrement.MAJOR),
+        range(4),
+    )
+)
 
 
 def find_increment_by_callable(
-    commit_messages: Iterable[str], get_increment: Callable[[str], Increment | None]
-) -> Increment | None:
+    commit_messages: Iterable[str],
+    get_increment: Callable[[str], SemVerIncrement | None],
+) -> SemVerIncrement | None:
     """Find the highest version increment from a list of messages.
 
     This function processes a list of messages and determines the highest version
@@ -23,7 +56,7 @@ def find_increment_by_callable(
     Args:
         commit_messages: A list of messages to analyze.
         get_increment: A callable that takes a commit message string and returns an
-            Increment value (MAJOR, MINOR, PATCH) or None if no increment is needed.
+            SemVerIncrement value (MAJOR, MINOR, PATCH) or None if no increment is needed.
 
     Returns:
         The highest version increment needed (MAJOR, MINOR, PATCH) or None if no
@@ -40,14 +73,16 @@ def find_increment_by_callable(
     return _find_highest_increment(increments)
 
 
-def _find_highest_increment(increments: Iterable[Increment | None]) -> Increment | None:
+def _find_highest_increment(
+    increments: Iterable[SemVerIncrement | None],
+) -> SemVerIncrement | None:
     return max(increments, key=lambda x: _VERSION_ORDERING[x], default=None)
 
 
 class BumpRule(Protocol):
     def get_increment(
         self, commit_message: str, major_version_zero: bool
-    ) -> Increment | None:
+    ) -> SemVerIncrement | None:
         """Determine the version increment based on a commit message.
 
         This method analyzes a commit message to determine what kind of version increment
@@ -60,7 +95,7 @@ def get_increment(
                               instead of MAJOR. This is useful for projects in 0.x.x versions.
 
         Returns:
-            Increment | None: The type of version increment needed:
+            SemVerIncrement | None: The type of version increment needed:
                 - "MAJOR": For breaking changes when major_version_zero is False
                 - "MINOR": For breaking changes when major_version_zero is True, or for new features
                 - "PATCH": For bug fixes, performance improvements, or refactors
@@ -76,19 +111,21 @@ class ConventionalCommitBumpRule(BumpRule):
 
     def get_increment(
         self, commit_message: str, major_version_zero: bool
-    ) -> Increment | None:
+    ) -> SemVerIncrement | None:
         if not (m := self._head_pattern.match(commit_message)):
             return None
 
         change_type = m.group("change_type")
         if m.group("bang") or self._RE_BREAKING_CHANGE.match(change_type):
-            return "MINOR" if major_version_zero else "MAJOR"
+            return (
+                SemVerIncrement.MINOR if major_version_zero else SemVerIncrement.MAJOR
+            )
 
         if change_type == "feat":
-            return "MINOR"
+            return SemVerIncrement.MINOR
 
         if change_type in self._PATCH_CHANGE_TYPES:
-            return "PATCH"
+            return SemVerIncrement.PATCH
 
         return None
 
@@ -118,8 +155,8 @@ class OldSchoolBumpRule(BumpRule):
     def __init__(
         self,
         bump_pattern: str,
-        bump_map: dict[str, Increment],
-        bump_map_major_version_zero: dict[str, Increment],
+        bump_map: dict[str, SemVerIncrement],
+        bump_map_major_version_zero: dict[str, SemVerIncrement],
     ):
         if not bump_map or not bump_pattern or not bump_map_major_version_zero:
             raise NoPatternMapError(
@@ -132,7 +169,7 @@ def __init__(
 
     def get_increment(
         self, commit_message: str, major_version_zero: bool
-    ) -> Increment | None:
+    ) -> SemVerIncrement | None:
         if not (m := self.bump_pattern.search(commit_message)):
             return None
 

commitizen/commands/bump.py

@@ -7,7 +7,11 @@
 import questionary
 
 from commitizen import bump, factory, git, hooks, out
-from commitizen.bump_rule import OldSchoolBumpRule, find_increment_by_callable
+from commitizen.bump_rule import (
+    OldSchoolBumpRule,
+    SemVerIncrement,
+    find_increment_by_callable,
+)
 from commitizen.changelog_formats import get_changelog_format
 from commitizen.commands.changelog import Changelog
 from commitizen.config import BaseConfig
@@ -29,7 +33,6 @@
 from commitizen.providers import get_provider
 from commitizen.tags import TagRules
 from commitizen.version_schemes import (
-    Increment,
     InvalidVersion,
     Prerelease,
     get_version_scheme,
@@ -120,22 +123,23 @@ def is_initial_tag(
                 is_initial = questionary.confirm("Is this the first tag created?").ask()
         return is_initial
 
-    def find_increment(self, commits: list[git.GitCommit]) -> Increment | None:
+    def find_increment(self, commits: list[git.GitCommit]) -> SemVerIncrement | None:
         # Update the bump map to ensure major version doesn't increment.
         is_major_version_zero: bool = self.bump_settings["major_version_zero"]
 
         # Fallback to old school bump rule if no bump rule is provided
         rule = self.cz.bump_rule or OldSchoolBumpRule(
             *self._get_validated_cz_bump(),
         )
+
         return find_increment_by_callable(
             (commit.message for commit in commits),
             lambda x: rule.get_increment(x, is_major_version_zero),
         )
 
     def _get_validated_cz_bump(
         self,
-    ) -> tuple[str, dict[str, Increment], dict[str, Increment]]:
+    ) -> tuple[str, dict[str, SemVerIncrement], dict[str, SemVerIncrement]]:
         """For fixing the type errors"""
         bump_pattern = self.cz.bump_pattern
         bump_map = self.cz.bump_map
@@ -145,9 +149,10 @@ def _get_validated_cz_bump(
                 f"'{self.config.settings['name']}' rule does not support bump"
             )
 
-        return cast(
-            tuple[str, dict[str, Increment], dict[str, Increment]],
-            (bump_pattern, bump_map, bump_map_major_version_zero),
+        return (
+            bump_pattern,
+            SemVerIncrement.safe_cast_dict(bump_map),
+            SemVerIncrement.safe_cast_dict(bump_map_major_version_zero),
         )
 
     def __call__(self) -> None:  # noqa: C901
@@ -166,7 +171,9 @@ def __call__(self) -> None:  # noqa: C901
 
         dry_run: bool = self.arguments["dry_run"]
         is_yes: bool = self.arguments["yes"]
-        increment: Increment | None = self.arguments["increment"]
+        increment: SemVerIncrement | None = SemVerIncrement.safe_cast(
+            self.arguments["increment"]
+        )
         prerelease: Prerelease | None = self.arguments["prerelease"]
         devrelease: int | None = self.arguments["devrelease"]
         is_files_only: bool | None = self.arguments["files_only"]
@@ -283,7 +290,7 @@ def __call__(self) -> None:  # noqa: C901
 
             # we create an empty PATCH increment for empty tag
             if increment is None and allow_no_commit:
-                increment = "PATCH"
+                increment = SemVerIncrement.PATCH
 
             new_version = current_version.bump(
                 increment,

commitizen/defaults.py

@@ -5,6 +5,8 @@
 from collections.abc import Iterable, MutableMapping, Sequence
 from typing import Any, TypedDict
 
+from commitizen.bump_rule import SemVerIncrement
+
 # Type
 Questions = Iterable[MutableMapping[str, Any]]
 
@@ -108,31 +110,27 @@ class Settings(TypedDict, total=False):
     "extras": {},
 }
 
-MAJOR = "MAJOR"
-MINOR = "MINOR"
-PATCH = "PATCH"
-
 CHANGELOG_FORMAT = "markdown"
 
 BUMP_PATTERN = r"^((BREAKING[\-\ ]CHANGE|\w+)(\(.+\))?!?):"
-BUMP_MAP = OrderedDict(
+BUMP_MAP = dict(
     (
-        (r"^.+!$", MAJOR),
-        (r"^BREAKING[\-\ ]CHANGE", MAJOR),
-        (r"^feat", MINOR),
-        (r"^fix", PATCH),
-        (r"^refactor", PATCH),
-        (r"^perf", PATCH),
+        (r"^.+!$", str(SemVerIncrement.MAJOR)),
+        (r"^BREAKING[\-\ ]CHANGE", str(SemVerIncrement.MAJOR)),
+        (r"^feat", str(SemVerIncrement.MINOR)),
+        (r"^fix", str(SemVerIncrement.PATCH)),
+        (r"^refactor", str(SemVerIncrement.PATCH)),
+        (r"^perf", str(SemVerIncrement.PATCH)),
     )
 )
-BUMP_MAP_MAJOR_VERSION_ZERO = OrderedDict(
+BUMP_MAP_MAJOR_VERSION_ZERO = dict(
     (
-        (r"^.+!$", MINOR),
-        (r"^BREAKING[\-\ ]CHANGE", MINOR),
-        (r"^feat", MINOR),
-        (r"^fix", PATCH),
-        (r"^refactor", PATCH),
-        (r"^perf", PATCH),
+        (r"^.+!$", str(SemVerIncrement.MINOR)),
+        (r"^BREAKING[\-\ ]CHANGE", str(SemVerIncrement.MINOR)),
+        (r"^feat", str(SemVerIncrement.MINOR)),
+        (r"^fix", str(SemVerIncrement.PATCH)),
+        (r"^refactor", str(SemVerIncrement.PATCH)),
+        (r"^perf", str(SemVerIncrement.PATCH)),
     )
 )
 change_type_order = ["BREAKING CHANGE", "Feat", "Fix", "Refactor", "Perf"]

commitizen/version_schemes.py

@@ -14,6 +14,8 @@
     runtime_checkable,
 )
 
+from commitizen.bump_rule import SemVerIncrement
+
 if sys.version_info >= (3, 10):
     from importlib import metadata
 else:
@@ -22,7 +24,7 @@
 from packaging.version import InvalidVersion  # noqa: F401: expose the common exception
 from packaging.version import Version as _BaseVersion
 
-from commitizen.defaults import MAJOR, MINOR, PATCH, Settings
+from commitizen.defaults import Settings
 from commitizen.exceptions import VersionSchemeUnknown
 
 if TYPE_CHECKING:
@@ -39,7 +41,6 @@
         from typing import Self
 
 
-Increment: TypeAlias = Literal["MAJOR", "MINOR", "PATCH"]
 Prerelease: TypeAlias = Literal["alpha", "beta", "rc"]
 DEFAULT_VERSION_PARSER = r"v?(?P<version>([0-9]+)\.([0-9]+)(?:\.([0-9]+))?(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+[0-9A-Za-z.]+)?(\w+)?)"
 
@@ -126,7 +127,7 @@ def __ne__(self, other: object) -> bool:
 
     def bump(
         self,
-        increment: Increment | None,
+        increment: SemVerIncrement | None,
         prerelease: Prerelease | None = None,
         prerelease_offset: int = 0,
         devrelease: int | None = None,
@@ -223,26 +224,30 @@ def generate_build_metadata(self, build_metadata: str | None) -> str:
 
         return f"+{build_metadata}"
 
-    def increment_base(self, increment: Increment | None = None) -> str:
+    def increment_base(self, increment: SemVerIncrement | None = None) -> str:
         prev_release = list(self.release)
-        increments = [MAJOR, MINOR, PATCH]
+        increments = [
+            SemVerIncrement.MAJOR,
+            SemVerIncrement.MINOR,
+            SemVerIncrement.PATCH,
+        ]
         base = dict(zip_longest(increments, prev_release, fillvalue=0))
 
-        if increment == MAJOR:
-            base[MAJOR] += 1
-            base[MINOR] = 0
-            base[PATCH] = 0
-        elif increment == MINOR:
-            base[MINOR] += 1
-            base[PATCH] = 0
-        elif increment == PATCH:
-            base[PATCH] += 1
+        if increment == SemVerIncrement.MAJOR:
+            base[SemVerIncrement.MAJOR] += 1
+            base[SemVerIncrement.MINOR] = 0
+            base[SemVerIncrement.PATCH] = 0
+        elif increment == SemVerIncrement.MINOR:
+            base[SemVerIncrement.MINOR] += 1
+            base[SemVerIncrement.PATCH] = 0
+        elif increment == SemVerIncrement.PATCH:
+            base[SemVerIncrement.PATCH] += 1
 
-        return f"{base[MAJOR]}.{base[MINOR]}.{base[PATCH]}"
+        return f"{base[SemVerIncrement.MAJOR]}.{base[SemVerIncrement.MINOR]}.{base[SemVerIncrement.PATCH]}"
 
     def bump(
         self,
-        increment: Increment | None,
+        increment: SemVerIncrement | None,
         prerelease: Prerelease | None = None,
         prerelease_offset: int = 0,
         devrelease: int | None = None,
@@ -272,12 +277,12 @@ def bump(
                 base = self.increment_base(increment)
             else:
                 base = f"{self.major}.{self.minor}.{self.micro}"
-                if increment == PATCH:
+                if increment == SemVerIncrement.PATCH:
                     pass
-                elif increment == MINOR:
+                elif increment == SemVerIncrement.MINOR:
                     if self.micro != 0:
                         base = self.increment_base(increment)
-                elif increment == MAJOR:
+                elif increment == SemVerIncrement.MAJOR:
                     if self.minor != 0 or self.micro != 0:
                         base = self.increment_base(increment)
             dev_version = self.generate_devrelease(devrelease)