python-semantic-release 9.15.0__py3-none-any.whl → 9.15.2__py3-none-any.whl

{python_semantic_release-9.15.0.dist-info → python_semantic_release-9.15.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-semantic-release
-Version: 9.15.0
+Version: 9.15.2
 Summary: Automatic Semantic Versioning for Python projects
 Author-email: Rolf Erik Lekang <me@rolflekang.com>
 License: MIT

{python_semantic_release-9.15.0.dist-info → python_semantic_release-9.15.2.dist-info}/RECORD

@@ -1,20 +1,20 @@
-semantic_release/__init__.py,sha256=Q0ZC22VGUXA_6IkFcuHHN5K6oxt97OYKhhUKMhX-6Ok,1229
-semantic_release/__main__.py,sha256=kuotDU7aFKrCBeAJUPWrbIxgJWAmrXUMnztCqWMDMPY,1292
+semantic_release/__init__.py,sha256=PaDXUxHfhYwLilGM9c0vX8F6Jooc8hMhPm3CL8UIX0M,1229
+semantic_release/__main__.py,sha256=KOIBOvLruqfi5ArXcWK3ucIZ7NB55kfCbycJaxx6aQg,1485
 semantic_release/const.py,sha256=Z1o2QNh60wSLeF-_1TemMBjU3ZXbV0XghnUFsbTVfOs,831
-semantic_release/enums.py,sha256=D5B_reQGGKQQT22HO5PUtvn2Bok3fkht6TfJtXkmAUg,1020
+semantic_release/enums.py,sha256=vrEw1UNRcNrFjPqOFnuUzfeoqKj0ChixVVlyk5fqbng,1744
 semantic_release/errors.py,sha256=PY9rmviSFBZkqawW6VXbUfmF9C_RNOIObcmeGxLefMo,2904
-semantic_release/gitproject.py,sha256=XR7DfLxLZudEtfFnqnzvCDTVY8vC7TFRM0JyBJOkS5w,8584
+semantic_release/gitproject.py,sha256=G4XrucN-ZwT1Kj4RMrABcr1vWb0bjKgurEeJjcL-61c,9422
 semantic_release/globals.py,sha256=imI9WKGa6MS2pTRAZiWZ2qIJup2eWnBz3OZmIj2YIHM,158
 semantic_release/helpers.py,sha256=d1jOX0SNyqPc_3wr14xR25FfpqhMd4Ev7MNBOWlScc0,5581
 semantic_release/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 semantic_release/changelog/__init__.py,sha256=Bg6Xe5Vt32rWoMscW-hd4sUwiZqzWmsg4CD1EhMesMY,262
 semantic_release/changelog/context.py,sha256=jyVluJq8Vu6TyyzQQrsBIQRKm7kEnh1GZt8ObwibR5k,5374
 semantic_release/changelog/release_history.py,sha256=nbd-WYVfQSWN4SKPPWEGU6QgNZLBrNxKKxfhPGKqnKc,8499
-semantic_release/changelog/template.py,sha256=ZgIWznm_Ik8jgLtCGxPv605TnSRTtFGyMvvEZRbe-Zk,5705
+semantic_release/changelog/template.py,sha256=O4EKXVJtN1z6FowcRUiZdZmi9u_TsTiXcHmYJnGyt94,5721
 semantic_release/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 semantic_release/cli/changelog_writer.py,sha256=RupwYqApOeAMidIvjCttnyyGNRxtLftmxDBmEu5azX0,9049
 semantic_release/cli/cli_context.py,sha256=Nop71LdVCJOeSUHgTXunMyK3xAu_QKQC2cRp1QBVkX0,4134
-semantic_release/cli/config.py,sha256=1PStwoY4OdWggD6MkCWLxoEqCzy18Jd84DTNh7FT0zk,30907
+semantic_release/cli/config.py,sha256=kb8r20PJ-oEJIS69zOQotbHcDpppsRuqwuazA7gQl0Y,30976
 semantic_release/cli/const.py,sha256=h7XE2D0D__TAZSrUUtVszwvzpkHTMOiQCf97XQNbEvA,163
 semantic_release/cli/github_actions_output.py,sha256=6oNwjnQBg9XF5QgGc4TgbwX_-W0aj65VwGSL4ALvqVg,2296
 semantic_release/cli/masking_filter.py,sha256=DxqjiJyABlzwwwZ1r8JGQpb6QrF00StJFm0-2-s5Fv0,3071
@@ -22,23 +22,23 @@ semantic_release/cli/util.py,sha256=FyXaBkeL7nXKjy3X9rQLEwvn7p46xPekp2V8Z-5MVrk,
 semantic_release/cli/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 semantic_release/cli/commands/changelog.py,sha256=w_sXuFJHIqcueBQdeNeWn6fqbLVPPl_c-dEhv3Pb_BA,3870
 semantic_release/cli/commands/generate_config.py,sha256=2xZOu3NpyhBp0pWr7d8ugKl_kjqQgpSsSMHq5wHTfrE,1699
-semantic_release/cli/commands/main.py,sha256=wHG51tbaAHKra21nRe3-FAfQT81-e5PGhv0KnerS15c,4100
+semantic_release/cli/commands/main.py,sha256=237rn_Od4LOWfjUjiUKI_jSV820MfcCtRpwPjxjLbyU,4312
 semantic_release/cli/commands/publish.py,sha256=y_LalPti_kZeQJzl2CR2pTZUK8DCMvNSTe4NaMC5TJA,2875
-semantic_release/cli/commands/version.py,sha256=dsPVyKELn_GSoNeX0YVVvLKDPmWbEpLXgxWyObKIl20,24170
+semantic_release/cli/commands/version.py,sha256=vC4myixs_w8UPj58ZqJmmochl8RWUBmCbseoOEnVmD8,24220
 semantic_release/commit_parser/__init__.py,sha256=cv5HFBdw7OJd4Laj4Ex8ZZ5Tml8GwXgQcXW6Pasr2Ao,615
 semantic_release/commit_parser/_base.py,sha256=LAscBtS3_28jebRCeR-eGo3UtAsuxCWBzgb7FF4n4Vo,3046
-semantic_release/commit_parser/angular.py,sha256=1lTU73k-DXiMHHdQ8iNS4L2cPnns49KFq6BNc8CiCZo,10441
-semantic_release/commit_parser/emoji.py,sha256=zkHOGfupnmO3EAILZM4yqEkHgYLrXzn8mcdHnB0V4S4,9974
+semantic_release/commit_parser/angular.py,sha256=zDYYOK1itsYJ0Ar7-cf29MnfrEpbQTeQCAcExWPH1fM,10486
+semantic_release/commit_parser/emoji.py,sha256=6HtvKvJZwPAvY2fNOXU_gpKf1rGrMiDd0rYamyrdQZ8,10002
 semantic_release/commit_parser/scipy.py,sha256=Fm_6WUaliLmqD397uVXwpOSDZ7LpMFu59oz-inKeHko,4526
 semantic_release/commit_parser/tag.py,sha256=4uwIKBqUM2SE6UTGIw-a7B6Jg1OONXmGwXsTyL3yZBA,3490
 semantic_release/commit_parser/token.py,sha256=RXdoCmKMTKMmUJGEUvfCiAOCPRrV0WubXojwa6FbvFg,7363
-semantic_release/commit_parser/util.py,sha256=wsormGXONAIFip4AUUYveY_UwnnUFNqItLA7nRGYLjk,2255
+semantic_release/commit_parser/util.py,sha256=KmJ-M-CJbc7q37GG7o595SmeBwrRrrnjP4q1C05jGYI,2463
 semantic_release/data/templates/angular/md/.release_notes.md.j2,sha256=BzpatS7WYBcpHii8qiDemyI1ygXM6Q1nbxdcdcps__U,2107
 semantic_release/data/templates/angular/md/CHANGELOG.md.j2,sha256=FZmrQ-qOIoSoJmAa_NFaRelfmqUpypU2xlDeScdGOf4,729
 semantic_release/data/templates/angular/md/.components/changelog_header.md.j2,sha256=qNxTuSr59CV_yyimVU_RYp5azCnK0l6nJ03Zf0u5Ugg,166
 semantic_release/data/templates/angular/md/.components/changelog_init.md.j2,sha256=MyEQdWUemGXKWDhvpTmubZdozd3iaLECZAI1VRlE7mg,862
 semantic_release/data/templates/angular/md/.components/changelog_update.md.j2,sha256=uVF4wbbjTMvl6Kbsq9xy3YIrj-uhBnHylEfA7S76aHI,2606
-semantic_release/data/templates/angular/md/.components/changes.md.j2,sha256=85LrnuHZhwKfdWhtqg_en6tl5UU2MzZnIJKb79j59Og,3996
+semantic_release/data/templates/angular/md/.components/changes.md.j2,sha256=AnF6sEsdaOeCS6E0_Q1PS430jufC1wg4ZMIJdMuBuNI,4000
 semantic_release/data/templates/angular/md/.components/first_release.md.j2,sha256=jMUZiLwhMqAOjdYOCphJxJr8C411cKRzhsabyebj_AY,162
 semantic_release/data/templates/angular/md/.components/macros.md.j2,sha256=GEql_lFHWqtfZUMYo8WT3E_YOTf0gvGhjqRQw0c7mlk,5890
 semantic_release/data/templates/angular/md/.components/unreleased_changes.md.j2,sha256=HRLj6cyRfPZXC0s-0Av6s0Gp3jKxWg9AIEtIXBVqJuY,177
@@ -62,14 +62,14 @@ semantic_release/hvcs/remote_hvcs_base.py,sha256=cV8qYHtP47bmfIZqV4K2EiMHskFEoIo
 semantic_release/hvcs/token_auth.py,sha256=ZjT56-NIPB4OKIt1qwHCu1TavXnrWFIBl9ARlg56hgU,663
 semantic_release/hvcs/util.py,sha256=guxisysY_IW5tv7aaV-iVPEVJzgbOs375kiRRpSquTI,2879
 semantic_release/version/__init__.py,sha256=CLhtGQry9dLIij5XyRa9ZevxU_1p8tjMTSQ-K_GMpWM,270
-semantic_release/version/algorithm.py,sha256=XI9nKhmcS6T62b5kRRna9CZl7gTRw98hdetFT31fe_o,16890
+semantic_release/version/algorithm.py,sha256=UiJch0cpMxbuL-K_yaah8VF3PVy8mdwj1K8hArcwvdo,15183
 semantic_release/version/declaration.py,sha256=f6Ld7hIhrqvDrRBapJHr-KDimuyo-4IG8009Zu9BIgU,7357
 semantic_release/version/translator.py,sha256=P1noIsVBn8u6zNOFjG0xKYOWapxqf_PHSMvMeLJ9kXg,3050
 semantic_release/version/version.py,sha256=6PCtSbLP88U1daoxnCwHc--YguZo4waGNLqJ5JfeczE,14175
-python_semantic_release-9.15.0.dist-info/AUTHORS.rst,sha256=XOReVvpymEFUPsS2QPH97jlfJBVrxwS2eu8-jVAe4gk,230
-python_semantic_release-9.15.0.dist-info/LICENSE,sha256=NE85nszX252sdQdu0xgS9qwfYES0k8qS6gW3uO4jRGE,1083
-python_semantic_release-9.15.0.dist-info/METADATA,sha256=i-z285QdMbctU1GapnRvsTz0o1HQPqtDIOiqdbx6_GM,3812
-python_semantic_release-9.15.0.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
-python_semantic_release-9.15.0.dist-info/entry_points.txt,sha256=r2Jql3GTQyugQnvf34l2eXk1O_Qx6llR_xixG1ZWgD0,105
-python_semantic_release-9.15.0.dist-info/top_level.txt,sha256=qYA24nyg3eP-ti5UW7Vuj2aXVmM0wqVHx4mREdRZNAA,17
-python_semantic_release-9.15.0.dist-info/RECORD,,
+python_semantic_release-9.15.2.dist-info/AUTHORS.rst,sha256=XOReVvpymEFUPsS2QPH97jlfJBVrxwS2eu8-jVAe4gk,230
+python_semantic_release-9.15.2.dist-info/LICENSE,sha256=NE85nszX252sdQdu0xgS9qwfYES0k8qS6gW3uO4jRGE,1083
+python_semantic_release-9.15.2.dist-info/METADATA,sha256=yD3qvMg3m175Z40HU3Gj5P8Z7z9Z8q4jhcwX3KS3JNM,3812
+python_semantic_release-9.15.2.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
+python_semantic_release-9.15.2.dist-info/entry_points.txt,sha256=r2Jql3GTQyugQnvf34l2eXk1O_Qx6llR_xixG1ZWgD0,105
+python_semantic_release-9.15.2.dist-info/top_level.txt,sha256=qYA24nyg3eP-ti5UW7Vuj2aXVmM0wqVHx4mREdRZNAA,17
+python_semantic_release-9.15.2.dist-info/RECORD,,

semantic_release/__init__.py

@@ -24,7 +24,7 @@ from semantic_release.version import (
     tags_and_versions,
 )
 
-__version__ = "9.15.0"
+__version__ = "9.15.2"
 
 __all__ = [
     "CommitParser",

semantic_release/__main__.py

@@ -34,7 +34,15 @@ def main() -> None:
                 ),
                 file=sys.stderr,
             )
