refactor(version_scheme): cleanup

commitizen/version_schemes.py

@@ -41,7 +41,9 @@
 
 Increment: TypeAlias = Literal["MAJOR", "MINOR", "PATCH"]
 Prerelease: TypeAlias = Literal["alpha", "beta", "rc"]
-DEFAULT_VERSION_PARSER = r"v?(?P<version>([0-9]+)\.([0-9]+)(?:\.([0-9]+))?(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+[0-9A-Za-z.]+)?(\w+)?)"
+_DEFAULT_VERSION_PARSER = re.compile(
+    r"v?(?P<version>([0-9]+)\.([0-9]+)(?:\.([0-9]+))?(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+[0-9A-Za-z.]+)?(\w+)?)"
+)
 
 
 @runtime_checkable
@@ -156,7 +158,7 @@ class BaseVersion(_BaseVersion):
     A base class implementing the `VersionProtocol` for PEP440-like versions.
     """
 
-    parser: ClassVar[re.Pattern] = re.compile(DEFAULT_VERSION_PARSER)
+    parser: ClassVar[re.Pattern] = _DEFAULT_VERSION_PARSER
     """Regex capturing this version scheme into a `version` group"""
 
     @property
@@ -265,39 +267,35 @@ def bump(
         if self.local and is_local_version:
             local_version = self.scheme(self.local).bump(increment)
             return self.scheme(f"{self.public}+{local_version}")  # type: ignore
-        else:
-            if not self.is_prerelease:
-                base = self.increment_base(increment)
-            elif exact_increment:
-                base = self.increment_base(increment)
-            else:
-                base = f"{self.major}.{self.minor}.{self.micro}"
-                if increment == PATCH:
-                    pass
-                elif increment == MINOR:
-                    if self.micro != 0:
-                        base = self.increment_base(increment)
-                elif increment == MAJOR:
-                    if self.minor != 0 or self.micro != 0:
-                        base = self.increment_base(increment)
-            dev_version = self.generate_devrelease(devrelease)
-
-            release = list(self.release)
-            if len(release) < 3:
-                release += [0] * (3 - len(release))
-            current_base = ".".join(str(part) for part in release)
-            if base == current_base:
-                pre_version = self.generate_prerelease(
-                    prerelease, offset=prerelease_offset
-                )
-            else:
-                base_version = cast(BaseVersion, self.scheme(base))
-                pre_version = base_version.generate_prerelease(
-                    prerelease, offset=prerelease_offset
-                )
-            build_metadata = self.generate_build_metadata(build_metadata)
-            # TODO: post version
-            return self.scheme(f"{base}{pre_version}{dev_version}{build_metadata}")  # type: ignore
+
+        base = self._get_increment_base(increment, exact_increment)
+        dev_version = self.generate_devrelease(devrelease)
+
+        release = list(self.release)
+        if len(release) < 3:
+            release += [0] * (3 - len(release))
+        current_base = ".".join(str(part) for part in release)
+
+        pre_version = (
+            self if base == current_base else cast(BaseVersion, self.scheme(base))
+        ).generate_prerelease(prerelease, offset=prerelease_offset)
+
+        # TODO: post version
+        return self.scheme(
+            f"{base}{pre_version}{dev_version}{self.generate_build_metadata(build_metadata)}"
+        )  # type: ignore
+
+    def _get_increment_base(
+        self, increment: Increment | None, exact_increment: bool
+    ) -> str:
+        if (
+            not self.is_prerelease
+            or exact_increment
+            or (increment == MINOR and self.micro != 0)
+            or (increment == MAJOR and (self.minor != 0 or self.micro != 0))
+        ):
+            return self.increment_base(increment)
+        return f"{self.major}.{self.minor}.{self.micro}"
 
 
 class Pep440(BaseVersion):
@@ -316,7 +314,7 @@ class SemVer(BaseVersion):
     """
 
     def __str__(self) -> str:
-        parts = []
+        parts: list[str] = []
 
         # Epoch
         if self.epoch != 0:
@@ -364,7 +362,7 @@ def prerelease(self) -> str | None:
         return None
 
     def __str__(self) -> str:
-        parts = []
+        parts: list[str] = []
 
         # Epoch
         if self.epoch != 0:
@@ -373,9 +371,19 @@ def __str__(self) -> str:
         # Release segment
         parts.append(".".join(str(x) for x in self.release))
 
+        if prerelease := self._get_prerelease():
+            parts.append(f"-{prerelease}")
+
+        # Local version segment
+        if self.local:
+            parts.append(f"+{self.local}")
+
+        return "".join(parts)
+
+    def _get_prerelease(self) -> str:
         # Pre-release identifiers
         # See: https://semver.org/spec/v2.0.0.html#spec-item-9
-        prerelease_parts = []
+        prerelease_parts: list[str] = []
         if self.prerelease:
             prerelease_parts.append(f"{self.prerelease}")
 
@@ -387,15 +395,7 @@ def __str__(self) -> str:
         if self.dev is not None:
             prerelease_parts.append(f"dev.{self.dev}")
 
-        if prerelease_parts:
-            parts.append("-")
-            parts.append(".".join(prerelease_parts))
-
-        # Local version segment
-        if self.local:
-            parts.append(f"+{self.local}")
-
-        return "".join(parts)
+        return ".".join(prerelease_parts)
 
 
 DEFAULT_SCHEME: VersionScheme = Pep440