fix quality

.project

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <projectDescription>
-	<name>{{project_name}}</name>
+	<name>gitversionhelper</name>
 	<comment></comment>
 	<projects>
 	</projects>

helpers/quality_check.py

@@ -61,7 +61,7 @@ class quality_check(helper_withresults_base):
                             '--ignore=_version.py',
                             '--reports=y',
                             '--score=yes',
-                            '--max-line-length=120',
+                            '--max-line-length=140',
                             'src.' + cls.pyproject['project']['name']], exit=False)
                 
             with open(cls.get_result_dir()/"report.json","w+", encoding='utf-8') as Outfile:

pyproject.toml

@@ -13,7 +13,7 @@ build-backend = "setuptools.build_meta"
 [tool.setuptools-git-versioning]
 enabled = true
 dev_template    = "{tag}.post{ccount}"
-#tag_filter      = "^\\d+\\.\\d+\\.\\d+$"
+tag_filter      = "^\\d+\\.\\d+\\.\\d+$"
 
 [project]
 name = "pygitversionhelper"

src/pygitversionhelper/__init__.py

@@ -19,4 +19,4 @@ except PackageNotFoundError: # pragma: no cover
     warnings.warn("can not read __version__, assuming local test context, setting it to ?.?.?")
     __version__ = "?.?.?"
 
-from .test_module import test_function
+from .gitversionhelper import gitversionhelper, gitversionhelperException

src/pygitversionhelper/gitversionhelper.py

