feat(version): add MANUAL_VERSION, --next and --patch to version command

commitizen/bump.py

@@ -15,7 +15,7 @@
 if TYPE_CHECKING:
     from collections.abc import Generator, Iterable
 
-    from commitizen.version_schemes import Increment, Version
+    from commitizen.version_schemes import Increment, VersionProtocol
 
 VERSION_TYPES = [None, PATCH, MINOR, MAJOR]
 
@@ -131,8 +131,8 @@ def _resolve_files_and_regexes(
 
 
 def create_commit_message(
-    current_version: Version | str,
-    new_version: Version | str,
+    current_version: VersionProtocol | str,
+    new_version: VersionProtocol | str,
     message_template: str | None = None,
 ) -> str:
     if message_template is None:

commitizen/cli.py

@@ -21,6 +21,7 @@
     InvalidCommandArgumentError,
     NoCommandFoundError,
 )
+from commitizen.version_increment import VersionIncrement
 
 logger = logging.getLogger(__name__)
 
@@ -542,13 +543,19 @@ def __call__(
                     },
                     {
                         "name": ["--major"],
-                        "help": "Output just the major version. Must be used with --project or --verbose.",
+                        "help": (
+                            "Output just the major version. Must be used with MANUAL_VERSION, "
+                            "--project, or --verbose."
+                        ),
                         "action": "store_true",
                         "exclusive_group": "group2",
                     },
                     {
                         "name": ["--minor"],
-                        "help": "Output just the minor version. Must be used with --project or --verbose.",
+                        "help": (
+                            "Output just the minor version. Must be used with MANUAL_VERSION, "
+                            "--project, or --verbose."
+                        ),
                         "action": "store_true",
                         "exclusive_group": "group2",
                     },
@@ -558,6 +565,33 @@ def __call__(
                         "action": "store_true",
                         "exclusive_group": "group2",
                     },
+                    {
+                        "name": ["--patch"],
+                        "help": (
+                            "Output the patch version only. Must be used with MANUAL_VERSION, "
+                            "--project, or --verbose."
+                        ),
+                        "action": "store_true",
+                        "exclusive_group": "group2",
+                    },
+                    {
+                        "name": ["--next"],
+                        "help": "Output the next version.",
+                        "type": str,
+                        "nargs": "?",
+                        "default": None,
+                        "const": "USE_GIT_COMMITS",
+                        "choices": ["USE_GIT_COMMITS"]
+                        + [str(increment) for increment in VersionIncrement],
+                        "exclusive_group": "group2",
+                    },
+                    {
+                        "name": "manual_version",
+                        "type": str,
+                        "nargs": "?",
+                        "help": "Use the version provided instead of the version from the project. Can be used to test the selected version scheme.",
+                        "metavar": "MANUAL_VERSION",
+                    },
                 ],
             },
         ],

commitizen/commands/init.py

@@ -17,7 +17,11 @@
     NoAnswersError,
 )
 from commitizen.git import get_latest_tag_name, get_tag_names, smart_open
-from commitizen.version_schemes import KNOWN_SCHEMES, Version, get_version_scheme
+from commitizen.version_schemes import (
+    KNOWN_SCHEMES,
+    VersionProtocol,
+    get_version_scheme,
+)
 
 if TYPE_CHECKING:
     from commitizen.config import (
@@ -265,7 +269,7 @@ def _ask_version_scheme(self) -> str:
         ).unsafe_ask()
         return scheme
 
-    def _ask_major_version_zero(self, version: Version) -> bool:
+    def _ask_major_version_zero(self, version: VersionProtocol) -> bool:
         """Ask for setting: major_version_zero"""
         if version.major > 0:
             return False
