Move module level implementation into VersionInfo

tomschr · tomschr · commit 89a62ef91f7a · 2020-03-17T23:18:31.000+01:00
Move implementations:

* semver.format_version -&gt; semver.VersionInfo.format_version
* Move _REGEX into VersionInfo class
* semver.parse -&gt; semver.VersionInfo.parse
* semver.bump_* -&gt; semver.VersionInfo.bump_*


Change implementation by calling VersionInfo methods:

* semver.compare
* semver.finalize_version
* semver.replace
* semver.parse_version_info
diff --git a/semver.py b/semver.py
@@ -14,26 +14,6 @@
 __maintainer__ = ["Sebastien Celles", "Tom Schraitle"]
 __maintainer_email__ = "s.celles@gmail.com"
 
-_REGEX = re.compile(
-    r"""
-        ^
-        (?P<major>0|[1-9]\d*)
-        \.
-        (?P<minor>0|[1-9]\d*)
-        \.
-        (?P<patch>0|[1-9]\d*)
-        (?:-(?P<prerelease>
-            (?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)
-            (?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*
-        ))?
-        (?:\+(?P<build>
-            [0-9a-zA-Z-]+
-            (?:\.[0-9a-zA-Z-]+)*
-        ))?
-        $
-        """,
-    re.VERBOSE,
-)
 
 _LAST_NUMBER = re.compile(r"(?:[^\d]*(\d+)[^\d]*)+")
 
@@ -69,17 +49,7 @@ def parse(version):
     >>> ver['build']
     'build.4'
     """
-    match = _REGEX.match(version)
-    if match is None:
-        raise ValueError("%s is not valid SemVer string" % version)
-
-    version_parts = match.groupdict()
-
-    version_parts["major"] = int(version_parts["major"])
-    version_parts["minor"] = int(version_parts["minor"])
-    version_parts["patch"] = int(version_parts["patch"])
-
-    return version_parts
+    return VersionInfo.parse(version)._asdict()
 
 
 def comparator(operator):
@@ -110,6 +80,26 @@ class VersionInfo(object):
     """
 
     __slots__ = ("_major", "_minor", "_patch", "_prerelease", "_build")
+    _REGEX = re.compile(
+        r"""
+            ^
+            (?P<major>0|[1-9]\d*)
+            \.
+            (?P<minor>0|[1-9]\d*)
+            \.
+            (?P<patch>0|[1-9]\d*)
+            (?:-(?P<prerelease>
+                (?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)
+                (?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*
+            ))?
+            (?:\+(?P<build>
+                [0-9a-zA-Z-]+
+                (?:\.[0-9a-zA-Z-]+)*
+            ))?
+            $
+            """,
+        re.VERBOSE,
+    )
 
     def __init__(self, major, minor=0, patch=0, prerelease=None, build=None):
         self._major = int(major)
@@ -195,7 +185,8 @@ def bump_major(self):
         >>> ver.bump_major()
         VersionInfo(major=4, minor=0, patch=0, prerelease=None, build=None)
         """
-        return parse_version_info(bump_major(str(self)))
+        cls = type(self)
+        return cls(self._major+1)
 
     def bump_minor(self):
         """
@@ -209,7 +200,8 @@ def bump_minor(self):
         >>> ver.bump_minor()
         VersionInfo(major=3, minor=5, patch=0, prerelease=None, build=None)
         """
-        return parse_version_info(bump_minor(str(self)))
+        cls = type(self)
+        return cls(self._major, self._minor+1)
 
     def bump_patch(self):
         """
@@ -223,7 +215,8 @@ def bump_patch(self):
         >>> ver.bump_patch()
         VersionInfo(major=3, minor=4, patch=6, prerelease=None, build=None)
         """
-        return parse_version_info(bump_patch(str(self)))
+        cls = type(self)
+        return cls(self._major, self._minor, self._patch+1)
 
     def bump_prerelease(self, token="rc"):
         """
@@ -239,7 +232,11 @@ def bump_prerelease(self, token="rc"):
         VersionInfo(major=3, minor=4, patch=5, prerelease='rc.2', \
 build=None)
         """
-        return parse_version_info(bump_prerelease(str(self), token))
+        cls = type(self)
+        prerelease = _increment_string(
+            self._prerelease or (token or "rc") + ".0"
+        )
+        return cls(self._major, self._minor, self._patch, prerelease)
 
     def bump_build(self, token="build"):
         """
