Merge branch 'v4-9-0-test' into feat/Add-config-option-for-line-length-warning

Author: Narwhal-fish

.pre-commit-config.yaml

@@ -24,7 +24,7 @@ repos:
       - id: debug-statements
       - id: no-commit-to-branch
       - id: check-merge-conflict
-      - id: check-toml
+      - id: check-toml # TOML linter (syntax checker)
       - id: check-yaml
         args: [ '--unsafe' ] # for mkdocs.yml
       - id: detect-private-key
@@ -55,17 +55,22 @@ repos:
         stages:
           - post-commit
 
+  - repo: https://github.com/ComPWA/taplo-pre-commit
+    rev: v0.9.3
+    hooks:
+      - id: taplo-format
+
   - repo: local
     hooks:
       - id: format
-        name: Format
+        name: Format Python code via Poetry
         language: system
         pass_filenames: false
         entry: poetry format
         types: [ python ]
 
       - id: linter and test
-        name: Linters
+        name: Linters via Poetry
         language: system
         pass_filenames: false
         entry: poetry lint

.taplo.toml

@@ -0,0 +1,4 @@
+include = ["pyproject.toml", ".taplo.toml"]
+
+[formatting]
+indent_string = "    "

commitizen/changelog.py

@@ -29,7 +29,7 @@
 
 import re
 from collections import OrderedDict, defaultdict
-from collections.abc import Generator, Iterable, Mapping, Sequence
+from collections.abc import Generator, Iterable, Mapping, MutableMapping, Sequence
 from dataclasses import dataclass
 from datetime import date
 from typing import TYPE_CHECKING, Any