+
         print(f"::ERROR:: {err}", file=sys.stderr)
+
+        if not globals.debug:
+            print(
+                "Run semantic-release in very verbose mode (-vv) to see the full traceback.",
+                file=sys.stderr,
+            )
+
         sys.exit(1)
 
 

semantic_release/changelog/template.py

@@ -124,9 +124,9 @@ def recursive_render(
             # is used for inserting into a current changelog. When using stream rendering
             # of the same file, it always came back empty
             log.debug("rendering %s to %s", src_file_path, output_file_path)
-            rendered_file = environment.get_template(src_file_path).render()
+            rendered_file = environment.get_template(src_file_path).render().rstrip()
             with open(output_file_path, "w", encoding="utf-8") as output_file:
-                output_file.write(rendered_file)
+                output_file.write(f"{rendered_file}\n")
 
             rendered_paths.append(output_file_path)
         else:

semantic_release/cli/commands/main.py

@@ -15,6 +15,7 @@ from semantic_release.cli.cli_context import CliContextObj
 from semantic_release.cli.config import GlobalCommandLineOptions
 from semantic_release.cli.const import DEFAULT_CONFIG_FILE
 from semantic_release.cli.util import rprint
+from semantic_release.enums import SemanticReleaseLogLevels
 
 # if TYPE_CHECKING:
 #     pass
@@ -108,7 +109,15 @@ def main(
     """
     console = Console(stderr=True)
 
-    log_level = [logging.WARNING, logging.INFO, logging.DEBUG][verbosity]
+    log_levels = [
+        SemanticReleaseLogLevels.WARNING,
+        SemanticReleaseLogLevels.INFO,
+        SemanticReleaseLogLevels.DEBUG,
+        SemanticReleaseLogLevels.SILLY,
+    ]
+
+    log_level = log_levels[verbosity]
+
     logging.basicConfig(
         level=log_level,
         format=FORMAT,
@@ -123,7 +132,7 @@ def main(
     logger = logging.getLogger(__name__)
     logger.debug("logging level set to: %s", logging.getLevelName(log_level))
 
-    if log_level == logging.DEBUG:
+    if log_level <= logging.DEBUG:
         globals.debug = True
 
     if noop:

semantic_release/cli/commands/version.py

@@ -653,6 +653,7 @@ def version(  # noqa: C901
         project.git_tag(
             tag_name=new_version.as_tag(),
             message=new_version.as_tag(),
+            isotimestamp=commit_date.isoformat(),
             noop=opts.noop,
         )
 

semantic_release/cli/config.py

@@ -360,9 +360,12 @@ class RawConfig(BaseModel):
         try:
             # Check for repository & walk up parent directories
             with Repo(str(dir_path), search_parent_directories=True) as git_repo:
-                found_path = Path(
-                    git_repo.working_tree_dir or git_repo.working_dir
-                ).absolute()
+                found_path = (
+                    Path(git_repo.working_tree_dir or git_repo.working_dir)
+                    .expanduser()
+                    .absolute()
+                )
+
         except InvalidGitRepositoryError as err:
             raise InvalidGitRepositoryError("No valid git repository found!") from err
 
@@ -370,7 +373,8 @@ class RawConfig(BaseModel):
             logging.warning(
                 "Found .git/ in higher parent directory rather than provided in configuration."
             )
-        return found_path
+
+        return found_path.resolve()
 
     @field_validator("commit_parser", mode="after")
     @classmethod

semantic_release/commit_parser/angular.py

@@ -21,7 +21,11 @@ from semantic_release.commit_parser.token import (
     ParseError,
     ParseResult,
 )
-from semantic_release.commit_parser.util import breaking_re, parse_paragraphs
+from semantic_release.commit_parser.util import (
+    breaking_re,
+    parse_paragraphs,
+    sort_numerically,
+)
 from semantic_release.enums import LevelBump
 from semantic_release.errors import InvalidParserOptions
 
@@ -195,7 +199,7 @@ class AngularCommitParser(CommitParser[ParseResult, AngularParserOptions]):
                     predicate.split(","),
                 )
             )
-            accumulator["linked_issues"] = sorted(
+            accumulator["linked_issues"] = sort_numerically(
                 set(accumulator["linked_issues"]).union(new_issue_refs)
             )
             # TODO: breaking change v10, removes resolution footers from descriptions

semantic_release/commit_parser/emoji.py

@@ -18,7 +18,7 @@ from semantic_release.commit_parser.token import (
     ParsedMessageResult,
     ParseResult,
 )
-from semantic_release.commit_parser.util import parse_paragraphs
+from semantic_release.commit_parser.util import parse_paragraphs, sort_numerically
 from semantic_release.enums import LevelBump
 from semantic_release.errors import InvalidParserOptions
 
@@ -186,7 +186,7 @@ class EmojiCommitParser(CommitParser[ParseResult, EmojiParserOptions]):
                     predicate.split(","),
                 )
             )
-            accumulator["linked_issues"] = sorted(
+            accumulator["linked_issues"] = sort_numerically(
                 set(accumulator["linked_issues"]).union(new_issue_refs)
             )
             # TODO: breaking change v10, removes resolution footers from descriptions

semantic_release/commit_parser/util.py

@@ -6,28 +6,34 @@ from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:  # pragma: no cover
     from re import Pattern
-    from typing import TypedDict
+    from typing import Sequence, TypedDict
 
     class RegexReplaceDef(TypedDict):
         pattern: Pattern
         repl: str
 
 
+number_pattern = regexp(r"(\d+)")
+
 breaking_re = regexp(r"BREAKING[ -]CHANGE:\s?(.*)")
+
 un_word_wrap: RegexReplaceDef = {
     # Match a line ending where the next line is not indented, or a bullet
     "pattern": regexp(r"((?<!-)\n(?![\s*-]))"),
     "repl": r" ",  # Replace with a space
 }
+
 un_word_wrap_hyphen: RegexReplaceDef = {
     "pattern": regexp(r"((?<=\w)-\n(?=\w))"),
     "repl": r"-",  # Replace with single hyphen
 }
+
 trim_line_endings: RegexReplaceDef = {
     # Match line endings with optional whitespace
     "pattern": regexp(r"[\r\t\f\v ]*\r?\n"),
     "repl": "\n",  # remove the optional whitespace & remove windows newlines
 }
+
 spread_out_git_footers: RegexReplaceDef = {
     # Match a git footer line, and add an extra newline after it
     # only be flexible enough for a double space indent (otherwise its probably on purpose)
@@ -65,3 +71,7 @@ def parse_paragraphs(text: str) -> list[str]:
             ],
         )
     )
+
+
+def sort_numerically(iterable: Sequence[str] | set[str]) -> list[str]:
+    return sorted(iterable, key=lambda x: int((number_pattern.search(x) or [-1])[0]))

semantic_release/data/templates/angular/md/.components/changes.md.j2

@@ -69,7 +69,7 @@ EXAMPLE:
 #}{%  if breaking_commits | length > 0
 %}{#    PREPROCESS COMMITS
 #}{%    set brk_ns = namespace(commits=breaking_commits)
-%}{{    apply_alphabetical_ordering_by_descriptions(brk_ns) | default("", true)
+%}{{    apply_alphabetical_ordering_by_brk_descriptions(brk_ns) | default("", true)
 }}{#
 #}{%    set brking_descriptions = []
 %}{#

semantic_release/enums.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import logging
 from enum import IntEnum, unique
 
 
@@ -37,3 +38,32 @@ class LevelBump(IntEnum):
         >>> LevelBump.from_string("minor") == LevelBump.MINOR
         """
         return cls[val.upper().replace("-", "_")]
+
+
+class SemanticReleaseLogLevels(IntEnum):
+    """IntEnum representing the log levels used by semantic-release."""
+
+    FATAL = logging.FATAL
+    CRITICAL = logging.CRITICAL
+    ERROR = logging.ERROR
+    WARNING = logging.WARNING
+    INFO = logging.INFO
+    DEBUG = logging.DEBUG
+    SILLY = 5
+
+    def __str__(self) -> str:
+        """
+        Return the level name rather than 'SemanticReleaseLogLevels.<level>'
+        E.g.
+        >>> str(SemanticReleaseLogLevels.DEBUG)
+        'DEBUG'
+        >>> str(SemanticReleaseLogLevels.CRITICAL)
+        'CRITICAL'
+        """
+        return self.name.upper()
+
+
+logging.addLevelName(
+    SemanticReleaseLogLevels.SILLY,
+    str(SemanticReleaseLogLevels.SILLY),
+)

semantic_release/gitproject.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 from contextlib import nullcontext
+from datetime import datetime
 from logging import getLogger
 from pathlib import Path
 from typing import TYPE_CHECKING
@@ -48,7 +49,9 @@ class GitProject:
         return self._logger
 
     def _get_custom_environment(
-        self, repo: Repo
+        self,
+        repo: Repo,
+        custom_vars: dict[str, str] | None = None,
     ) -> nullcontext[None] | _GeneratorContextManager[None]:
         """
         git.custom_environment is a context manager but
@@ -56,15 +59,26 @@ class GitProject:
         we need to throw it away and re-create it in
         order to use it again
         """
+        author_vars = (
+            {
+                "GIT_AUTHOR_NAME": self._commit_author.name,
+                "GIT_AUTHOR_EMAIL": self._commit_author.email,
+                "GIT_COMMITTER_NAME": self._commit_author.name,
+                "GIT_COMMITTER_EMAIL": self._commit_author.email,
+            }
+            if self._commit_author
+            else {}
+        )
+
+        custom_env_vars = {
+            **author_vars,
+            **(custom_vars or {}),
+        }
+
         return (
             nullcontext()
-            if not self._commit_author
-            else repo.git.custom_environment(
-                GIT_AUTHOR_NAME=self._commit_author.name,
-                GIT_AUTHOR_EMAIL=self._commit_author.email,
-                GIT_COMMITTER_NAME=self._commit_author.name,
-                GIT_COMMITTER_EMAIL=self._commit_author.email,
-            )
+            if not custom_env_vars
+            else repo.git.custom_environment(**custom_env_vars)
         )
 
     def is_dirty(self) -> bool:
@@ -182,19 +196,32 @@ class GitProject:
                     self.logger.exception(str(err))
                     raise GitCommitError("Failed to commit changes") from err
 
-    def git_tag(self, tag_name: str, message: str, noop: bool = False) -> None:
+    def git_tag(
+        self, tag_name: str, message: str, isotimestamp: str, noop: bool = False
+    ) -> None:
+        try:
+            datetime.fromisoformat(isotimestamp)
+        except ValueError as err:
+            raise ValueError("Invalid timestamp format") from err
+
         if noop:
-            command = (
-                f"""\
-                GIT_AUTHOR_NAME={self._commit_author.name} \\
-                GIT_AUTHOR_EMAIL={self._commit_author.email} \\
-                GIT_COMMITTER_NAME={self._commit_author.name} \\
-                GIT_COMMITTER_EMAIL={self._commit_author.email} \\
-                """
-                if self._commit_author
-                else ""
+            command = str.join(
+                " ",
+                [
+                    f"GIT_COMMITTER_DATE={isotimestamp}",
+                    *(
+                        [
+                            f"GIT_AUTHOR_NAME={self._commit_author.name}",
+                            f"GIT_AUTHOR_EMAIL={self._commit_author.email}",
+                            f"GIT_COMMITTER_NAME={self._commit_author.name}",
+                            f"GIT_COMMITTER_EMAIL={self._commit_author.email}",
+                        ]
+                        if self._commit_author
+                        else [""]
+                    ),
+                    f"git tag -a {tag_name} -m '{message}'",
+                ],
             )
-            command += f"git tag -a {tag_name} -m '{message}'"
 
             noop_report(
                 indented(
@@ -206,7 +233,10 @@ class GitProject:
             )
             return
 
-        with Repo(str(self.project_root)) as repo, self._get_custom_environment(repo):
+        with Repo(str(self.project_root)) as repo, self._get_custom_environment(
+            repo,
+            {"GIT_COMMITTER_DATE": isotimestamp},
+        ):
             try:
                 repo.git.tag("-a", tag_name, m=message)
             except GitCommandError as err:

semantic_release/version/algorithm.py

@@ -1,20 +1,19 @@
 from __future__ import annotations
 
 import logging
-from queue import Queue
+from contextlib import suppress
+from queue import LifoQueue
 from typing import TYPE_CHECKING, Iterable
 
 from semantic_release.commit_parser import ParsedCommit
 from semantic_release.const import DEFAULT_VERSION
-from semantic_release.enums import LevelBump
-from semantic_release.errors import InvalidVersion, MissingMergeBaseError
-from semantic_release.version.version import Version
+from semantic_release.enums import LevelBump, SemanticReleaseLogLevels
+from semantic_release.errors import InternalError, InvalidVersion
 
 if TYPE_CHECKING:  # pragma: no cover
-    from git.objects.blob import Blob
+    from typing import Sequence
+
     from git.objects.commit import Commit
-    from git.objects.tag import TagObject
-    from git.objects.tree import Tree
     from git.refs.tag import Tag
     from git.repo.base import Repo
 
@@ -24,8 +23,10 @@ if TYPE_CHECKING:  # pragma: no cover
         ParserOptions,
     )
     from semantic_release.version.translator import VersionTranslator
+    from semantic_release.version.version import Version
+
 
-log = logging.getLogger(__name__)
+logger = logging.getLogger(__name__)
 
 
 def tags_and_versions(
@@ -44,99 +45,78 @@ def tags_and_versions(
         try:
             version = translator.from_tag(tag.name)
         except (NotImplementedError, InvalidVersion) as e:
-            log.warning(
+            logger.warning(
                 "Couldn't parse tag %s as as Version: %s",
                 tag.name,
                 str(e),
-                exc_info=log.isEnabledFor(logging.DEBUG),
+                exc_info=logger.isEnabledFor(logging.DEBUG),
             )
             continue
 
         if version:
             ts_and_vs.append((tag, version))
 
-    log.info("found %s previous tags", len(ts_and_vs))
+    logger.info("found %s previous tags", len(ts_and_vs))
     return sorted(ts_and_vs, reverse=True, key=lambda v: v[1])
 
 
-def _bfs_for_latest_version_in_history(
-    merge_base: Commit | TagObject | Blob | Tree,
-    full_release_tags_and_versions: list[tuple[Tag, Version]],
-) -> Version | None:
-    """
-    Run a breadth-first search through the given `merge_base`'s parents,
-    looking for the most recent version corresponding to a commit in the
-    `merge_base`'s parents' history. If no commits in the history correspond
-    to a released version, return None
-    """
-    tag_sha_2_version_lookup = {
-        tag.commit.hexsha: version for tag, version in full_release_tags_and_versions
-    }
-
-    # Step 3. Latest full release version within the history of the current branch
-    # Breadth-first search the merge-base and its parent commits for one which matches
-    # the tag of the latest full release tag in history
-    def bfs(start_commit: Commit | TagObject | Blob | Tree) -> Version | None:
-        # Derived from Geeks for Geeks
-        # https://www.geeksforgeeks.org/python-program-for-breadth-first-search-or-bfs-for-a-graph/?ref=lbp
-
-        # Create a queue for BFS
-        q: Queue[Commit | TagObject | Blob | Tree] = Queue()
+def _traverse_graph_for_commits(
+    head_commit: Commit,
+    latest_release_tag_str: str = "",
+) -> Sequence[Commit]:
+    # Depth-first search
+    def dfs(start_commit: Commit, stop_nodes: set[Commit]) -> Sequence[Commit]:
+        # Create a stack for DFS
+        stack: LifoQueue[Commit] = LifoQueue()
 
         # Create a set to store visited graph nodes (commit objects in this case)
-        visited: set[Commit | TagObject | Blob | Tree] = set()
-
-        # Add the source node in the queue & mark as visited to start the search
-        q.put(start_commit)
-        visited.add(start_commit)
+        visited: set[Commit] = set()
 
-        # Initialize the result to None
-        result = None
+        # Initialize the result
+        commits: list[Commit] = []
 
-        # Traverse the git history until it finds a version tag if one exists
-        while not q.empty():
-            node = q.get()
-            visited.add(node)
+        # Add the source node in the queue to start the search
+        stack.put(start_commit)
 
-            log.debug("checking if commit %s matches any tags", node.hexsha)
-            version = tag_sha_2_version_lookup.get(node.hexsha, None)
-
-            if version is not None:
-                log.info(
-                    "found latest version in branch history: %r (%s)",
-                    str(version),
-                    node.hexsha[:7],
-                )
-                result = version
-                break
+        # Traverse the git history capturing each commit found before it reaches a stop node
+        while not stack.empty():
+            if (node := stack.get()) in visited or node in stop_nodes:
+                continue
 
-            log.debug("commit %s doesn't match any tags", node.hexsha)
+            visited.add(node)
+            commits.append(node)
 
-            # Add all parent commits to the queue if they haven't been visited
+            # Add all parent commits to the stack from left to right so that the rightmost is popped first
+            # as the left side is generally the merged into branch
             for parent in node.parents:
-                if parent in visited:
-                    log.debug("parent commit %s already visited", node.hexsha)
-                    continue
-
-                log.debug("queuing parent commit %s", parent.hexsha)
-                q.put(parent)
-
-        return result
+                logger.debug("queuing parent commit %s", parent.hexsha[:7])
+                stack.put(parent)
+
+        return commits
+
+    # Run a Depth First Search to find all the commits since the last release
+    commits_since_last_release = dfs(
+        start_commit=head_commit,
+        stop_nodes=set(
+            head_commit.repo.iter_commits(latest_release_tag_str)
+            if latest_release_tag_str
+            else []
+        ),
+    )
 
-    # Run a Breadth First Search to find the latest version in the history
-    latest_version = bfs(merge_base)
-    if latest_version is not None:
-        log.info("the latest version in this branch's history is %s", latest_version)
-    else:
-        log.info("no version tags found in this branch's history")
+    log_msg = (
+        f"Found {len(commits_since_last_release)} commits since the last release!"
+        if len(commits_since_last_release) > 0
+        else "No commits found since the last release!"
+    )
+    logger.info(log_msg)
 
-    return latest_version
+    return commits_since_last_release
 
 
 def _increment_version(
     latest_version: Version,
     latest_full_version: Version,
-    latest_full_version_in_history: Version,
     level_bump: LevelBump,
     prerelease: bool,
     prerelease_token: str,
@@ -147,23 +127,25 @@ def _increment_version(
     Using the given versions, along with a given `level_bump`, increment to
     the next version according to whether or not this is a prerelease.
 
-    `latest_version`, `latest_full_version` and `latest_full_version_in_history`
-    can be the same, but aren't necessarily.
-
     `latest_version` is the most recent version released from this branch's history.
-    `latest_full_version` is the most recent full release (i.e. not a prerelease)
-    anywhere in the repository's history, including commits which aren't present on
-    this branch.
-    `latest_full_version_in_history`, correspondingly, is the latest full release which
-    is in this branch's history.
+    `latest_full_version`, the most recent full release (i.e. not a prerelease)
+    in this branch's history.
+
+    `latest_version` and `latest_full_version` can be the same, but aren't necessarily.
     """
     local_vars = list(locals().items())
-    log.debug("_increment_version: %s", ", ".join(f"{k} = {v}" for k, v in local_vars))
+    logger.log(
+        SemanticReleaseLogLevels.SILLY,
+        "_increment_version: %s",
+        str.join(", ", [f"{k} = {v}" for k, v in local_vars]),
+    )
+
+    # Handle variations where the latest version is 0.x.x
     if latest_version.major == 0:
         if not allow_zero_version:
             # Set up default version to be 1.0.0 if currently 0.x.x which means a commented
             # breaking change is not required to bump to 1.0.0
-            log.debug(
+            logger.debug(
                 "Bumping major version as 0.x.x versions are disabled because of allow_zero_version=False"
             )
             level_bump = LevelBump.MAJOR
@@ -173,93 +155,99 @@ def _increment_version(
             # breaking changes should increment the minor digit
             # Correspondingly, we reduce the level that we increment the
             # version by.
-            log.debug(
+            logger.debug(
                 "reducing version increment due to 0. version and major_on_zero=False"
             )
 
             level_bump = min(level_bump, LevelBump.MINOR)
 
-    if prerelease:
-        log.debug("prerelease=true")
-        target_final_version = latest_full_version.finalize_version()
-        diff_with_last_released_version = (
-            latest_version - latest_full_version_in_history
-        )
-        log.debug(
-            "diff between the latest version %s and the latest full release version %s "
-            "is: %s",
-            latest_version,
-            latest_full_version_in_history,
-            diff_with_last_released_version,
-        )
-        # 6a i) if the level_bump > the level bump introduced by any prerelease tag
-        # before e.g. 1.2.4-rc.3 -> 1.3.0-rc.1
-        if level_bump > diff_with_last_released_version:
-            log.debug(
-                "this release has a greater bump than any change since the last full "
-                "release, %s",
-                latest_full_version_in_history,
-            )
-            return target_final_version.bump(level_bump).to_prerelease(
-                token=prerelease_token
-            )
+    logger.debug(
+        "prerelease=%s and the latest version %s %s prerelease",
+        prerelease,
+        latest_version,
+        "is a" if latest_version.is_prerelease else "is not a",
+    )
 
-        # 6a ii) if level_bump <= the level bump introduced by prerelease tag
-        log.debug(
-            "there has already been at least a %s release since the last full "
-            "release %s",
-            level_bump,
-            latest_full_version_in_history,
-        )
-        log.debug("this release will increment the prerelease revision")
-        return latest_version.to_prerelease(
-            token=prerelease_token,
-            revision=(
-                1
-                if latest_version.prerelease_token != prerelease_token
-                else (latest_version.prerelease_revision or 0) + 1
-            ),
+    if level_bump == LevelBump.NO_RELEASE:
+        raise ValueError("level_bump must be at least PRERELEASE_REVISION")
+
+    if level_bump == LevelBump.PRERELEASE_REVISION and not latest_version.is_prerelease:
+        raise ValueError(
+            "Cannot increment a non-prerelease version with a prerelease level bump"
         )
 
-    # 6b. if not prerelease
-    # NOTE: These can actually be condensed down to the single line
-    # 6b. i) if there's been a prerelease
+    # assume we always want to increment the version that is the latest in the branch's history
+    base_version = latest_version
+
+    # if the current version is a prerelease & we want a new prerelease, then
+    # figure out if we need to bump the prerelease revision or start a new prerelease
     if latest_version.is_prerelease:
-        log.debug(
-            "prerelease=false and the latest version %s is a prerelease", latest_version
-        )
-        diff_with_last_released_version = (
-            latest_version - latest_full_version_in_history
-        )
-        log.debug(
-            "diff between the latest version %s and the latest full release version %s "
-            "is: %s",
+        # find the change since the last full release because if the current version is a prerelease
+        # then we need to predict properly the next full version
+        diff_with_last_released_version = latest_version - latest_full_version
+        logger.debug(
+            "the diff b/w the latest version '%s' and the latest full release version '%s' is: %s",
             latest_version,
-            latest_full_version_in_history,
+            latest_full_version,
             diff_with_last_released_version,
         )
-        if level_bump > diff_with_last_released_version:
-            log.debug(
-                "this release has a greater bump than any change since the last full "
-                "release, %s",
-                latest_full_version_in_history,
-            )
-            return latest_version.bump(level_bump).finalize_version()
-        log.debug(
-            "there has already been at least a %s release since the last full "
-            "release %s",
-            level_bump,
-            latest_full_version_in_history,
+
+        # Since the difference is less than or equal to the level bump and we want a new prerelease,
+        # we can abort early and just increment the revision
+        if level_bump <= diff_with_last_released_version:
+            # 6a ii) if level_bump <= the level bump introduced by the previous tag (latest_version)
+            if prerelease:
+                logger.debug(
+                    "there has already been at least a %s release since the last full release %s",
+                    level_bump,
+                    latest_full_version,
+                )
+                logger.debug("Incrementing the prerelease revision...")
+                new_revision = base_version.to_prerelease(
+                    token=prerelease_token,
+                    revision=(
+                        1
+                        if latest_version.prerelease_token != prerelease_token
+                        else (latest_version.prerelease_revision or 0) + 1
+                    ),
+                )
+                logger.debug("Incremented %s to %s", base_version, new_revision)
+                return new_revision
+
+            # When we don't want a prerelease, but the previous version is a prerelease that
+            # had a greater bump than we currently are applying, choose the larger bump instead
+            # as it consumes this bump
+            logger.debug("Finalizing the prerelease version...")
+            return base_version.finalize_version()
+
+        # Fallthrough to handle all larger level bumps
+        logger.debug(
+            "this release has a greater bump than any change since the last full release, %s",
+            latest_full_version,
         )
-        return latest_version.finalize_version()
 
-    # 6b. ii) If there's been no prerelease
-    log.debug(
-        "prerelease=false and %s is not a prerelease; bumping with a %s release",
-        latest_version,
-        level_bump,
+        # Fallthrough, if we don't want a prerelease, or if we do but the level bump is greater
+        #
+        # because the current version is a prerelease, we must start from the last full version
+        # Case 1: we identified that the level bump is greater than the change since
+        #         the last full release, this will also reset the prerelease revision
+        # Case 2: we don't want a prerelease, so consider only the last full version in history
+        base_version = latest_full_version
+
+    # From the base version, we can now increment the version according to the level bump
+    # regardless of the prerelease status as bump() handles the reset and pass through
+    logger.debug("Bumping %s with a %s bump", base_version, level_bump)
+    target_next_version = base_version.bump(level_bump)
+
+    # Converting to/from a prerelease if necessary
+    target_next_version = (
+        target_next_version.to_prerelease(token=prerelease_token)
+        if prerelease
+        else target_next_version.finalize_version()
     )
-    return latest_version.bump(level_bump)
+
+    logger.debug("Incremented %s to %s", base_version, target_next_version)
+    return target_next_version
 
 
 def next_version(
@@ -274,181 +262,118 @@ def next_version(
     Evaluate the history within `repo`, and based on the tags and commits in the repo
     history, identify the next semantic version that should be applied to a release
     """
-    # Step 1. All tags, sorted descending by semver ordering rules
-    all_git_tags_as_versions = tags_and_versions(repo.tags, translator)
-    all_full_release_tags_and_versions = list(
-        filter(lambda t_v: not t_v[1].is_prerelease, all_git_tags_as_versions)
-    )
-    log.info(
-        "Found %s full releases (excluding prereleases)",
-        len(all_full_release_tags_and_versions),
-    )
-
     # Default initial version
-    latest_full_release_tag, latest_full_release_version = next(
-        iter(all_full_release_tags_and_versions),
-        (None, translator.from_string(DEFAULT_VERSION)),
+    # Since the translator is configured by the user, we can't guarantee that it will
+    # be able to parse the default version. So we first cast it to a tag using the default
+    # value and the users configured tag format, then parse it back to a version object
+    default_initial_version = translator.from_tag(
+        translator.str_to_tag(DEFAULT_VERSION)
     )
-
-    # we can safely scan the extra commits on this
-    # branch if it's never been released, but we have no other
-    # guarantees that other branches exist
-    # Note the merge_base might be on our current branch, it's not
-    # necessarily the merge base of the current branch with `main`
-    other_ref = (
-        repo.active_branch
-        if latest_full_release_tag is None
-        else latest_full_release_tag.name
-    )
-
-    # Conditional log message to inform what was chosen as the comparison point
-    # to find the merge base of the current branch with the latest full release
-    log_msg = (
-        str.join(
-            ", ",
-            [
-                "No full releases have been made yet",
-                f"the default version to use is {latest_full_release_version}",
-            ],
-        )
-        if latest_full_release_tag is None
-        else str.join(
-            ", ",
-            [
-                f"The last full release was {latest_full_release_version}",
-                f"tagged as {latest_full_release_tag!r}",
-            ],
-        )
-    )
-
-    log.info(log_msg)
-    merge_bases = repo.merge_base(other_ref, repo.active_branch)
-
-    if len(merge_bases) < 1:
-        raise MissingMergeBaseError(
-            f"Unable to find merge-base between {other_ref} and {repo.active_branch.name}"
-        )
-
-    if len(merge_bases) > 1:
-        raise NotImplementedError(
-            str.join(
-                " ",
-                [
-                    "This branch has more than one merge-base with the",
-                    "latest version, which is not yet supported",
-                ],
-            )
+    if default_initial_version is None:
+        raise InternalError(
+            "Translator was unable to parse the embedded default version"
         )
 
-    merge_base = merge_bases[0]
+    # Step 1. All tags, sorted descending by semver ordering rules
+    all_git_tags_as_versions = tags_and_versions(repo.tags, translator)
 
-    if merge_base is None:
-        str_tag_name = (
-            "None" if latest_full_release_tag is None else latest_full_release_tag.name
-        )
-        raise ValueError(
-            f"The merge_base found by merge_base({str_tag_name}, {repo.active_branch}) "
-            "is None"
-        )
+    # Retrieve all commit hashes (regardless of merges) in the current branch's history from repo origin
+    commit_hash_set = {
+        commit.hexsha
+        for commit in _traverse_graph_for_commits(head_commit=repo.active_branch.commit)
+    }
 
-    latest_full_version_in_history = _bfs_for_latest_version_in_history(
-        merge_base=merge_base,
-        full_release_tags_and_versions=all_full_release_tags_and_versions,
-    )
-    log.info(
-        "The last full version in this branch's history was %s",
-        latest_full_version_in_history,
+    # Filter all releases that are not found in the current branch's history
+    historic_versions: list[Version] = []
+    for tag, version in all_git_tags_as_versions:
+        # TODO: move this to tags_and_versions() function?
+        # Ignore the error that is raised when tag points to a Blob or Tree object rather
+        # than a commit object (tags that point to tags that then point to commits are resolved automatically)
+        with suppress(ValueError):
+            if tag.commit.hexsha in commit_hash_set:
+                historic_versions.append(version)
+
+    # Step 2. Get the latest final release version in the history of the current branch
+    #  or fallback to the default 0.0.0 starting version value if none are found
+    latest_full_release_version = next(
+        filter(
+            lambda version: not version.is_prerelease,
+            historic_versions,
+        ),
+        default_initial_version,
     )
 
-    commits_since_last_full_release = (
-        repo.iter_commits()
-        if latest_full_version_in_history is None
-        else repo.iter_commits(f"{latest_full_version_in_history.as_tag()}...")
+    logger.info(
+        f"The last full version in this branch's history was {latest_full_release_version}"
+        if latest_full_release_version != default_initial_version
+        else "No full releases found in this branch's history"
     )
 
-    # Step 4. Parse each commit since the last release and find any tags that have
-    # been added since then.
-    parsed_levels: set[LevelBump] = set()
-    latest_version = latest_full_version_in_history or Version(
-        0,
-        0,
-        0,
-        prerelease_token=translator.prerelease_token,
-        tag_format=translator.tag_format,
+    # Step 3. Determine the latest release version in the history of the current branch
+    # If we the desired result is a prerelease, we must determine if there was any previous
+    # prerelease in the history of the current branch beyond the latest_full_release_version.
+    # Important to note that, we only consider prereleases that are of the same prerelease token
+    # as the basis of incrementing the prerelease revision.
+    # If we are not looking for a prerelease, this is the same as the last full release.
+    latest_version = (
+        latest_full_release_version
+        if not prerelease
+        else next(
+            filter(
+                lambda version: all(
+                    [
+                        version.is_prerelease,
+                        version.prerelease_token == translator.prerelease_token,
+                        version >= latest_full_release_version,
+                    ]
+                ),
+                historic_versions,
+            ),
+            latest_full_release_version,  # default
+        )
     )
 
-    # We only include pre-releases here if doing a prerelease.
-    # If it's not a prerelease, we need to include commits back
-    # to the last full version in consideration for what kind of
-    # bump to produce. However if we're doing a prerelease, we can
-    # include prereleases here to potentially consider a smaller portion
-    # of history (from a prerelease since the last full release, onwards)
-
-    # Note that a side-effect of this is, if at some point the configuration
-    # for a particular branch pattern changes w.r.t. prerelease=True/False,
-    # the new kind of version will be produced from the commits already
-    # included in a prerelease since the last full release on the branch
-    tag_sha_2_version_lookup = {
-        tag.commit.hexsha: (tag, version)
-        for tag, version in all_git_tags_as_versions
-        if prerelease or not version.is_prerelease
-    }
-
-    # N.B. these should be sorted so long as we iterate the commits in reverse order
-    for commit in commits_since_last_full_release:
-        parse_result = commit_parser.parse(commit)
-        if isinstance(parse_result, ParsedCommit):
-            log.debug(
-                "adding %s to the levels identified in commits_since_last_full_release",
-                parse_result.bump,
-            )
-            parsed_levels.add(parse_result.bump)
+    logger.info("The latest release in this branch's history was %s", latest_version)
 
-        log.debug("checking if commit %s matches any tags", commit.hexsha)
-        t_v = tag_sha_2_version_lookup.get(commit.hexsha, None)
-
-        if t_v is None:
-            # If we haven't found the latest prerelease on the branch,
-            # keep the loop going to look for it
-            log.debug("no tags correspond to commit %s", commit.hexsha)
-            continue
+    # Step 4. Walk the git tree to find all commits that have been made since the last release
+    commits_since_last_release = _traverse_graph_for_commits(
+        head_commit=repo.active_branch.commit,
+        latest_release_tag_str=(
+            # NOTE: the default_initial_version should not actually exist on the repository (ie v0.0.0)
+            # so we provide an empty tag string when there are no tags on the repository yet
+            latest_version.as_tag() if latest_version != default_initial_version else ""
+        ),
+    )
 
-        # Unpack the tuple
-        tag, latest_version = t_v
-        log.debug(
-            "tag %r (%s) matches commit %s. the latest version is %s",
-            tag.name,
-            tag.commit.hexsha,
-            commit.hexsha,
-            latest_version,
+    # Step 5. Parse the commits to determine the bump level that should be applied
+    parsed_levels: set[LevelBump] = {
+        parsed_result.bump  # type: ignore[union-attr] # too complex for type checkers
+        for parsed_result in filter(
+            lambda parsed_result: isinstance(parsed_result, ParsedCommit),
+            map(commit_parser.parse, commits_since_last_release),
         )
-        break
+    }
 
-    log.debug(
-        "parsed the following distinct levels from the commits since the last release: "
-        "%s",
+    logger.debug(
+        "parsed the following distinct levels from the commits since the last release: %s",
         parsed_levels,
     )
+
     level_bump = max(parsed_levels, default=LevelBump.NO_RELEASE)
-    log.info("The type of the next release release is: %s", level_bump)
-    if level_bump is LevelBump.NO_RELEASE:  # noqa: SIM102
-        if latest_version.major != 0 or allow_zero_version:
-            log.info("No release will be made")
-            return latest_version
+    logger.info("The type of the next release release is: %s", level_bump)
+
+    if all(
+        [
+            level_bump is LevelBump.NO_RELEASE,
+            latest_version.major != 0 or allow_zero_version,
+        ]
+    ):
+        logger.info("No release will be made")
+        return latest_version
 
     return _increment_version(
         latest_version=latest_version,
         latest_full_version=latest_full_release_version,
-        latest_full_version_in_history=(
-            latest_full_version_in_history
-            or Version(
-                0,
-                0,
-                0,
-                prerelease_token=translator.prerelease_token,
-                tag_format=translator.tag_format,
-            )
-        ),
         level_bump=level_bump,
         prerelease=prerelease,
         prerelease_token=translator.prerelease_token,