refactor(bump_rule): resolve comments

bearomorphism · bearomorphism · commit d2413c13dda6 · 2025-08-24T22:14:58.000+08:00
diff --git a/commitizen/bump_rule.py b/commitizen/bump_rule.py
@@ -12,12 +12,14 @@
 class VersionIncrement(IntEnum):
     """An enumeration representing semantic versioning increments.
 
-    This class defines the three types of version increments according to semantic versioning:
+    This class defines the four types of version increments according to semantic versioning:
+    - NONE: For commits that don't require a version bump (docs, style, etc.)
     - PATCH: For backwards-compatible bug fixes
     - MINOR: For backwards-compatible functionality additions
     - MAJOR: For incompatible API changes
     """
 
+    NONE = auto()
     PATCH = auto()
     MINOR = auto()
     MAJOR = auto()
@@ -26,16 +28,16 @@ def __str__(self) -> str:
         return self.name
 
     @classmethod
-    def safe_cast(cls, value: object) -> VersionIncrement | None:
+    def safe_cast(cls, value: object) -> VersionIncrement:
         if not isinstance(value, str):
-            return None
+            return VersionIncrement.NONE
         try:
             return cls[value]
         except KeyError:
-            return None
+            return VersionIncrement.NONE
 
-    @classmethod
-    def safe_cast_dict(cls, d: Mapping[str, object]) -> dict[str, VersionIncrement]:
+    @staticmethod
+    def safe_cast_dict(d: Mapping[str, object]) -> dict[str, VersionIncrement]:
         return {
             k: v
             for k, v in ((k, VersionIncrement.safe_cast(v)) for k, v in d.items())
@@ -45,8 +47,8 @@ def safe_cast_dict(cls, d: Mapping[str, object]) -> dict[str, VersionIncrement]:
     @staticmethod
     def get_highest_by_messages(
         commit_messages: Iterable[str],
-        extract_increment: Callable[[str], VersionIncrement | None],
-    ) -> VersionIncrement | None:
+        extract_increment: Callable[[str], VersionIncrement],
+    ) -> VersionIncrement:
         """Find the highest version increment from a list of messages.
 
         This function processes a list of messages and determines the highest version
@@ -76,9 +78,9 @@ def get_highest_by_messages(
 
     @staticmethod
     def get_highest(
-        increments: Iterable[VersionIncrement | None],
-    ) -> VersionIncrement | None:
-        return max(filter(None, increments), default=None)
+        increments: Iterable[VersionIncrement],
+    ) -> VersionIncrement:
+        return max(increments, default=VersionIncrement.NONE)
 
 
 class BumpRule(Protocol):
@@ -94,7 +96,7 @@ class BumpRule(Protocol):
 
     def extract_increment(
         self, commit_message: str, major_version_zero: bool
-    ) -> VersionIncrement | None:
+    ) -> VersionIncrement:
         """Determine the version increment based on a commit message.
 
         This method analyzes a commit message to determine what kind of version increment