@@ -167,8 +167,8 @@ def process_commit_message(
     hook: MessageBuilderHook | None,
     parsed: re.Match[str],
     commit: GitCommit,
-    changes: dict[str | None, list],
-    change_type_map: dict[str, str] | None = None,
+    ref_changes: MutableMapping[str | None, list],
+    change_type_map: Mapping[str, str] | None = None,
 ) -> None:
     message: dict[str, Any] = {
         "sha1": commit.rev,
@@ -178,13 +178,16 @@ def process_commit_message(
         **parsed.groupdict(),
     }
 
-    if processed := hook(message, commit) if hook else message:
-        messages = [processed] if isinstance(processed, dict) else processed
-        for msg in messages:
-            change_type = msg.pop("change_type", None)
-            if change_type_map:
-                change_type = change_type_map.get(change_type, change_type)
-            changes[change_type].append(msg)
+    processed_msg = hook(message, commit) if hook else message
+    if not processed_msg:
+        return
+
+    messages = [processed_msg] if isinstance(processed_msg, dict) else processed_msg
+    for msg in messages:
+        change_type = msg.pop("change_type", None)
+        if change_type_map:
+            change_type = change_type_map.get(change_type, change_type)
+        ref_changes[change_type].append(msg)
 
 
 def generate_ordered_changelog_tree(
@@ -251,6 +254,7 @@ def incremental_build(
     unreleased_start = metadata.unreleased_start
     unreleased_end = metadata.unreleased_end
     latest_version_position = metadata.latest_version_position
+
     skip = False
     output_lines: list[str] = []
     for index, line in enumerate(lines):
@@ -260,9 +264,7 @@ def incremental_build(
             skip = False
             if (
                 latest_version_position is None
-                or isinstance(latest_version_position, int)
-                and isinstance(unreleased_end, int)
-                and latest_version_position > unreleased_end
+                or latest_version_position > unreleased_end
             ):
                 continue
 
@@ -271,13 +273,15 @@ def incremental_build(
 
         if index == latest_version_position:
             output_lines.extend([new_content, "\n"])
-
         output_lines.append(line)
-    if not isinstance(latest_version_position, int):
-        if output_lines and output_lines[-1].strip():
-            # Ensure at least one blank line between existing and new content.
-            output_lines.append("\n")
-        output_lines.append(new_content)
+
+    if latest_version_position is not None:
+        return output_lines
+
+    if output_lines and output_lines[-1].strip():
+        # Ensure at least one blank line between existing and new content.
+        output_lines.append("\n")
+    output_lines.append(new_content)
     return output_lines
 
 

commitizen/cli.py

@@ -52,16 +52,13 @@ def __call__(
     ) -> None:
         if not isinstance(values, str):
             return
-        if "=" not in values:
+
+        key, sep, value = values.partition("=")
+        if not key or not sep:
             raise InvalidCommandArgumentError(
                 f"Option {option_string} expect a key=value format"
             )
         kwargs = getattr(namespace, self.dest, None) or {}
-        key, value = values.split("=", 1)
-        if not key:
-            raise InvalidCommandArgumentError(
-                f"Option {option_string} expect a key=value format"
-            )
         kwargs[key] = value.strip("'\"")
         setattr(namespace, self.dest, kwargs)
 

commitizen/commands/bump.py

@@ -23,7 +23,6 @@
     NoPatternMapError,
     NotAGitProjectError,
     NotAllowed,
-    NoVersionSpecifiedError,
 )
 from commitizen.providers import get_provider
 from commitizen.tags import TagRules
@@ -163,11 +162,7 @@ def _find_increment(self, commits: list[git.GitCommit]) -> Increment | None:
     def __call__(self) -> None:
         """Steps executed to bump."""
         provider = get_provider(self.config)
-
-        try:
-            current_version = self.scheme(provider.get_version())
-        except TypeError:
-            raise NoVersionSpecifiedError()
+        current_version = self.scheme(provider.get_version())
 
         increment = self.arguments["increment"]
         prerelease = self.arguments["prerelease"]
@@ -177,36 +172,22 @@ def __call__(self) -> None:
         build_metadata = self.arguments["build_metadata"]
         get_next = self.arguments["get_next"]
         allow_no_commit = self.arguments["allow_no_commit"]
+        major_version_zero = self.arguments["major_version_zero"]
 
         if manual_version:
-            if increment:
-                raise NotAllowed("--increment cannot be combined with MANUAL_VERSION")
-
-            if prerelease:
-                raise NotAllowed("--prerelease cannot be combined with MANUAL_VERSION")
-
-            if devrelease is not None:
-                raise NotAllowed("--devrelease cannot be combined with MANUAL_VERSION")
-
-            if is_local_version:
-                raise NotAllowed(
-                    "--local-version cannot be combined with MANUAL_VERSION"
-                )
-
-            if build_metadata:
-                raise NotAllowed(
-                    "--build-metadata cannot be combined with MANUAL_VERSION"
-                )
-
-            if self.bump_settings["major_version_zero"]:
-                raise NotAllowed(
-                    "--major-version-zero cannot be combined with MANUAL_VERSION"
-                )
-
-            if get_next:
-                raise NotAllowed("--get-next cannot be combined with MANUAL_VERSION")
-
-        if self.bump_settings["major_version_zero"] and current_version.release[0]:
+            for val, option in (
+                (increment, "--increment"),
+                (prerelease, "--prerelease"),
+                (devrelease is not None, "--devrelease"),
+                (is_local_version, "--local-version"),
+                (build_metadata, "--build-metadata"),
+                (major_version_zero, "--major-version-zero"),
+                (get_next, "--get-next"),
+            ):
+                if val:
+                    raise NotAllowed(f"{option} cannot be combined with MANUAL_VERSION")
+
+        if major_version_zero and current_version.release[0]:
             raise NotAllowed(
                 f"--major-version-zero is meaningless for current version {current_version}"
             )
@@ -215,11 +196,13 @@ def __call__(self) -> None:
             raise NotAllowed("--local-version cannot be combined with --build-metadata")
 
         if get_next:
-            # if trying to use --get-next, we should not allow --changelog or --changelog-to-stdout
-            if self.changelog_flag or self.changelog_to_stdout:
-                raise NotAllowed(
-                    "--changelog or --changelog-to-stdout is not allowed with --get-next"
-                )
+            for value, option in (
+                (self.changelog_flag, "--changelog"),
+                (self.changelog_to_stdout, "--changelog-to-stdout"),
+            ):
+                if value:
+                    raise NotAllowed(f"{option} cannot be combined with --get-next")
+
             # --get-next is a special case, taking precedence over config for 'update_changelog_on_bump'
             self.changelog_config = False
             # Setting dry_run to prevent any unwanted changes to the repo or files

commitizen/commands/changelog.py

@@ -11,7 +11,6 @@
 from commitizen import changelog, defaults, factory, git, out
 from commitizen.changelog_formats import get_changelog_format
 from commitizen.config import BaseConfig
-from commitizen.cz.base import ChangelogReleaseHook, MessageBuilderHook
 from commitizen.cz.utils import strip_local_version
 from commitizen.exceptions import (
     DryRunExit,
@@ -174,28 +173,23 @@ def _write_changelog(
 
             changelog_file.write(changelog_out)
 
-    def _export_template(self) -> None:
-        tpl = changelog.get_changelog_template(self.cz.template_loader, self.template)
-        # TODO: fix the following type ignores
-        src = Path(tpl.filename)  # type: ignore[arg-type]
-        Path(self.export_template_to).write_text(src.read_text())  # type: ignore[arg-type]
+    def _export_template(self, dist: str) -> None:
+        filename = changelog.get_changelog_template(
+            self.cz.template_loader, self.template
+        ).filename
+        if filename is None:
+            raise NotAllowed("Template filename is not set")
+
+        text = Path(filename).read_text()
+        Path(dist).write_text(text)
 
     def __call__(self) -> None:
         commit_parser = self.cz.commit_parser
         changelog_pattern = self.cz.changelog_pattern
         start_rev = self.start_rev
-        unreleased_version = self.unreleased_version
-        changelog_meta = changelog.Metadata()
-        change_type_map: dict[str, str] | None = self.change_type_map
-        changelog_message_builder_hook: MessageBuilderHook | None = (
-            self.cz.changelog_message_builder_hook
-        )
-        changelog_release_hook: ChangelogReleaseHook | None = (
-            self.cz.changelog_release_hook
-        )
 
         if self.export_template_to:
-            return self._export_template()
+            return self._export_template(self.export_template_to)
 
         if not changelog_pattern or not commit_parser:
             raise NoPatternMapError(
@@ -209,45 +203,53 @@ def __call__(self) -> None:
         assert self.file_name
 
         tags = self.tag_rules.get_version_tags(git.get_tags(), warn=True)
-        end_rev = ""
+        changelog_meta = changelog.Metadata()
         if self.incremental:
             changelog_meta = self.changelog_format.get_metadata(self.file_name)
             if changelog_meta.latest_version:
                 start_rev = self._find_incremental_rev(
                     strip_local_version(changelog_meta.latest_version_tag or ""), tags
                 )
+
+        end_rev = ""
         if self.rev_range:
             start_rev, end_rev = changelog.get_oldest_and_newest_rev(
                 tags,
                 self.rev_range,
                 self.tag_rules,
             )
+
         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
         ):
             raise NoCommitsFoundError("No commits found")
+
         tree = changelog.generate_tree_from_commits(
             commits,
             tags,
             commit_parser,
             changelog_pattern,
-            unreleased_version,
-            change_type_map=change_type_map,
-            changelog_message_builder_hook=changelog_message_builder_hook,
-            changelog_release_hook=changelog_release_hook,
+            self.unreleased_version,
+            change_type_map=self.change_type_map,
+            changelog_message_builder_hook=self.cz.changelog_message_builder_hook,
+            changelog_release_hook=self.cz.changelog_release_hook,
             rules=self.tag_rules,
         )
         if self.change_type_order:
             tree = changelog.generate_ordered_changelog_tree(
                 tree, self.change_type_order
             )
 
-        extras = self.cz.template_extras.copy()
-        extras.update(self.config.settings["extras"])
-        extras.update(self.extras)
         changelog_out = changelog.render_changelog(
-            tree, loader=self.cz.template_loader, template=self.template, **extras
+            tree,
+            self.cz.template_loader,
+            self.template,
+            **{
+                **self.cz.template_extras,
+                **self.config.settings["extras"],
+                **self.extras,
+            },
         ).lstrip("\n")
 
         # Dry_run is executed here to avoid checking and reading the files