@@ -0,0 +1,481 @@
+# pygitversionhelper (c) by chacha
+#
+# pygitversionhelper  is licensed under a
+# Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International Unported License.
+#
+# You should have received a copy of the license along with this
+# work.  If not, see <https://creativecommons.org/licenses/by-nc-sa/4.0/>.
+
+"""
+This module is the main gitversionhelper file, containing all the code.
+This project aim to be kept compact and focused on helping doing handy 
+things with git when it deal with project versions/tags.
+"""
+
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+import os
+import subprocess
+import re
+from copy import copy
+import logging
+
+from packaging.version import VERSION_PATTERN as packaging_VERSION_PATTERN
+
+# Only imports the below statements during type checking
+if TYPE_CHECKING:
+    from typing import Union
+
+def _exec(cmd: str, root: str | os.PathLike | None = None) -> list[str]:
+    """
+    helper function to handle system cmd execution
+    Args:
+        cmd: command line to be executed
+        root: root directory where the command need to be executed
+    Return:
+        a list of command's return lines
+        
+    """
+
+    p = subprocess.run(cmd.split(), text=True, cwd=root, capture_output=True, check=False)
+    if re.search("not a git repository",p.stderr):
+        raise gitversionhelper.repository.notAGitRepository()
+    if re.search("fatal:",p.stderr):
+        raise gitversionhelper.unknownGITFatalError()
+    if int(p.returncode) < 0:
+        raise gitversionhelper.unknownGITError
+
+    lines = p.stdout.splitlines()
+    return [line.rstrip() for line in lines if line.rstrip()]
+
+class gitversionhelperException(Exception):
+    """
+    general Module Exception
+    """
+
+class gitversionhelper: # pylint: disable=too-few-public-methods
+    """
+    main gitversionhelper class
+    """
+    class wrongArguments(gitversionhelperException):
+        """
+        wrong argument generic exception
+        """
+
+    class unknownGITError(gitversionhelperException):
+        """
+        unknown git error generic exception
+        """
+
+    class unknownGITFatalError(unknownGITError):
+        """
+        unknown fatal git error generic exception
+        """
+
+    class repository:
+        """
+        class containing methods focusing on repository
+        """
+        class repositoryException(gitversionhelperException):
+            """
+            generic repository exeption
+            """
+
+        class notAGitRepository(repositoryException):
+            """
+            not a git repository exception
+            """
+
+        class repositoryDirty(repositoryException):
+            """
+            dirty repository exception
+            """
+
+        @classmethod
+        def isDirty(cls) -> bool:
+            """
+            check if the repository is in dirty state
+            Return:
+                True if it is dirty
+            """
+            return bool(_exec("git status --short"))
+
+    class tag:
+        """
+        class containing methods focusing on tags
+        """
+        __OptDict = {"same_branch": "same_branch"}
+        __validGitTagSort=["","v:refname","-v:refname","taggerdate","committerdate","-taggerdate","-committerdate"]
+
+        class tagException(gitversionhelperException):
+            """
+            generic tag exception
+            """
+
+        class tagNotFound(tagException):
+            """
+            tag not found exception
+            """
+
+        class moreThanOneTag(tagException):
+            """
+            more than one tag exception
+            """
+
+        @classmethod
+        def getTags(cls,sort:str = "version:refname") -> list[str]:
+            """
+            retrieve all tags from a repository
+            Args:
+                sort: sorting constraints (git format)
+            Return:
+                the tags list
+            """
+            if sort not in cls.__validGitTagSort:
+                raise gitversionhelper.wrongArguments("sort option not in allowed list")
+            return _exec(f"git tag -l --sort={sort}")
+
+        @classmethod
+        def getLastTag(cls,**kwargs) -> Union[str,None]:
+            """
+            retrieve the last tag from a repository
+            Kwargs:
+                same_branch(bool): force searching only in the same branch
+            Return:
+                the tag
+            """
+            if ((cls.__OptDict["same_branch"] in kwargs) and (kwargs[cls.__OptDict["same_branch"]] is True)):
+                res = _exec("git describe --tags --abbrev=0")
+            else:
+                res = _exec("git rev-list --tags --max-count=1")
+                if len(res)==1:
+                    res = _exec(f"git describe --tags {res[0]}")
+
+            if len(res)==0: 
+                raise cls.tagNotFound("no tag found in commit history")
+            if len(res)!=1: 
+                raise cls.moreThanOneTag("multiple tags on same commit is unsupported")   
+            return res[0]
+
+        @classmethod
+        def getDistanceFromTag(cls,tag=None,**kwargs) -> int:
+            """
+            retrieve the distance between HEAD and tag in the repository
+            Arguments:
+                tag: reference tag, if None the most recent one will be used
+            Kwargs:
+                same_branch(bool): force searching only in the same branch
+            Return:
+                the tag
+            """
+            if tag is None:
+                tag = cls.getLastTag(**kwargs)
+            return int(_exec(f"git rev-list {tag}..HEAD --count")[0])
+
+    class version:
+        """
+        class containing methods focusing on versions
+        """
+        __OptDict = {   "version_std":      "version_std",
+                        "formated_output":  "formated_output",
+                        "output_format":    "output_format"}
+        DefaultInputFormat = "Auto"
+        VersionStds    = { "SemVer" : { "regex" :               r"^(?P<major>0|[1-9]\d*)\.(?P<minor>0|[1-9]\d*)\.(?P<patch>0|[1-9]\d*)"\
+                                                                r"(?:-(?P<prerelease>(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)"\
+                                                                r"(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?"\
+                                                                r"(?:\+(?P<buildmetadata>[0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$",
+                                        "regex_preversion_num": r"(?:\.)(?P<num>(?:\d+(?!\w))+)", 
+                                        "regex_build_num"     : r"(?:\.)(?P<num>(?:\d+(?!\w))+)"          
+                                                                
+                                                                },
+                           "PEP440" : { "regex" :               packaging_VERSION_PATTERN,
+                           "Auto"   : None
+                           }
+        }
+        __versionReseted = False
+        class versionException(gitversionhelperException):
+            """
+            generic version exception
+            """
+
+        class noValidVersion(versionException):
+            """
+            no valid version found exception
+            """
+
+        class MetaVersion:
+            """
+            generic version object
+            """
+            __OptDict                   = {  "bump_type":             "bump_type",
+                                             "bump_dev_strategy":     "bump_dev_strategy"}
+            DefaultBumpType             = "patch"
+            BumpTypes                   = ["major","minor","patch","dev"]
+            DefaultBumpDevStrategy      = "post"
+            BumpDevStrategys            = ["post","pre-patch","pre-minor","pre-major"]
+            version_std                 = "None"
+
+            major: int      = 0
+            minor: int      = 1
+            patch: int      = 0
+            pre_count:int   = 0
+            post_count:int  = 0
+            raw:str         = "0.1.0"
+
+            def __init__(self,version_std,major=0,minor=1,patch=0,pre_count=0,post_count=0,raw="0.1.0"): #pylint: disable=R0913
+                self.version_std = version_std 
+                self.major       = major
+                self.minor       = minor
+                self.patch       = patch
+                self.pre_count   = pre_count
+                self.post_count  = post_count
+                self.raw         = raw
+
+            @classmethod
+            def _getBumpDevStrategy(cls,**kwargs) -> str:
+                """
+                get selected bump_dev_strategy
+                Kwargs:
+                    bump_dev_strategy(str): the given bump_dev_strategy (can be None)
+                Return:
+                    Kwargs given bump_dev_strategy or the default one.
+                """
+                BumpDevStrategy = cls.DefaultBumpDevStrategy
+                if (cls.__OptDict["bump_dev_strategy"] in kwargs):
+                    if kwargs[cls.__OptDict["bump_dev_strategy"]] in cls.BumpDevStrategys:
+                        BumpDevStrategy = kwargs[cls.__OptDict["bump_dev_strategy"]]
+                    else:
+                        raise gitversionhelper.wrongArguments(f"invalid {cls.__OptDict['bump_type']} requested")
+                return BumpDevStrategy
+
+            @classmethod
+            def _getBumpType(cls,**kwargs) -> str:
+                """
+                get selected bump_type
+                Kwargs:
+                    bump_type(str): the given bump_type (can be None)
+                Return:
+                    Kwargs given bump_type or the default one.
+                """
+                BumpType = cls.DefaultBumpType
+                if (cls.__OptDict["bump_type"] in kwargs):
+                    if kwargs[cls.__OptDict["bump_type"]] in cls.BumpTypes:
+                        BumpType = kwargs[cls.__OptDict["bump_type"]]
+                    else:
+                        raise gitversionhelper.wrongArguments(f"invalid {cls.__OptDict['bump_type']} requested")
+                return BumpType
+
+            def bump(self,amount:int=1,**kwargs): # pylint: disable=R0912
+                """
+                bump the version to the next one
+                Kwargs:
+                    bump_type(str): the given bump_type (can be None)
+                    bump_dev_strategy(str): the given bump_dev_strategy (can be None)
+                Return:
+                    the bumped version
+                """
+                BumpType = self._getBumpType(**kwargs)
+                BumpDevStrategy=self._getBumpDevStrategy(**kwargs)
+                _v=copy(self)
+
+                if BumpType == "dev":
+                    if BumpDevStrategy == "post":
+                        if _v.pre_count > 0:
+                            _v.pre_count = _v.pre_count + amount
+                        else:
+                            _v.post_count = _v.post_count + amount
+                    elif BumpDevStrategy in ["pre-patch","pre-minor","pre-major"]:
+                        if _v.post_count > 0:
+                            _v.post_count = _v.post_count + amount
+                        else:
+                            if _v.pre_count == 0:
+                                if BumpDevStrategy == "pre-patch":
+                                    _v.patch = _v.patch + 1
+                                elif BumpDevStrategy == "pre-minor":
+                                    _v.minor = _v.minor + 1
+                                    _v.patch = 0
+                                elif BumpDevStrategy == "pre-major":
+                                    _v.major = _v.major + 1
+                                    _v.minor = 0
+                                    _v.patch = 0
+                            _v.pre_count = _v.pre_count + amount
+                else:
+                    if BumpType == "major":
+                        _v.major = _v.major + amount
+                    elif BumpType == "minor":
+                        _v.minor = _v.minor + amount
+                    elif BumpType == "patch":
+                        _v.patch = _v.patch + amount
+                    _v.pre_count=0
+                    _v.post_count=0
+
+                _v.raw=_v.doFormatVersion(**kwargs)
+                return _v
+
+            def doFormatVersion(self,**kwargs):
+                return gitversionhelper.version.doFormatVersion(self,**kwargs)
+
+        @classmethod
+        def _getVersionStd(cls,**kwargs):
+            """
+            get selected version_std
+            Kwargs:
+                version_std(str): the given version_std (can be None)
+            Return:
+                Kwargs given version_std or the default one.
+            """
+            VersionStd = cls.DefaultInputFormat
+            if cls.__OptDict["version_std"] in kwargs:
+                if kwargs[cls.__OptDict["version_std"]] in cls.VersionStds:
+                    VersionStd = kwargs[cls.__OptDict["version_std"]]
+                else:
+                    raise gitversionhelper.wrongArguments(f"invalid {cls.__OptDict['version_std']} requested")
+            return VersionStd
+
+        @classmethod
+        def getCurrentVersion(cls,**kwargs) -> Union[str,MetaVersion]:
+            if gitversionhelper.repository.isDirty() is not False:
+                raise gitversionhelper.repository.repositoryDirty(  "The repository is dirty and a current version" \
+                                                                    " can not be generated.")
+            saved_kwargs = copy(kwargs)
+            if "formated_output" in kwargs:
+                del saved_kwargs["formated_output"]
+
+            _v = cls.getLastVersion(**saved_kwargs)
+
+            if not cls.__versionReseted:
+                amount  = gitversionhelper.tag.getDistanceFromTag(_v.raw,**kwargs)
+                _v = _v.bump(amount,**kwargs)
+
+            if ((cls.__OptDict["formated_output"] in kwargs) and (kwargs[cls.__OptDict["formated_output"]] is True)):
+                return _v.doFormatVersion(**kwargs)
+            return _v
+
+        @classmethod
+        def getLastVersion(cls,**kwargs) -> Union[str,MetaVersion]: # pylint: disable=R0914, R0912, R0915
+            """
+            bump the last version from tags
+            Kwargs:
+                version_std(str): the given version_std (can be None)
+                same_branch(bool): force searching only in the same branch
+                formated_output(bool) : output a formated version string
+            Return:
+                the last version
+            """
+            VersionStd = cls._getVersionStd(**kwargs)
+
+            bAutoVersionStd = False 
+            if VersionStd == "Auto":
+                bAutoVersionStd = True 
+
+            lastTag=cls.MetaVersion.raw
+            cls.__versionReseted = False
+            try:
+                lastTag = gitversionhelper.tag.getLastTag(**kwargs)
+            except gitversionhelper.tag.tagNotFound:
+                logging.warning('tag not found, reseting versionning')
+                cls.__versionReseted = True
+
+            bFound = False 
+            if VersionStd == "SemVer" or (bAutoVersionStd is True) :
+                _r=re.compile(r"^\s*" + cls.VersionStds["SemVer"]["regex"] + r"\s*$",   re.VERBOSE | \
+                                                                                        re.IGNORECASE)
+                _m = re.match(_r,lastTag)
+                if not _m:
+                    pass
+                else:
+                    major, minor, patch =   int(_m.group("major")),\
+                                            int(_m.group("minor")),\
+                                            int(_m.group("patch"))
+
+                    pre_count = 0
+                    if _pre := _m.group("prerelease"):
+                        if (_match := re.search (cls.VersionStds["SemVer"]["regex_preversion_num"],_pre)) is not None:
+                            pre_count = int(_match.group("num"))
+                        else:
+                            pre_count = 1
+
+                    post_count = 0
+                    if _post := _m.group("buildmetadata"):
+                        if (_match := re.search (cls.VersionStds["SemVer"]["regex_build_num"],_post)) is not None:
+                            post_count = int(_match.group("num"))
+                        else:
+                            post_count = 1
+                    bFound = True
+                    VersionStd = "SemVer"
+
+            if VersionStd == "PEP440" or ( (bAutoVersionStd is True)  and (bFound is not True)):
+                _r=re.compile(r"^\s*" + cls.VersionStds["PEP440"]["regex"] + r"\s*$",   re.VERBOSE | \
+                                                                                        re.IGNORECASE)
+                _m = re.match(_r,lastTag)
+                if not _m:
+                    pass
+                else:
+                    ver=_m.group("release").split(".")
+                    ver += ["0"] * (3 - len(ver))
+                    ver[0]=int(ver[0])
+                    ver[1]=int(ver[1])
+                    ver[2]=int(ver[2])
+                    major, minor, patch = tuple(ver)
+                    pre_count  = int(_m.group("pre_n")) if _m.group("pre_n") else 0
+                    post_count = int(_m.group("post_n2")) if _m.group("post_n2") else 0
+                    bFound = True
+                    VersionStd = "PEP440"
+
+            if not bFound :
+                raise gitversionhelper.version.noValidVersion("no valid version found in tags")
+
+            _v = cls.MetaVersion(VersionStd, major, minor, patch, pre_count, post_count, lastTag)
+
+            if ((cls.__OptDict["formated_output"] in kwargs) and (kwargs[cls.__OptDict["formated_output"]] is True)):
+                return _v.doFormatVersion(**kwargs)
+            return _v
+
+        @classmethod
+        def doFormatVersion(cls,inputversion:MetaVersion,**kwargs):
+            """
+            output a formated version string
+            Args:
+                inputversion: version to be rendered
+            Return:
+                formated version string
+            """
+
+            VersionStd = cls._getVersionStd(**kwargs)
+            if VersionStd=="Auto" :
+                VersionStd = inputversion.version_std
+
+            OutputFormat = None
+            revpattern=""
+            revcount=""
+            post_count = inputversion.post_count
+            pre_count  = inputversion.pre_count
+            patch      = inputversion.patch
+
+            if cls.__OptDict["output_format"] in kwargs:
+                OutputFormat=kwargs[cls.__OptDict["output_format"]]
+
+            if OutputFormat is None:
+                OutputFormat = "{major}.{minor}.{patch}{revpattern}{revcount}"
+                if post_count > 0 and pre_count > 0:
+                    raise RuntimeError("pre and post release can not be present at the same time")
+                if      VersionStd == "PEP440":
+                    if post_count > 0:
+                        revpattern=".post"
+                        revcount=f"{post_count}"
+                    elif pre_count > 0:
+                        revpattern=".pre"
+                        revcount=f"{pre_count}"
+                elif    VersionStd == "SemVer":
+                    if post_count > 0:
+                        revpattern="+post"
+                        revcount=f".{post_count}"
+                    elif pre_count > 0:
+                        revpattern="-pre"
+                        revcount=f".{pre_count}"
+            return OutputFormat.format( major=inputversion.major, \
+                                        minor=inputversion.minor, \
+                                        patch=patch,              \
+                                        revpattern=revpattern,    \
+                                        revcount=revcount)

