commitizen 4.9.1__tar.gz → 4.10.0__tar.gz

{commitizen-4.9.1 → commitizen-4.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: commitizen
-Version: 4.9.1
+Version: 4.10.0
 Summary: Python commitizen client tool
 License: MIT License
          
@@ -23,6 +23,7 @@ License: MIT License
          LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
          OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
          SOFTWARE.
+License-File: LICENSE
 Keywords: commitizen,conventional,commits,git
 Author: Santiago Fraire
 Author-email: santiwilly@gmail.com
@@ -55,7 +56,7 @@ Requires-Dist: prompt_toolkit (!=3.0.52)
 Requires-Dist: pyyaml (>=3.08)
 Requires-Dist: questionary (>=2.0,<3.0)
 Requires-Dist: termcolor (>=1.1.0,<4.0.0)
-Requires-Dist: tomlkit (>=0.5.3,<1.0.0)
+Requires-Dist: tomlkit (>=0.8.0,<1.0.0)
 Requires-Dist: typing-extensions (>=4.0.1,<5.0.0) ; python_version < "3.11"
 Project-URL: Changelog, https://github.com/commitizen-tools/commitizen/blob/master/CHANGELOG.md
 Project-URL: Documentation, https://commitizen-tools.github.io/commitizen/

commitizen-4.10.0/commitizen/__version__.py

@@ -0,0 +1 @@
+__version__ = "4.10.0"

{commitizen-4.9.1 → commitizen-4.10.0}/commitizen/bump.py

@@ -3,13 +3,13 @@ from __future__ import annotations
 import os
 import re
 from collections import OrderedDict
-from collections.abc import Iterable
+from collections.abc import Generator, Iterable
 from glob import iglob
 from logging import getLogger
 from string import Template
 from typing import cast
 
-from commitizen.defaults import BUMP_MESSAGE, ENCODING, MAJOR, MINOR, PATCH
+from commitizen.defaults import BUMP_MESSAGE, MAJOR, MINOR, PATCH
 from commitizen.exceptions import CurrentVersionNotFoundError
 from commitizen.git import GitCommit, smart_open
 from commitizen.version_schemes import Increment, Version
@@ -64,8 +64,8 @@ def update_version_in_files(
     new_version: str,
     files: Iterable[str],
     *,
-    check_consistency: bool = False,
-    encoding: str = ENCODING,
+    check_consistency: bool,
+    encoding: str,
 ) -> list[str]:
     """Change old version to the new one in every file given.
 
@@ -75,16 +75,22 @@ def update_version_in_files(
 
     Returns the list of updated files.
     """
-    # TODO: separate check step and write step
-    updated = []
-    for path, regex in _files_and_regexes(files, current_version):
-        current_version_found, version_file = _bump_with_regex(
-            path,
-            current_version,
-            new_version,
-            regex,
-            encoding=encoding,
-        )
+    updated_files = []
+
+    for path, pattern in _resolve_files_and_regexes(files, current_version):
+        current_version_found = False
+        bumped_lines = []
+
+        with open(path, encoding=encoding) as version_file:
+            for line in version_file:
+                bumped_line = (
+                    line.replace(current_version, new_version)
+                    if pattern.search(line)
+                    else line
+                )
+
+                current_version_found = current_version_found or bumped_line != line
+                bumped_lines.append(bumped_line)
 
         if check_consistency and not current_version_found:
             raise CurrentVersionNotFoundError(
@@ -93,53 +99,32 @@ def update_version_in_files(
                 "version_files are possibly inconsistent."
             )
 
+        bumped_version_file_content = "".join(bumped_lines)
+
         # Write the file out again
         with smart_open(path, "w", encoding=encoding) as file:
-            file.write(version_file)
-        updated.append(path)
-    return updated
+            file.write(bumped_version_file_content)
+        updated_files.append(path)
+
+    return updated_files
 
 
-def _files_and_regexes(patterns: Iterable[str], version: str) -> list[tuple[str, str]]:
+def _resolve_files_and_regexes(
+    patterns: Iterable[str], version: str
+) -> Generator[tuple[str, re.Pattern], None, None]:
     """
     Resolve all distinct files with their regexp from a list of glob patterns with optional regexp
     """
-    out: set[tuple[str, str]] = set()
+    filepath_set: set[tuple[str, str]] = set()
     for pattern in patterns:
         drive, tail = os.path.splitdrive(pattern)
         path, _, regex = tail.partition(":")
         filepath = drive + path
-        if not regex:
-            regex = re.escape(version)
+        regex = regex or re.escape(version)
 
-        for file in iglob(filepath):
-            out.add((file, regex))
+        filepath_set.update((path, regex) for path in iglob(filepath))
 
-    return sorted(out)
-
-
-def _bump_with_regex(
-    version_filepath: str,
-    current_version: str,
-    new_version: str,
-    regex: str,
-    encoding: str = ENCODING,
-) -> tuple[bool, str]:
-    current_version_found = False
-    lines = []
-    pattern = re.compile(regex)
-    with open(version_filepath, encoding=encoding) as f:
-        for line in f:
-            if not pattern.search(line):
-                lines.append(line)
-                continue
-
-            bumped_line = line.replace(current_version, new_version)
-            if bumped_line != line:
-                current_version_found = True
-            lines.append(bumped_line)
-
-    return current_version_found, "".join(lines)
+    return ((path, re.compile(regex)) for path, regex in sorted(filepath_set))
 
 
 def create_commit_message(

{commitizen-4.9.1 → commitizen-4.10.0}/commitizen/changelog_formats/base.py

@@ -24,11 +24,9 @@ class BaseFormat(ChangelogFormat, metaclass=ABCMeta):
         # Constructor needs to be redefined because `Protocol` prevent instantiation by default
         # See: https://bugs.python.org/issue44807
         self.config = config
-        self.encoding = self.config.settings["encoding"]
-        self.tag_format = self.config.settings["tag_format"]
         self.tag_rules = TagRules(
             scheme=get_version_scheme(self.config.settings),
-            tag_format=self.tag_format,
+            tag_format=self.config.settings["tag_format"],
             legacy_tag_formats=self.config.settings["legacy_tag_formats"],
             ignored_tag_formats=self.config.settings["ignored_tag_formats"],
         )
@@ -37,7 +35,9 @@ class BaseFormat(ChangelogFormat, metaclass=ABCMeta):
         if not os.path.isfile(filepath):
             return Metadata()
 
-        with open(filepath, encoding=self.encoding) as changelog_file:
+        with open(
+            filepath, encoding=self.config.settings["encoding"]
+        ) as changelog_file:
             return self.get_metadata_from_file(changelog_file)
 
     def get_metadata_from_file(self, file: IO[Any]) -> Metadata:

commitizen-4.10.0/commitizen/changelog_formats/restructuredtext.py

@@ -0,0 +1,88 @@
+from __future__ import annotations
+
+from itertools import zip_longest
+from typing import IO
+
+from commitizen.changelog import Metadata
+
+from .base import BaseFormat
+
+
+class RestructuredText(BaseFormat):
+    extension = "rst"
+
+    def get_metadata_from_file(self, file: IO[str]) -> Metadata:
+        """
+        RestructuredText section titles are not one-line-based,
+        they spread on 2 or 3 lines and levels are not predefined
+        but determined by their occurrence order.
+
+        It requires its own algorithm.
+
+        For a more generic approach, you need to rely on `docutils`.
+        """
+        out_metadata = Metadata()
+        unreleased_title_kind: str | tuple[str, str] | None = None
+        is_overlined_title = False
+        lines = [line.strip().lower() for line in file.readlines()]
+
+        for index, (first, second, third) in enumerate(
+            zip_longest(lines, lines[1:], lines[2:], fillvalue="")
+        ):
+            title: str | None = None
+            kind: str | tuple[str, str] | None = None
+            if _is_overlined_title(first, second, third):
+                title = second
+                kind = (first[0], third[0])
+                is_overlined_title = True
+            elif not is_overlined_title and _is_underlined_title(first, second):
+                title = first
+                kind = second[0]
+            else:
+                is_overlined_title = False
+
+            if not title:
+                continue
+
+            if "unreleased" in title:
+                unreleased_title_kind = kind
+                out_metadata.unreleased_start = index
+                continue
+
+            if unreleased_title_kind and unreleased_title_kind == kind:
+                out_metadata.unreleased_end = index
+            # Try to find the latest release done
+            if version := self.tag_rules.search_version(title):
+                out_metadata.latest_version = version[0]
+                out_metadata.latest_version_tag = version[1]
+                out_metadata.latest_version_position = index
+                break
+
+        if (
+            out_metadata.unreleased_start is not None
+            and out_metadata.unreleased_end is None
+        ):
+            out_metadata.unreleased_end = (
+                out_metadata.latest_version_position
+                if out_metadata.latest_version
+                else len(lines)
+            )
+
+        return out_metadata
+
+
+def _is_overlined_title(first: str, second: str, third: str) -> bool:
+    return (
+        len(first) == len(third) >= len(second)
+        and first[0] == third[0]
+        and all(char == first[0] for char in first)
+        and _is_underlined_title(second, third)
+    )
+
+
+def _is_underlined_title(first: str, second: str) -> bool:
+    return (
+        len(second) >= len(first)
+        and not second.isalnum()
+        and all(char == second[0] for char in second)
+    )

{commitizen-4.9.1 → commitizen-4.10.0}/commitizen/cli.py

@@ -160,7 +160,6 @@ data = {
                     {
                         "name": ["-l", "--message-length-limit"],
                         "type": int,
-                        "default": 0,
                         "help": "length limit of the commit message; 0 for no limit",
                     },
                     {
@@ -499,7 +498,6 @@ data = {
                     {
                         "name": ["-l", "--message-length-limit"],
                         "type": int,
-                        "default": 0,
                         "help": "length limit of the commit message; 0 for no limit",
                     },
                 ],
@@ -543,6 +541,18 @@ data = {
                         "action": "store_true",
                         "exclusive_group": "group1",
                     },
+                    {
+                        "name": ["--major"],
+                        "help": "get just the major version",
+                        "action": "store_true",
+                        "exclusive_group": "group2",
+                    },
+                    {
+                        "name": ["--minor"],
+                        "help": "get just the minor version",
+                        "action": "store_true",
+                        "exclusive_group": "group2",
+                    },
                 ],
             },
         ],

{commitizen-4.9.1 → commitizen-4.10.0}/commitizen/cmd.py

@@ -22,13 +22,15 @@ def _try_decode(bytes_: bytes) -> str:
     try:
         return bytes_.decode("utf-8")
     except UnicodeDecodeError:
-        charset_match = from_bytes(bytes_).best()
-        if charset_match is None:
-            raise CharacterSetDecodeError()
-        try:
-            return bytes_.decode(charset_match.encoding)
-        except UnicodeDecodeError as e:
-            raise CharacterSetDecodeError() from e
+        pass
+
+    charset_match = from_bytes(bytes_).best()
+    if charset_match is None:
+        raise CharacterSetDecodeError()
+    try:
+        return bytes_.decode(charset_match.encoding)
+    except UnicodeDecodeError as e:
+        raise CharacterSetDecodeError() from e
 
 
 def run(cmd: str, env: Mapping[str, str] | None = None) -> Command:

{commitizen-4.9.1 → commitizen-4.10.0}/commitizen/commands/bump.py

@@ -67,7 +67,6 @@ class Bump:
             raise NotAGitProjectError()
 
         self.config: BaseConfig = config
-        self.encoding = config.settings["encoding"]
         self.arguments = arguments
         self.bump_settings = cast(
             BumpArgs,
@@ -216,8 +215,8 @@ class Bump:
 
         rules = TagRules.from_settings(cast(Settings, self.bump_settings))
         current_tag = rules.find_tag_for(git.get_tags(), current_version)
-        current_tag_version = getattr(
-            current_tag, "name", rules.normalize_tag(current_version)
+        current_tag_version = (
+            current_tag.name if current_tag else rules.normalize_tag(current_version)
         )
 
         is_initial = self._is_initial_tag(current_tag, self.arguments["yes"])
@@ -335,7 +334,7 @@ class Bump:
                 str(new_version),
                 self.bump_settings["version_files"],
                 check_consistency=self.check_consistency,
-                encoding=self.encoding,
+                encoding=self.config.settings["encoding"],
             )
         )
 

{commitizen-4.9.1 → commitizen-4.10.0}/commitizen/commands/changelog.py

@@ -67,7 +67,6 @@ class Changelog:
             else changelog_file_name
         )
 
-        self.encoding = self.config.settings["encoding"]
         self.cz = factory.committer_factory(self.config)
 
         self.start_rev = arguments.get("start_rev") or self.config.settings.get(
@@ -104,12 +103,10 @@ class Changelog:
             or defaults.CHANGE_TYPE_ORDER,
         )
         self.rev_range = arguments.get("rev_range")
-        self.tag_format = (
-            arguments.get("tag_format") or self.config.settings["tag_format"]
-        )
         self.tag_rules = TagRules(
             scheme=self.scheme,
-            tag_format=self.tag_format,
+            tag_format=arguments.get("tag_format")
+            or self.config.settings["tag_format"],
             legacy_tag_formats=self.config.settings["legacy_tag_formats"],
             ignored_tag_formats=self.config.settings["ignored_tag_formats"],
             merge_prereleases=arguments.get("merge_prerelease")
@@ -159,7 +156,9 @@ class Changelog:
     def _write_changelog(
         self, changelog_out: str, lines: list[str], changelog_meta: changelog.Metadata
     ) -> None:
-        with smart_open(self.file_name, "w", encoding=self.encoding) as changelog_file:
+        with smart_open(
+            self.file_name, "w", encoding=self.config.settings["encoding"]
+        ) as changelog_file:
             partial_changelog: str | None = None
             if self.incremental:
                 new_lines = changelog.incremental_build(
@@ -261,7 +260,9 @@ class Changelog:
 
         lines = []
         if self.incremental and os.path.isfile(self.file_name):
-            with open(self.file_name, encoding=self.encoding) as changelog_file:
+            with open(
+                self.file_name, encoding=self.config.settings["encoding"]
+            ) as changelog_file:
                 lines = changelog_file.readlines()
 
         self._write_changelog(changelog_out, lines, changelog_meta)

{commitizen-4.9.1 → commitizen-4.10.0}/commitizen/commands/check.py

@@ -7,6 +7,7 @@ from typing import TypedDict
 from commitizen import factory, git, out
 from commitizen.config import BaseConfig
 from commitizen.exceptions import (
+    CommitMessageLengthExceededError,
     InvalidCommandArgumentError,
     InvalidCommitMessageError,
     NoCommitsFoundError,
@@ -18,7 +19,7 @@ class CheckArgs(TypedDict, total=False):
     commit_msg: str
     rev_range: str
     allow_abort: bool
-    message_length_limit: int
+    message_length_limit: int | None
     allowed_prefixes: list[str]
     message: str
     use_default_range: bool
@@ -41,8 +42,11 @@ class Check:
         self.allow_abort = bool(
             arguments.get("allow_abort", config.settings["allow_abort"])
         )
+
         self.use_default_range = bool(arguments.get("use_default_range"))
-        self.max_msg_length = arguments.get("message_length_limit", 0)
+        self.max_msg_length = arguments.get(
+            "message_length_limit", config.settings.get("message_length_limit", None)
+        )
 
         # we need to distinguish between None and [], which is a valid value
         allowed_prefixes = arguments.get("allowed_prefixes")
@@ -71,7 +75,6 @@ class Check:
             self.commit_msg = sys.stdin.read()
 
         self.config: BaseConfig = config
-        self.encoding = config.settings["encoding"]
         self.cz = factory.committer_factory(self.config)
 
     def __call__(self) -> None:
@@ -79,6 +82,7 @@ class Check:
 
         Raises:
             InvalidCommitMessageError: if the commit provided not follows the conventional pattern
+            NoCommitsFoundError: if no commit is found with the given range
         """
         commits = self._get_commits()
         if not commits:
@@ -88,7 +92,7 @@ class Check:
         invalid_msgs_content = "\n".join(
             f'commit "{commit.rev}": "{commit.message}"'
             for commit in commits
-            if not self._validate_commit_message(commit.message, pattern)
+            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
@@ -105,7 +109,9 @@ class Check:
             # Get commit message from command line (--message)
             return self.commit_msg
 
-        with open(self.commit_msg_file, encoding=self.encoding) as commit_file:
+        with open(
+            self.commit_msg_file, encoding=self.config.settings["encoding"]
+        ) as commit_file:
             # Get commit message from file (--commit-msg-file)
             return commit_file.read()
 
@@ -151,7 +157,7 @@ class Check:
         return "\n".join(lines)
 
     def _validate_commit_message(
-        self, commit_msg: str, pattern: re.Pattern[str]
+        self, commit_msg: str, pattern: re.Pattern[str], commit_hash: str
     ) -> bool:
         if not commit_msg:
             return self.allow_abort
@@ -159,9 +165,14 @@ class Check:
         if any(map(commit_msg.startswith, self.allowed_prefixes)):
             return True
 
-        if self.max_msg_length:
+        if self.max_msg_length is not None:
             msg_len = len(commit_msg.partition("\n")[0].strip())
             if msg_len > self.max_msg_length:
-                return False
+                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-4.9.1 → commitizen-4.10.0}/commitizen/commands/commit.py

@@ -33,7 +33,7 @@ class CommitArgs(TypedDict, total=False):
     dry_run: bool
     edit: bool
     extra_cli_args: str
-    message_length_limit: int
+    message_length_limit: int | None
     no_retry: bool
     signoff: bool
     write_message_to_file: Path | None
@@ -48,47 +48,53 @@ class Commit:
             raise NotAGitProjectError()
 
         self.config: BaseConfig = config
-        self.encoding = config.settings["encoding"]
         self.cz = factory.committer_factory(self.config)
         self.arguments = arguments
-        self.temp_file: str = get_backup_file_path()
+        self.backup_file_path = get_backup_file_path()
 
     def _read_backup_message(self) -> str | None:
         # Check the commit backup file exists
-        if not os.path.isfile(self.temp_file):
+        if not self.backup_file_path.is_file():
             return None
 
         # Read commit message from backup
-        with open(self.temp_file, encoding=self.encoding) as f:
+        with open(
+            self.backup_file_path, encoding=self.config.settings["encoding"]
+        ) as f:
             return f.read().strip()
 
-    def _prompt_commit_questions(self) -> str:
+    def _get_message_by_prompt_commit_questions(self) -> str:
         # Prompt user for the commit message
-        cz = self.cz
-        questions = cz.questions()
+        questions = self.cz.questions()
         for question in (q for q in questions if q["type"] == "list"):
             question["use_shortcuts"] = self.config.settings["use_shortcuts"]
         try:
-            answers = questionary.prompt(questions, style=cz.style)
+            answers = questionary.prompt(questions, style=self.cz.style)
         except ValueError as err:
             root_err = err.__context__
             if isinstance(root_err, CzException):
-                raise CustomError(root_err.__str__())
+                raise CustomError(str(root_err))
             raise err
 
         if not answers:
             raise NoAnswersError()
 
-        message = cz.message(answers)
-        message_len = len(message.partition("\n")[0].strip())
-        message_length_limit = self.arguments.get("message_length_limit", 0)
-        if 0 < message_length_limit < message_len:
-            raise CommitMessageLengthExceededError(
-                f"Length of commit message exceeds limit ({message_len}/{message_length_limit})"
-            )
+        message = self.cz.message(answers)
+        if limit := self.arguments.get(
+            "message_length_limit", self.config.settings.get("message_length_limit", 0)
+        ):
+            self._validate_subject_length(message=message, length_limit=limit)
 
         return message
 
+    def _validate_subject_length(self, *, message: str, length_limit: int) -> None:
+        # By the contract, message_length_limit is set to 0 for no limit
+        subject = message.partition("\n")[0].strip()
+        if len(subject) > length_limit:
+            raise CommitMessageLengthExceededError(
+                f"Length of commit message exceeds limit ({len(subject)}/{length_limit}), subject: '{subject}'"
+            )
+
     def manual_edit(self, message: str) -> str:
         editor = git.get_core_editor()
         if editor is None:
@@ -108,16 +114,18 @@ class Commit:
 
     def _get_message(self) -> str:
         if self.arguments.get("retry"):
-            m = self._read_backup_message()
-            if m is None:
+            commit_message = self._read_backup_message()
+            if commit_message is None:
                 raise NoCommitBackupError()
-            return m
+            return commit_message
 
-        if self.config.settings.get("retry_after_failure") and not self.arguments.get(
-            "no_retry"
+        if (
+            self.config.settings.get("retry_after_failure")
+            and not self.arguments.get("no_retry")
+            and (backup_message := self._read_backup_message())
         ):
-            return self._read_backup_message() or self._prompt_commit_questions()
-        return self._prompt_commit_questions()
+            return backup_message
+        return self._get_message_by_prompt_commit_questions()
 
     def __call__(self) -> None:
         extra_args = self.arguments.get("extra_cli_args", "")
@@ -139,15 +147,17 @@ class Commit:
         if write_message_to_file is not None and write_message_to_file.is_dir():
             raise NotAllowed(f"{write_message_to_file} is a directory")
 
-        m = self._get_message()
+        commit_message = self._get_message()
         if self.arguments.get("edit"):
-            m = self.manual_edit(m)
+            commit_message = self.manual_edit(commit_message)
 
-        out.info(f"\n{m}\n")
+        out.info(f"\n{commit_message}\n")
 
         if write_message_to_file:
-            with smart_open(write_message_to_file, "w", encoding=self.encoding) as file:
-                file.write(m)
+            with smart_open(
+                write_message_to_file, "w", encoding=self.config.settings["encoding"]
+            ) as file:
+                file.write(commit_message)
 
         if dry_run:
             raise DryRunExit()
@@ -155,13 +165,15 @@ class Commit:
         if self.config.settings["always_signoff"] or signoff:
             extra_args = f"{extra_args} -s".strip()
 
-        c = git.commit(m, args=extra_args)
+        c = git.commit(commit_message, args=extra_args)
         if c.return_code != 0:
             out.error(c.err)
 
             # Create commit backup
-            with smart_open(self.temp_file, "w", encoding=self.encoding) as f:
-                f.write(m)
+            with smart_open(
+                self.backup_file_path, "w", encoding=self.config.settings["encoding"]
+            ) as f:
+                f.write(commit_message)
 
             raise CommitError()
 
@@ -170,7 +182,7 @@ class Commit:
             return
 
         with contextlib.suppress(FileNotFoundError):
-            os.remove(self.temp_file)
+            self.backup_file_path.unlink()
         out.write(c.err)
         out.write(c.out)
         out.success("Commit successful!")