fix(1694): changelog_merge_prerelease not working on cz bump

.github/workflows/pythonpackage.yml

@@ -6,7 +6,7 @@ jobs:
   python-check:
     strategy:
       matrix:
-        python-version: ["3.9", "3.10", "3.11", "3.12", "3.13", "3.14"]
+        python-version: ["3.10", "3.11", "3.12", "3.13", "3.14"]
         platform: [ubuntu-22.04, macos-latest, windows-latest]
     runs-on: ${{ matrix.platform }}
     steps:

commitizen/changelog.py

@@ -72,6 +72,19 @@ def __post_init__(self) -> None:
             self.latest_version_tag = self.latest_version
 
 
+@dataclass
+class IncrementalMergeInfo:
+    """
+    Information regarding the last non-pre-release, parsed from the changelog.
+
+    Required to merge pre-releases on bump.
+    Separate from Metadata to not mess with the interface.
+    """
+
+    name: str | None = None
+    index: int | None = None
+
+
 def get_commit_tag(commit: GitCommit, tags: list[GitTag]) -> GitTag | None:
     return next((tag for tag in tags if tag.rev == commit.rev), None)
 
@@ -86,15 +99,18 @@ def generate_tree_from_commits(
     changelog_message_builder_hook: MessageBuilderHook | None = None,
     changelog_release_hook: ChangelogReleaseHook | None = None,
     rules: TagRules | None = None,
+    during_version_bump: bool = False,
 ) -> Generator[dict[str, Any], None, None]:
     pat = re.compile(changelog_pattern)
     map_pat = re.compile(commit_parser, re.MULTILINE)
     body_map_pat = re.compile(commit_parser, re.MULTILINE | re.DOTALL)
     rules = rules or TagRules()
 
     # Check if the latest commit is not tagged