src/pygitversionhelper/test_module.py

@@ -1,43 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-
-# pygitversionhelper (c) by chacha
-#
-# pygitversionhelper  is licensed under a
-# Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International Unported License.
-#
-# You should have received a copy of the license along with this
-# work.  If not, see <https://creativecommons.org/licenses/by-nc-sa/4.0/>.
-
-"""Phasellus tellus lectus, volutpat eu dapibus ut, suscipit vel augue.
-
-Tips:
-    Aliquam non leo vel libero sagittis viverra. Quisque lobortis nunc sit amet augue euismod laoreet.
-Note:
-    Maecenas volutpat porttitor pretium. Aliquam suscipit quis nisi non imperdiet.
-Note:
-    Vivamus et efficitur lorem, eget imperdiet tortor. Integer vel interdum sem.
-"""
-
-from __future__ import annotations
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:  # Only imports the below statements during type checking
-    pass
-
-def test_function(testvar: int) -> int:
-    """ A test function that return testvar+1 and print "Hello world !"
-
-    Proin eget sapien eget ipsum efficitur mollis nec ac nibh.   
-    
-    Note:
-        Morbi id lectus maximus, condimentum nunc eget, porta felis. In tristique velit tortor.
-    
-    Args:
-        testvar: any integer
-    
-    Returns:
-        testvar+1
-    """
-    print("Hello world !")
-    return testvar+1

test/test_gitversionhelper.py