@@ -107,24 +109,24 @@ def extract_increment(
                               instead of MAJOR. This is useful for projects in 0.x.x versions.
 
         Returns:
-            VersionIncrement | None: The type of version increment needed:
+            VersionIncrement: The type of version increment needed:
+                - NONE: For commits that don't require a version bump (docs, style, etc.)
                 - 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
-                - None: For commits that don't require a version bump (docs, style, etc.)
         """
 
 
 class ConventionalCommitBumpRule(BumpRule):
-    _BREAKING_CHANGE_TYPES = set(["BREAKING CHANGE", "BREAKING-CHANGE"])
-    _MINOR_CHANGE_TYPES = set(["feat"])
-    _PATCH_CHANGE_TYPES = set(["fix", "perf", "refactor"])
+    _BREAKING_CHANGE_TYPES = {"BREAKING CHANGE", "BREAKING-CHANGE"}
+    _MINOR_CHANGE_TYPES = {"feat"}
+    _PATCH_CHANGE_TYPES = {"fix", "perf", "refactor"}
 
     def extract_increment(
         self, commit_message: str, major_version_zero: bool
-    ) -> VersionIncrement | None:
+    ) -> VersionIncrement:
         if not (m := self._head_pattern.match(commit_message)):
-            return None
+            return VersionIncrement.NONE
 
         change_type = m.group("change_type")
         if m.group("bang") or change_type in self._BREAKING_CHANGE_TYPES:
@@ -138,7 +140,7 @@ def extract_increment(
         if change_type in self._PATCH_CHANGE_TYPES:
             return VersionIncrement.PATCH
 
-        return None
+        return VersionIncrement.NONE
 
     @cached_property
     def _head_pattern(self) -> re.Pattern:
@@ -225,9 +227,9 @@ def __init__(
 
     def extract_increment(
         self, commit_message: str, major_version_zero: bool
-    ) -> VersionIncrement | None:
+    ) -> VersionIncrement:
         if not (m := self.bump_pattern.search(commit_message)):
-            return None
+            return VersionIncrement.NONE
 
         effective_bump_map = (
             self.bump_map_major_version_zero if major_version_zero else self.bump_map
@@ -250,4 +252,4 @@ def extract_increment(
         for match_pattern, increment in effective_bump_map.items():
             if re.match(match_pattern, found_keyword):
                 return increment
-        return None
+        return VersionIncrement.NONE
diff --git a/commitizen/commands/bump.py b/commitizen/commands/bump.py
@@ -144,7 +144,7 @@ def _is_initial_tag(
         )
         return bool(questionary.confirm("Is this the first tag created?").ask())
 
-    def _find_increment(self, commits: list[git.GitCommit]) -> VersionIncrement | None:
+    def _find_increment(self, commits: list[git.GitCommit]) -> VersionIncrement:
         # Update the bump map to ensure major version doesn't increment.
         is_major_version_zero = self.bump_settings["major_version_zero"]
 
@@ -170,7 +170,7 @@ def __call__(self) -> None:
 
         if manual_version:
             for val, option in (
-                (increment, "--increment"),
+                (increment != VersionIncrement.NONE, "--increment"),
                 (prerelease, "--prerelease"),
                 (devrelease is not None, "--devrelease"),
                 (is_local_version, "--local-version"),
@@ -225,7 +225,7 @@ def __call__(self) -> None:
                     f"Invalid manual version: '{manual_version}'"
                 ) from exc
         else:
-            if increment is None:
+            if increment == VersionIncrement.NONE:
                 commits = git.get_commits(current_tag.name if current_tag else None)
 
                 # No commits, there is no need to create an empty tag.
@@ -243,15 +243,19 @@ def __call__(self) -> None:
 
             # It may happen that there are commits, but they are not eligible
             # for an increment, this generates a problem when using prerelease (#281)
-            if prerelease and increment is None and not current_version.is_prerelease:
+            if (
+                prerelease
+                and increment == VersionIncrement.NONE
+                and not current_version.is_prerelease
+            ):
                 raise NoCommitsFoundError(
                     "[NO_COMMITS_FOUND]\n"
                     "No commits found to generate a pre-release.\n"
                     "To avoid this error, manually specify the type of increment with `--increment`"
                 )
 
             # we create an empty PATCH increment for empty tag
-            if increment is None and allow_no_commit:
+            if increment == VersionIncrement.NONE and allow_no_commit:
                 increment = VersionIncrement.PATCH
 
             new_version = current_version.bump(
@@ -270,7 +274,10 @@ def __call__(self) -> None:
         )
 
         if get_next:
-            if increment is None and new_tag_version == current_tag_version:
+            if (
+                increment == VersionIncrement.NONE
+                and new_tag_version == current_tag_version
+            ):
                 raise NoneIncrementExit(
                     "[NO_COMMITS_TO_BUMP]\n"
                     "The commits found are not eligible to be bumped"
@@ -292,7 +299,10 @@ def __call__(self) -> None:
         else:
             out.write(information)
 
-        if increment is None and new_tag_version == current_tag_version:
+        if (
+            increment == VersionIncrement.NONE
+            and new_tag_version == current_tag_version
+        ):
             raise NoneIncrementExit(
                 "[NO_COMMITS_TO_BUMP]\nThe commits found are not eligible to be bumped"
             )
diff --git a/commitizen/version_schemes.py b/commitizen/version_schemes.py
@@ -143,7 +143,7 @@ def __ne__(self, other: object) -> bool:
 
     def bump(
         self,
-        increment: VersionIncrement | None,
+        increment: VersionIncrement,
         prerelease: Prerelease | None = None,
         prerelease_offset: int = 0,
         devrelease: int | None = None,
@@ -238,7 +238,7 @@ def generate_build_metadata(self, build_metadata: str | None) -> str:
 
         return f"+{build_metadata}"
 
-    def increment_base(self, increment: VersionIncrement | None = None) -> str:
+    def increment_base(self, increment: VersionIncrement) -> str:
         base = dict(
             zip_longest(
                 (
@@ -265,7 +265,7 @@ def increment_base(self, increment: VersionIncrement | None = None) -> str:
 
     def bump(
         self,
-        increment: VersionIncrement | None,
+        increment: VersionIncrement,
         prerelease: Prerelease | None = None,
         prerelease_offset: int = 0,
         devrelease: int | None = None,
@@ -307,7 +307,7 @@ def bump(
         )  # type: ignore[return-value]
 
     def _get_increment_base(
-        self, increment: VersionIncrement | None, exact_increment: bool
+        self, increment: VersionIncrement, exact_increment: bool
     ) -> str:
         if (
             not self.is_prerelease
diff --git a/tests/test_bump_rule.py b/tests/test_bump_rule.py
