add missing java lib in groovy

test: add missing unit test

Jenkinsfile

@@ -6,7 +6,12 @@
 // 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 groovy.xml.XmlUtil
+import static javax.xml.xpath.XPathConstants.*
+import javax.xml.xpath.*
+import groovy.xml.DOMBuilder
+import groovy.xml.dom.DOMCategory
+import java.math.RoundingMode
 
 // configurable settings:
 // use to send email if workflow problem
@@ -28,6 +33,10 @@ def _MkDocsWebURL            = "dabauto--mkdocs-web.dmz.chacha.home/mkdocs-web/"
 def _MkDocsWebCredentials    = "2c5b684e-3787-4b37-8aca-b3dd4a383fe2" 
 def _PypiCredentials         = "Pypi"
 
+
+def badge_coverage = addEmbeddableBadgeConfiguration(id: "coverage",   subject: "unit-test coverage")
+def badge_complexity = addEmbeddableBadgeConfiguration(id: "complexity", subject: "code complexity")
+
 // commands Helper: /!\ Made for GITEA /!\
 String determineRepoUserName() {
     return scm.getUserRemoteConfigs()[0].getUrl().tokenize('/')[3].split("\\.")[0]
@@ -63,6 +72,28 @@ String ExtractBaseVersion(inVersion) {
     return matcher[0][1]
 }
 
+int GetCoverageValue(String CoverageFilePath,String XPath)
+{ 
+  //File file = new File(CoverageFilePath)
+  //coverageReportRaw = file.getText('UTF-8')
+  coverageReportRaw = readFile(CoverageFilePath)
+  coverageReport = DOMBuilder.parse(new StringReader(coverageReportRaw), false, false)
+  coverageReportRoot = coverageReport.documentElement
+  
+  def xpath = XPathFactory.newInstance().newXPath()
+  res = xpath.evaluate(XPath,coverageReportRoot,NUMBER)
+  return res
+}
+
+int GetCoverageValue_lines_valid(String CoverageFilePath) { return GetCoverageValue(CoverageFilePath,"/coverage/@lines-valid") }
+int GetCoverageValue_lines_covered(String CoverageFilePath) { return GetCoverageValue(CoverageFilePath,"/coverage/@lines-covered") }
+int GetCoverageValue_line_rate(String CoverageFilePath) { return GetCoverageValue(CoverageFilePath,"/coverage/@line-rate") }
+int GetCoverageValue_branches_valid(String CoverageFilePath) { return GetCoverageValue(CoverageFilePath,"/coverage/@branches-valid") }
+int GetCoverageValue_branches_covered(String CoverageFilePath) { return GetCoverageValue(CoverageFilePath,"/coverage/@branches-covered") }
+int GetCoverageValue_branch_rate(String CoverageFilePath) { return GetCoverageValue(CoverageFilePath,"/coverage/@branch-rate") }
+int GetCoverageValue_branches_complexity(String CoverageFilePath) { return GetCoverageValue(CoverageFilePath,"/coverage/@branches-complexity") }
+
+
 pipeline {
 	
 	// for Docker based build (preferable)
@@ -400,6 +431,23 @@ pipeline {
                         println unit_test_full_name__html
                         unit_test_full_name__xml=findFiles(glob:  "helpers-results/unit_test_full/*.xml")[0].getName()
                         println unit_test_full_name__xml
+                        
+                        coverage_report_path = "helpers-results/unit_test_coverage/test_coverage.xml"
+                        println GetCoverageValue_lines_valid(coverage_report_path)
+                        println GetCoverageValue_lines_covered(coverage_report_path)
+                        println GetCoverageValue_line_rate(coverage_report_path)
+                        println GetCoverageValue_branches_valid(coverage_report_path)
+                        println GetCoverageValue_branches_covered(coverage_report_path)
+                        println GetCoverageValue_branch_rate(coverage_report_path)
+                        println GetCoverageValue_branches_complexity(coverage_report_path)
+                        
+                        full_rate = (GetCoverageValue_line_rate(coverage_report_path) + GetCoverageValue_branch_rate(coverage_report_path)) / 2 
+                        sz_full_rate =Float.toString(full_rate.setScale(2, RoundingMode.HALF_EVEN))
+                        badge_coverage.setStatus(sz_full_rate)
+                        
+                        complexity = GetCoverageValue_branches_complexity(coverage_report_path)
+                        sz_complexity =Float.toString(complexity.setScale(2, RoundingMode.HALF_EVEN))
+                        badge_complexity.setStatus(sz_complexity)
                     }
                 }
 			}

helpers/__main__.py

@@ -16,89 +16,93 @@ import os
 import logging
 import sys
 
-if __package__=="helpers":
+if __package__ == "helpers":
     # when calling the module from: > python -m helpers
-    from .types_check   import    types_check
-    from .quality_check import  quality_check
-    from .unit_test     import      unit_test
-    from .doc_gen       import        doc_gen
-    from .changelog_gen import  changelog_gen
-else:  
+    from .types_check import types_check
+    from .quality_check import quality_check
+    from .unit_test import unit_test
+    from .doc_gen import doc_gen
+    from .changelog_gen import changelog_gen
+else:
     # when calling the __main__.py file (from IDE)
-    from helpers.types_check import    types_check
-    from helpers.quality_check import  quality_check
-    from helpers.unit_test import      unit_test
-    from helpers.doc_gen import        doc_gen
-    from helpers.changelog_gen import  changelog_gen
-    
+    from helpers.types_check import types_check
+    from helpers.quality_check import quality_check
+    from helpers.unit_test import unit_test
+    from helpers.doc_gen import doc_gen
+    from helpers.changelog_gen import changelog_gen
+
 logging.getLogger().setLevel(logging.INFO)
 
 if __name__ == "__main__":
-    project_rootdir_path=Path(__file__).parent.parent.absolute()
+    project_rootdir_path = Path(__file__).parent.parent.absolute()
 
     with open(project_rootdir_path / "pyproject.toml", mode="rb") as fp:
         pyproject = tomli.load(fp)
-    
-    parser = argparse.ArgumentParser(   prog        = 'continuous-integration-helper',
-                                        description = 'A tiny set of scripts to help continous integration on python')
-    
-    parser.add_argument('-tc',  '--type-check',     dest='typecheck',       action='store_true',    help='enable static typing check') 
-    
-    parser.add_argument('-ut',  '--unit-test',      dest='unittest',        action='store_true',    help='enable unit-test')    
-    parser.add_argument('-cc',  '--coverage-check', dest='coveragecheck',   action='store_true',    help='enable unit-test coverage check (requires unit-test)')         
 
-    parser.add_argument('-qc',  '--quality-check',  dest='qualitycheck',    action='store_true',    help='enable code quality check') 
-    
-    parser.add_argument('-dg',  '--doc-gen',        dest='docgen',          action='store_true',    help='enable documentation generation using MkDoc') 
-    parser.add_argument('-pdf', '--doc-gen-pdf',    dest='docgenpdf',       action='store_true',    help='enable pdf documentation export (requires doc-gen)') 
-    
-    parser.add_argument('-clg', '--changelog-gen',  dest='changeloggen',    action='store_true',    help='enable changelog generation')   
-    
+    parser = argparse.ArgumentParser(
+        prog="continuous-integration-helper", description="A tiny set of scripts to help continous integration on python"
+    )
+
+    parser.add_argument("-tc", "--type-check", dest="typecheck", action="store_true", help="enable static typing check")
+
+    parser.add_argument("-ut", "--unit-test", dest="unittest", action="store_true", help="enable unit-test")
+    parser.add_argument(
+        "-cc", "--coverage-check", dest="coveragecheck", action="store_true", help="enable unit-test coverage check (requires unit-test)"
+    )
+
+    parser.add_argument("-qc", "--quality-check", dest="qualitycheck", action="store_true", help="enable code quality check")
+
+    parser.add_argument("-dg", "--doc-gen", dest="docgen", action="store_true", help="enable documentation generation using MkDoc")
+    parser.add_argument(
+        "-pdf", "--doc-gen-pdf", dest="docgenpdf", action="store_true", help="enable pdf documentation export (requires doc-gen)"
+    )
+
+    parser.add_argument("-clg", "--changelog-gen", dest="changeloggen", action="store_true", help="enable changelog generation")
+
     args = parser.parse_args()
-    
+
     ##################################
     # Dev / Debug forced toogles
     #
-    #--------------------------------
+    # --------------------------------
     #
-    #args.typecheck      = True
-    #args.qualitycheck   = True
-    #args.unittest       = True
-    #args.coveragecheck  = True
-    #args.docgen         = True
-    #args.docgenpdf      = True
-    #args.changeloggen   = True
-    
+    # args.typecheck      = True
+    # args.qualitycheck   = True
+    # args.unittest       = True
+    # args.coveragecheck  = True
+    # args.docgen         = True
+    # args.docgenpdf      = True
+    # args.changeloggen   = True
+
     helpers = []
-    if  args.typecheck == True:
+    if args.typecheck == True:
         helpers.append(types_check)
-        
-    if  args.unittest == True:
+
+    if args.unittest == True:
         helpers.append(unit_test)
-    
-    if  args.coveragecheck == True:
+
+    if args.coveragecheck == True:
         if args.unittest == True:
             unit_test.enable_coverage_check = True
         else:
             raise RuntimeError("unit-test is required to enable coverage-check")
-    
-    if  args.qualitycheck == True:
+
+    if args.qualitycheck == True:
         helpers.append(quality_check)
-        
-    if  args.docgen == True:
+
+    if args.docgen == True:
         helpers.append(doc_gen)
-    
-    if args.docgenpdf==True:
+
+    if args.docgenpdf == True:
         if args.docgen == True:
             doc_gen.enable_gen_pdf = True
         else:
             raise RuntimeError("doc-gen is required to enable doc-gen-pdf")
-        
-    if  args.changeloggen == True:
+
+    if args.changeloggen == True:
         helpers.append(changelog_gen)
-    
+
     for helper in helpers:
-        helper.set_context(project_rootdir_path,pyproject)
+        helper.set_context(project_rootdir_path, pyproject)
         helper.reset_result_dir()
         helper.do_job()
-        

helpers/changelog_gen.py

@@ -9,16 +9,15 @@
 from __future__ import annotations
 from typing import TYPE_CHECKING
 
-#from pathlib import Path
-#import os
-#import datetime
+# from pathlib import Path
+# import os
+# import datetime
 
 
 from .helper_base import helper_base
 
 
-class changelog_gen(helper_base): 
-    
-    @classmethod  
-    def do_job(cls): 
-        pass
+class changelog_gen(helper_base):
+    @classmethod
+    def do_job(cls):
+        pass

helpers/doc_gen.py

@@ -17,6 +17,7 @@ from pathlib import Path
 from distutils.dir_util import copy_tree
 
 import yaml
+
 try:
     from yaml import CLoader as Loader, CDumper as Dumper
 except ImportError:
@@ -24,35 +25,36 @@ except ImportError:
 
 from .helper_base import helper_withresults_base
 
-class doc_gen(helper_withresults_base): 
+
+class doc_gen(helper_withresults_base):
     enable_gen_pdf: bool = False
-    
-    @classmethod  
-    def do_job(cls): 
+
+    @classmethod
+    def do_job(cls):
         print(cls.project_rootdir_path)
         print()
-        
+
         # create doc root dir
-        doc_path = cls.project_rootdir_path/"docs"
+        doc_path = cls.project_rootdir_path / "docs"
         cls._reset_dir(doc_path)
-        
-        site_path = cls.get_result_dir()/"site"
+
+        site_path = cls.get_result_dir() / "site"
         cls._reset_dir(site_path)
-        
+
         # copy files from main project dir
-        shutil.copyfile(str(cls.project_rootdir_path/"README.md"),str(doc_path/"README.md"))
-        shutil.copyfile(str(cls.project_rootdir_path/"LICENSE.md"),str(doc_path/"LICENSE.md"))
-        
+        shutil.copyfile(str(cls.project_rootdir_path / "README.md"), str(doc_path / "README.md"))
+        shutil.copyfile(str(cls.project_rootdir_path / "LICENSE.md"), str(doc_path / "LICENSE.md"))
+
         # copy files from static-doc dir
