refactor(command_bump): use bump rules

Author: bearomorphism

commitizen/bump.py

@@ -2,63 +2,20 @@
 
 import os
 import re
-from collections import OrderedDict
 from glob import iglob
 from logging import getLogger
 from string import Template
-from typing import cast
 
 from commitizen.defaults import MAJOR, MINOR, PATCH, bump_message, encoding
 from commitizen.exceptions import CurrentVersionNotFoundError
-from commitizen.git import GitCommit, smart_open
-from commitizen.version_schemes import Increment, Version
+from commitizen.git import smart_open
+from commitizen.version_schemes import Version
 
 VERSION_TYPES = [None, PATCH, MINOR, MAJOR]
 
 logger = getLogger("commitizen")
 
 
-# TODO: replace this with find_increment_by_callable?
-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)
-
-
 def update_version_in_files(
     current_version: str,
     new_version: str,

commitizen/commands/bump.py

@@ -7,7 +7,7 @@
 import questionary
 
 from commitizen import bump, factory, git, hooks, out
-from commitizen.bump_rule import find_increment_by_callable
+from commitizen.bump_rule import OldSchoolBumpRule, find_increment_by_callable
 from commitizen.changelog_formats import get_changelog_format
 from commitizen.commands.changelog import Changelog
 from commitizen.config import BaseConfig
@@ -124,27 +124,31 @@ def find_increment(self, commits: list[git.GitCommit]) -> Increment | None:
         # Update the bump map to ensure major version doesn't increment.
         is_major_version_zero: bool = self.bump_settings["major_version_zero"]
 
-        if rule := self.cz.bump_rule:
-            return find_increment_by_callable(
-                (commit.message for commit in commits),
-                lambda x: rule.get_increment(x, is_major_version_zero),
-            )
-
-        bump_map = (
-            self.cz.bump_map_major_version_zero
-            if is_major_version_zero
-            else self.cz.bump_map
+        # 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),
         )
-        bump_pattern = self.cz.bump_pattern
 
-        if not bump_map or not bump_pattern:
+    def _get_validated_cz_bump(
+        self,
+    ) -> tuple[str, dict[str, Increment], dict[str, Increment]]:
+        """For fixing the type errors"""
+        bump_pattern = self.cz.bump_pattern
+        bump_map = self.cz.bump_map
+        bump_map_major_version_zero = self.cz.bump_map_major_version_zero
+        if not bump_pattern or not bump_map or not bump_map_major_version_zero:
             raise NoPatternMapError(
                 f"'{self.config.settings['name']}' rule does not support bump"
             )
-        increment = bump.find_increment(
-            commits, regex=bump_pattern, increments_map=bump_map
+
+        return cast(
+            tuple[str, dict[str, Increment], dict[str, Increment]],
+            (bump_pattern, bump_map, bump_map_major_version_zero),
         )
-        return increment
 
     def __call__(self) -> None:  # noqa: C901
         """Steps executed to bump."""