GeezerVison

import os

import re

from collections import OrderedDict

from glob import iglob

from logging import getLogger

from string import Template

from typing import TYPE_CHECKING, cast

from typing import TYPE_CHECKING

from commitizen.defaults import BUMP_MESSAGE, MAJOR, MINOR, PATCH

from commitizen.defaults import BUMP_MESSAGE

from commitizen.exceptions import CurrentVersionNotFoundError

from commitizen.git import GitCommit, smart_open

from commitizen.git import smart_open

if TYPE_CHECKING:

from collections.abc import Generator, Iterable

from commitizen.version_schemes import Increment, VersionProtocol

VERSION_TYPES = [None, PATCH, MINOR, MAJOR]

logger = getLogger("commitizen")

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)

from commitizen.version_schemes import VersionProtocol

def update_version_in_files(

)

from commitizen.providers import get_provider

from commitizen.tags import TagRules

from commitizen.version_increment import VersionIncrement

from commitizen.version_schemes import (

Increment,

InvalidVersion,

return bool(questionary.confirm("Is this the first tag created?").ask())

def _find_increment(self, commits: list[git.GitCommit]) -> Increment | None:

"""Determine the highest configured increment across candidate commits."""

# Update the bump map to ensure major version doesn't increment.

# self.cz.bump_map = defaults.bump_map_major_version_zero

bump_map = (

self.cz.bump_map_major_version_zero

if self.bump_settings["major_version_zero"]

raise NoPatternMapError(

f"'{self.config.settings['name']}' rule does not support bump"

)

return bump.find_increment(

self.cz.filter_commits_before_bump(commits),

regex=bump_pattern,

increments_map=bump_map,

commit_messages = (

commit.message for commit in self.cz.filter_commits_before_bump(commits)

)

increment = VersionIncrement.get_highest_by_messages(

commit_messages,

bump_pattern,

bump_map,

)

if increment == VersionIncrement.NONE:

return None

return cast("Increment", str(increment))

def _validate_arguments(self, current_version: VersionProtocol) -> None:

errors: list[str] = []

from packaging.version import InvalidVersion

from commitizen import bump, factory, git, out

from commitizen import factory, git, out

from commitizen.__version__ import __version__

from commitizen.config import BaseConfig

from commitizen.exceptions import (

raise NoPatternMapError(

f"'{self.config.settings['name']}' rule does not support bump"

)

increment = bump.find_increment(

self.cz.filter_commits_before_bump(commits),

regex=bump_pattern,

increments_map=bump_map,

next_increment = VersionIncrement.get_highest_by_messages(

(commit.message for commit in self.cz.filter_commits_before_bump(commits)),

bump_pattern,

bump_map,

)

increment: Increment | None

if next_increment == VersionIncrement.NONE:

increment = None

elif next_increment == VersionIncrement.PATCH:

increment = "PATCH"

elif next_increment == VersionIncrement.MINOR:

increment = "MINOR"

else:

increment = "MAJOR"

# TODO: Consider adding all the parameters `.bump` supports:

# prerelease, prerelease_offset,exact_increment, etc..

class BaseCommitizen(metaclass=ABCMeta):

bump_pattern: str | None = None

bump_map: dict[str, str] | None = None

bump_map_major_version_zero: dict[str, str] | None = None

bump_map: Mapping[str, str | None] | None = None

bump_map_major_version_zero: Mapping[str, str | None] | None = None

default_style_config: list[tuple[str, str]] = [

("qmark", "fg:#ff9d00 bold"),

("question", "bold"),

from commitizen.cz.utils import multiple_line_breaker, required_validator

if TYPE_CHECKING:

from collections.abc import Mapping

from commitizen.question import CzQuestion

__all__ = ["ConventionalCommitsCz"]

class ConventionalCommitsCz(BaseCommitizen):

bump_pattern = defaults.BUMP_PATTERN

bump_map = defaults.BUMP_MAP

bump_map_major_version_zero = defaults.BUMP_MAP_MAJOR_VERSION_ZERO

bump_map: Mapping[str, str | None] = defaults.BUMP_MAP

bump_map_major_version_zero: Mapping[str, str | None] = (

defaults.BUMP_MAP_MAJOR_VERSION_ZERO

)

commit_parser = r"^((?P<change_type>feat|fix|refactor|perf|BREAKING CHANGE)(?:\((?P<scope>[^()\r\n]*)\)|\()?(?P<breaking>!)?|\w+!):\s(?P<message>.*)?"

change_type_map = {

"feat": "Feat",

def _derive_major_version_zero(

bump_map: Mapping[str, str],

) -> OrderedDict[str, str]:

bump_map: Mapping[str, str | None],

) -> OrderedDict[str, str | None]:

"""Derive a ``bump_map_major_version_zero`` from a user-supplied

class CustomizeCommitsCz(BaseCommitizen):

bump_pattern = defaults.BUMP_PATTERN

bump_map = defaults.BUMP_MAP

bump_map_major_version_zero = defaults.BUMP_MAP_MAJOR_VERSION_ZERO

bump_map: Mapping[str, str | None] = defaults.BUMP_MAP

bump_map_major_version_zero: Mapping[str, str | None] = (

defaults.BUMP_MAP_MAJOR_VERSION_ZERO

)

change_type_order = defaults.CHANGE_TYPE_ORDER

def __init__(self, config: BaseConfig) -> None:

class CzSettings(TypedDict, total=False):

bump_pattern: str

bump_map: OrderedDict[str, str]

bump_map_major_version_zero: OrderedDict[str, str]

bump_map: OrderedDict[str, str | None]

bump_map_major_version_zero: OrderedDict[str, str | None]

change_type_order: list[str]

questions: Iterable[CzQuestion]

from __future__ import annotations

import re

from enum import IntEnum

from typing import TYPE_CHECKING

if TYPE_CHECKING:

from collections.abc import Iterable, Mapping

RegexPattern = str | re.Pattern[str]

class VersionIncrement(IntEnum):

NONE = 0

MAJOR = 3

def __str__(self) -> str:

"""Return the legacy string representation used by existing callers."""

return self.name

@classmethod

def from_value(cls, value: object) -> VersionIncrement:

"""Convert external increment input into a known increment.

if not isinstance(value, str):

return VersionIncrement.NONE

try:

return cls[value]

except KeyError:

return VersionIncrement.NONE

@classmethod

def _compile_pattern(cls, regex: RegexPattern) -> re.Pattern[str]:

"""Normalize a bump-pattern input into a compiled regular expression."""

if isinstance(regex, re.Pattern):

return regex

return re.compile(regex)

@classmethod

def _from_bump_map_value(cls, value: object) -> VersionIncrement:

"""Resolve a configured bump-map value or reject invalid rule output.

if value is None:

return cls.NONE

if value == "PATCH":

return cls.PATCH

if value == "MINOR":

return cls.MINOR

if value == "MAJOR":

return cls.MAJOR

raise ValueError(f"Invalid bump increment: {value!r}")

@classmethod

def from_match(

cls, matched_text: str, increments_map: Mapping[str, object]

) -> VersionIncrement:

"""Resolve one extracted bump token against a configured bump map.

for match_pattern, increment in increments_map.items():

if re.match(match_pattern, matched_text):

return cls._from_bump_map_value(increment)

return cls.NONE

@classmethod

def from_message(

cls, message: str, regex: RegexPattern, increments_map: Mapping[str, object]

) -> VersionIncrement:

"""Compute the highest increment contributed by one commit message.

select_pattern = cls._compile_pattern(regex)

increment = cls.NONE

for line in message.split("\n"):

result = select_pattern.search(line)

if not result:

continue

increment = max(

increment,

cls.from_match(result.group(1), increments_map),

)

if increment == cls.MAJOR:

return increment

return increment

@classmethod

def get_highest_by_messages(

cls,

messages: Iterable[str],

regex: RegexPattern,

increments_map: Mapping[str, object],

) -> VersionIncrement:

"""Compute the highest increment across many commit messages.

select_pattern = cls._compile_pattern(regex)

return max(

(

cls.from_message(message, select_pattern, increments_map)

for message in messages

),

default=cls.NONE,

)

| `schema_pattern` | `str` | `""` | (OPTIONAL) The regular expression used to do commit message validation. Used by `cz check`. |

| `info_path` | `str` | `""` | (OPTIONAL) The path to the file that contains explanation of the commit rules. Used by `cz info`. If not provided `cz info`, will load `info` instead. |

| `info` | `str` | `""` | (OPTIONAL) Explanation of the commit rules. Used by `cz info`. |

| `bump_map` | `dict` | `None` | (OPTIONAL) Dictionary mapping the extracted information to a `SemVer` increment type (`MAJOR`, `MINOR`, `PATCH`) |

| `bump_map` | `dict` | `None` | (OPTIONAL) Dictionary mapping the extracted information to a `SemVer` increment type (`MAJOR`, `MINOR`, `PATCH`). In JSON and YAML configs, `null` keeps a matched rule from bumping the version. |

| `bump_pattern` | `str` | `None` | (OPTIONAL) Regex to extract information from commit (subject and body) |

| `change_type_order` | `str` | `None` | (OPTIONAL) List of strings used to order the Changelog. All other types will be sorted alphabetically. Default is `["BREAKING CHANGE", "Feat", "Fix", "Refactor", "Perf"]` |

| `commit_parser` | `str` | `None` | (OPTIONAL) Regex to extract information used in creating changelog. [See more][changelog-spec] |

| Parameter | Type | Default | Description |

| -------------- | ------ | ------- | ----------------------------------------------------------------------------------------------------- |

| `bump_pattern` | `str` | `None` | Regex to extract information from commit (subject and body) |

| `bump_map` | `dict` | `None` | Dictionary mapping the extracted information to a `SemVer` increment type (`MAJOR`, `MINOR`, `PATCH`) |

| `bump_map` | `dict` | `None` | Dictionary mapping the extracted information to a `SemVer` increment type (`MAJOR`, `MINOR`, `PATCH`). Use `None` when a matched rule should not bump the version. |

Let's see an example.