refactor(bump): to use VersionProtocol interface instead packaging.Version subclass

Signed-off-by: apkawa <apkawa@gmail.com>

Author: Apkawa

commitizen/bump.py

@@ -10,6 +10,7 @@
 from commitizen.defaults import MAJOR, MINOR, PATCH, bump_message
 from commitizen.exceptions import CurrentVersionNotFoundError
 from commitizen.git import GitCommit, smart_open
+from commitizen.version_types import VersionProtocol
 
 
 def find_increment(
@@ -120,8 +121,8 @@ def generate_version(
     prerelease_offset: int = 0,
     devrelease: Optional[int] = None,
     is_local_version: bool = False,
-    version_type_cls: Optional[Type[Version]] = None,
-) -> Version:
+    version_type_cls: Optional[Type[VersionProtocol]] = None,
+) -> VersionProtocol:
     """Based on the given increment a proper semver will be generated.
 
     For now the rules and versioning scheme is based on
@@ -210,9 +211,9 @@ def _version_to_regex(version: str) -> str:
 
 
 def normalize_tag(
-    version: Union[Version, str],
+    version: Union[VersionProtocol, str],
     tag_format: Optional[str] = None,
-    version_type_cls: Optional[Type[Version]] = None,
+    version_type_cls: Optional[Type[VersionProtocol]] = None,
 ) -> str:
     """The tag and the software version might be different.
 

commitizen/version_types.py

@@ -1,33 +1,94 @@
+import sys
+import typing
+
+if sys.version_info >= (3, 8):
+    from typing import Protocol as _Protocol
+else:
+    _Protocol = object
+
 from packaging.version import Version
 
 
-class SemVerVersion(Version):
+class VersionProtocol(_Protocol):
+    def __init__(self, _version: typing.Union[Version, str]):
+        raise NotImplementedError("must be implemented")
+
+    def __str__(self) -> str:
+        raise NotImplementedError("must be implemented")
+
+    @property
+    def release(self) -> typing.Tuple[int, ...]:
+        raise NotImplementedError("must be implemented")
+
+    @property
+    def is_prerelease(self) -> bool:
+        raise NotImplementedError("must be implemented")
+
+    @property
+    def pre(self) -> typing.Optional[typing.Tuple[str, int]]:
+        raise NotImplementedError("must be implemented")
+
+    @property
+    def local(self) -> typing.Optional[str]:
+        raise NotImplementedError("must be implemented")
+
+    @property
+    def public(self) -> str:
+        raise NotImplementedError("must be implemented")
+
+
+class SemVerVersion(VersionProtocol):
+    def __init__(self, version: str):
+        self._version = Version(version)
+
+    @property
+    def release(self) -> typing.Tuple[int, ...]:
+        return self._version.release
+
+    @property
+    def is_prerelease(self) -> bool:
+        return self._version.is_prerelease
+
+    @property
+    def pre(self) -> typing.Optional[typing.Tuple[str, int]]:
+        return self._version.pre
+
+    @property
+    def local(self) -> typing.Optional[str]:
+        return self._version.local
+
+    @property
+    def public(self) -> str:
+        return self._version.public
+
     def __str__(self) -> str:
         parts = []
 
+        version = self._version
+
         # Epoch
-        if self.epoch != 0:
-            parts.append(f"{self.epoch}!")
+        if version.epoch != 0:
+            parts.append(f"{version.epoch}!")
 
         # Release segment
-        parts.append(".".join(str(x) for x in self.release))
+        parts.append(".".join(str(x) for x in version.release))
 
         # Pre-release
-        if self.pre is not None:
-            pre = "".join(str(x) for x in self.pre)
+        if version.pre is not None:
+            pre = "".join(str(x) for x in version.pre)
             parts.append(f"-{pre}")
 
         # Post-release
-        if self.post is not None:
-            parts.append(f"-post{self.post}")
+        if version.post is not None:
+            parts.append(f"-post{version.post}")
 
         # Development release
-        if self.dev is not None:
-            parts.append(f"-dev{self.dev}")
+        if version.dev is not None:
+            parts.append(f"-dev{version.dev}")
 
         # Local version segment
-        if self.local is not None:
-            parts.append(f"+{self.local}")
+        if version.local is not None:
+            parts.append(f"+{version.local}")
 
         return "".join(parts)