@@ -255,7 +252,11 @@ def bump_build(self, token="build"):
         VersionInfo(major=3, minor=4, patch=5, prerelease='rc.1', \
 build='build.10')
         """
-        return parse_version_info(bump_build(str(self), token))
+        cls = type(self)
+        build = _increment_string(
+            self._build or (token or "build") + ".0"
+        )
+        return cls(self._major, self._minor, self._patch, self._prerelease, build)
 
     @comparator
     def __eq__(self, other):
@@ -286,7 +287,7 @@ def __repr__(self):
         return "%s(%s)" % (type(self).__name__, s)
 
     def __str__(self):
-        return format_version(*(self._astuple()))
+        return VersionInfo.format_version(*(self._astuple()))
 
     def __hash__(self):
         return hash(self._astuple())
@@ -304,7 +305,17 @@ def parse(version):
         VersionInfo(major=3, minor=4, patch=5, \
 prerelease='pre.2', build='build.4')
         """
-        return parse_version_info(version)
+        match = VersionInfo._REGEX.match(version)
+        if match is None:
+            raise ValueError("%s is not valid SemVer string" % version)
+
+        version_parts = match.groupdict()
+
+        version_parts["major"] = int(version_parts["major"])
+        version_parts["minor"] = int(version_parts["minor"])
+        version_parts["patch"] = int(version_parts["patch"])
+
+        return VersionInfo(**version_parts)
 
     def replace(self, **parts):
         """Replace one or more parts of a version and return a new
@@ -344,6 +355,31 @@ def isvalid(cls, version):
         except ValueError:
             return False
 
+    @staticmethod
+    def format_version(major, minor, patch, prerelease=None, build=None):
+        """
+        Format a version according to the Semantic Versioning specification.
+
+        :param int major: the required major part of a version
+        :param int minor: the required minor part of a version
+        :param int patch: the required patch part of a version
+        :param str prerelease: the optional prerelease part of a version
+        :param str build: the optional build part of a version
+        :return: the formatted string
+        :rtype: str
+
+        >>> semver.VersionInfo.format_version(3, 4, 5, 'pre.2', 'build.4')
+        '3.4.5-pre.2+build.4'
+        """
+        version = "%d.%d.%d" % (major, minor, patch)
+        if prerelease is not None:
+            version = version + "-%s" % prerelease
+
+        if build is not None:
+            version = version + "+%s" % build
+
+        return version
+
 
 def _to_dict(obj):
     if isinstance(obj, VersionInfo):
@@ -373,16 +409,7 @@ def parse_version_info(version):
     >>> version_info.build
     'build.4'
     """
-    parts = parse(version)
-    version_info = VersionInfo(
-        parts["major"],
-        parts["minor"],
-        parts["patch"],
-        parts["prerelease"],
-        parts["build"],
-    )
-
-    return version_info
+    return VersionInfo.parse(version)
 
 
 def _nat_cmp(a, b):
@@ -449,7 +476,8 @@ def compare(ver1, ver2):
     0
     """
 
-    v1, v2 = parse(ver1), parse(ver2)
+    v1 = VersionInfo.parse(ver1)._asdict()
+    v2 = VersionInfo.parse(ver2)._asdict()
 
     return _compare_by_keys(v1, v2)
 
@@ -556,14 +584,7 @@ def format_version(major, minor, patch, prerelease=None, build=None):
     >>> semver.format_version(3, 4, 5, 'pre.2', 'build.4')
     '3.4.5-pre.2+build.4'
     """
-    version = "%d.%d.%d" % (major, minor, patch)
-    if prerelease is not None:
-        version = version + "-%s" % prerelease
-
-    if build is not None:
-        version = version + "+%s" % build
-
-    return version
+    return VersionInfo.format_version(major, minor, patch, prerelease, build)
 
 
 def _increment_string(string):