-        copy_tree(str(cls.project_rootdir_path/"docs-static"),str(doc_path))
-        
+        copy_tree(str(cls.project_rootdir_path / "docs-static"), str(doc_path))
+
         # generating API doc + nav from python docstrings
         reference_path = doc_path / "reference"
         cls._reset_dir(reference_path)
-        
+
         for path in sorted((cls.project_rootdir_path / "src").rglob("*.py")):
-            module_path = path.relative_to(cls.project_rootdir_path/ "src").with_suffix("")
-            doc_path = path.relative_to(cls.project_rootdir_path/ "src").with_suffix(".md") 
+            module_path = path.relative_to(cls.project_rootdir_path / "src").with_suffix("")
+            doc_path = path.relative_to(cls.project_rootdir_path / "src").with_suffix(".md")
             full_doc_path = Path(reference_path, doc_path)
 
             parts = list(module_path.parts)
@@ -61,43 +63,44 @@ class doc_gen(helper_withresults_base):
                 parts = parts[:-1]
             elif parts[-1] == "__main__":
                 continue
-            
+
             cls._reset_dir(os.path.dirname(full_doc_path))
             with open(full_doc_path, "w+") as fd:
-                identifier = "src."+".".join(parts)
+                identifier = "src." + ".".join(parts)
                 print("::: " + identifier, file=fd)
-  
-            
-        cmdopts = [f"{sys.executable}","-m","mkdocs","-v","build","--site-dir",str(site_path),"--clean"]
-  
+
+        cmdopts = [f"{sys.executable}", "-m", "mkdocs", "-v", "build", "--site-dir", str(site_path), "--clean"]
+
         # little hack here, to enable / disable pdf generation using own class config
-        # => reason is mkdocs seems to try loading the plugin even if we disable it, so we need to 
+        # => reason is mkdocs seems to try loading the plugin even if we disable it, so we need to
         # manually process the configuration file.
-        mkdocsCfg=None
-        with open(cls.project_rootdir_path / "mkdocs.yml",'r') as mkdocsCfgFile:
+        mkdocsCfg = None
+        with open(cls.project_rootdir_path / "mkdocs.yml", "r") as mkdocsCfgFile:
             mkdocsCfg = yaml.load(mkdocsCfgFile, Loader=yaml.SafeLoader)
-            
-            if cls.enable_gen_pdf==True:
-                mkdocsCfg['plugins'].append({   'with-pdf':{
-                                                    'cover_subtitle':   'User Manual',
-                                                    'cover_logo':       str(cls.project_rootdir_path / 'docs-static' / 'Library.jpg'),
-                                                    'verbose':          False,
-                                                    'media_type':       'print',
-                                                    'exclude_pages':    ['LICENSE'],
-                                                    'output_path':      str(site_path / 'pdf' / 'manual.pdf')  
-                                            }})
+
+            if cls.enable_gen_pdf == True:
+                mkdocsCfg["plugins"].append(
+                    {
+                        "with-pdf": {
+                            "cover_subtitle": "User Manual",
+                            "cover_logo": str(cls.project_rootdir_path / "docs-static" / "Library.jpg"),
+                            "verbose": False,
+                            "media_type": "print",
+                            "exclude_pages": ["LICENSE"],
+                            "output_path": str(site_path / "pdf" / "manual.pdf"),
+                        }
+                    }
+                )
             else:
-                for subelem in mkdocsCfg['plugins']:
-                    if isinstance(subelem,dict) :
-                        if 'with-pdf' in subelem.keys():  
-                            mkdocsCfg['plugins'].remove(subelem)
-                            break          
-            
-        with open(cls.project_rootdir_path / "mkdocs.yml",'w') as mkdocsCfgFile:
-            mkdocsCfgFile.write(yaml.dump(mkdocsCfg, Dumper=Dumper,default_flow_style=False, sort_keys=False))
-            
-        
-        res=cls.run_cmd(cmdopts)
+                for subelem in mkdocsCfg["plugins"]:
+                    if isinstance(subelem, dict):
+                        if "with-pdf" in subelem.keys():
+                            mkdocsCfg["plugins"].remove(subelem)
+                            break
+
+        with open(cls.project_rootdir_path / "mkdocs.yml", "w") as mkdocsCfgFile:
+            mkdocsCfgFile.write(yaml.dump(mkdocsCfg, Dumper=Dumper, default_flow_style=False, sort_keys=False))
+
+        res = cls.run_cmd(cmdopts)
         print(res.decode())
-        print(' !! done')
-        
+        print(" !! done")

helpers/helper_base.py

@@ -9,64 +9,66 @@
 from __future__ import annotations
 from typing import TYPE_CHECKING
 
-from abc import ABC,abstractmethod
+from abc import ABC, abstractmethod
 import os
 from pathlib import Path
 import subprocess
 
 if TYPE_CHECKING:  # Only imports the below statements during type checking
-    from typing     import Union
+    from typing import Union
+
 
 class helper_base(ABC):
-    project_rootdir_path: Union[Path,None]  = None
-    pyproject: Union[dict,None]             = None
-    current_dir: Union[Path,None]           = None
-       
-    @classmethod 
-    def set_context(cls,project_rootdir_path:Path, pyproject:dict):
-        cls.project_rootdir_path    = project_rootdir_path
-        cls.pyproject               = pyproject
-        cls.current_dir             = Path(__file__).parent.absolute()
-        
-    @classmethod    
+    project_rootdir_path: Union[Path, None] = None
+    pyproject: Union[dict, None] = None
+    current_dir: Union[Path, None] = None
+
+    @classmethod
+    def set_context(cls, project_rootdir_path: Path, pyproject: dict):
+        cls.project_rootdir_path = project_rootdir_path
+        cls.pyproject = pyproject
+        cls.current_dir = Path(__file__).parent.absolute()
+
+    @classmethod
     def get_result_dir(cls):
         return None
- 
-    @staticmethod  
-    def _reset_dir(dirpath:Path):  
+
+    @staticmethod
+    def _reset_dir(dirpath: Path):
         dirpath = Path(dirpath)
         if not os.path.exists(dirpath):
             os.makedirs(dirpath)
-        [f.unlink() for f in Path(dirpath).glob("*") if f.is_file()] 
-    
-    @classmethod    
+        [f.unlink() for f in Path(dirpath).glob("*") if f.is_file()]
+
+    @classmethod
     def reset_result_dir(cls):
         result_dir = cls.get_result_dir()
         if result_dir != None:
             cls._reset_dir(result_dir)
-    
-    @classmethod 
+
+    @classmethod
     @abstractmethod
-    def do_job(cls):  
+    def do_job(cls):
         raise NotImplementedError()
 
-    @classmethod  
+    @classmethod
     def run_cmd_(cls, cmdarray):
         process = subprocess.run(cmdarray, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True, check=True)
         return process.stdout
-    
-    @classmethod  
+
+    @classmethod
     def run_cmd(cls, cmdarray):
         p = subprocess.run(cmdarray, capture_output=True)
         print(p.stdout)
         print(p.stderr)
         return p.stdout
-    
+
+
 class helper_withresults_base(helper_base):
-    helper_results_dir: Union[Path,None] = None
-        
-    @classmethod    
+    helper_results_dir: Union[Path, None] = None
+
+    @classmethod
     def get_result_dir(cls):
-        if cls.helper_results_dir==None:
-            cls.helper_results_dir=cls.__name__
-        return Path(__file__).parent.parent.absolute() / "helpers-results" / cls.helper_results_dir
+        if cls.helper_results_dir == None:
+            cls.helper_results_dir = cls.__name__
+        return Path(__file__).parent.parent.absolute() / "helpers-results" / cls.helper_results_dir

helpers/quality_check.py

@@ -25,197 +25,221 @@ import pylint_json2html
 
 from .helper_base import helper_withresults_base
 
+
 class PyLintMetricNotFound(Warning):
     pass
 
-class quality_check(helper_withresults_base): 
-    PylintMessageList=dict()
-    
-    @classmethod  
+
+class quality_check(helper_withresults_base):
+    PylintMessageList = dict()
+
+    @classmethod
     def GetPylintMessageList(cls):
-        Messagelist=dict()
-        regex = r"^:([a-zA-Z-]+) \(([^\)]+)\)"  
-        for line in cls.run_cmd([sys.executable,"-m","pylint","--list-msgs"]).splitlines():
-            if res:=re.search(regex,line.decode()):
-                Messagelist[res.group(1)]=res.group(2)
+        Messagelist = dict()
+        regex = r"^:([a-zA-Z-]+) \(([^\)]+)\)"
+        for line in cls.run_cmd([sys.executable, "-m", "pylint", "--list-msgs"]).splitlines():
+            if res := re.search(regex, line.decode()):
+                Messagelist[res.group(1)] = res.group(2)
         cls.PylintMessageList = Messagelist
 
     @staticmethod
-    def TryExtractPYReportMetric(line: str,tag: str):
-        regex=f"^(?:\|{tag}\s*\|)(\d+)(?=\s*|)"
-        if res:=re.search(regex,line):
+    def TryExtractPYReportMetric(line: str, tag: str):
+        regex = f"^(?:\|{tag}\s*\|)(\d+)(?=\s*|)"
+        if res := re.search(regex, line):
             return float(res.group(1))
         raise PyLintMetricNotFound()
 
-    @classmethod  
-    def do_job(cls):  
+    @classmethod
+    def do_job(cls):
         print("checking code quality ...")
         cls.GetPylintMessageList()
-        
-        RES_all=dict()
+
+        RES_all = dict()
         with StringIO() as StdOutput:
-            JsonContent=""
+            JsonContent = ""
             with redirect_stdout(StdOutput):
