refactor(schemes): ensure that the entire version scheme processing is encapsulated into schemes

Author: noirbizarre

commitizen/bump.py

@@ -3,11 +3,10 @@
 import os
 import re
 from collections import OrderedDict
-from itertools import zip_longest
 from string import Template
 from typing import List, Optional, Tuple, Union
 
-from commitizen.defaults import MAJOR, MINOR, PATCH, bump_message
+from commitizen.defaults import bump_message
 from commitizen.exceptions import CurrentVersionNotFoundError
 from commitizen.git import GitCommit, smart_open
 from commitizen.schemes import DEFAULT_SCHEME, Scheme, Version
@@ -46,115 +45,6 @@ def find_increment(
     return increment
 
 
-def prerelease_generator(
-    current_version: str, prerelease: Optional[str] = None, offset: int = 0
-) -> str:
-    """Generate prerelease
-
-    X.YaN   # Alpha release
-    X.YbN   # Beta release
-    X.YrcN  # Release Candidate
-    X.Y  # Final
-
-    This function might return something like 'alpha1'
-    but it will be handled by Version.
-    """
-    if not prerelease:
-        return ""
-
-    version = Version(current_version)
-    # version.pre is needed for mypy check
-    if version.is_prerelease and version.pre and prerelease.startswith(version.pre[0]):
-        prev_prerelease: int = version.pre[1]
-        new_prerelease_number = prev_prerelease + 1
-    else:
-        new_prerelease_number = offset
-    pre_version = f"{prerelease}{new_prerelease_number}"
-    return pre_version
-
-
-def devrelease_generator(devrelease: int = None) -> str:
-    """Generate devrelease
-
-    The devrelease version should be passed directly and is not
-    inferred based on the previous version.
-    """
-    if devrelease is None:
-        return ""
-
-    return f"dev{devrelease}"
-
-
-def semver_generator(current_version: str, increment: str = None) -> str:
-    version = Version(current_version)
-    prev_release = list(version.release)
-    increments = [MAJOR, MINOR, PATCH]
-    increments_version = dict(zip_longest(increments, prev_release, fillvalue=0))
-
-    # This flag means that current version
-    # must remove its prerelease tag,
-    # so it doesn't matter the increment.
-    # Example: 1.0.0a0 with PATCH/MINOR -> 1.0.0
-    if not version.is_prerelease:
-        if increment == MAJOR:
-            increments_version[MAJOR] += 1
-            increments_version[MINOR] = 0
-            increments_version[PATCH] = 0
-        elif increment == MINOR:
-            increments_version[MINOR] += 1
-            increments_version[PATCH] = 0
-        elif increment == PATCH:
-            increments_version[PATCH] += 1
-
-    return str(
-        f"{increments_version['MAJOR']}."
-        f"{increments_version['MINOR']}."
-        f"{increments_version['PATCH']}"
-    )
-
-
-def generate_version(
-    current_version: str,
-    increment: str,
-    prerelease: Optional[str] = None,
-    prerelease_offset: int = 0,
-    devrelease: Optional[int] = None,
-    is_local_version: bool = False,
-    scheme: Optional[Scheme] = None,
-) -> Version:
-    """Based on the given increment a proper semver will be generated.
-
-    For now the rules and versioning scheme is based on
-    python's PEP 0440.
-    More info: https://www.python.org/dev/peps/pep-0440/
-
-    Example:
-        PATCH 1.0.0 -> 1.0.1
-        MINOR 1.0.0 -> 1.1.0
-        MAJOR 1.0.0 -> 2.0.0
-    """
-    scheme = scheme or DEFAULT_SCHEME
-
-    if is_local_version:
-        version = scheme(current_version)
-        dev_version = devrelease_generator(devrelease=devrelease)
-        pre_version = prerelease_generator(
-            str(version.local), prerelease=prerelease, offset=prerelease_offset
-        )
-        semver = semver_generator(str(version.local), increment=increment)
-
-        return scheme(f"{version.public}+{semver}{pre_version}{dev_version}")
-    else:
-        dev_version = devrelease_generator(devrelease=devrelease)
-        pre_version = prerelease_generator(
-            current_version, prerelease=prerelease, offset=prerelease_offset
-        )
-        semver = semver_generator(current_version, increment=increment)
-
-        # TODO: post version
-        return scheme(f"{semver}{pre_version}{dev_version}")
-
-
 def update_version_in_files(
     current_version: str, new_version: str, files: List[str], *, check_consistency=False
 ) -> None:
@@ -227,18 +117,13 @@ def normalize_tag(
     | ver1.0.0.a0 | 1.0.0a0 |
     """
     scheme = scheme or DEFAULT_SCHEME
-
-    if isinstance(version, str):
-        version = scheme(version)
+    version = scheme(version) if isinstance(version, str) else version
 
     if not tag_format:
         return str(version)
 
     major, minor, patch = version.release
-    prerelease = ""
-    # version.pre is needed for mypy check
-    if version.is_prerelease and version.pre:
-        prerelease = f"{version.pre[0]}{version.pre[1]}"
+    prerelease = version.prerelease or ""
 
     t = Template(tag_format)
     return t.safe_substitute(
@@ -249,7 +134,7 @@ def normalize_tag(
 def create_commit_message(
     current_version: Union[Version, str],
     new_version: Union[Version, str],
-    message_template: str = None,
+    message_template: Optional[str] = None,
 ) -> str:
     if message_template is None:
         message_template = bump_message

commitizen/changelog.py

@@ -30,15 +30,15 @@
 import re
 from collections import OrderedDict, defaultdict
 from datetime import date
-from typing import TYPE_CHECKING, Callable, Dict, Iterable, List, Optional, Tuple
+from typing import TYPE_CHECKING, Callable, Dict, Iterable, List, Optional, Tuple, cast
 
 from jinja2 import Environment, PackageLoader
-from packaging.version import InvalidVersion, Version
+from packaging.version import InvalidVersion
 
-from commitizen import defaults
 from commitizen.bump import normalize_tag
 from commitizen.exceptions import InvalidConfigurationError, NoCommitsFoundError
 from commitizen.git import GitCommit, GitTag
+from commitizen.schemes import DEFAULT_SCHEME, Pep440
 
 if TYPE_CHECKING:
     from commitizen.schemes import Scheme
@@ -48,23 +48,18 @@ def get_commit_tag(commit: GitCommit, tags: List[GitTag]) -> Optional[GitTag]:
     return next((tag for tag in tags if tag.rev == commit.rev), None)
 
 
-def get_version(tag: GitTag) -> Optional[Version]:
-    version = None
-    try:
-        version = Version(tag.name)
-    except InvalidVersion:
-        pass
-    return version
-
-
 def tag_included_in_changelog(
-    tag: GitTag, used_tags: List, merge_prerelease: bool
+    tag: GitTag,
+    used_tags: List,
+    merge_prerelease: bool,
+    scheme: Scheme = DEFAULT_SCHEME,
 ) -> bool:
     if tag in used_tags:
         return False
 
-    version = get_version(tag)
-    if version is None:
+    try:
+        version = scheme(tag.name)
+    except InvalidVersion:
         return False
 
     if merge_prerelease and version.is_prerelease:
@@ -82,6 +77,7 @@ def generate_tree_from_commits(
     change_type_map: Optional[Dict[str, str]] = None,
     changelog_message_builder_hook: Optional[Callable] = None,
     merge_prerelease: bool = False,
+    scheme: Scheme = DEFAULT_SCHEME,
 ) -> Iterable[Dict]:
     pat = re.compile(changelog_pattern)
     map_pat = re.compile(commit_parser, re.MULTILINE)
@@ -107,7 +103,7 @@ def generate_tree_from_commits(
         commit_tag = get_commit_tag(commit, tags)
 
         if commit_tag is not None and tag_included_in_changelog(
-            commit_tag, used_tags, merge_prerelease
+            commit_tag, used_tags, merge_prerelease, scheme=scheme
         ):
             used_tags.append(commit_tag)
             yield {
@@ -180,13 +176,13 @@ def render_changelog(tree: Iterable) -> str:
     return changelog
 
 
-def parse_version_from_markdown(value: str) -> Optional[str]:
+def parse_version_from_markdown(value: str, scheme: Scheme = Pep440) -> Optional[str]:
     if not value.startswith("#"):
         return None
-    m = re.search(defaults.version_parser, value)
+    m = scheme.parser.search(value)
     if not m:
         return None
-    return m.groupdict().get("version")
+    return cast(str, m.groupdict().get("version"))
 
 
 def parse_title_type_of_line(value: str) -> Optional[str]:
@@ -197,7 +193,7 @@ def parse_title_type_of_line(value: str) -> Optional[str]:
     return m.groupdict().get("title")
 
 
-def get_metadata(filepath: str) -> Dict:
+def get_metadata(filepath: str, scheme: Scheme = Pep440) -> Dict:
     unreleased_start: Optional[int] = None
     unreleased_end: Optional[int] = None
     unreleased_title: Optional[str] = None
@@ -230,7 +226,7 @@ def get_metadata(filepath: str) -> Dict:
                 unreleased_end = index
 
             # Try to find the latest release done
-            version = parse_version_from_markdown(line)
+            version = parse_version_from_markdown(line, scheme)
             if version:
                 latest_version = version
                 latest_version_position = index

commitizen/cli.py

@@ -4,7 +4,7 @@
 from pathlib import Path
 from functools import partial
 from types import TracebackType
-from typing import List
+from typing import List, Optional
 
 import argcomplete
 from decli import cli
@@ -353,7 +353,7 @@
 
 
 def commitizen_excepthook(
-    type, value, traceback, debug=False, no_raise: List[int] = None
+    type, value, traceback, debug=False, no_raise: Optional[List[int]] = None
 ):
     traceback = traceback if isinstance(traceback, TracebackType) else None
     if not no_raise:

commitizen/commands/bump.py

@@ -63,7 +63,7 @@ def __init__(self, config: BaseConfig, arguments: dict):
         self.pre_bump_hooks = self.config.settings["pre_bump_hooks"]
         self.post_bump_hooks = self.config.settings["post_bump_hooks"]
         scheme = arguments["scheme"] or self.config.settings.get("scheme")
-        self.scheme = scheme and schemes.SCHEMES[scheme]
+        self.scheme = scheme and schemes.SCHEMES[scheme] or schemes.DEFAULT_SCHEME
 
     def is_initial_tag(self, current_tag_version: str, is_yes: bool = False) -> bool:
         """Check if reading the whole git tree up to HEAD is needed."""
@@ -107,9 +107,10 @@ def __call__(self):  # noqa: C901
         """Steps executed to bump."""
         provider = get_provider(self.config)
         current_version: str = provider.get_version()
+        # scheme =
 
         try:
-            current_version_instance: Version = Version(current_version)
+            current_version_instance: Version = self.scheme(current_version)
         except TypeError:
             raise NoVersionSpecifiedError()
 
@@ -183,7 +184,7 @@ def __call__(self):  # noqa: C901
 
         if manual_version:
             try:
-                new_version = Version(manual_version)
+                new_version = self.scheme(manual_version)
             except InvalidVersion as exc:
                 raise InvalidManualVersion(
                     "[INVALID_MANUAL_VERSION]\n"
@@ -211,14 +212,12 @@ def __call__(self):  # noqa: C901
             if prerelease and current_version_instance.is_prerelease:
                 increment = None
 
-            new_version = bump.generate_version(
-                current_version,
+            new_version = current_version_instance.bump(
                 increment,
                 prerelease=prerelease,
                 prerelease_offset=prerelease_offset,
                 devrelease=devrelease,
                 is_local_version=is_local_version,
-                scheme=self.scheme,
             )
 
         new_tag_version = bump.normalize_tag(

commitizen/commands/changelog.py

@@ -63,7 +63,7 @@ def __init__(self, config: BaseConfig, args):
         ) or self.config.settings.get("changelog_merge_prerelease")
 
         scheme = self.config.settings.get("scheme")
-        self.scheme = scheme and schemes.SCHEMES[scheme]
+        self.scheme = scheme and schemes.SCHEMES[scheme] or schemes.DEFAULT_SCHEME
 
     def _find_incremental_rev(self, latest_version: str, tags: List[GitTag]) -> str:
         """Try to find the 'start_rev'.
@@ -145,7 +145,7 @@ def __call__(self):
         end_rev = ""
 
         if self.incremental:
-            changelog_meta = changelog.get_metadata(self.file_name)
+            changelog_meta = changelog.get_metadata(self.file_name, self.scheme)
             latest_version = changelog_meta.get("latest_version")
             if latest_version:
                 latest_tag_version: str = bump.normalize_tag(
@@ -179,6 +179,7 @@ def __call__(self):
             change_type_map=change_type_map,
             changelog_message_builder_hook=changelog_message_builder_hook,
             merge_prerelease=merge_prerelease,
+            scheme=self.scheme,
         )
         if self.change_type_order:
             tree = changelog.order_changelog_tree(tree, self.change_type_order)

commitizen/cz/conventional_commits/conventional_commits.py

@@ -32,7 +32,6 @@ class ConventionalCommitsCz(BaseCommitizen):
     bump_map = defaults.bump_map
     bump_map_major_version_zero = defaults.bump_map_major_version_zero
     commit_parser = defaults.commit_parser
-    version_parser = defaults.version_parser
     change_type_map = {
         "feat": "Feat",
         "fix": "Fix",

commitizen/defaults.py

@@ -113,4 +113,3 @@ class Settings(TypedDict, total=False):
 bump_message = "bump: version $current_version → $new_version"
 
 commit_parser = r"^((?P<change_type>feat|fix|refactor|perf|BREAKING CHANGE)(?:\((?P<scope>[^()\r\n]*)\)|\()?(?P<breaking>!)?|\w+!):\s(?P<message>.*)?"  # noqa
-version_parser = r"(?P<version>([0-9]+)\.([0-9]+)\.([0-9]+)(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+[0-9A-Za-z-]+)?(\w+)?)"