@@ -591,8 +612,7 @@ def bump_major(version):
     >>> semver.bump_major("3.4.5")
     '4.0.0'
     """
-    verinfo = parse(version)
-    return format_version(verinfo["major"] + 1, 0, 0)
+    return str(VersionInfo.parse(version).bump_major())
 
 
 def bump_minor(version):
@@ -606,8 +626,7 @@ def bump_minor(version):
     >>> semver.bump_minor("3.4.5")
     '3.5.0'
     """
-    verinfo = parse(version)
-    return format_version(verinfo["major"], verinfo["minor"] + 1, 0)
+    return str(VersionInfo.parse(version).bump_minor())
 
 
 def bump_patch(version):
@@ -621,8 +640,7 @@ def bump_patch(version):
     >>> semver.bump_patch("3.4.5")
     '3.4.6'
     """
-    verinfo = parse(version)
-    return format_version(verinfo["major"], verinfo["minor"], verinfo["patch"] + 1)
+    return str(VersionInfo.parse(version).bump_patch())
 
 
 def bump_prerelease(version, token="rc"):
@@ -637,13 +655,7 @@ def bump_prerelease(version, token="rc"):
     >>> semver.bump_prerelease('3.4.5', 'dev')
     '3.4.5-dev.1'
     """
-    verinfo = parse(version)
-    verinfo["prerelease"] = _increment_string(
-        verinfo["prerelease"] or (token or "rc") + ".0"
-    )
-    return format_version(
-        verinfo["major"], verinfo["minor"], verinfo["patch"], verinfo["prerelease"]
-    )
+    return str(VersionInfo.parse(version).bump_prerelease(token))
 
 
 def bump_build(version, token="build"):
@@ -658,15 +670,7 @@ def bump_build(version, token="build"):
     >>> semver.bump_build('3.4.5-rc.1+build.9')
     '3.4.5-rc.1+build.10'
     """
-    verinfo = parse(version)
-    verinfo["build"] = _increment_string(verinfo["build"] or (token or "build") + ".0")
-    return format_version(
-        verinfo["major"],
-        verinfo["minor"],
-        verinfo["patch"],
-        verinfo["prerelease"],
-        verinfo["build"],
-    )
+    return str(VersionInfo.parse(version).bump_build(token))
 
 
 def finalize_version(version):
@@ -680,8 +684,26 @@ def finalize_version(version):
     >>> semver.finalize_version('1.2.3-rc.5')
     '1.2.3'
     """
-    verinfo = parse(version)
-    return format_version(verinfo["major"], verinfo["minor"], verinfo["patch"])
+    verinfo = VersionInfo.parse(version)
+    return VersionInfo.format_version(verinfo.major, verinfo.minor, verinfo.patch)
+
+
+def replace(version, **parts):
+    """
+    Replace one or more parts of a version and return the new string.
+
+    :param str version: the version string to replace
+    :param dict parts: the parts to be updated. Valid keys are:
+      ``major``, ``minor``, ``patch``, ``prerelease``, or ``build``
+    :return: the replaced version string
+    :raises: TypeError, if ``parts`` contains invalid keys
+    :rtype: str
+
+    >>> import semver
+    >>> semver.replace("1.2.3", major=2, patch=10)
+    '2.2.10'
+    """
+    return str(VersionInfo.parse(version).replace(**parts))
 
 
 def cmd_bump(args):
@@ -707,7 +729,7 @@ def cmd_bump(args):
         # print the help and exit
         args.parser.parse_args(["bump", "-h"])
 
-    ver = parse_version_info(args.version)
+    ver = VersionInfo.parse(args.version)
     # get the respective method and call it
     func = getattr(ver, maptable[args.bump])
     return str(func())
@@ -826,25 +848,6 @@ def main(cliargs=None):
         return 2
 
 
-def replace(version, **parts):
-    """
-    Replace one or more parts of a version and return the new string.
-
-    :param str version: the version string to replace
-    :param dict parts: the parts to be updated. Valid keys are:
-      ``major``, ``minor``, ``patch``, ``prerelease``, or ``build``
-    :return: the replaced version string
-    :raises: TypeError, if ``parts`` contains invalid keys
-    :rtype: str
-
-    >>> import semver
-    >>> semver.replace("1.2.3", major=2, patch=10)
-    '2.2.10'
-    """
-    version = parse_version_info(version)
-    return str(version.replace(**parts))
-
-
 if __name__ == "__main__":
     import doctest
 