@@ -323,7 +327,7 @@ def _write_config_to_file(
     cz_name: str,
     version_provider: str,
     version_scheme: str,
-    version: Version,
+    version: VersionProtocol,
     tag_format: str,
     update_changelog_on_bump: bool,
     major_version_zero: bool,

commitizen/commands/version.py

@@ -2,22 +2,32 @@
 import sys
 from typing import TypedDict
 
+from packaging.version import InvalidVersion
+
 from commitizen import out
 from commitizen.__version__ import __version__
 from commitizen.config import BaseConfig
 from commitizen.exceptions import NoVersionSpecifiedError, VersionSchemeUnknown
 from commitizen.providers import get_provider
 from commitizen.tags import TagRules
-from commitizen.version_schemes import get_version_scheme
+from commitizen.version_increment import VersionIncrement
+from commitizen.version_schemes import Increment, get_version_scheme
 
 
 class VersionArgs(TypedDict, total=False):
+    manual_version: str | None
+    next: str | None
+
+    # Exclusive groups 1
     commitizen: bool
     report: bool
     project: bool
     verbose: bool
+
+    # Exclusive groups 2
     major: bool
     minor: bool
+    patch: bool
     tag: bool
 
 
@@ -43,40 +53,85 @@ def __call__(self) -> None:
         if self.arguments.get("verbose"):
             out.write(f"Installed Commitizen Version: {__version__}")
 
-        if not self.arguments.get("commitizen") and (
-            self.arguments.get("project") or self.arguments.get("verbose")
+        if self.arguments.get("commitizen"):
+            out.write(__version__)
+            return
+
+        if (
+            self.arguments.get("project")
+            or self.arguments.get("verbose")
+            or self.arguments.get("next")
+            or self.arguments.get("manual_version")
         ):
+            version_str = self.arguments.get("manual_version")
+            if version_str is None:
+                try:
+                    version_str = get_provider(self.config).get_version()
+                except NoVersionSpecifiedError:
+                    out.error("No project information in this project.")
+                    return
             try:
-                version = get_provider(self.config).get_version()
-            except NoVersionSpecifiedError:
-                out.error("No project information in this project.")
-                return
-            try:
-                version_scheme = get_version_scheme(self.config.settings)(version)
+                scheme_factory = get_version_scheme(self.config.settings)
             except VersionSchemeUnknown:
                 out.error("Unknown version scheme.")
                 return
 
+            try:
+                version = scheme_factory(version_str)
+            except InvalidVersion:
+                out.error(f"Invalid version: '{version_str}'")
+                return
+
+            if next_increment_str := self.arguments.get("next"):
+                if next_increment_str == "USE_GIT_COMMITS":
+                    # TODO: implement USE_GIT_COMMITS by deriving the increment from
+                    # git history. This requires refactoring the bump logic out of
+                    # `commitizen/commands/bump.py` so it can be reused here. See #1678.
+                    out.error("--next USE_GIT_COMMITS is not implemented yet.")
+                    return
+
+                next_increment = VersionIncrement.from_value(next_increment_str)
+                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"
+                version = version.bump(increment=increment)
+
             if self.arguments.get("major"):
-                version = f"{version_scheme.major}"
-            elif self.arguments.get("minor"):
-                version = f"{version_scheme.minor}"
-            elif self.arguments.get("tag"):
+                out.write(version.major)
+                return
+            if self.arguments.get("minor"):
+                out.write(version.minor)
+                return
+            if self.arguments.get("patch"):
+                out.write(version.micro)
+                return
+
+            display_version: str
+            if self.arguments.get("tag"):
                 tag_rules = TagRules.from_settings(self.config.settings)
-                version = tag_rules.normalize_tag(version_scheme)
+                display_version = tag_rules.normalize_tag(version)
+            else:
+                display_version = str(version)
 
             out.write(
-                f"Project Version: {version}"
+                f"Project Version: {display_version}"
                 if self.arguments.get("verbose")
-                else version
+                else display_version
             )
             return
 
-        if self.arguments.get("major") or self.arguments.get("minor"):
-            out.error(
-                "Major or minor version can only be used with --project or --verbose."
-            )
-            return
+        for argument in ("major", "minor", "patch"):
+            if self.arguments.get(argument):
+                out.error(
+                    f"{argument} can only be used with MANUAL_VERSION, --project or --verbose."
+                )
+                return
 
         if self.arguments.get("tag"):
             out.error("Tag can only be used with --project or --verbose.")

commitizen/out.py

@@ -9,35 +9,35 @@
         sys.stdout.reconfigure(encoding="utf-8")
 
 
-def write(value: str, *args: object) -> None:
+def write(value: object, *args: object) -> None:
     """Intended to be used when value is multiline."""
     print(value, *args)
 
 
-def line(value: str, *args: object, **kwargs: Any) -> None:
+def line(value: object, *args: object, **kwargs: Any) -> None:
     """Wrapper in case I want to do something different later."""
     print(value, *args, **kwargs)
 
 
-def error(value: str) -> None:
-    message = colored(value, "red")
+def error(value: object) -> None:
+    message = colored(str(value), "red")
     line(message, file=sys.stderr)
 
 
-def success(value: str) -> None:
-    message = colored(value, "green")
+def success(value: object) -> None:
+    message = colored(str(value), "green")
     line(message)
 
 
-def info(value: str) -> None:
-    message = colored(value, "blue")
+def info(value: object) -> None:
+    message = colored(str(value), "blue")
     line(message)
 
 
-def diagnostic(value: str) -> None:
+def diagnostic(value: object) -> None:
     line(value, file=sys.stderr)
 
 
-def warn(value: str) -> None:
-    message = colored(value, "magenta")
+def warn(value: object) -> None:
+    message = colored(str(value), "magenta")
     line(message, file=sys.stderr)

commitizen/tags.py

@@ -14,7 +14,7 @@
 from commitizen.version_schemes import (
     DEFAULT_SCHEME,
     InvalidVersion,
-    Version,
+    VersionProtocol,
     VersionScheme,
     get_version_scheme,
 )
@@ -23,8 +23,6 @@
     import sys
     from collections.abc import Iterable, Sequence
 
-    from commitizen.version_schemes import VersionScheme
-
     # Self is Python 3.11+ but backported in typing-extensions
     if sys.version_info < (3, 11):
         from typing_extensions import Self
@@ -75,7 +73,7 @@ class TagRules:
     assert not rules.is_version_tag("warn1.0.0", warn=True)  # Does warn
 
     assert rules.search_version("# My v1.0.0 version").version == "1.0.0"
-    assert rules.extract_version("v1.0.0") == Version("1.0.0")
+    assert rules.extract_version("v1.0.0") == rules.scheme("1.0.0")
     try:
         assert rules.extract_version("not-a-v1.0.0")
     except InvalidVersion:
@@ -145,7 +143,7 @@ def get_version_tags(
         """Filter in version tags and warn on unexpected tags"""
         return [tag for tag in tags if self.is_version_tag(tag, warn)]
 
-    def extract_version(self, tag: GitTag) -> Version:
+    def extract_version(self, tag: GitTag) -> VersionProtocol:
         """
         Extract a version from the tag as defined in tag formats.
 
@@ -195,7 +193,7 @@ def search_version(self, text: str, last: bool = False) -> VersionTag | None:
         return VersionTag(version, match.group(0))
 
     def normalize_tag(
-        self, version: Version | str, tag_format: str | None = None
+        self, version: VersionProtocol | str, tag_format: str | None = None
     ) -> str:
         """
         The tag and the software version might be different.
@@ -225,7 +223,7 @@ def normalize_tag(
         )
 
     def find_tag_for(
-        self, tags: Iterable[GitTag], version: Version | str
+        self, tags: Iterable[GitTag], version: VersionProtocol | str
     ) -> GitTag | None:
         """Find the first matching tag for a given version."""
         version = self.scheme(version) if isinstance(version, str) else version
@@ -234,7 +232,7 @@ def find_tag_for(
         # If the requested version is incomplete (e.g., "1.2"), try to find the latest
         # matching tag that shares the provided prefix.
         if len(release) < 3:
-            matching_versions: list[tuple[Version, GitTag]] = []
+            matching_versions: list[tuple[VersionProtocol, GitTag]] = []
             for tag in tags:
                 try:
                     tag_version = self.extract_version(tag)

commitizen/version_increment.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+from enum import IntEnum
+
+
+class VersionIncrement(IntEnum):
+    """Semantic versioning bump increments.
+
+    IntEnum keeps a total order compatible with NONE < PATCH < MINOR < MAJOR
+    for comparisons across the codebase.
+
+    - NONE: no bump (docs-only / style commits, etc.)
+    - PATCH: backwards-compatible bug fixes
+    - MINOR: backwards-compatible features
+    - MAJOR: incompatible API changes
+    """
+
+    NONE = 0
+    PATCH = 1
+    MINOR = 2
+    MAJOR = 3
+
+    def __str__(self) -> str:
+        return self.name
+
+    @classmethod
+    def from_value(cls, value: object) -> VersionIncrement:
+        if not isinstance(value, str):
+            return VersionIncrement.NONE
+        try:
+            return cls[value]
+        except KeyError:
+            return VersionIncrement.NONE