-
-    current_tag = get_commit_tag(commits[0], tags) if commits else None
+    if during_version_bump and rules.merge_prereleases:
+        current_tag = None
+    else:
+        current_tag = get_commit_tag(commits[0], tags) if commits else None
     current_tag_name = unreleased_version or "Unreleased"
     current_tag_date = (
         date.today().isoformat() if unreleased_version is not None else ""

commitizen/changelog_formats/__init__.py

@@ -1,17 +1,14 @@
 from __future__ import annotations
 
-import sys
-from typing import TYPE_CHECKING, Callable, ClassVar, Protocol
-
-if sys.version_info >= (3, 10):
-    from importlib import metadata
-else:
-    import importlib_metadata as metadata
+from importlib import metadata
+from typing import TYPE_CHECKING, ClassVar, Protocol
 
 from commitizen.exceptions import ChangelogFormatUnknown
 
 if TYPE_CHECKING:
-    from commitizen.changelog import Metadata
+    from collections.abc import Callable
+
+    from commitizen.changelog import IncrementalMergeInfo, Metadata
     from commitizen.config.base_config import BaseConfig
 
 CHANGELOG_FORMAT_ENTRYPOINT = "commitizen.changelog_format"
@@ -50,6 +47,12 @@ def get_metadata(self, filepath: str) -> Metadata:
         """
         raise NotImplementedError
 
+    def get_latest_full_release(self, filepath: str) -> IncrementalMergeInfo:
+        """
+        Extract metadata for the last non-pre-release.
+        """
+        raise NotImplementedError
+
 
 KNOWN_CHANGELOG_FORMATS: dict[str, type[ChangelogFormat]] = {
     ep.name: ep.load()

commitizen/changelog_formats/base.py

@@ -4,7 +4,9 @@
 from abc import ABCMeta
 from typing import IO, TYPE_CHECKING, Any, ClassVar
 
-from commitizen.changelog import Metadata
+from commitizen.changelog import IncrementalMergeInfo, Metadata
+from commitizen.config.base_config import BaseConfig
+from commitizen.git import GitTag
 from commitizen.tags import TagRules, VersionTag
 from commitizen.version_schemes import get_version_scheme
 
@@ -60,17 +62,42 @@ def get_metadata_from_file(self, file: IO[Any]) -> Metadata:
                 meta.unreleased_end = index
 
             # Try to find the latest release done
-            parsed = self.parse_version_from_title(line)
-            if parsed:
-                meta.latest_version = parsed.version
-                meta.latest_version_tag = parsed.tag
+            parsed_version = self.parse_version_from_title(line)
+            if parsed_version:
+                meta.latest_version = parsed_version.version
+                meta.latest_version_tag = parsed_version.tag
                 meta.latest_version_position = index
                 break  # there's no need for more info
         if meta.unreleased_start is not None and meta.unreleased_end is None:
             meta.unreleased_end = index
 
         return meta
 
+    def get_latest_full_release(self, filepath: str) -> IncrementalMergeInfo:
+        if not os.path.isfile(filepath):
+            return IncrementalMergeInfo()
+
+        with open(
+            filepath, encoding=self.config.settings["encoding"]
+        ) as changelog_file:
+            return self.get_latest_full_release_from_file(changelog_file)
+
+    def get_latest_full_release_from_file(self, file: IO[Any]) -> IncrementalMergeInfo:
+        latest_version_index: int | None = None
+        for index, line in enumerate(file):
+            latest_version_index = index
+            line = line.strip().lower()
+
+            parsed_version = self.parse_version_from_title(line)
+            if (
+                parsed_version
+                and not self.tag_rules.extract_version(
+                    GitTag(parsed_version.tag, "", "")
+                ).is_prerelease
+            ):
+                return IncrementalMergeInfo(name=parsed_version.tag, index=index)
+        return IncrementalMergeInfo(index=latest_version_index)
+
     def parse_version_from_title(self, line: str) -> VersionTag | None:
         """
         Extract the version from a title line if any

commitizen/commands/bump.py

@@ -314,6 +314,8 @@ def __call__(self) -> None:
                 "extras": self.extras,
                 "incremental": True,
                 "dry_run": dry_run,
+                # governs logic for merge_prerelease
+                "during_version_bump": self.arguments["prerelease"] is None,
             }
             if self.changelog_to_stdout:
                 changelog_cmd = Changelog(

commitizen/commands/changelog.py

@@ -44,6 +44,7 @@ class ChangelogArgs(TypedDict, total=False):
     template: str
     extras: dict[str, Any]
     export_template: str
+    during_version_bump: bool | None
 
 
 class Changelog:
@@ -124,6 +125,8 @@ def __init__(self, config: BaseConfig, arguments: ChangelogArgs) -> None:
         self.extras = arguments.get("extras") or {}
         self.export_template_to = arguments.get("export_template")
 
+        self.during_version_bump: bool = arguments.get("during_version_bump") or False
+
     def _find_incremental_rev(self, latest_version: str, tags: Iterable[GitTag]) -> str:
         """Try to find the 'start_rev'.
 
@@ -222,6 +225,21 @@ def __call__(self) -> None:
                 self.tag_rules,
             )
 
+        if self.during_version_bump and self.tag_rules.merge_prereleases:
+            latest_full_release_info = self.changelog_format.get_latest_full_release(
+                self.file_name
+            )
+            if latest_full_release_info.index:
+                changelog_meta.unreleased_start = 0
+                changelog_meta.latest_version_position = latest_full_release_info.index
+                changelog_meta.unreleased_end = latest_full_release_info.index - 1
+
+            start_rev = latest_full_release_info.name or ""
+            if not start_rev and latest_full_release_info.index:
+                # Only pre-releases in changelog
+                changelog_meta.latest_version_position = None
+                changelog_meta.unreleased_end = latest_full_release_info.index + 1
+
         commits = git.get_commits(start=start_rev, end=end_rev, args="--topo-order")
         if not commits and (
             self.current_version is None or not self.current_version.is_prerelease
@@ -238,6 +256,7 @@ def __call__(self) -> None:
             changelog_message_builder_hook=self.cz.changelog_message_builder_hook,
             changelog_release_hook=self.cz.changelog_release_hook,
             rules=self.tag_rules,
+            during_version_bump=self.during_version_bump,
         )
         if self.change_type_order:
             tree = changelog.generate_ordered_changelog_tree(

commitizen/commands/check.py

@@ -6,7 +6,6 @@
 
 from commitizen import factory, git, out
 from commitizen.exceptions import (
-    CommitMessageLengthExceededError,
     InvalidCommandArgumentError,
     InvalidCommitMessageError,
     NoCommitsFoundError,
@@ -83,26 +82,32 @@ def __call__(self) -> None:
         """Validate if commit messages follows the conventional pattern.
 
         Raises:
-            InvalidCommitMessageError: if the commit provided not follows the conventional pattern
+            InvalidCommitMessageError: if the commit provided does not follow the conventional pattern
             NoCommitsFoundError: if no commit is found with the given range
         """
         commits = self._get_commits()
         if not commits:
             raise NoCommitsFoundError(f"No commit found with range: '{self.rev_range}'")
 
         pattern = re.compile(self.cz.schema_pattern())
-        invalid_msgs_content = "\n".join(
-            f'commit "{commit.rev}": "{commit.message}"'
+        invalid_commits = [
+            (commit, check.errors)
             for commit in commits
-            if not self._validate_commit_message(commit.message, pattern, commit.rev)
-        )
-        if invalid_msgs_content:
-            # TODO: capitalize the first letter of the error message for consistency in v5
+            if not (
+                check := self.cz.validate_commit_message(
+                    commit_msg=commit.message,
+                    pattern=pattern,
+                    allow_abort=self.allow_abort,
+                    allowed_prefixes=self.allowed_prefixes,
+                    max_msg_length=self.max_msg_length,
+                    commit_hash=commit.rev,
+                )
+            ).is_valid
+        ]
+
+        if invalid_commits:
             raise InvalidCommitMessageError(
-                "commit validation: failed!\n"
-                "please enter a commit message in the commitizen format.\n"
-                f"{invalid_msgs_content}\n"
-                f"pattern: {pattern.pattern}"
+                self.cz.format_exception_message(invalid_commits)
             )
         out.success("Commit validation: successful!")
 
@@ -157,24 +162,3 @@ def _filter_comments(msg: str) -> str:
             if not line.startswith("#"):
                 lines.append(line)
         return "\n".join(lines)
-
-    def _validate_commit_message(
-        self, commit_msg: str, pattern: re.Pattern[str], commit_hash: str
-    ) -> bool:
-        if not commit_msg:
-            return self.allow_abort
-
-        if any(map(commit_msg.startswith, self.allowed_prefixes)):
-            return True
-
-        if self.max_msg_length is not None:
-            msg_len = len(commit_msg.partition("\n")[0].strip())
-            if msg_len > self.max_msg_length:
-                raise CommitMessageLengthExceededError(
-                    f"commit validation: failed!\n"
-                    f"commit message length exceeds the limit.\n"
-                    f'commit "{commit_hash}": "{commit_msg}"\n'
-                    f"message length limit: {self.max_msg_length} (actual: {msg_len})"
-                )
-
-        return bool(pattern.match(commit_msg))

commitizen/cz/__init__.py

@@ -2,14 +2,9 @@
 
 import importlib
 import pkgutil
-import sys
 import warnings
-
-if sys.version_info >= (3, 10):
-    from importlib import metadata
-else:
-    import importlib_metadata as metadata
-
+from collections.abc import Iterable
+from importlib import metadata
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:

commitizen/cz/base.py

@@ -1,13 +1,17 @@
 from __future__ import annotations
 
 from abc import ABCMeta, abstractmethod
-from typing import TYPE_CHECKING, Any, Callable, Protocol
+from collections.abc import Iterable, Mapping
+from typing import TYPE_CHECKING, Any, NamedTuple, Protocol
 
 from jinja2 import BaseLoader, PackageLoader
 from prompt_toolkit.styles import Style
 
+from commitizen.exceptions import CommitMessageLengthExceededError
+
 if TYPE_CHECKING:
-    from collections.abc import Iterable, Mapping
+    import re
+    from collections.abc import Callable, Iterable, Mapping
 
     from commitizen import git
     from commitizen.config.base_config import BaseConfig
@@ -26,6 +30,11 @@ def __call__(
     ) -> dict[str, Any]: ...
 
 
+class ValidationResult(NamedTuple):
+    is_valid: bool
+    errors: list
+
+
 class BaseCommitizen(metaclass=ABCMeta):
     bump_pattern: str | None = None
     bump_map: dict[str, str] | None = None
@@ -43,7 +52,7 @@ class BaseCommitizen(metaclass=ABCMeta):
         ("disabled", "fg:#858585 italic"),
     ]
 
-    # The whole subject will be parsed as message by default
+    # The whole subject will be parsed as a message by default
     # This allows supporting changelog for any rule system.
     # It can be modified per rule
     commit_parser: str | None = r"(?P<message>.*)"
@@ -101,3 +110,55 @@ def schema_pattern(self) -> str:
     @abstractmethod
     def info(self) -> str:
         """Information about the standardized commit message."""
+
+    def validate_commit_message(
+        self,
+        *,
+        commit_msg: str,
+        pattern: re.Pattern[str],
+        allow_abort: bool,
+        allowed_prefixes: list[str],
+        max_msg_length: int | None,
+        commit_hash: str,
+    ) -> ValidationResult:
+        """Validate commit message against the pattern."""
+        if not commit_msg:
+            return ValidationResult(
+                allow_abort, [] if allow_abort else ["commit message is empty"]
+            )
+
+        if any(map(commit_msg.startswith, allowed_prefixes)):
+            return ValidationResult(True, [])
+
+        if max_msg_length is not None:
+            msg_len = len(commit_msg.partition("\n")[0].strip())
+            if msg_len > max_msg_length:
+                # TODO: capitalize the first letter of the error message for consistency in v5
+                raise CommitMessageLengthExceededError(
+                    f"commit validation: failed!\n"
+                    f"commit message length exceeds the limit.\n"
+                    f'commit "{commit_hash}": "{commit_msg}"\n'
+                    f"message length limit: {max_msg_length} (actual: {msg_len})"
+                )
+
+        return ValidationResult(
+            bool(pattern.match(commit_msg)),
+            [f"pattern: {pattern.pattern}"],
+        )
+
+    def format_exception_message(
+        self, invalid_commits: list[tuple[git.GitCommit, list]]
+    ) -> str:
+        """Format commit errors."""
+        displayed_msgs_content = "\n".join(
+            [
+                f'commit "{commit.rev}": "{commit.message}\n"' + "\n".join(errors)
+                for commit, errors in invalid_commits
+            ]
+        )
+        # TODO: capitalize the first letter of the error message for consistency in v5
+        return (
+            "commit validation: failed!\n"
+            "please enter a commit message in the commitizen format.\n"
+            f"{displayed_msgs_content}"
+        )