-                pylint_Run(['--output-format=json,parseable',
-                            '--disable=invalid-name',
-                            '--ignore=_version.py',
-                            '--reports=y',
-                            '--score=yes',
-                            '--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:
+                pylint_Run(
+                    [
+                        "--output-format=json,parseable",
+                        "--disable=invalid-name",
+                        "--ignore=_version.py",
+                        "--reports=y",
+                        "--score=yes",
+                        "--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:
                 # hacky way of exctracting json + having overall score...
                 class TScanState(Enum):
-                    TEXT_REPORT                 = 1
-                    JSON_REPORT                 = 2
-                    OTHER_REPORT_START          = 3
-                    OTHER_REPORT_STATISTICS     = 4
-                    OTHER_REPORT_METRICS        = 5
-                    OTHER_REPORT_DUPLICATION    = 6
-                    OTHER_REPORT_MESSAGES_CAT   = 7
-                    OTHER_REPORT_MESSAGES       = 8
-                    OTHER_REPORT_END            = 99
-                    
-                RES_all['Statistics']           = dict()
-                RES_all['RawMetrics']           = dict()
-                RES_all['RawMetricsPercent']    = dict()
-                RES_all['Duplication']          = dict()
-                RES_all['MessagesCat']          = dict()
-                RES_all['Messages']             = dict()
-                RES_all['GlobalScore']          = -999
-                RES_all['NbAnalysedStatments']  = -999
-                RES_all['NbAnalysedLines']      = -999
-                
+                    TEXT_REPORT = 1
+                    JSON_REPORT = 2
+                    OTHER_REPORT_START = 3
+                    OTHER_REPORT_STATISTICS = 4
+                    OTHER_REPORT_METRICS = 5
+                    OTHER_REPORT_DUPLICATION = 6
+                    OTHER_REPORT_MESSAGES_CAT = 7
+                    OTHER_REPORT_MESSAGES = 8
+                    OTHER_REPORT_END = 99
+
+                RES_all["Statistics"] = dict()
+                RES_all["RawMetrics"] = dict()
+                RES_all["RawMetricsPercent"] = dict()
+                RES_all["Duplication"] = dict()
+                RES_all["MessagesCat"] = dict()
+                RES_all["Messages"] = dict()
+                RES_all["GlobalScore"] = -999
+                RES_all["NbAnalysedStatments"] = -999
+                RES_all["NbAnalysedLines"] = -999
+
                 ScanState = TScanState.TEXT_REPORT
-                for line in StdOutput.getvalue().split('\n'):     
-                    print(line)                   
-                    if      ScanState == TScanState.TEXT_REPORT:
+                for line in StdOutput.getvalue().split("\n"):
+                    print(line)
+                    if ScanState == TScanState.TEXT_REPORT:
                         # ignoring this part, we need json
-                        if line=='[':
-                            JsonContent+=line
+                        if line == "[":
+                            JsonContent += line
                             ScanState = TScanState.JSON_REPORT
-                        elif line=='[]':
-                            JsonContent+=line
+                        elif line == "[]":
+                            JsonContent += line
                             ScanState = TScanState.OTHER_REPORT_START
-                            
-                    elif    ScanState == TScanState.JSON_REPORT:
-                        JsonContent+=line
-                        if line==']':
+
+                    elif ScanState == TScanState.JSON_REPORT:
+                        JsonContent += line
+                        if line == "]":
                             ScanState = TScanState.OTHER_REPORT_START
-                            
-                    elif    ScanState == TScanState.OTHER_REPORT_START:
-                        if res:=re.search(r"^(\d+)(?= statements analysed.)",line):
-                            RES_all['NbAnalysedStatments'] = float(res.group(1))
+
+                    elif ScanState == TScanState.OTHER_REPORT_START:
+                        if res := re.search(r"^(\d+)(?= statements analysed.)", line):
+                            RES_all["NbAnalysedStatments"] = float(res.group(1))
                         if line == "Statistics by type":
                             ScanState = TScanState.OTHER_REPORT_STATISTICS
-                            
-                    elif    ScanState == TScanState.OTHER_REPORT_STATISTICS:
-                        if res:=re.search(r"^(\d+)(?= lines have been analyzed)",line):
-                            RES_all['NbAnalysedLines' ]= float(res.group(1))
+
+                    elif ScanState == TScanState.OTHER_REPORT_STATISTICS:
+                        if res := re.search(r"^(\d+)(?= lines have been analyzed)", line):
+                            RES_all["NbAnalysedLines"] = float(res.group(1))
                         elif line == "Raw metrics":
                             ScanState = TScanState.OTHER_REPORT_METRICS
                         else:
-                            with suppress(PyLintMetricNotFound): RES_all['Statistics']['module']      = cls.TryExtractPYReportMetric(line,"module")
-                            with suppress(PyLintMetricNotFound): RES_all['Statistics']['class']       = cls.TryExtractPYReportMetric(line,"class")
-                            with suppress(PyLintMetricNotFound): RES_all['Statistics']['method']      = cls.TryExtractPYReportMetric(line,"method")
-                            with suppress(PyLintMetricNotFound): RES_all['Statistics']['function']    = cls.TryExtractPYReportMetric(line,"function")
-                        
-                    elif    ScanState == TScanState.OTHER_REPORT_METRICS:
+                            with suppress(PyLintMetricNotFound):
+                                RES_all["Statistics"]["module"] = cls.TryExtractPYReportMetric(line, "module")
+                            with suppress(PyLintMetricNotFound):
+                                RES_all["Statistics"]["class"] = cls.TryExtractPYReportMetric(line, "class")
+                            with suppress(PyLintMetricNotFound):
+                                RES_all["Statistics"]["method"] = cls.TryExtractPYReportMetric(line, "method")
+                            with suppress(PyLintMetricNotFound):
+                                RES_all["Statistics"]["function"] = cls.TryExtractPYReportMetric(line, "function")
+
+                    elif ScanState == TScanState.OTHER_REPORT_METRICS:
                         if line == "Duplication":
-                            RES_all['RawMetricsPercent']['code']        =  RES_all['RawMetrics']['code']        / RES_all['NbAnalysedLines' ]
-                            RES_all['RawMetricsPercent']['docstring']   =  RES_all['RawMetrics']['docstring']   / RES_all['NbAnalysedLines' ]
-                            RES_all['RawMetricsPercent']['comment']     =  RES_all['RawMetrics']['comment']     / RES_all['NbAnalysedLines' ]
-                            RES_all['RawMetricsPercent']['empty']       =  RES_all['RawMetrics']['empty']       / RES_all['NbAnalysedLines' ]
+                            RES_all["RawMetricsPercent"]["code"] = RES_all["RawMetrics"]["code"] / RES_all["NbAnalysedLines"]
+                            RES_all["RawMetricsPercent"]["docstring"] = RES_all["RawMetrics"]["docstring"] / RES_all["NbAnalysedLines"]
+                            RES_all["RawMetricsPercent"]["comment"] = RES_all["RawMetrics"]["comment"] / RES_all["NbAnalysedLines"]
+                            RES_all["RawMetricsPercent"]["empty"] = RES_all["RawMetrics"]["empty"] / RES_all["NbAnalysedLines"]
                             ScanState = TScanState.OTHER_REPORT_DUPLICATION
                         else:
-                            with suppress(PyLintMetricNotFound): RES_all['RawMetrics']['code']         = cls.TryExtractPYReportMetric(line,"code")
-                            with suppress(PyLintMetricNotFound): RES_all['RawMetrics']['docstring']    = cls.TryExtractPYReportMetric(line,"docstring")
-                            with suppress(PyLintMetricNotFound): RES_all['RawMetrics']['comment']      = cls.TryExtractPYReportMetric(line,"comment")
-                            with suppress(PyLintMetricNotFound): RES_all['RawMetrics']['empty']        = cls.TryExtractPYReportMetric(line,"empty")    
-                            
-                    elif    ScanState == TScanState.OTHER_REPORT_DUPLICATION:
+                            with suppress(PyLintMetricNotFound):
+                                RES_all["RawMetrics"]["code"] = cls.TryExtractPYReportMetric(line, "code")
+                            with suppress(PyLintMetricNotFound):
+                                RES_all["RawMetrics"]["docstring"] = cls.TryExtractPYReportMetric(line, "docstring")
+                            with suppress(PyLintMetricNotFound):
+                                RES_all["RawMetrics"]["comment"] = cls.TryExtractPYReportMetric(line, "comment")
+                            with suppress(PyLintMetricNotFound):
+                                RES_all["RawMetrics"]["empty"] = cls.TryExtractPYReportMetric(line, "empty")
+
+                    elif ScanState == TScanState.OTHER_REPORT_DUPLICATION:
                         if line == "Messages by category":
                             ScanState = TScanState.OTHER_REPORT_MESSAGES_CAT
                         else:
-                            with suppress(PyLintMetricNotFound): RES_all['Duplication']['NbDupLines']               = cls.TryExtractPYReportMetric(line,"nb duplicated lines")
-                            with suppress(PyLintMetricNotFound): RES_all['Duplication']['PersentDuplicatedLines']   = cls.TryExtractPYReportMetric(line,"percent duplicated lines")
-                            
-                    elif    ScanState == TScanState.OTHER_REPORT_MESSAGES_CAT:
+                            with suppress(PyLintMetricNotFound):
+                                RES_all["Duplication"]["NbDupLines"] = cls.TryExtractPYReportMetric(line, "nb duplicated lines")
+                            with suppress(PyLintMetricNotFound):
+                                RES_all["Duplication"]["PersentDuplicatedLines"] = cls.TryExtractPYReportMetric(
+                                    line, "percent duplicated lines"
+                                )
+
+                    elif ScanState == TScanState.OTHER_REPORT_MESSAGES_CAT:
                         if line == "Messages":
                             ScanState = TScanState.OTHER_REPORT_MESSAGES
                         else:
-                            with suppress(PyLintMetricNotFound): RES_all['MessagesCat']['Convention']              = cls.TryExtractPYReportMetric(line,"convention")
-                            with suppress(PyLintMetricNotFound): RES_all['MessagesCat']['Refactor']                = cls.TryExtractPYReportMetric(line,"refactor")
-                            with suppress(PyLintMetricNotFound): RES_all['MessagesCat']['Warning']                 = cls.TryExtractPYReportMetric(line,"warning")
-                            with suppress(PyLintMetricNotFound): RES_all['MessagesCat']['Error']                   = cls.TryExtractPYReportMetric(line,"error")
-                            
-                    elif    ScanState == TScanState.OTHER_REPORT_MESSAGES:
+                            with suppress(PyLintMetricNotFound):
+                                RES_all["MessagesCat"]["Convention"] = cls.TryExtractPYReportMetric(line, "convention")
+                            with suppress(PyLintMetricNotFound):
+                                RES_all["MessagesCat"]["Refactor"] = cls.TryExtractPYReportMetric(line, "refactor")
+                            with suppress(PyLintMetricNotFound):
+                                RES_all["MessagesCat"]["Warning"] = cls.TryExtractPYReportMetric(line, "warning")
+                            with suppress(PyLintMetricNotFound):
+                                RES_all["MessagesCat"]["Error"] = cls.TryExtractPYReportMetric(line, "error")
+
+                    elif ScanState == TScanState.OTHER_REPORT_MESSAGES:
                         # approx match because the number of '-' depend on screen width..
                         if line.startswith("--------"):
                             ScanState = TScanState.OTHER_REPORT_END
                         else:
                             for PylintMessage in cls.PylintMessageList.keys():
-                                with suppress(PyLintMetricNotFound): RES_all['Messages'][PylintMessage]            = cls.TryExtractPYReportMetric(line,PylintMessage)
-                            
-                    elif    ScanState == TScanState.OTHER_REPORT_END:
-                        if res:=re.search(r"(?<=Your code has been rated at )(\d+(?:\.\d+)?)/10",line):
-                            RES_all['GlobalScore']=float(res.group(1))
-                            print(RES_all['GlobalScore'])
+                                with suppress(PyLintMetricNotFound):
+                                    RES_all["Messages"][PylintMessage] = cls.TryExtractPYReportMetric(line, PylintMessage)
+
+                    elif ScanState == TScanState.OTHER_REPORT_END:
+                        if res := re.search(r"(?<=Your code has been rated at )(\d+(?:\.\d+)?)/10", line):
+                            RES_all["GlobalScore"] = float(res.group(1))
+                            print(RES_all["GlobalScore"])
                     else:
                         raise RuntimeError("Invalid ScanState")
                 Outfile.write(JsonContent)
-                
-        with open(cls.get_result_dir()/"metrics.json", 'w') as json_file:  
+
+        with open(cls.get_result_dir() / "metrics.json", "w") as json_file:
             json.dump(RES_all, json_file)
-  
-        # exporting all Data in one csv, unused atm because jenkins seems not able to select columns from csv an keep displaying all...  
+
+        # exporting all Data in one csv, unused atm because jenkins seems not able to select columns from csv an keep displaying all...
         # => to export a working full csv we need to a 'flat' dict (no more nested dict)
         RES_all_trim = copy.deepcopy(RES_all)
         del RES_all_trim["Messages"]
-        flat_RES_all=pandas.json_normalize(RES_all_trim, sep='_').to_dict(orient='records')[0]
-                  
-        with open(cls.get_result_dir()/"metrics.csv", 'w', newline='') as csv_file:  
-            writer = csv.DictWriter(csv_file,fieldnames=flat_RES_all.keys())
+        flat_RES_all = pandas.json_normalize(RES_all_trim, sep="_").to_dict(orient="records")[0]
+
+        with open(cls.get_result_dir() / "metrics.csv", "w", newline="") as csv_file:
+            writer = csv.DictWriter(csv_file, fieldnames=flat_RES_all.keys())
             writer.writeheader()
             writer.writerow(flat_RES_all)
-            
+
         # splited csv exports for jenkins plots: RawMetricsPercent
         RES_all_percent = RES_all["RawMetricsPercent"]
-        with open(cls.get_result_dir()/"metrics_rawpercent.csv", 'w', newline='') as csv_file:  
-            writer = csv.DictWriter(csv_file,fieldnames=RES_all_percent.keys())
+        with open(cls.get_result_dir() / "metrics_rawpercent.csv", "w", newline="") as csv_file:
+            writer = csv.DictWriter(csv_file, fieldnames=RES_all_percent.keys())
             writer.writeheader()
             writer.writerow(RES_all_percent)
 
         # splited csv exports for jenkins plots: Statistics + Duplication + NbAnalysedStatments + NbAnalysedLines
         RES_all_stats = copy.deepcopy(RES_all["Statistics"])
-        RES_all_stats["NbDupLines"]             = RES_all['Duplication']['NbDupLines']
-        RES_all_stats["PersentDuplicatedLines"] = RES_all['Duplication']['PersentDuplicatedLines'] 
-        RES_all_stats["NbAnalysedStatments"]    = RES_all['NbAnalysedStatments' ]
-        RES_all_stats["NbAnalysedLines"]        = RES_all['NbAnalysedLines' ]
-        with open(cls.get_result_dir()/"metrics_Statistics.csv", 'w', newline='') as csv_file:  
-            writer = csv.DictWriter(csv_file,fieldnames=RES_all_stats.keys())
+        RES_all_stats["NbDupLines"] = RES_all["Duplication"]["NbDupLines"]
+        RES_all_stats["PersentDuplicatedLines"] = RES_all["Duplication"]["PersentDuplicatedLines"]
+        RES_all_stats["NbAnalysedStatments"] = RES_all["NbAnalysedStatments"]
+        RES_all_stats["NbAnalysedLines"] = RES_all["NbAnalysedLines"]
+        with open(cls.get_result_dir() / "metrics_Statistics.csv", "w", newline="") as csv_file:
+            writer = csv.DictWriter(csv_file, fieldnames=RES_all_stats.keys())
             writer.writeheader()
             writer.writerow(RES_all_stats)
-            
+
         # splited csv exports for jenkins plots: Statistics + Duplication
-        RES_all_MessagesCat = RES_all['MessagesCat']
-        with open(cls.get_result_dir()/"metrics_MessagesCat.csv", 'w', newline='') as csv_file:  
-            writer = csv.DictWriter(csv_file,fieldnames=RES_all_MessagesCat.keys())
+        RES_all_MessagesCat = RES_all["MessagesCat"]
+        with open(cls.get_result_dir() / "metrics_MessagesCat.csv", "w", newline="") as csv_file:
+            writer = csv.DictWriter(csv_file, fieldnames=RES_all_MessagesCat.keys())
             writer.writeheader()
             writer.writerow(RES_all_MessagesCat)
-            
+
         # splited csv exports for jenkins plots: GlobalScore
-        RES_GlobalScore = {'GlobalScore': RES_all['GlobalScore']}
-        with open(cls.get_result_dir()/"metrics_GlobalScore.csv", 'w', newline='') as csv_file:  
-            writer = csv.DictWriter(csv_file,fieldnames=RES_GlobalScore.keys())
+        RES_GlobalScore = {"GlobalScore": RES_all["GlobalScore"]}
+        with open(cls.get_result_dir() / "metrics_GlobalScore.csv", "w", newline="") as csv_file:
+            writer = csv.DictWriter(csv_file, fieldnames=RES_GlobalScore.keys())
             writer.writeheader()
             writer.writerow(RES_GlobalScore)
-              
+
         # converting the report using pylint_json2html (/!\ internal API, but as their is no leading '_' ...)
-        with open(cls.get_result_dir()/"report.html","w+", encoding='utf-8') as Outfile:
+        with open(cls.get_result_dir() / "report.html", "w+", encoding="utf-8") as Outfile:
             raw_data = json.loads(JsonContent)
-            report=pylint_json2html.Report( raw_data)
+            report = pylint_json2html.Report(raw_data)
             Outfile.write(report.render())
-                
+
         print("Done")

helpers/types_check.py

@@ -16,36 +16,46 @@ from mypy import api
 from .helper_base import helper_withresults_base
 
 
-class types_check(helper_withresults_base): 
+class types_check(helper_withresults_base):
     JUnitReportName = "junit.xml"
-    
-    @classmethod  
-    def do_job(cls):  
+
+    @classmethod
+    def do_job(cls):
         print("checking code typing ...")
-        result = api.run([      # project path
-                                "-m",
-                                "src." + str(cls.pyproject['project']['name']),
-                                # analysis configuration
-                                "--ignore-missing-imports",
-                                "--strict-equality",
-                                # reports generation
-                                "--cobertura-xml-report",   str(cls.get_result_dir()),
-                                "--html-report",            str(cls.get_result_dir()),
-                                "--linecount-report",       str(cls.get_result_dir()),
-                                "--linecoverage-report",    str(cls.get_result_dir()),
-                                "--lineprecision-report",   str(cls.get_result_dir()),
-                                "--txt-report",             str(cls.get_result_dir()),
-                                "--xml-report",             str(cls.get_result_dir()),
-                                "--junit-xml",              str(cls.get_result_dir()) + "/" + cls.JUnitReportName
-                                ])
-        
+        result = api.run(
+            [  # project path
+                "-m",
+                "src." + str(cls.pyproject["project"]["name"]),
+                # analysis configuration
+                "--ignore-missing-imports",
+                "--strict-equality",
+                # reports generation
+                "--cobertura-xml-report",
+                str(cls.get_result_dir()),
+                "--html-report",
+                str(cls.get_result_dir()),
+                "--linecount-report",
+                str(cls.get_result_dir()),
+                "--linecoverage-report",
+                str(cls.get_result_dir()),
+                "--lineprecision-report",
+                str(cls.get_result_dir()),
+                "--txt-report",
+                str(cls.get_result_dir()),
+                "--xml-report",
+                str(cls.get_result_dir()),
+                "--junit-xml",
+                str(cls.get_result_dir()) + "/" + cls.JUnitReportName,
+            ]
+        )
+
         if result[0]:
-            print('\nType checking report:\n')
+            print("\nType checking report:\n")
             print(result[0])  # stdout
-        
+
         if result[1]:
-            print('\nError report:\n')
+            print("\nError report:\n")
             print(result[1])  # stderr
-        
-        print('\nExit status:', result[2])
-        print("Done")
+
+        print("\nExit status:", result[2])
+        print("Done")

helpers/unit_test.py

@@ -21,34 +21,36 @@ from junit2htmlreport import parser as junit2html_parser
 from .helper_base import helper_withresults_base
 
 
-class unit_test(helper_withresults_base): 
-    enable_coverage_check:  bool = False
-    enable_xml_export:      bool = True
+class unit_test(helper_withresults_base):
+    enable_coverage_check: bool = False
+    enable_xml_export: bool = True
     enable_full_xml_export: bool = True
-    FullReportName: str         = "full_report"
-    CoverageReportName: str     = "test_coverage"
-    
-    @classmethod  
-    def do_job(cls): 
-        if cls.enable_coverage_check==True:
+    FullReportName: str = "full_report"
+    CoverageReportName: str = "test_coverage"
+
+    @classmethod
+    def do_job(cls):
+        if cls.enable_coverage_check == True:
             import coverage
-        
+
         # preparing unittest framework
         test_loader = unittest.TestLoader()
-        
+
         if cls.enable_coverage_check == True:
-            #we start coverage now because module files discovery is part of the coverage measurement
-            CoverageReportPath = Path(str(cls.get_result_dir())+"_coverage")
+            # we start coverage now because module files discovery is part of the coverage measurement
+            CoverageReportPath = Path(str(cls.get_result_dir()) + "_coverage")
             cls._reset_dir(CoverageReportPath)
-            cov = coverage.Coverage(cover_pylib=False,branch=True,source_pkgs=["src."+cls.pyproject['project']['name']])
+            cov = coverage.Coverage(cover_pylib=False, branch=True, source_pkgs=["src." + cls.pyproject["project"]["name"]])
             cov.start()
-        
-        package_tests = test_loader.discover(start_dir=str(cls.project_rootdir_path / "test"),top_level_dir=str(cls.project_rootdir_path / "test"))
+
+        package_tests = test_loader.discover(
+            start_dir=str(cls.project_rootdir_path / "test"), top_level_dir=str(cls.project_rootdir_path / "test")
+        )
         if cls.enable_xml_export:
             testRunner = xmlrunner.XMLTestRunner(output=str(str(cls.get_result_dir())))
         else:
             testRunner = unittest.TextTestRunner()
-             
+
         # running the test
         testRunner.run(package_tests)
 
@@ -57,23 +59,23 @@ class unit_test(helper_withresults_base):
             cov.stop()
             cov.save()
             cov.html_report(directory=str(CoverageReportPath))
-            cov.xml_report(outfile=(CoverageReportPath/f"{cls.CoverageReportName}.xml"))
-              
+            cov.xml_report(outfile=(CoverageReportPath / f"{cls.CoverageReportName}.xml"))
+
         # computing results (Only if xml available)
         if cls.enable_full_xml_export == True:
             print("Full reports generation...")
-            FullReportPath = Path(str(cls.get_result_dir())+"_full")
+            FullReportPath = Path(str(cls.get_result_dir()) + "_full")
             cls._reset_dir(FullReportPath)
-            
+
             FullJUnitReport = JUnitXml()
-            for fname in [fname for fname in os.listdir(cls.get_result_dir()) if fname.endswith('.xml')]:
-                FullJUnitReport+=JUnitXml.fromfile(str(cls.get_result_dir() / fname))
-                
+            for fname in [fname for fname in os.listdir(cls.get_result_dir()) if fname.endswith(".xml")]:
+                FullJUnitReport += JUnitXml.fromfile(str(cls.get_result_dir() / fname))
+
             current_datetime = datetime.datetime.utcnow().strftime("%Y%m%dT%H%M%SZ")
             full_report_base_name = f'{cls.pyproject["project"]["name"]}-{cls.FullReportName}-{current_datetime}'
-            FullJUnitReport.write(str(FullReportPath / f'{full_report_base_name}.xml'))
-            report = junit2html_parser.Junit(FullReportPath/ f'{full_report_base_name}.xml')
+            FullJUnitReport.write(str(FullReportPath / f"{full_report_base_name}.xml"))
+            report = junit2html_parser.Junit(FullReportPath / f"{full_report_base_name}.xml")
             html = report.html()
-            with open(FullReportPath/ f'{full_report_base_name}.html', "wb") as outfile:
-                outfile.write(html.encode('utf-8'))
-            print("Done")
+            with open(FullReportPath / f"{full_report_base_name}.html", "wb") as outfile:
+                outfile.write(html.encode("utf-8"))
+            print("Done")

src/pygitversionhelper/__init__.py

@@ -14,8 +14,9 @@ from importlib.metadata import version, PackageNotFoundError
 
 try:  # pragma: no cover
     __version__ = version("pygitversionhelper")
-except PackageNotFoundError: # pragma: no cover
+except PackageNotFoundError:  # pragma: no cover
     import warnings
+
     warnings.warn("can not read __version__, assuming local test context, setting it to ?.?.?")
     __version__ = "?.?.?"
 

src/pygitversionhelper/gitversionhelper.py

@@ -37,9 +37,7 @@ import logging
 from packaging.version import VERSION_PATTERN as packaging_VERSION_PATTERN
 
 
-def _exec(
-    cmd: str, root: str | os.PathLike | None = None, raw: bool = False
-) -> list[str]:
+def _exec(cmd: str, root: str | os.PathLike | None = None, raw: bool = False) -> list[str]:
     """
     helper function to handle system cmd execution
     Args:
@@ -60,9 +58,9 @@ def _exec(
     )
     if re.search("not a git repository", p.stderr):
         raise gitversionhelper.repository.notAGitRepository()
-    if re.search("fatal:", p.stderr):  # pragma: nocover
+    if re.search("fatal:", p.stderr):
         raise gitversionhelper.unknownGITFatalError(p.stderr)
-    if int(p.returncode) < 0:  # pragma: nocover
+    if int(p.returncode) < 0:
         raise gitversionhelper.unknownGITError(p.stderr)
 
     if raw:
@@ -147,7 +145,7 @@ class gitversionhelper:  # pylint: disable=too-few-public-methods
         def getMessagesSinceTag(cls, tag: str, **kwargs) -> str:
             """
             retrieve a commits message history from repository
-            from LastCommit to the given tag
+            from Latest commit to the given tag
             Keyword Arguments:
                 merged_output: output one single merged string
                 same_branch(bool): force searching only in the same branch
@@ -157,23 +155,15 @@ class gitversionhelper:  # pylint: disable=too-few-public-methods
             current_commit_id = cls.getLast(**kwargs)
             tag_commit_id = cls.getFromTag(tag)
 
-            if (cls.__OptDict["same_branch"] in kwargs) and (
-                kwargs[cls.__OptDict["same_branch"]] is True
-            ):
-                commits = _exec(
-                    f"git rev-list --first-parent --ancestry-path {tag_commit_id}..{current_commit_id}"
-                )
+            if (cls.__OptDict["same_branch"] in kwargs) and (kwargs[cls.__OptDict["same_branch"]] is True):
+                commits = _exec(f"git rev-list --first-parent --ancestry-path {tag_commit_id}..{current_commit_id}")
             else:
-                commits = _exec(
-                    f"git rev-list --ancestry-path {tag_commit_id}..{current_commit_id}"
-                )
+                commits = _exec(f"git rev-list --ancestry-path {tag_commit_id}..{current_commit_id}")
             result = []
             for commit in commits:
                 result.append(cls.getMessage(commit))
 
-            if (cls.__OptDict["merged_output"] in kwargs) and (
-                kwargs[cls.__OptDict["merged_output"]] is True
-            ):
+            if (cls.__OptDict["merged_output"] in kwargs) and (kwargs[cls.__OptDict["merged_output"]] is True):
                 print("JOIN")
                 return os.linesep.join(result)
             return result
@@ -224,19 +214,13 @@ class gitversionhelper:  # pylint: disable=too-few-public-methods
             Returns:
                 the commit Id
             """
-            if (cls.__OptDict["same_branch"] in kwargs) and (
-                kwargs[cls.__OptDict["same_branch"]] is True
-            ):
+            if (cls.__OptDict["same_branch"] in kwargs) and (kwargs[cls.__OptDict["same_branch"]] is True):
                 try:
                     res = _exec("git rev-parse HEAD")
                 except gitversionhelper.unknownGITFatalError as _e:
-                    raise cls.commitNotFound(
-                        "no commit found in commit history"
-                    ) from _e
+                    raise cls.commitNotFound("no commit found in commit history") from _e
             else:
-                res = _exec(
-                    'git for-each-ref --sort=-committerdate refs/heads/ --count 1 --format="%(objectname)"'
-                )
+                res = _exec('git for-each-ref --sort=-committerdate refs/heads/ --count 1 --format="%(objectname)"')
 
             if len(res) == 0:
                 raise cls.commitNotFound("no commit found in commit history")
@@ -286,29 +270,21 @@ class gitversionhelper:  # pylint: disable=too-few-public-methods
             if sort not in cls.__validGitTagSort:
                 raise gitversionhelper.wrongArguments("sort option not in allowed list")
 
-            if (cls.__OptDict["same_branch"] in kwargs) and (
-                kwargs[cls.__OptDict["same_branch"]] is True
-            ):
+            if (cls.__OptDict["same_branch"] in kwargs) and (kwargs[cls.__OptDict["same_branch"]] is True):
                 currentBranch = _exec("git rev-parse --abbrev-ref HEAD")
-                return list(
-                    reversed(
-                        _exec(f"git tag --merged {currentBranch[0]} --sort={sort}")
-                    )
-                )
+                return list(reversed(_exec(f"git tag --merged {currentBranch[0]} --sort={sort}")))
             return list(reversed(_exec(f"git tag -l --sort={sort}")))
 
         @classmethod
         def getLastTag(cls, **kwargs) -> str | None:
             """
-            retrieve the last tag from a repository
+            retrieve the Latest tag from a repository
             Keyword Arguments:
                 same_branch(bool): force searching only in the same branch
             Returns:
                 the tag
             """
-            if (cls.__OptDict["same_branch"] in kwargs) and (
-                kwargs[cls.__OptDict["same_branch"]] is True
-            ):
+            if (cls.__OptDict["same_branch"] in kwargs) and (kwargs[cls.__OptDict["same_branch"]] is True):
                 res = _exec("git describe --tags --first-parent --abbrev=0")
             else:
                 res = _exec("git rev-list --tags --date-order --max-count=1")
@@ -317,14 +293,14 @@ class gitversionhelper:  # pylint: disable=too-few-public-methods
 
             if len(res) == 0:
                 raise cls.tagNotFound("no tag found in commit history")
-            if len(res) != 1:  # pragma: nocover
+            if len(res) != 1:
                 raise cls.moreThanOneTag("multiple tags on same commit is unsupported")
             return res[0]
 
         @classmethod
         def getDistanceFromTag(cls, tag: str = None, **kwargs) -> int:
             """
-            retrieve the distance between HEAD and tag in the repository
+            retrieve the distance between Latest commit and tag in the repository
             Arguments:
                 tag: reference tag, if None the most recent one will be used
             Keyword Arguments:
@@ -428,15 +404,10 @@ class gitversionhelper:  # pylint: disable=too-few-public-methods
                 """
                 BumpDevStrategy = cls.DefaultBumpDevStrategy
                 if cls.__OptDict["bump_dev_strategy"] in kwargs:
-                    if (
-                        kwargs[cls.__OptDict["bump_dev_strategy"]]
-                        in cls.BumpDevStrategys
-                    ):
+                    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"
-                        )
+                        raise gitversionhelper.wrongArguments(f"invalid {cls.__OptDict['bump_type']} requested")
                 return BumpDevStrategy
 
             @classmethod
@@ -453,14 +424,10 @@ class gitversionhelper:  # pylint: disable=too-few-public-methods
                     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"
-                        )
+                        raise gitversionhelper.wrongArguments(f"invalid {cls.__OptDict['bump_type']} requested")
                 return BumpType
 
-            def bump(
-                self, amount: int = 1, **kwargs
-            ) -> gitversionhelper.version.MetaVersion | str:  # pylint: disable=R0912
+            def bump(self, amount: int = 1, **kwargs) -> gitversionhelper.version.MetaVersion | str:  # pylint: disable=R0912
                 """
                 bump the version to the next one
                 Keyword Arguments:
@@ -508,9 +475,7 @@ class gitversionhelper:  # pylint: disable=too-few-public-methods
                     _v.post_count = 0
                 _v.raw = _v.doFormatVersion(**kwargs)
 
-                if (self.__OptDict["formated_output"] in kwargs) and (
-                    kwargs[self.__OptDict["formated_output"]] is True
-                ):
+                if (self.__OptDict["formated_output"] in kwargs) and (kwargs[self.__OptDict["formated_output"]] is True):
                     return _v.doFormatVersion(**kwargs)
                 return _v
 
@@ -538,9 +503,7 @@ class gitversionhelper:  # pylint: disable=too-few-public-methods
                 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"
-                    )
+                    raise gitversionhelper.wrongArguments(f"invalid {cls.__OptDict['version_std']} requested")
             return VersionStd
 
         @classmethod
@@ -557,10 +520,7 @@ class gitversionhelper:  # pylint: disable=too-few-public-methods
                 the last version
             """
             if gitversionhelper.repository.isDirty() is not False:
-                raise gitversionhelper.repository.repositoryDirty(
-                    "The repository is dirty and a current version"
-                    " can not be generated."
-                )
+                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"]
@@ -571,9 +531,7 @@ class gitversionhelper:  # pylint: disable=too-few-public-methods
                 amount = gitversionhelper.tag.getDistanceFromTag(_v.raw, **kwargs)
                 _v = _v.bump(amount, **saved_kwargs)
 
-            if (cls.__OptDict["formated_output"] in kwargs) and (
-                kwargs[cls.__OptDict["formated_output"]] is True
-            ):
+            if (cls.__OptDict["formated_output"] in kwargs) and (kwargs[cls.__OptDict["formated_output"]] is True):
                 return _v.doFormatVersion(**kwargs)
             return _v
 
@@ -583,7 +541,7 @@ class gitversionhelper:  # pylint: disable=too-few-public-methods
             Same as getCurrentVersion() with formated_output kwarg activated
             """
             kwargs["formated_output"] = True
-            return cls.getCurrentVersion(kwargs)
+            return cls.getCurrentVersion(**kwargs)
 
         @classmethod
         def _parseTag(cls, tag, **kwargs):  # pylint: disable=R0914, R0912, R0915
@@ -618,31 +576,21 @@ class gitversionhelper:  # pylint: disable=too-few-public-methods
 
                     pre_count = 0
                     if _pre := _m.group("prerelease"):
-                        if (
-                            _match := re.search(
-                                cls.VersionStds["SemVer"]["regex_preversion_num"], _pre
-                            )
-                        ) is not None:
+                        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:
+                        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)
-            ):
+            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,
@@ -663,22 +611,14 @@ class gitversionhelper:  # pylint: disable=too-few-public-methods
                     VersionStd = "PEP440"
 
             if not bFound:
-                raise gitversionhelper.version.noValidVersion(
-                    "no valid version found in tags"
-                )
+                raise gitversionhelper.version.noValidVersion("no valid version found in tags")
 
             if pre_count > 0 and post_count > 0:
-                raise cls.PreAndPostVersionUnsupported(
-                    "can not parse a version with both pre" " and post release number."
-                )
-            return cls.MetaVersion(
-                VersionStd, major, minor, patch, pre_count, post_count, tag
-            )
+                raise cls.PreAndPostVersionUnsupported("can not parse a version with both pre and post release number.")
+            return cls.MetaVersion(VersionStd, major, minor, patch, pre_count, post_count, tag)
 
         @classmethod
-        def getLastVersion(
-            cls, **kwargs
-        ) -> MetaVersion | str:  # pylint: disable=R0914, R0912, R0915
+        def getLastVersion(cls, **kwargs) -> MetaVersion | str:  # pylint: disable=R0914, R0912, R0915
             """get the last version from tags
             Keyword Arguments:
                 version_std(str): the given version_std (can be None)
@@ -700,9 +640,7 @@ class gitversionhelper:  # pylint: disable=too-few-public-methods
             try:
                 _v = cls._parseTag(lastTag, **kwargs)
             except gitversionhelper.version.noValidVersion as _ex:
-                if (cls.__OptDict["ignore_unknown_tags"] in kwargs) and (
-                    kwargs[cls.__OptDict["ignore_unknown_tags"]] is True
-                ):
+                if (cls.__OptDict["ignore_unknown_tags"] in kwargs) and (kwargs[cls.__OptDict["ignore_unknown_tags"]] is True):
                     tags = gitversionhelper.tag.getTags(sort="taggerdate", **kwargs)
                     _v = None
                     for _tag in tags:
@@ -714,9 +652,7 @@ class gitversionhelper:  # pylint: disable=too-few-public-methods
                 if _v is None:
                     raise gitversionhelper.version.noValidVersion() from _ex
 
-            if (cls.__OptDict["formated_output"] in kwargs) and (
-                kwargs[cls.__OptDict["formated_output"]] is True
-            ):
+            if (cls.__OptDict["formated_output"] in kwargs) and (kwargs[cls.__OptDict["formated_output"]] is True):
                 return _v.doFormatVersion(**kwargs)
             return _v
 
@@ -750,8 +686,7 @@ class gitversionhelper:  # pylint: disable=too-few-public-methods
                 OutputFormat = "{major}.{minor}.{patch}{revpattern}{revcount}"
                 if post_count > 0 and pre_count > 0:
                     raise gitversionhelper.version.PreAndPostVersionUnsupported(
-                        "cannot output a version with both pre "
-                        "and post release number."
+                        "cannot output a version with both pre and post release number."
                     )
                 if VersionStd == "PEP440":
                     if post_count > 0:

test/test_gitversionhelper.py

@@ -40,9 +40,7 @@ class Test_gitversionhelper(unittest.TestCase):
 
         _v = pygitversionhelper.gitversionhelper.version.getLastVersion(**kwargs)
 
-        self.assertIsInstance(
-            _v, pygitversionhelper.gitversionhelper.version.MetaVersion
-        )
+        self.assertIsInstance(_v, pygitversionhelper.gitversionhelper.version.MetaVersion)
         self.assertIsInstance(_v.raw, str)
         self.assertEqual(_v.raw, tag)
         self.assertIsInstance(_v.major, int)
@@ -73,9 +71,7 @@ class Test_gitversionhelper(unittest.TestCase):
         self._test_version_format(_v, tag, **kwargs)
 
     def test_nominal__version__formated_output(self):
-        _v = pygitversionhelper.gitversionhelper.version.MetaVersion(
-            "PEP440", 1, 0, 0, 0, 0, "1.0.0"
-        )
+        _v = pygitversionhelper.gitversionhelper.version.MetaVersion("PEP440", 1, 0, 0, 0, 0, "1.0.0")
         self.assertEqual("1.0.1", _v.bump(formated_output=True))
         self.assertEqual("2.0.0", _v.bump(formated_output=True, bump_type="major"))
 
@@ -302,6 +298,8 @@ class Test_gitversionhelper(unittest.TestCase):
         self.assertEqual(_v.pre_count, 0)
         self.assertEqual(_v.post_count, 2)
         self.assertEqual(_v.doFormatVersion(), "2.1.2+post.2")
+        self.assertEqual(_v.doFormatVersion(version_std="SemVer"), "2.1.2+post.2")
+        self.assertEqual(_v.doFormatVersion(version_std="PEP440"), "2.1.2.post2")
 
         _v = _v.bump(bump_type="patch")
         self.assertEqual(_v.raw, "2.1.3")
@@ -507,13 +505,9 @@ class Test_gitversionhelper(unittest.TestCase):
         os.system("git add .")
         os.system('git commit -m  "first commit"')
 
-        _v = pygitversionhelper.gitversionhelper.version.getLastVersion(
-            version_std="PEP440"
-        )
+        _v = pygitversionhelper.gitversionhelper.version.getLastVersion(version_std="PEP440")
 
-        self.assertIsInstance(
-            _v, pygitversionhelper.gitversionhelper.version.MetaVersion
-        )
+        self.assertIsInstance(_v, pygitversionhelper.gitversionhelper.version.MetaVersion)
         self._test_version_format(_v, "0.1.0", version_std="PEP440")
         self.assertEqual(_v.raw, "0.1.0")
         self.assertEqual(_v.major, 0)
@@ -527,13 +521,9 @@ class Test_gitversionhelper(unittest.TestCase):
         os.system("git add .")
         os.system('git commit -m  "first commit"')
 
-        _v = pygitversionhelper.gitversionhelper.version.getLastVersion(
-            version_std="SemVer"
-        )
+        _v = pygitversionhelper.gitversionhelper.version.getLastVersion(version_std="SemVer")
 
-        self.assertIsInstance(
-            _v, pygitversionhelper.gitversionhelper.version.MetaVersion
-        )
+        self.assertIsInstance(_v, pygitversionhelper.gitversionhelper.version.MetaVersion)
         self._test_version_format(_v, "0.1.0", version_std="SemVer")
         self.assertEqual(_v.raw, "0.1.0")
         self.assertEqual(_v.major, 0)
@@ -549,15 +539,22 @@ class Test_gitversionhelper(unittest.TestCase):
 
         _v = pygitversionhelper.gitversionhelper.version.getLastVersion()
 
-        self.assertIsInstance(
-            _v, pygitversionhelper.gitversionhelper.version.MetaVersion
-        )
+        self.assertIsInstance(_v, pygitversionhelper.gitversionhelper.version.MetaVersion)
         self._test_version_format(_v, "0.1.0")
         self.assertEqual(_v.raw, "0.1.0")
         self.assertEqual(_v.major, 0)
         self.assertEqual(_v.minor, 1)
         self.assertEqual(_v.patch, 0)
 
+    def test_nominal__version___getCurrentFormatedVersion(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")
+
+        self.assertEqual(pygitversionhelper.gitversionhelper.version.getCurrentFormatedVersion(), "0.2.0")
+
     def test_nominal__version___AUTO_bump_commits(self):
         with open("demofile.txt", "w+t") as tmpFile:
             tmpFile.write("testvalue")
@@ -567,9 +564,7 @@ class Test_gitversionhelper(unittest.TestCase):
 
         _v = pygitversionhelper.gitversionhelper.version.getCurrentVersion()
 
-        self.assertIsInstance(
-            _v, pygitversionhelper.gitversionhelper.version.MetaVersion
-        )
+        self.assertIsInstance(_v, pygitversionhelper.gitversionhelper.version.MetaVersion)
         self._test_version_format(_v, "0.2.0")
         self.assertEqual(_v.raw, "0.2.0")
         self.assertEqual(_v.major, 0)
@@ -585,9 +580,7 @@ class Test_gitversionhelper(unittest.TestCase):
 
         _v = pygitversionhelper.gitversionhelper.version.getCurrentVersion()
 
-        self.assertIsInstance(
-            _v, pygitversionhelper.gitversionhelper.version.MetaVersion
-        )
+        self.assertIsInstance(_v, pygitversionhelper.gitversionhelper.version.MetaVersion)
         self._test_version_format(_v, "0.2.1")
         self.assertEqual(_v.raw, "0.2.1")
         self.assertEqual(_v.major, 0)
@@ -608,9 +601,7 @@ class Test_gitversionhelper(unittest.TestCase):
 
         _v = pygitversionhelper.gitversionhelper.version.getCurrentVersion()
 
-        self.assertIsInstance(
-            _v, pygitversionhelper.gitversionhelper.version.MetaVersion
-        )
+        self.assertIsInstance(_v, pygitversionhelper.gitversionhelper.version.MetaVersion)
         self._test_version_format(_v, "0.2.3")
         self.assertEqual(_v.raw, "0.2.3")
         self.assertEqual(_v.major, 0)
@@ -624,13 +615,9 @@ class Test_gitversionhelper(unittest.TestCase):
         os.system("git add .")
         os.system('git commit -m  "5th commit"')
 
-        _v = pygitversionhelper.gitversionhelper.version.getCurrentVersion(
-            bump_type="dev"
-        )
+        _v = pygitversionhelper.gitversionhelper.version.getCurrentVersion(bump_type="dev")
 
-        self.assertIsInstance(
-            _v, pygitversionhelper.gitversionhelper.version.MetaVersion
-        )
+        self.assertIsInstance(_v, pygitversionhelper.gitversionhelper.version.MetaVersion)
         self.assertIsInstance(_v.raw, str)
         self._test_version_format(_v, "0.2.0+post.4")
         self.assertEqual(_v.raw, "0.2.0+post.4")
@@ -640,13 +627,9 @@ class Test_gitversionhelper(unittest.TestCase):
         self.assertEqual(_v.pre_count, 0)
         self.assertEqual(_v.post_count, 4)
 
-        _v = pygitversionhelper.gitversionhelper.version.getCurrentVersion(
-            bump_type="dev", bump_dev_strategy="pre-patch"
-        )
+        _v = pygitversionhelper.gitversionhelper.version.getCurrentVersion(bump_type="dev", bump_dev_strategy="pre-patch")
 
-        self.assertIsInstance(
-            _v, pygitversionhelper.gitversionhelper.version.MetaVersion
-        )
+        self.assertIsInstance(_v, pygitversionhelper.gitversionhelper.version.MetaVersion)
         self._test_version_format(_v, "0.2.1-pre.4")
         self.assertEqual(_v.raw, "0.2.1-pre.4")
         self.assertEqual(_v.major, 0)
@@ -655,13 +638,9 @@ class Test_gitversionhelper(unittest.TestCase):
         self.assertEqual(_v.pre_count, 4)
         self.assertEqual(_v.post_count, 0)
 
-        _v = pygitversionhelper.gitversionhelper.version.getCurrentVersion(
-            bump_type="dev", bump_dev_strategy="pre-minor"
-        )
+        _v = pygitversionhelper.gitversionhelper.version.getCurrentVersion(bump_type="dev", bump_dev_strategy="pre-minor")
 
-        self.assertIsInstance(
-            _v, pygitversionhelper.gitversionhelper.version.MetaVersion
-        )
+        self.assertIsInstance(_v, pygitversionhelper.gitversionhelper.version.MetaVersion)
         self._test_version_format(_v, "0.3.0-pre.4")
         self.assertEqual(_v.raw, "0.3.0-pre.4")
         self.assertEqual(_v.major, 0)
@@ -670,13 +649,9 @@ class Test_gitversionhelper(unittest.TestCase):
         self.assertEqual(_v.pre_count, 4)
         self.assertEqual(_v.post_count, 0)
 
-        _v = pygitversionhelper.gitversionhelper.version.getCurrentVersion(
-            bump_type="dev", bump_dev_strategy="pre-major"
-        )
+        _v = pygitversionhelper.gitversionhelper.version.getCurrentVersion(bump_type="dev", bump_dev_strategy="pre-major")
 
-        self.assertIsInstance(
-            _v, pygitversionhelper.gitversionhelper.version.MetaVersion
-        )
+        self.assertIsInstance(_v, pygitversionhelper.gitversionhelper.version.MetaVersion)
         self._test_version_format(_v, "1.0.0-pre.4")
         self.assertEqual(_v.raw, "1.0.0-pre.4")
         self.assertEqual(_v.major, 1)
@@ -701,9 +676,9 @@ class Test_gitversionhelper(unittest.TestCase):
 
         self.assertEqual(
             "V_1_0",
-            pygitversionhelper.gitversionhelper.version.getCurrentVersion(
-                bump_type="dev", bump_dev_strategy="pre-major"
-            ).doFormatVersion(output_format="V_{major}_{minor}"),
+            pygitversionhelper.gitversionhelper.version.getCurrentVersion(bump_type="dev", bump_dev_strategy="pre-major").doFormatVersion(
+                output_format="V_{major}_{minor}"
+            ),
         )
         self.assertEqual(
             "V_1_0",
@@ -714,12 +689,16 @@ class Test_gitversionhelper(unittest.TestCase):
                 formated_output=True,
             ),
         )
+        self.assertEqual(
+            "0.1.1",
+            pygitversionhelper.gitversionhelper.version.getLastVersion(
+                formated_output=True,
+            ),
+        )
 
     def test_nominal__git__emptyrepo(self):
         _v = pygitversionhelper.gitversionhelper.version.getCurrentVersion()
-        self.assertIsInstance(
-            _v, pygitversionhelper.gitversionhelper.version.MetaVersion
-        )
+        self.assertIsInstance(_v, pygitversionhelper.gitversionhelper.version.MetaVersion)
         self._test_version_format(_v, "0.1.0")
         self.assertEqual(_v.raw, "0.1.0")
 
@@ -735,32 +714,20 @@ class Test_gitversionhelper(unittest.TestCase):
         with open("demofile.txt", "w+t") as tmpFile:
             tmpFile.write("testvalue225")
 
-        with self.assertRaises(
-            pygitversionhelper.gitversionhelper.repository.repositoryDirty
-        ):
+        with self.assertRaises(pygitversionhelper.gitversionhelper.repository.repositoryDirty):
             pygitversionhelper.gitversionhelper.version.getCurrentVersion()
 
     def test_defect__version_post_and_pre_output(self):
-        _v = pygitversionhelper.gitversionhelper.version.MetaVersion(
-            "PEP440", 0, 0, 1, 1, 1, "0.0.1.pre1.post1"
-        )
-        with self.assertRaises(
-            pygitversionhelper.gitversionhelper.version.PreAndPostVersionUnsupported
-        ):
+        _v = pygitversionhelper.gitversionhelper.version.MetaVersion("PEP440", 0, 0, 1, 1, 1, "0.0.1.pre1.post1")
+        with self.assertRaises(pygitversionhelper.gitversionhelper.version.PreAndPostVersionUnsupported):
             _v.doFormatVersion()
 
-        _v = pygitversionhelper.gitversionhelper.version.MetaVersion(
-            "SemVer", 0, 0, 1, 1, 1, "0.0.1-pre.1+post.1"
-        )
-        with self.assertRaises(
-            pygitversionhelper.gitversionhelper.version.PreAndPostVersionUnsupported
-        ):
+        _v = pygitversionhelper.gitversionhelper.version.MetaVersion("SemVer", 0, 0, 1, 1, 1, "0.0.1-pre.1+post.1")
+        with self.assertRaises(pygitversionhelper.gitversionhelper.version.PreAndPostVersionUnsupported):
             _v.doFormatVersion()
 
     def test_defect__version_post_and_pre_parse(self):
-        with self.assertRaises(
-            pygitversionhelper.gitversionhelper.version.PreAndPostVersionUnsupported
-        ):
+        with self.assertRaises(pygitversionhelper.gitversionhelper.version.PreAndPostVersionUnsupported):
             pygitversionhelper.gitversionhelper.version._parseTag("0.0.1.pre1.post1")
 
     def test_defect__git__wrongargument_sortargs(self):
@@ -790,16 +757,12 @@ class Test_gitversionhelper(unittest.TestCase):
     def test_defect__wrongargument_bump_type(self):
         _v = self._test_version_readback("0.1.1", version_std="PEP440")
         with self.assertRaises(pygitversionhelper.gitversionhelper.wrongArguments):
-            pygitversionhelper.gitversionhelper.version.getCurrentVersion(
-                bump_type="toto"
-            )
+            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):
-            pygitversionhelper.gitversionhelper.version.getCurrentVersion(
-                bump_dev_strategy="toto"
-            )
+            pygitversionhelper.gitversionhelper.version.getCurrentVersion(bump_dev_strategy="toto")
 
     def test_nominal__tag__getDistanceFromTag(self):
         with open("demofile.txt", "w+t") as tmpFile:
@@ -829,12 +792,8 @@ class Test_gitversionhelper(unittest.TestCase):
         os.system("git add .")
         os.system('git commit -m  "commit"')
 
-        self.assertEqual(
-            2, pygitversionhelper.gitversionhelper.tag.getDistanceFromTag()
-        )
-        self.assertEqual(
-            4, pygitversionhelper.gitversionhelper.tag.getDistanceFromTag("0.2.0")
-        )
+        self.assertEqual(2, pygitversionhelper.gitversionhelper.tag.getDistanceFromTag())
+        self.assertEqual(4, pygitversionhelper.gitversionhelper.tag.getDistanceFromTag("0.2.0"))
 
     def test_nominal__tag__getTags(self):
         with open("demofile.txt", "w+t") as tmpFile:
@@ -1028,12 +987,8 @@ class Test_gitversionhelper(unittest.TestCase):
         print("===")
         """
 
-        _v = pygitversionhelper.gitversionhelper.version.getLastVersion(
-            version_std="PEP440"
-        )
-        self.assertIsInstance(
-            _v, pygitversionhelper.gitversionhelper.version.MetaVersion
-        )
+        _v = pygitversionhelper.gitversionhelper.version.getLastVersion(version_std="PEP440")
+        self.assertIsInstance(_v, pygitversionhelper.gitversionhelper.version.MetaVersion)
         self._test_version_format(_v, "0.2.0", version_std="PEP440")
         self.assertEqual(_v.raw, "0.2.0")
         self.assertEqual(_v.major, 0)
@@ -1046,12 +1001,8 @@ class Test_gitversionhelper(unittest.TestCase):
         os.system('git commit -m  "3rd commit"')
         os.system(f"git tag 0.3.0")
 
-        _v = pygitversionhelper.gitversionhelper.version.getLastVersion(
-            version_std="PEP440"
-        )
-        self.assertIsInstance(
-            _v, pygitversionhelper.gitversionhelper.version.MetaVersion
-        )
+        _v = pygitversionhelper.gitversionhelper.version.getLastVersion(version_std="PEP440")
+        self.assertIsInstance(_v, pygitversionhelper.gitversionhelper.version.MetaVersion)
         self._test_version_format(_v, "0.3.0", version_std="PEP440")
         self.assertEqual(_v.raw, "0.3.0")
         self.assertEqual(_v.major, 0)
@@ -1060,24 +1011,16 @@ class Test_gitversionhelper(unittest.TestCase):
 
         os.system("git switch master")
 
-        _v = pygitversionhelper.gitversionhelper.version.getLastVersion(
-            version_std="PEP440"
-        )
-        self.assertIsInstance(
-            _v, pygitversionhelper.gitversionhelper.version.MetaVersion
-        )
+        _v = pygitversionhelper.gitversionhelper.version.getLastVersion(version_std="PEP440")
+        self.assertIsInstance(_v, pygitversionhelper.gitversionhelper.version.MetaVersion)
         self._test_version_format(_v, "0.3.0", version_std="PEP440")
         self.assertEqual(_v.raw, "0.3.0")
         self.assertEqual(_v.major, 0)
         self.assertEqual(_v.minor, 3)
         self.assertEqual(_v.patch, 0)
 
-        _v = pygitversionhelper.gitversionhelper.version.getLastVersion(
-            version_std="PEP440", same_branch=True
-        )
-        self.assertIsInstance(
-            _v, pygitversionhelper.gitversionhelper.version.MetaVersion
-        )
+        _v = pygitversionhelper.gitversionhelper.version.getLastVersion(version_std="PEP440", same_branch=True)
+        self.assertIsInstance(_v, pygitversionhelper.gitversionhelper.version.MetaVersion)
         self._test_version_format(_v, "0.1.0", version_std="PEP440")
         self.assertEqual(_v.raw, "0.1.0")
         self.assertEqual(_v.major, 0)
@@ -1086,24 +1029,16 @@ class Test_gitversionhelper(unittest.TestCase):
 
         os.system('git merge --no-ff dev -m "merge dev into master"')
 
-        _v = pygitversionhelper.gitversionhelper.version.getLastVersion(
-            version_std="PEP440", same_branch=True
-        )
-        self.assertIsInstance(
-            _v, pygitversionhelper.gitversionhelper.version.MetaVersion
-        )
+        _v = pygitversionhelper.gitversionhelper.version.getLastVersion(version_std="PEP440", same_branch=True)
+        self.assertIsInstance(_v, pygitversionhelper.gitversionhelper.version.MetaVersion)
         self._test_version_format(_v, "0.1.0", version_std="PEP440")
         self.assertEqual(_v.raw, "0.1.0")
         self.assertEqual(_v.major, 0)
         self.assertEqual(_v.minor, 1)
         self.assertEqual(_v.patch, 0)
 
-        _v = pygitversionhelper.gitversionhelper.version.getLastVersion(
-            version_std="PEP440"
-        )
-        self.assertIsInstance(
-            _v, pygitversionhelper.gitversionhelper.version.MetaVersion
-        )
+        _v = pygitversionhelper.gitversionhelper.version.getLastVersion(version_std="PEP440")
+        self.assertIsInstance(_v, pygitversionhelper.gitversionhelper.version.MetaVersion)
         self._test_version_format(_v, "0.3.0", version_std="PEP440")
         self.assertEqual(_v.raw, "0.3.0")
         self.assertEqual(_v.major, 0)
@@ -1112,24 +1047,16 @@ class Test_gitversionhelper(unittest.TestCase):
 
         os.system(f"git tag 0.4.0")
 
-        _v = pygitversionhelper.gitversionhelper.version.getLastVersion(
-            version_std="PEP440", same_branch=True
-        )
-        self.assertIsInstance(
-            _v, pygitversionhelper.gitversionhelper.version.MetaVersion
-        )
+        _v = pygitversionhelper.gitversionhelper.version.getLastVersion(version_std="PEP440", same_branch=True)
+        self.assertIsInstance(_v, pygitversionhelper.gitversionhelper.version.MetaVersion)
         self._test_version_format(_v, "0.4.0", version_std="PEP440")
         self.assertEqual(_v.raw, "0.4.0")
         self.assertEqual(_v.major, 0)
         self.assertEqual(_v.minor, 4)
         self.assertEqual(_v.patch, 0)
 
-        _v = pygitversionhelper.gitversionhelper.version.getLastVersion(
-            version_std="PEP440"
-        )
-        self.assertIsInstance(
-            _v, pygitversionhelper.gitversionhelper.version.MetaVersion
-        )
+        _v = pygitversionhelper.gitversionhelper.version.getLastVersion(version_std="PEP440")
+        self.assertIsInstance(_v, pygitversionhelper.gitversionhelper.version.MetaVersion)
         self._test_version_format(_v, "0.4.0", version_std="PEP440")
         self.assertEqual(_v.raw, "0.4.0")
         self.assertEqual(_v.major, 0)
@@ -1143,17 +1070,11 @@ class Test_gitversionhelper(unittest.TestCase):
         os.system('git commit -m  "2nd commit"')
         os.system(f"git tag INVALIDTAG")
 
-        with self.assertRaises(
-            pygitversionhelper.gitversionhelper.version.noValidVersion
-        ):
+        with self.assertRaises(pygitversionhelper.gitversionhelper.version.noValidVersion):
             _v = pygitversionhelper.gitversionhelper.version.getLastVersion()
 
-        with self.assertRaises(
-            pygitversionhelper.gitversionhelper.version.noValidVersion
-        ):
-            _v = pygitversionhelper.gitversionhelper.version.getLastVersion(
-                ignore_unknown_tags=True
-            )
+        with self.assertRaises(pygitversionhelper.gitversionhelper.version.noValidVersion):
+            _v = pygitversionhelper.gitversionhelper.version.getLastVersion(ignore_unknown_tags=True)
 
     def test_defect__tag__invalidtag_inbetween(self):
         with open("demofile.txt", "w+t") as tmpFile:
@@ -1168,17 +1089,11 @@ class Test_gitversionhelper(unittest.TestCase):
         os.system('git commit -m  "commit"')
         os.system(f"git tag INVALIDTAG")
 
-        with self.assertRaises(
-            pygitversionhelper.gitversionhelper.version.noValidVersion
-        ):
+        with self.assertRaises(pygitversionhelper.gitversionhelper.version.noValidVersion):
             _v = pygitversionhelper.gitversionhelper.version.getLastVersion()
 
-        _v = pygitversionhelper.gitversionhelper.version.getLastVersion(
-            ignore_unknown_tags=True
-        )
-        self.assertIsInstance(
-            _v, pygitversionhelper.gitversionhelper.version.MetaVersion
-        )
+        _v = pygitversionhelper.gitversionhelper.version.getLastVersion(ignore_unknown_tags=True)
+        self.assertIsInstance(_v, pygitversionhelper.gitversionhelper.version.MetaVersion)
         self._test_version_format(_v, "0.0.1", version_std="PEP440")
         self.assertEqual(_v.raw, "0.0.1")
         self.assertEqual(_v.major, 0)
@@ -1203,17 +1118,11 @@ class Test_gitversionhelper(unittest.TestCase):
         os.system('git commit -m  "commit"')
         os.system(f"git tag INVALIDTA4")
 
-        with self.assertRaises(
-            pygitversionhelper.gitversionhelper.version.noValidVersion
-        ):
+        with self.assertRaises(pygitversionhelper.gitversionhelper.version.noValidVersion):
             _v = pygitversionhelper.gitversionhelper.version.getLastVersion()
 
-        _v = pygitversionhelper.gitversionhelper.version.getLastVersion(
-            ignore_unknown_tags=True
-        )
-        self.assertIsInstance(
-            _v, pygitversionhelper.gitversionhelper.version.MetaVersion
-        )
+        _v = pygitversionhelper.gitversionhelper.version.getLastVersion(ignore_unknown_tags=True)
+        self.assertIsInstance(_v, pygitversionhelper.gitversionhelper.version.MetaVersion)
         self._test_version_format(_v, "0.0.1", version_std="PEP440")
         self.assertEqual(_v.raw, "0.0.1")
         self.assertEqual(_v.major, 0)
@@ -1227,21 +1136,15 @@ class Test_gitversionhelper(unittest.TestCase):
         os.system(f"git tag 0.1.2")
 
         _v = pygitversionhelper.gitversionhelper.version.getLastVersion()
-        self.assertIsInstance(
-            _v, pygitversionhelper.gitversionhelper.version.MetaVersion
-        )
+        self.assertIsInstance(_v, pygitversionhelper.gitversionhelper.version.MetaVersion)
         self._test_version_format(_v, "0.1.2", version_std="PEP440")
         self.assertEqual(_v.raw, "0.1.2")
         self.assertEqual(_v.major, 0)
         self.assertEqual(_v.minor, 1)
         self.assertEqual(_v.patch, 2)
 
-        _v = pygitversionhelper.gitversionhelper.version.getLastVersion(
-            ignore_unknown_tags=True
-        )
-        self.assertIsInstance(
-            _v, pygitversionhelper.gitversionhelper.version.MetaVersion
-        )
+        _v = pygitversionhelper.gitversionhelper.version.getLastVersion(ignore_unknown_tags=True)
+        self.assertIsInstance(_v, pygitversionhelper.gitversionhelper.version.MetaVersion)
         self._test_version_format(_v, "0.1.2", version_std="PEP440")
         self.assertEqual(_v.raw, "0.1.2")
         self.assertEqual(_v.major, 0)
@@ -1254,17 +1157,11 @@ class Test_gitversionhelper(unittest.TestCase):
         os.system('git commit -m  "commit"')
         os.system(f"git tag INVALIDTA5")
 
-        with self.assertRaises(
-            pygitversionhelper.gitversionhelper.version.noValidVersion
-        ):
+        with self.assertRaises(pygitversionhelper.gitversionhelper.version.noValidVersion):
             _v = pygitversionhelper.gitversionhelper.version.getLastVersion()
 
-        _v = pygitversionhelper.gitversionhelper.version.getLastVersion(
-            ignore_unknown_tags=True
-        )
-        self.assertIsInstance(
-            _v, pygitversionhelper.gitversionhelper.version.MetaVersion
-        )
+        _v = pygitversionhelper.gitversionhelper.version.getLastVersion(ignore_unknown_tags=True)
+        self.assertIsInstance(_v, pygitversionhelper.gitversionhelper.version.MetaVersion)
         self._test_version_format(_v, "0.1.2", version_std="PEP440")
         self.assertEqual(_v.raw, "0.1.2")
         self.assertEqual(_v.major, 0)
@@ -1278,21 +1175,15 @@ class Test_gitversionhelper(unittest.TestCase):
         os.system(f"git tag 0.1.3")
 
         _v = pygitversionhelper.gitversionhelper.version.getLastVersion()
-        self.assertIsInstance(
-            _v, pygitversionhelper.gitversionhelper.version.MetaVersion
-        )
+        self.assertIsInstance(_v, pygitversionhelper.gitversionhelper.version.MetaVersion)
         self._test_version_format(_v, "0.1.3", version_std="PEP440")
         self.assertEqual(_v.raw, "0.1.3")
         self.assertEqual(_v.major, 0)
         self.assertEqual(_v.minor, 1)
         self.assertEqual(_v.patch, 3)
 
-        _v = pygitversionhelper.gitversionhelper.version.getLastVersion(
-            ignore_unknown_tags=True
-        )
-        self.assertIsInstance(
-            _v, pygitversionhelper.gitversionhelper.version.MetaVersion
-        )
+        _v = pygitversionhelper.gitversionhelper.version.getLastVersion(ignore_unknown_tags=True)
+        self.assertIsInstance(_v, pygitversionhelper.gitversionhelper.version.MetaVersion)
         self._test_version_format(_v, "0.1.3", version_std="PEP440")
         self.assertEqual(_v.raw, "0.1.3")
         self.assertEqual(_v.major, 0)
@@ -1349,9 +1240,7 @@ class Test_gitversionhelper(unittest.TestCase):
         fourth2_commit = pygitversionhelper.gitversionhelper.commit.getLast()
         self.assertEqual(fourth2_commit, fourth_commit)
 
-        fourth3_commit = pygitversionhelper.gitversionhelper.commit.getLast(
-            same_branch=True
-        )
+        fourth3_commit = pygitversionhelper.gitversionhelper.commit.getLast(same_branch=True)
 
         self.assertNotEqual(fourth3_commit, fourth_commit)
         self.assertEqual(fourth3_commit, third_commit)
@@ -1370,23 +1259,21 @@ class Test_gitversionhelper(unittest.TestCase):
         fifth2_commit = pygitversionhelper.gitversionhelper.commit.getLast()
         self.assertEqual(fifth2_commit, fifth_commit)
 
-        fifth2_commit = pygitversionhelper.gitversionhelper.commit.getLast(
-            same_branch=True
-        )
+        fifth2_commit = pygitversionhelper.gitversionhelper.commit.getLast(same_branch=True)
         self.assertEqual(fifth2_commit, fourth_commit)
 
     def test_defect__commit_notfound(self):
 
-        with self.assertRaises(
-            pygitversionhelper.gitversionhelper.commit.commitNotFound
-        ):
+        with self.assertRaises(pygitversionhelper.gitversionhelper.commit.commitNotFound):
             pygitversionhelper.gitversionhelper.commit.getLast()
 
-        with self.assertRaises(
-            pygitversionhelper.gitversionhelper.commit.commitNotFound
-        ):
+        with self.assertRaises(pygitversionhelper.gitversionhelper.commit.commitNotFound):
             pygitversionhelper.gitversionhelper.commit.getLast(same_branch=True)
 
+    def test_defect__commit_getMessage_notfound(self):
+        with self.assertRaises(pygitversionhelper.gitversionhelper.commit.commitNotFound):
+            pygitversionhelper.gitversionhelper.commit.getMessage("")
+
     def test_nominal__commit_getFromTag(self):
         with open("demofile.txt", "w+t") as tmpFile:
             tmpFile.write("testvalue")
@@ -1409,9 +1296,7 @@ class Test_gitversionhelper(unittest.TestCase):
 
     def test_defect__commit_notfound2(self):
 
-        with self.assertRaises(
-            pygitversionhelper.gitversionhelper.commit.commitNotFound
-        ):
+        with self.assertRaises(pygitversionhelper.gitversionhelper.commit.commitNotFound):
             pygitversionhelper.gitversionhelper.commit.getFromTag("TAG")
 
         with open("demofile.txt", "w+t") as tmpFile:
@@ -1419,16 +1304,12 @@ class Test_gitversionhelper(unittest.TestCase):
         os.system("git add .")
         os.system('git commit -m  "commit"')
 
-        with self.assertRaises(
-            pygitversionhelper.gitversionhelper.commit.commitNotFound
-        ):
+        with self.assertRaises(pygitversionhelper.gitversionhelper.commit.commitNotFound):
             pygitversionhelper.gitversionhelper.commit.getFromTag("TAG")
 
         os.system(f"git tag OTHER_TAG")
 
-        with self.assertRaises(
-            pygitversionhelper.gitversionhelper.commit.commitNotFound
-        ):
+        with self.assertRaises(pygitversionhelper.gitversionhelper.commit.commitNotFound):
             pygitversionhelper.gitversionhelper.commit.getFromTag("TAG")
 
     def test_nominal__commit_getMessage(self):
@@ -1464,9 +1345,7 @@ class Test_gitversionhelper(unittest.TestCase):
         self.assertEqual(message, commit_message)
 
     def test_nominal__commit_getMessagesSinceLastTag(self):
-        commit_message1 = (
-            "1.1 update this" + os.linesep + "1.1 fix that" + os.linesep + "1.1 test"
-        )
+        commit_message1 = "1.1 update this" + os.linesep + "1.1 fix that" + os.linesep + "1.1 test"
         commit_message1 = commit_message1.replace("\r\n", "\n").replace("\n", "\r\n")
         with open("demofile.txt", "w+t") as tmpFile:
             tmpFile.write("testvalue")
@@ -1477,9 +1356,7 @@ class Test_gitversionhelper(unittest.TestCase):
         subprocess.run(cmd, text=True, check=True)
         os.system(f"git tag 0.1.1")
 
-        commit_message2 = (
-            "2.1 update this" + os.linesep + "2.1 fix that" + os.linesep + "2.1 test"
-        )
+        commit_message2 = "2.1 update this" + os.linesep + "2.1 fix that" + os.linesep + "2.1 test"
         commit_message2 = commit_message2.replace("\r\n", "\n").replace("\n", "\r\n")
         with open("demofile.txt", "w+t") as tmpFile:
             tmpFile.write("testvalue2")
@@ -1489,9 +1366,7 @@ class Test_gitversionhelper(unittest.TestCase):
         cmd.append(commit_message2)
         subprocess.run(cmd, text=True, check=True)
 
-        commit_message3 = (
-            "3.1 update this" + os.linesep + "3.1 fix that" + os.linesep + "3.1 test"
-        )
+        commit_message3 = "3.1 update this" + os.linesep + "3.1 fix that" + os.linesep + "3.1 test"
         commit_message3 = commit_message3.replace("\r\n", "\n").replace("\n", "\r\n")
         with open("demofile.txt", "w+t") as tmpFile:
             tmpFile.write("testvalue3")
@@ -1501,9 +1376,7 @@ class Test_gitversionhelper(unittest.TestCase):
         cmd.append(commit_message3)
         subprocess.run(cmd, text=True, check=True)
 
-        commit_message4 = (
-            "4.1 update this" + os.linesep + "4.1 fix that" + os.linesep + "4.1 test"
-        )
+        commit_message4 = "4.1 update this" + os.linesep + "4.1 fix that" + os.linesep + "4.1 test"
         commit_message4 = commit_message4.replace("\r\n", "\n").replace("\n", "\r\n")
         with open("demofile.txt", "w+t") as tmpFile:
             tmpFile.write("testvalue4")
@@ -1516,12 +1389,30 @@ class Test_gitversionhelper(unittest.TestCase):
         res = pygitversionhelper.gitversionhelper.commit.getMessagesSinceTag("0.1.1")
         self.assertEqual([commit_message4, commit_message3, commit_message2], res)
 
-        res = pygitversionhelper.gitversionhelper.commit.getMessagesSinceTag(
-            "0.1.1", merged_output=True
-        )
-        self.assertEqual(
-            os.linesep.join([commit_message4, commit_message3, commit_message2]), res
-        )
+        res = pygitversionhelper.gitversionhelper.commit.getMessagesSinceTag("0.1.1", merged_output=True)
+        self.assertEqual(os.linesep.join([commit_message4, commit_message3, commit_message2]), res)
+
+        cmd = "git checkout -b dev".split()
+        subprocess.run(cmd, text=True, check=True)
+
+        commit_message5 = "5.1 update this" + os.linesep + "5.1 fix that" + os.linesep + "5.1 test"
+        commit_message5 = commit_message5.replace("\r\n", "\n").replace("\n", "\r\n")
+        with open("demofile.txt", "w+t") as tmpFile:
+            tmpFile.write("testvalue5")
+        os.system("git add .")
+
+        cmd = "git commit -m".split()
+        cmd.append(commit_message5)
+        subprocess.run(cmd, text=True, check=True)
+
+        cmd = "git switch master".split()
+        subprocess.run(cmd, text=True, check=True)
+
+        res = pygitversionhelper.gitversionhelper.commit.getMessagesSinceTag("0.1.1", merged_output=True, same_branch=True)
+        self.assertEqual(os.linesep.join([commit_message4, commit_message3, commit_message2]), res)
+
+        res = pygitversionhelper.gitversionhelper.commit.getMessagesSinceTag("0.1.1", merged_output=True)
+        self.assertEqual(os.linesep.join([commit_message5, commit_message4, commit_message3, commit_message2]), res)
 
     def tearDown(self):
         os.chdir("/")
@@ -1534,9 +1425,7 @@ class Test_gitversionhelperNoRepo(unittest.TestCase):
         os.chdir(self.TmpWorkingDirPath)
 
     def test_defect__norepo(self):
-        with self.assertRaises(
-            pygitversionhelper.gitversionhelper.repository.notAGitRepository
-        ):
+        with self.assertRaises(pygitversionhelper.gitversionhelper.repository.notAGitRepository):
             _v = pygitversionhelper.gitversionhelper.version.getCurrentVersion()
 
     def tearDown(self):