@@ -0,0 +1,774 @@
+# pygitversionhelper (c) by chacha
+#
+# pygitversionhelper  is licensed under a
+# Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International Unported License.
+#
+# You should have received a copy of the license along with this
+# work.  If not, see <https://creativecommons.org/licenses/by-nc-sa/4.0/>.
+
+import unittest
+
+import tempfile
+import os
+import pathlib
+import re
+
+from contextlib import redirect_stdout,redirect_stderr
+
+print(__name__)
+print(__package__)
+
+from src import pygitversionhelper
+
+HelperRegex=r"^(?P<MAJ>\d+)\.(?P<MIN>\d+)\.(?P<PATCH>\d+)([\.\-\+])?(?:.*)?"
+
+class Test_gitversionhelper(unittest.TestCase):
+    def setUp(self):
+        self.TmpWorkingDir=tempfile.TemporaryDirectory()
+        self.TmpWorkingDirPath=pathlib.Path(self.TmpWorkingDir.name)
+        os.chdir(self.TmpWorkingDirPath)
+        os.system("git init")
+        os.system('git config --local user.name "john doe"')
+        os.system('git config --local user.email "john@doe.org"')
+        
+    def _test_version_readback(self,tag:str,**kwargs):
+        with  open("demofile.txt", "w+t") as tmpFile:
+            tmpFile.write("testvalue")
+
+        os.system("git add .")
+        os.system("git commit -m  \"first commit\"")
+        os.system(f"git tag {tag}")
+        
+        _v = pygitversionhelper.gitversionhelper.version.getLastVersion(**kwargs)
+        
+        self.assertIsInstance(_v, pygitversionhelper.gitversionhelper.version.MetaVersion)
+        self.assertIsInstance(_v.raw, str)
+        self.assertEqual(_v.raw, tag)
+        self.assertIsInstance(_v.major, int)
+        self.assertIsInstance(_v.minor, int)
+        self.assertIsInstance(_v.patch, int)
+        self.assertIsInstance(_v.pre_count, int)
+        self.assertIsInstance(_v.post_count, int)
+        
+
+        _m = re.match(HelperRegex, tag)
+        self.assertEqual(int(_m.group("MAJ")),_v.major)
+        self.assertEqual(int(_m.group("MIN")),_v.minor)
+        self.assertEqual(int(_m.group("PATCH")),_v.patch)
+        return _v
+        
+    def _test_version_format(self,_v:pygitversionhelper.gitversionhelper.version.MetaVersion,tag:str,**kwargs):
+        _f=_v.doFormatVersion(**kwargs)
+        self.assertRegex(_f,HelperRegex)
+        self.assertEqual(_f, tag)
+        
+    def _test_version_readback_simple(self,tag:str,**kwargs):   
+        _v=self._test_version_readback(tag,**kwargs)
+        self._test_version_format(_v,tag,**kwargs)
+        
+    def test_nominal_version_auto_1(self):
+        self._test_version_readback_simple("0.0.1")
+    def test_nominal_version_auto_2(self):
+        self._test_version_readback_simple("0.0.2")
+    def test_nominal_version_auto_3(self):
+        self._test_version_readback_simple("0.1.0")
+    def test_nominal_version_auto_4(self):
+        self._test_version_readback_simple("0.1.1")
+    def test_nominal_version_auto_5(self):
+        self._test_version_readback_simple("1.0.0")
+    def test_nominal_version_auto_6(self):
+        self._test_version_readback_simple("1.1.0")
+    def test_nominal_version_auto_7(self):
+        self._test_version_readback_simple("1.2.0")
+    def test_nominal_version_auto_8(self):
+        self._test_version_readback_simple("1.1.1")
+    def test_nominal_version_auto_9(self):
+        self._test_version_readback_simple("1.2.1")
+    def test_nominal_version_auto_PEP440_post(self):
+        self._test_version_readback_simple("1.2.1.post1")
+    def test_nominal_version_auto_PEP440_pre(self):
+        self._test_version_readback_simple("1.2.1.pre1")
+    def test_nominal_version_auto_PEP440_post_2(self):
+        self._test_version_readback_simple("1.2.1.post10")
+    def test_nominal_version_auto_PEP440_pre_2(self):
+        self._test_version_readback_simple("1.2.1.pre10")
+        
+    def test_nominal_version_auto_SemVer_post(self):
+        self._test_version_readback_simple("1.2.1+post.1")
+    def test_nominal_version_auto_SemVer_pre(self):
+        self._test_version_readback_simple("1.2.1-pre.1")
+    def test_nominal_version_auto_SemVer_post_2(self):
+        self._test_version_readback_simple("1.2.1+post.10")
+    def test_nominal_version_auto_Semver_pre_2(self):
+        self._test_version_readback_simple("1.2.1-pre.10")
+
+    def test_nominal_version_PEP440_1(self):
+        self._test_version_readback_simple("0.0.1",version_std="PEP440")
+    def test_nominal_version_PEP440_2(self):
+        self._test_version_readback_simple("0.0.2",version_std="PEP440")
+    def test_nominal_version_PEP440_3(self):
+        self._test_version_readback_simple("0.1.0",version_std="PEP440")
+    def test_nominal_version_PEP440_4(self):
+        self._test_version_readback_simple("0.1.1",version_std="PEP440")
+    def test_nominal_version_PEP440_5(self):
+        self._test_version_readback_simple("1.0.0",version_std="PEP440")
+    def test_nominal_version_PEP440_6(self):
+        self._test_version_readback_simple("1.1.0",version_std="PEP440")
+    def test_nominal_version_PEP440_7(self):
+        self._test_version_readback_simple("1.2.0",version_std="PEP440")
+    def test_nominal_version_PEP440_8(self):
+        self._test_version_readback_simple("1.1.1",version_std="PEP440")
+    def test_nominal_version_PEP440_9(self):
+        self._test_version_readback_simple("1.2.1",version_std="PEP440")
+    def test_nominal_version_PEP440_post(self):
+        self._test_version_readback_simple("1.2.1.post1",version_std="PEP440")
+    def test_nominal_version_PEP440_pre(self):
+        self._test_version_readback_simple("1.2.1.pre1",version_std="PEP440")
+    def test_nominal_version_PEP440_post_2(self):
+        self._test_version_readback_simple("1.2.1.post10",version_std="PEP440")
+    def test_nominal_version_PEP440_pre_2(self):
+        self._test_version_readback_simple("1.2.1.pre10",version_std="PEP440")
+
+    def test_nominal_version_SemVer_1(self):
+        self._test_version_readback_simple("0.0.1",version_std="SemVer")
+    def test_nominal_version_SemVer_2(self):
+        self._test_version_readback_simple("0.0.2",version_std="SemVer")
+    def test_nominal_version_SemVer_3(self):
+        self._test_version_readback_simple("0.1.0",version_std="SemVer")
+    def test_nominal_version_SemVer_4(self):
+        self._test_version_readback_simple("0.1.1",version_std="SemVer")
+    def test_nominal_version_SemVer_5(self):
+        self._test_version_readback_simple("1.0.0",version_std="SemVer")
+    def test_nominal_version_SemVer_6(self):
+        self._test_version_readback_simple("1.1.0",version_std="SemVer")
+    def test_nominal_version_SemVer_7(self):
+        self._test_version_readback_simple("1.2.0",version_std="SemVer")
+    def test_nominal_version_SemVer_8(self):
+        self._test_version_readback_simple("1.1.1",version_std="SemVer")
+    def test_nominal_version_SemVer_9(self):
+        self._test_version_readback_simple("1.2.1",version_std="SemVer")
+    def test_nominal_version_SemVer_post(self):
+        self._test_version_readback_simple("1.2.1+post.1",version_std="SemVer")
+    def test_nominal_version_SemVer_pre(self):
+        self._test_version_readback_simple("1.2.1-pre.1",version_std="SemVer")
+    def test_nominal_version_SemVer_post_2(self):
+        self._test_version_readback_simple("1.2.1+post.10",version_std="SemVer")
+    def test_nominal_version_SemVer_pre_2(self):
+        self._test_version_readback_simple("1.2.1-pre.10",version_std="SemVer")
+        
+    def test_nominal_version_post_PEP440_to_SemVer(self):
+        _v=self._test_version_readback("1.2.1.post10",version_std="PEP440")
+        self._test_version_format(_v,"1.2.1+post.10",version_std="SemVer")
+        
+    def test_nominal_version_post_SemVer_to_PEP440(self):
+        _v=self._test_version_readback("1.2.1+post.10",version_std="SemVer")
+        self._test_version_format(_v,"1.2.1.post10",version_std="PEP440")
+
+    def test_nominal_version_pre_PEP440_to_SemVer(self):
+        _v=self._test_version_readback("1.2.1.pre10",version_std="PEP440")
+        self._test_version_format(_v,"1.2.1-pre.10",version_std="SemVer")
+        
+    def test_nominal_version_pre_SemVer_to_PEP440(self):
+        _v=self._test_version_readback("1.2.1-pre.10",version_std="SemVer")
+        self._test_version_format(_v,"1.2.1.pre10",version_std="PEP440")
+              
+    def test_nominal_version_post_SemVer_nonum(self):
+        _v=self._test_version_readback("1.2.1+post",version_std="SemVer")
+        self._test_version_format(_v,"1.2.1+post.1",version_std="SemVer")
+        
+    def test_nominal_version_post_SemVer_nonum_random(self):
+        _v=self._test_version_readback("1.2.1+toto",version_std="SemVer")
+        self._test_version_format(_v,"1.2.1+post.1",version_std="SemVer")
+        
+    def test_nominal_version_pre_SemVer_nonum(self):
+        _v=self._test_version_readback("1.2.1-pre",version_std="SemVer")
+        self._test_version_format(_v,"1.2.1-pre.1",version_std="SemVer")
+        
+    def test_nominal_version_pre_SemVer_nonum_random(self):
+        _v=self._test_version_readback("1.2.1-toto",version_std="SemVer")
+        self._test_version_format(_v,"1.2.1-pre.1",version_std="SemVer")
+        
+    def test_version_pump_SemVer(self,**kwargs):
+        _v = self._test_version_readback("1.0.0",version_std="SemVer")
+        
+        _v = _v.bump()
+        self.assertIsInstance(_v.raw, str)
+        self.assertIsInstance(_v.major, int)
+        self.assertIsInstance(_v.minor, int)
+        self.assertIsInstance(_v.patch, int)
+        self.assertIsInstance(_v.pre_count, int)
+        self.assertIsInstance(_v.post_count, int)
+        self.assertEqual(_v.raw, "1.0.1")
+        self.assertEqual(_v.major, 1)
+        self.assertEqual(_v.minor, 0)
+        self.assertEqual(_v.patch, 1)
+        self.assertEqual(_v.pre_count, 0)
+        self.assertEqual(_v.post_count, 0)
+        self.assertEqual(_v.doFormatVersion(), "1.0.1")
+        
+        _v = _v.bump(bump_type="patch")
+        self.assertEqual(_v.raw, "1.0.2")
+        self.assertEqual(_v.major, 1)
+        self.assertEqual(_v.minor, 0)
+        self.assertEqual(_v.patch, 2)
+        self.assertEqual(_v.pre_count, 0)
+        self.assertEqual(_v.post_count, 0)
+        self.assertEqual(_v.doFormatVersion(), "1.0.2")
+        
+        _v = _v.bump(bump_type="minor")
+        self.assertEqual(_v.raw, "1.1.2")
+        self.assertEqual(_v.major, 1)
+        self.assertEqual(_v.minor, 1)
+        self.assertEqual(_v.patch, 2)
+        self.assertEqual(_v.pre_count, 0)
+        self.assertEqual(_v.post_count, 0)
+        self.assertEqual(_v.doFormatVersion(), "1.1.2")
+        
+        _v = _v.bump(bump_type="major")
+        self.assertEqual(_v.raw, "2.1.2")
+        self.assertEqual(_v.major, 2)
+        self.assertEqual(_v.minor, 1)
+        self.assertEqual(_v.patch, 2)
+        self.assertEqual(_v.pre_count, 0)
+        self.assertEqual(_v.post_count, 0)
+        self.assertEqual(_v.doFormatVersion(), "2.1.2")
+        
+        _v = _v.bump(bump_type="dev")
+        self.assertEqual(_v.raw, "2.1.2+post.1")
+        self.assertEqual(_v.major, 2)
+        self.assertEqual(_v.minor, 1)
+        self.assertEqual(_v.patch, 2)
+        self.assertEqual(_v.pre_count, 0)
+        self.assertEqual(_v.post_count, 1)
+        self.assertEqual(_v.doFormatVersion(), "2.1.2+post.1")
+        
+        _v = _v.bump(bump_type="dev")
+        self.assertEqual(_v.raw, "2.1.2+post.2")
+        self.assertEqual(_v.major, 2)
+        self.assertEqual(_v.minor, 1)
+        self.assertEqual(_v.patch, 2)
+        self.assertEqual(_v.pre_count, 0)
+        self.assertEqual(_v.post_count, 2)
+        self.assertEqual(_v.doFormatVersion(), "2.1.2+post.2")
+        
+        _v = _v.bump(bump_type="patch")
+        self.assertEqual(_v.raw, "2.1.3")
+        self.assertEqual(_v.major, 2)
+        self.assertEqual(_v.minor, 1)
+        self.assertEqual(_v.patch, 3)
+        self.assertEqual(_v.pre_count, 0)
+        self.assertEqual(_v.post_count, 0)
+        self.assertEqual(_v.doFormatVersion(), "2.1.3")     
+        
+        _v = _v.bump(bump_type="dev",bump_dev_strategy="pre-patch")
+        self.assertEqual(_v.raw, "2.1.4-pre.1")
+        self.assertEqual(_v.major, 2)
+        self.assertEqual(_v.minor, 1)
+        self.assertEqual(_v.patch, 4)
+        self.assertEqual(_v.pre_count, 1)
+        self.assertEqual(_v.post_count, 0)
+        self.assertEqual(_v.doFormatVersion(), "2.1.4-pre.1")
+        
+        _v = _v.bump(bump_type="dev",bump_dev_strategy="pre-patch")
+        self.assertEqual(_v.raw, "2.1.4-pre.2")
+        self.assertEqual(_v.major, 2)
+        self.assertEqual(_v.minor, 1)
+        self.assertEqual(_v.patch, 4)
+        self.assertEqual(_v.pre_count, 2)
+        self.assertEqual(_v.post_count, 0)
+        self.assertEqual(_v.doFormatVersion(), "2.1.4-pre.2")
+        
+        _v = _v.bump(bump_type="dev",bump_dev_strategy="post")
+        self.assertEqual(_v.raw, "2.1.4-pre.3")
+        self.assertEqual(_v.major, 2)
+        self.assertEqual(_v.minor, 1)
+        self.assertEqual(_v.patch, 4)
+        self.assertEqual(_v.pre_count, 3)
+        self.assertEqual(_v.post_count, 0)
+        self.assertEqual(_v.doFormatVersion(), "2.1.4-pre.3")
+        
+        _v = _v.bump(bump_type="patch")
+        self.assertEqual(_v.raw, "2.1.5")
+        self.assertEqual(_v.major, 2)
+        self.assertEqual(_v.minor, 1)
+        self.assertEqual(_v.patch, 5)
+        self.assertEqual(_v.pre_count, 0)
+        self.assertEqual(_v.post_count, 0)
+        self.assertEqual(_v.doFormatVersion(), "2.1.5")  
+        
+        _v = _v.bump(bump_type="dev",bump_dev_strategy="post")
+        self.assertEqual(_v.raw, "2.1.5+post.1")
+        self.assertEqual(_v.major, 2)
+        self.assertEqual(_v.minor, 1)
+        self.assertEqual(_v.patch, 5)
+        self.assertEqual(_v.pre_count, 0)
+        self.assertEqual(_v.post_count, 1)
+        self.assertEqual(_v.doFormatVersion(), "2.1.5+post.1")
+        
+        _v = _v.bump(bump_type="dev",bump_dev_strategy="pre-patch")
+        self.assertEqual(_v.raw, "2.1.5+post.2")
+        self.assertEqual(_v.major, 2)
+        self.assertEqual(_v.minor, 1)
+        self.assertEqual(_v.patch, 5)
+        self.assertEqual(_v.pre_count, 0)
+        self.assertEqual(_v.post_count, 2)
+        self.assertEqual(_v.doFormatVersion(), "2.1.5+post.2")
+
+    def test_version_pump_PEP440(self,**kwargs):
+        _v = self._test_version_readback("1.0.0",version_std="PEP440")
+        
+        _v = _v.bump()
+        self.assertIsInstance(_v.raw, str)
+        self.assertIsInstance(_v.major, int)
+        self.assertIsInstance(_v.minor, int)
+        self.assertIsInstance(_v.patch, int)
+        self.assertIsInstance(_v.pre_count, int)
+        self.assertIsInstance(_v.post_count, int)
+        self.assertEqual(_v.raw, "1.0.1")
+        self.assertEqual(_v.major, 1)
+        self.assertEqual(_v.minor, 0)
+        self.assertEqual(_v.patch, 1)
+        self.assertEqual(_v.pre_count, 0)
+        self.assertEqual(_v.post_count, 0)
+        self.assertEqual(_v.doFormatVersion(), "1.0.1")
+        
+        _v = _v.bump(bump_type="patch")
+        self.assertEqual(_v.raw, "1.0.2")
+        self.assertEqual(_v.major, 1)
+        self.assertEqual(_v.minor, 0)
+        self.assertEqual(_v.patch, 2)
+        self.assertEqual(_v.pre_count, 0)
+        self.assertEqual(_v.post_count, 0)
+        self.assertEqual(_v.doFormatVersion(), "1.0.2")
+        
+        _v = _v.bump(bump_type="minor")
+        self.assertEqual(_v.raw, "1.1.2")
+        self.assertEqual(_v.major, 1)
+        self.assertEqual(_v.minor, 1)
+        self.assertEqual(_v.patch, 2)
+        self.assertEqual(_v.pre_count, 0)
+        self.assertEqual(_v.post_count, 0)
+        self.assertEqual(_v.doFormatVersion(), "1.1.2")
+        
+        _v = _v.bump(bump_type="major")
+        self.assertEqual(_v.raw, "2.1.2")
+        self.assertEqual(_v.major, 2)
+        self.assertEqual(_v.minor, 1)
+        self.assertEqual(_v.patch, 2)
+        self.assertEqual(_v.pre_count, 0)
+        self.assertEqual(_v.post_count, 0)
+        self.assertEqual(_v.doFormatVersion(), "2.1.2")
+        
+        _v = _v.bump(bump_type="dev")
+        self.assertEqual(_v.raw, "2.1.2.post1")
+        self.assertEqual(_v.major, 2)
+        self.assertEqual(_v.minor, 1)
+        self.assertEqual(_v.patch, 2)
+        self.assertEqual(_v.pre_count, 0)
+        self.assertEqual(_v.post_count, 1)
+        self.assertEqual(_v.doFormatVersion(), "2.1.2.post1")
+        
+        _v = _v.bump(bump_type="dev")
+        self.assertEqual(_v.raw, "2.1.2.post2")
+        self.assertEqual(_v.major, 2)
+        self.assertEqual(_v.minor, 1)
+        self.assertEqual(_v.patch, 2)
+        self.assertEqual(_v.pre_count, 0)
+        self.assertEqual(_v.post_count, 2)
+        self.assertEqual(_v.doFormatVersion(), "2.1.2.post2")
+        
+        _v = _v.bump(bump_type="patch")
+        self.assertEqual(_v.raw, "2.1.3")
+        self.assertEqual(_v.major, 2)
+        self.assertEqual(_v.minor, 1)
+        self.assertEqual(_v.patch, 3)
+        self.assertEqual(_v.pre_count, 0)
+        self.assertEqual(_v.post_count, 0)
+        self.assertEqual(_v.doFormatVersion(), "2.1.3")     
+        
+        _v = _v.bump(bump_type="dev",bump_dev_strategy="pre-patch")
+        self.assertEqual(_v.raw, "2.1.4.pre1")
+        self.assertEqual(_v.major, 2)
+        self.assertEqual(_v.minor, 1)
+        self.assertEqual(_v.patch, 4)
+        self.assertEqual(_v.pre_count, 1)
+        self.assertEqual(_v.post_count, 0)
+        self.assertEqual(_v.doFormatVersion(), "2.1.4.pre1")
+        
+        _v = _v.bump(bump_type="dev",bump_dev_strategy="pre-patch")
+        self.assertEqual(_v.raw, "2.1.4.pre2")
+        self.assertEqual(_v.major, 2)
+        self.assertEqual(_v.minor, 1)
+        self.assertEqual(_v.patch, 4)
+        self.assertEqual(_v.pre_count, 2)
+        self.assertEqual(_v.post_count, 0)
+        self.assertEqual(_v.doFormatVersion(), "2.1.4.pre2")
+        
+        _v = _v.bump(bump_type="dev",bump_dev_strategy="post")
+        self.assertEqual(_v.raw, "2.1.4.pre3")
+        self.assertEqual(_v.major, 2)
+        self.assertEqual(_v.minor, 1)
+        self.assertEqual(_v.patch, 4)
+        self.assertEqual(_v.pre_count, 3)
+        self.assertEqual(_v.post_count, 0)
+        self.assertEqual(_v.doFormatVersion(), "2.1.4.pre3")
+        
+        _v = _v.bump(bump_type="patch")
+        self.assertEqual(_v.raw, "2.1.5")
+        self.assertEqual(_v.major, 2)
+        self.assertEqual(_v.minor, 1)
+        self.assertEqual(_v.patch, 5)
+        self.assertEqual(_v.pre_count, 0)
+        self.assertEqual(_v.post_count, 0)
+        self.assertEqual(_v.doFormatVersion(), "2.1.5")  
+        
+        _v = _v.bump(bump_type="dev",bump_dev_strategy="post")
+        self.assertEqual(_v.raw, "2.1.5.post1")
+        self.assertEqual(_v.major, 2)
+        self.assertEqual(_v.minor, 1)
+        self.assertEqual(_v.patch, 5)
+        self.assertEqual(_v.pre_count, 0)
+        self.assertEqual(_v.post_count, 1)
+        self.assertEqual(_v.doFormatVersion(), "2.1.5.post1")
+        
+        _v = _v.bump(bump_type="dev",bump_dev_strategy="pre-patch")
+        self.assertEqual(_v.raw, "2.1.5.post2")
+        self.assertEqual(_v.major, 2)
+        self.assertEqual(_v.minor, 1)
+        self.assertEqual(_v.patch, 5)
+        self.assertEqual(_v.pre_count, 0)
+        self.assertEqual(_v.post_count, 2)
+        self.assertEqual(_v.doFormatVersion(), "2.1.5.post2")
+        
+    def test_nominal_version_SemVer_zeroRev(self):
+        _v=self._test_version_readback("0.0.0",version_std="SemVer")
+        self._test_version_format(_v,"0.0.0",version_std="SemVer")
+        
+    def test_nominal_version_PEP440_zeroRev(self):
+        _v=self._test_version_readback("0.0.0",version_std="PEP440")
+        self._test_version_format(_v,"0.0.0",version_std="PEP440")
+        
+
+    def test_nominal_version_PEP440_noRev_noTag(self):
+        with  open("demofile.txt", "w+t") as tmpFile:
+            tmpFile.write("testvalue")
+
+        os.system("git add .")
+        os.system("git commit -m  \"first commit\"")
+        
+        _v = pygitversionhelper.gitversionhelper.version.getLastVersion(version_std="PEP440")
+        
+        self.assertIsInstance(_v, pygitversionhelper.gitversionhelper.version.MetaVersion)
+        self.assertIsInstance(_v.raw, str)
+        self.assertEqual(_v.raw, "0.1.0")
+        self.assertIsInstance(_v.major, int)
+        self.assertIsInstance(_v.minor, int)
+        self.assertIsInstance(_v.patch, int)
+        self.assertIsInstance(_v.pre_count, int)
+        self.assertIsInstance(_v.post_count, int)
+        
+        self.assertEqual(_v.major,0)
+        self.assertEqual(_v.minor,1)
+        self.assertEqual(_v.patch,0)
+        self._test_version_format(_v,"0.1.0",version_std="PEP440")
+        
+    def test_nominal_version_SemVer_noRev_noTag(self):
+        with  open("demofile.txt", "w+t") as tmpFile:
+            tmpFile.write("testvalue")
+
+        os.system("git add .")
+        os.system("git commit -m  \"first commit\"")
+        
+        _v = pygitversionhelper.gitversionhelper.version.getLastVersion(version_std="SemVer")
+        
+        self.assertIsInstance(_v, pygitversionhelper.gitversionhelper.version.MetaVersion)
+        self.assertIsInstance(_v.raw, str)
+        self.assertEqual(_v.raw, "0.1.0")
+        self.assertIsInstance(_v.major, int)
+        self.assertIsInstance(_v.minor, int)
+        self.assertIsInstance(_v.patch, int)
+        self.assertIsInstance(_v.pre_count, int)
+        self.assertIsInstance(_v.post_count, int)
+        
+        self.assertEqual(_v.major,0)
+        self.assertEqual(_v.minor,1)
+        self.assertEqual(_v.patch,0)
+        self._test_version_format(_v,"0.1.0",version_std="SemVer")
+        
+    def test_nominal_version_AUTO_noRev_noTag(self):
+        with  open("demofile.txt", "w+t") as tmpFile:
+            tmpFile.write("testvalue")
+
+        os.system("git add .")
+        os.system("git commit -m  \"first commit\"")
+        
+        _v = pygitversionhelper.gitversionhelper.version.getLastVersion()
+        
+        self.assertIsInstance(_v, pygitversionhelper.gitversionhelper.version.MetaVersion)
+        self.assertIsInstance(_v.raw, str)
+        self.assertEqual(_v.raw, "0.1.0")
+        self.assertIsInstance(_v.major, int)
+        self.assertIsInstance(_v.minor, int)
+        self.assertIsInstance(_v.patch, int)
+        self.assertIsInstance(_v.pre_count, int)
+        self.assertIsInstance(_v.post_count, int)
+        
+        self.assertEqual(_v.major,0)
+        self.assertEqual(_v.minor,1)
+        self.assertEqual(_v.patch,0)
+        self._test_version_format(_v,"0.1.0")
+        
+        
+    def test_nominal_version_AUTO_bump_commits(self):
+        with  open("demofile.txt", "w+t") as tmpFile:
+            tmpFile.write("testvalue")
+        os.system("git add .")
+        os.system("git commit -m  \"first commit\"")
+        os.system(f"git tag 0.2.0")
+        
+        _v = pygitversionhelper.gitversionhelper.version.getCurrentVersion()
+        
+        self.assertIsInstance(_v, pygitversionhelper.gitversionhelper.version.MetaVersion)
+        self.assertIsInstance(_v.raw, str)
+        self.assertEqual(_v.raw, "0.2.0")
+        self.assertIsInstance(_v.major, int)
+        self.assertIsInstance(_v.minor, int)
+        self.assertIsInstance(_v.patch, int)
+        self.assertIsInstance(_v.pre_count, int)
+        self.assertIsInstance(_v.post_count, int)
+        
+        self.assertEqual(_v.major,0)
+        self.assertEqual(_v.minor,2)
+        self.assertEqual(_v.patch,0)
+        self.assertEqual(_v.pre_count,0)
+        self.assertEqual(_v.post_count,0)
+        self._test_version_format(_v,"0.2.0")     
+        
+        with  open("demofile.txt", "w+t") as tmpFile:
+            tmpFile.write("testvalue22")  
+        os.system("git add .")
+        os.system("git commit -m  \"2nd commit\"")
+
+        _v = pygitversionhelper.gitversionhelper.version.getCurrentVersion()
+        
+        self.assertIsInstance(_v, pygitversionhelper.gitversionhelper.version.MetaVersion)
+        self.assertIsInstance(_v.raw, str)
+        self.assertEqual(_v.raw, "0.2.1")
+        self.assertIsInstance(_v.major, int)
+        self.assertIsInstance(_v.minor, int)
+        self.assertIsInstance(_v.patch, int)
+        self.assertIsInstance(_v.pre_count, int)
+        self.assertIsInstance(_v.post_count, int)
+        
+        self.assertEqual(_v.major,0)
+        self.assertEqual(_v.minor,2)
+        self.assertEqual(_v.patch,1)
+        self.assertEqual(_v.pre_count,0)
+        self.assertEqual(_v.post_count,0)
+        self._test_version_format(_v,"0.2.1")     
+
+        with  open("demofile.txt", "w+t") as tmpFile:
+            tmpFile.write("testvalue223")  
+        os.system("git add .")
+        os.system("git commit -m  \"3rd commit\"")
+        
+        with  open("demofile.txt", "w+t") as tmpFile:
+            tmpFile.write("testvalue224")  
+        os.system("git add .")
+        os.system("git commit -m  \"4th commit\"")
+        
+        _v = pygitversionhelper.gitversionhelper.version.getCurrentVersion()
+        
+        self.assertIsInstance(_v, pygitversionhelper.gitversionhelper.version.MetaVersion)
+        self.assertIsInstance(_v.raw, str)
+        self.assertEqual(_v.raw, "0.2.3")
+        self.assertIsInstance(_v.major, int)
+        self.assertIsInstance(_v.minor, int)
+        self.assertIsInstance(_v.patch, int)
+        self.assertIsInstance(_v.pre_count, int)
+        self.assertIsInstance(_v.post_count, int)
+        
+        self.assertEqual(_v.major,0)
+        self.assertEqual(_v.minor,2)
+        self.assertEqual(_v.patch,3)
+        self.assertEqual(_v.pre_count,0)
+        self.assertEqual(_v.post_count,0)
+        self._test_version_format(_v,"0.2.3")  
+         
+        with  open("demofile.txt", "w+t") as tmpFile:
+            tmpFile.write("testvalue225")  
+        os.system("git add .")
+        os.system("git commit -m  \"5th commit\"")  
+        
+        _v = pygitversionhelper.gitversionhelper.version.getCurrentVersion(bump_type="dev")
+        
+        self.assertIsInstance(_v, pygitversionhelper.gitversionhelper.version.MetaVersion)
+        self.assertIsInstance(_v.raw, str)
+        self.assertEqual(_v.raw, "0.2.0+post.4")
+        self.assertIsInstance(_v.major, int)
+        self.assertIsInstance(_v.minor, int)
+        self.assertIsInstance(_v.patch, int)
+        self.assertIsInstance(_v.pre_count, int)
+        self.assertIsInstance(_v.post_count, int)
+        
+        self.assertEqual(_v.major,0)
+        self.assertEqual(_v.minor,2)
+        self.assertEqual(_v.patch,0)
+        self.assertEqual(_v.pre_count,0)
+        self.assertEqual(_v.post_count,4)
+        self._test_version_format(_v,"0.2.0+post.4")  
+        
+        _v = pygitversionhelper.gitversionhelper.version.getCurrentVersion(bump_type="dev",bump_dev_strategy="pre-patch")
+        
+        self.assertIsInstance(_v, pygitversionhelper.gitversionhelper.version.MetaVersion)
+        self.assertIsInstance(_v.raw, str)
+        self.assertEqual(_v.raw, "0.2.1-pre.4")
+        self.assertIsInstance(_v.major, int)
+        self.assertIsInstance(_v.minor, int)
+        self.assertIsInstance(_v.patch, int)
+        self.assertIsInstance(_v.pre_count, int)
+        self.assertIsInstance(_v.post_count, int)
+        
+        self.assertEqual(_v.major,0)
+        self.assertEqual(_v.minor,2)
+        self.assertEqual(_v.patch,1)
+        self.assertEqual(_v.pre_count,4)
+        self.assertEqual(_v.post_count,0)
+        self._test_version_format(_v,"0.2.1-pre.4")   
+        
+        _v = pygitversionhelper.gitversionhelper.version.getCurrentVersion(bump_type="dev",bump_dev_strategy="pre-minor")
+        
+        self.assertIsInstance(_v, pygitversionhelper.gitversionhelper.version.MetaVersion)
+        self.assertIsInstance(_v.raw, str)
+        self.assertEqual(_v.raw, "0.3.0-pre.4")
+        self.assertIsInstance(_v.major, int)
+        self.assertIsInstance(_v.minor, int)
+        self.assertIsInstance(_v.patch, int)
+        self.assertIsInstance(_v.pre_count, int)
+        self.assertIsInstance(_v.post_count, int)
+        
+        self.assertEqual(_v.major,0)
+        self.assertEqual(_v.minor,3)
+        self.assertEqual(_v.patch,0)
+        self.assertEqual(_v.pre_count,4)
+        self.assertEqual(_v.post_count,0)
+        self._test_version_format(_v,"0.3.0-pre.4") 
+          
+        _v = pygitversionhelper.gitversionhelper.version.getCurrentVersion(bump_type="dev",bump_dev_strategy="pre-major")
+        
+        self.assertIsInstance(_v, pygitversionhelper.gitversionhelper.version.MetaVersion)
+        self.assertIsInstance(_v.raw, str)
+        self.assertEqual(_v.raw, "1.0.0-pre.4")
+        self.assertIsInstance(_v.major, int)
+        self.assertIsInstance(_v.minor, int)
+        self.assertIsInstance(_v.patch, int)
+        self.assertIsInstance(_v.pre_count, int)
+        self.assertIsInstance(_v.post_count, int)
+        
+        self.assertEqual(_v.major,1)
+        self.assertEqual(_v.minor,0)
+        self.assertEqual(_v.patch,0)
+        self.assertEqual(_v.pre_count,4)
+        self.assertEqual(_v.post_count,0)
+        self._test_version_format(_v,"1.0.0-pre.4")    
+        
+    def test_nominal_custom_format(self):
+        _v=self._test_version_readback("0.1.1",version_std="PEP440")
+        
+        self.assertEqual("V_0_1_1____",_v.doFormatVersion(output_format="V_{major}_{minor}_{patch}____{revcount}"))
+        self.assertEqual("V_0_1",_v.doFormatVersion(output_format="V_{major}_{minor}"))
+        
+        with  open("demofile.txt", "w+t") as tmpFile:
+            tmpFile.write("testvalue225")  
+        os.system("git add .")
+        os.system("git commit -m  \"5th commit\"")  
+        
+        self.assertEqual("V_1_0",pygitversionhelper.gitversionhelper.version.getCurrentVersion(bump_type="dev",bump_dev_strategy="pre-major").doFormatVersion(output_format="V_{major}_{minor}"))
+        self.assertEqual("V_1_0",pygitversionhelper.gitversionhelper.version.getCurrentVersion(bump_type="dev",bump_dev_strategy="pre-major",output_format="V_{major}_{minor}",formated_output=True))
+
+
+    def test_nominal_emptyrepo(self):
+        _v = pygitversionhelper.gitversionhelper.version.getCurrentVersion()
+        self.assertIsInstance(_v, pygitversionhelper.gitversionhelper.version.MetaVersion)
+        self.assertIsInstance(_v.raw, str)
+        self.assertEqual(_v.raw, "0.1.0")
+        self.assertIsInstance(_v.major, int)
+        self.assertIsInstance(_v.minor, int)
+        self.assertIsInstance(_v.patch, int)
+        self.assertIsInstance(_v.pre_count, int)
+        self.assertIsInstance(_v.post_count, int)
+        
+        self.assertEqual(_v.major,0)
+        self.assertEqual(_v.minor,1)
+        self.assertEqual(_v.patch,0)
+        self.assertEqual(_v.pre_count,0)
+        self.assertEqual(_v.post_count,0)
+        self._test_version_format(_v,"0.1.0")  
+        
+    def test_defect_dirty(self):
+        _v=self._test_version_readback("0.1.1",version_std="PEP440")
+        
+        with  open("demofile.txt", "w+t") as tmpFile:
+            tmpFile.write("testvalue225") 
+             
+        with self.assertRaises(pygitversionhelper.gitversionhelper.repository.repositoryDirty) as context:
+            pygitversionhelper.gitversionhelper.version.getCurrentVersion()
+
+    def test_defect_wrongargument_git_sortargs(self):
+        with self.assertRaises(pygitversionhelper.gitversionhelper.wrongArguments) as context:
+            pygitversionhelper.gitversionhelper.tag.getTags(sort="toto")
+            
+    def test_defect_git_notagfound(self):
+        with  open("demofile.txt", "w+t") as tmpFile:
+            tmpFile.write("testvalue")
+        os.system("git add .")
+        os.system("git commit -m  \"first commit\"")
+        with self.assertRaises(pygitversionhelper.gitversionhelper.tag.tagNotFound) as context:
+            pygitversionhelper.gitversionhelper.tag.getLastTag()
+            
+    """ This test is impossible to do
+    def test_defect_git_multipletagsfound(self):
+        with  open("demofile.txt", "w+t") as tmpFile:
+            tmpFile.write("testvalue")
+        os.system("git add .")
+        os.system("git commit -m  \"first commit\"")
+        os.system(f"git tag 0.1.0")
+        os.system(f"git tag 0.2.0")
+        with self.assertRaises(pygitversionhelper.gitversionhelper.tag.moreThanOneTag) as context:
+            pygitversionhelper.gitversionhelper.tag.getLastTag()
+    """
+    
+    def test_defect_wrongargument_bump_type(self):
+        _v=self._test_version_readback("0.1.1",version_std="PEP440")
+        with self.assertRaises(pygitversionhelper.gitversionhelper.wrongArguments) as context:
+            pygitversionhelper.gitversionhelper.version.getCurrentVersion(bump_type="toto")
+            
+    def test_defect_wrongargument_bump_dev_strategy(self):
+        _v=self._test_version_readback("0.1.1",version_std="PEP440")
+        with self.assertRaises(pygitversionhelper.gitversionhelper.wrongArguments) as context:
+            pygitversionhelper.gitversionhelper.version.getCurrentVersion(bump_dev_strategy="toto")
+            
+            
+    
+    def tearDown(self):
+        os.chdir("/")
+    
+class Test_gitversionhelperNoRepo(unittest.TestCase):
+    def setUp(self):
+        self.TmpWorkingDir=tempfile.TemporaryDirectory()
+        self.TmpWorkingDirPath=pathlib.Path(self.TmpWorkingDir.name)
+        os.chdir(self.TmpWorkingDirPath)
+
+    def test_defect_norepo(self):
+        with self.assertRaises(pygitversionhelper.gitversionhelper.repository.notAGitRepository) as context:
+            _v = pygitversionhelper.gitversionhelper.version.getCurrentVersion()
+
+    def tearDown(self):
+        os.chdir("/")
+        
+#print(gitversionhelper.tag.getLastTag(same_branch=True))
+#print(gitversionhelper.tag.getDistanceFromLastTag(same_branch=True))
+
+#print(gitversionhelper.version.getLastVersion(same_branch=True,version_std="PEP440"))
+#print(gitversionhelper.version.getLastVersion(same_branch=True,version_std="PEP440"))
+#print(gitversionhelper.version.getLastVersion(same_branch=False,version_std="PEP440"))

test/test_test_module.py

@@ -1,32 +0,0 @@
-# pygitversionhelper (c) by chacha
-#
-# pygitversionhelper  is licensed under a
-# Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International Unported License.
-#
-# You should have received a copy of the license along with this
-# work.  If not, see <https://creativecommons.org/licenses/by-nc-sa/4.0/>.
-
-import unittest
-from io import StringIO 
-from contextlib import redirect_stdout,redirect_stderr
-
-print(__name__)
-print(__package__)
-
-from src import pygitversionhelper
-
-class Testtest_module(unittest.TestCase):
-    def test_version(self):
-        self.assertNotEqual(pygitversionhelper.__version__,"?.?.?")
-
-    def test_test_module(self):
-        
-        with redirect_stdout(StringIO()) as capted_stdout, redirect_stderr(StringIO()) as capted_stderr:
-            self.assertEqual(pygitversionhelper.test_function(41),42)
-            
-        self.assertEqual(len(capted_stderr.getvalue()),0)
-        self.assertEqual(capted_stdout.getvalue().strip(),"Hello world !")
-        self.assertEqual(len(capted_stderr.getvalue()),0)
-
-
-