python-semantic-release 10.3.2__py3-none-any.whl → 10.4.1__py3-none-any.whl

{python_semantic_release-10.3.2.dist-info → python_semantic_release-10.4.1.dist-info}/METADATA

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

{python_semantic_release-10.3.2.dist-info → python_semantic_release-10.4.1.dist-info}/RECORD

@@ -1,4 +1,4 @@
-python_semantic_release-10.3.2.dist-info/licenses/LICENSE,sha256=NE85nszX252sdQdu0xgS9qwfYES0k8qS6gW3uO4jRGE,1083
+python_semantic_release-10.4.1.dist-info/licenses/LICENSE,sha256=NE85nszX252sdQdu0xgS9qwfYES0k8qS6gW3uO4jRGE,1083
 semantic_release/__init__.py,sha256=tRJWhrn_dUt0QycXD2DoJSfEP5uwmxngH7jvbG2i-hA,1317
 semantic_release/__main__.py,sha256=pksxr6g1vkKq98Q1lShsxG8tk55IMiSMHzAHKyFU5x0,1704
 semantic_release/const.py,sha256=wInJR7vcOgT1ysm5VuJQ6lD_ZGYnCwRVKz7Uz3htQc4,861
@@ -15,7 +15,7 @@ semantic_release/changelog/template.py,sha256=eqOjtVfBbksgTK4CAZOajfkaAcKueJ-FhF
 semantic_release/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 semantic_release/cli/changelog_writer.py,sha256=2jP5b0LK61Y2tb22GQSFFmwHwXd2WjbopgsMAmsQsfY,9284
 semantic_release/cli/cli_context.py,sha256=Nop71LdVCJOeSUHgTXunMyK3xAu_QKQC2cRp1QBVkX0,4134
-semantic_release/cli/config.py,sha256=4UCx4-jzKpggb7dZM3fnZoi8rPiUGWtEmLiCfWlro7I,33458
+semantic_release/cli/config.py,sha256=dCQ1HqzBc_8RG_oTQtBMuCnM7zOEj9E1bDblxobg8os,33569
 semantic_release/cli/const.py,sha256=h7XE2D0D__TAZSrUUtVszwvzpkHTMOiQCf97XQNbEvA,163
 semantic_release/cli/github_actions_output.py,sha256=yC0nsMvEFGACjDwB8DdmGKwNGI8aIIhDxRHrmcS7tzA,5410
 semantic_release/cli/masking_filter.py,sha256=GsTyaoZbUVJLXVMqeXhCttXK84UnBQ8cNDSHxd52sOc,3218
@@ -25,16 +25,20 @@ semantic_release/cli/commands/changelog.py,sha256=wJfd4VVfrGnu2jnIpG25cdVcbXIX-E
 semantic_release/cli/commands/generate_config.py,sha256=2xZOu3NpyhBp0pWr7d8ugKl_kjqQgpSsSMHq5wHTfrE,1699
 semantic_release/cli/commands/main.py,sha256=u1zhkkvKCZ2TtUqjzvdFTe5UZsvfws_pjqqo6CY0bBo,4351
 semantic_release/cli/commands/publish.py,sha256=CE_LJTxFnc337MfpsfdJopi7QCwwE13GqGNQ-dNgWis,2871
-semantic_release/cli/commands/version.py,sha256=CwFwoBP896Y9dc_p5bAyjZFbuD78tCS-q5IueQsOVSU,26634
-semantic_release/commit_parser/__init__.py,sha256=6euiDgj9bwOx1rP96vUjq090usviXkbo7OVOnRBGfcw,742
+semantic_release/cli/commands/version.py,sha256=vlBNbQq0rW930UpI983-Rr-71fdK6qVPjMiRqMTBBUE,26616
+semantic_release/commit_parser/__init__.py,sha256=uCC2YI-EDPUAa6TwWYJA8TS7baWE2bXrLEGcrhJKofI,1323
 semantic_release/commit_parser/_base.py,sha256=DLsHnbXG-39JkUbcnsBCSV2GmV35w1rasyoMhK8G0UE,3058
 semantic_release/commit_parser/angular.py,sha256=MY_fo9F4EZ-ac8wYzBR0uD94O5Li2D-8zEMR01wss4c,18534
-semantic_release/commit_parser/conventional.py,sha256=Iyy8txkshK8HikizFVa7pnJHBSWDhOhF45zR866QxQM,18672
 semantic_release/commit_parser/emoji.py,sha256=0VecUMMcj43UaKDZ2GaFFUG26zOJAvXsEobTHaXNkk0,17749
 semantic_release/commit_parser/scipy.py,sha256=gA9TfmrxGVvtv6kki6N_9abJx-_WlpBsSX2TBh0YgPw,19463
 semantic_release/commit_parser/tag.py,sha256=bVO2XghM0G_eW2rG9Xc2q5TPsjtxr-xcHK5RpE1u_HM,3537
 semantic_release/commit_parser/token.py,sha256=1_q8mJ4SRu7kNfa-Nxr8fEyuvCfjPgiPEitqSP1KR5g,7904
 semantic_release/commit_parser/util.py,sha256=hcLjc16o7l6y_5Hfl8IxmF4ijaJD62JdjdB2DJWAe-g,3959
+semantic_release/commit_parser/conventional/__init__.py,sha256=JHPL3S6trM4Le9MXnXc6iPYxxQnE4j0LG83_BWIomOw,602
+semantic_release/commit_parser/conventional/options.py,sha256=AnRgTRMF-3X5QonTqq6bqJEbmGgQBzppyRZ79hct28g,2598
+semantic_release/commit_parser/conventional/options_monorepo.py,sha256=7OCpuaYhw01bfoffTGfPgEWzRRyVsdsq_n2eo8Dt8-8,3210
+semantic_release/commit_parser/conventional/parser.py,sha256=Pex26cvMqAKx9NPH3KROYg7k76R0Nsbs4aHor5SbMZg,16671
+semantic_release/commit_parser/conventional/parser_monorepo.py,sha256=nVAc_gK4tJ5UM_rd9KbXgBWeBgrI_q2-vav3_4748r8,21189
 semantic_release/data/templates/conventional/md/.release_notes.md.j2,sha256=DlMVAJMGqE27TwJ-2kviYaFhd3uWqXiU6Ikl15Ukne8,2512
 semantic_release/data/templates/conventional/md/CHANGELOG.md.j2,sha256=FZmrQ-qOIoSoJmAa_NFaRelfmqUpypU2xlDeScdGOf4,729
 semantic_release/data/templates/conventional/md/.components/changelog_header.md.j2,sha256=qNxTuSr59CV_yyimVU_RYp5azCnK0l6nJ03Zf0u5Ugg,166
@@ -73,8 +77,8 @@ semantic_release/version/declarations/enum.py,sha256=3n5Py9DoFkmItIdsmtQrJgmAhep
 semantic_release/version/declarations/i_version_replacer.py,sha256=oP6BxJuxwI44roI6448tomShv1sMoy9ry8TlhhIQtfc,2416
 semantic_release/version/declarations/pattern.py,sha256=MpUmsHYGAVAuFSKSb29FLcWeUCEHG_TRyhMO-2DWAAs,8308
 semantic_release/version/declarations/toml.py,sha256=2K4DtX5Qq1iHT8cG8mISPTMmp50w6Av0KmLAKZPYqq8,4931
-python_semantic_release-10.3.2.dist-info/METADATA,sha256=Hvdc-N4cJe-GX8gGtD08rfqjASK0I93EaYxuCU6pNK4,3927
-python_semantic_release-10.3.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-python_semantic_release-10.3.2.dist-info/entry_points.txt,sha256=kzkCyDJsMOwgpFwEWKE9wxN1tXaUP6g6GIO4xtc0QuE,162
-python_semantic_release-10.3.2.dist-info/top_level.txt,sha256=qYA24nyg3eP-ti5UW7Vuj2aXVmM0wqVHx4mREdRZNAA,17
-python_semantic_release-10.3.2.dist-info/RECORD,,
+python_semantic_release-10.4.1.dist-info/METADATA,sha256=_p8pbdBeY6Sz6ch5N7HguLDiBT2IzfNR5NflXHrTt38,3927
+python_semantic_release-10.4.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+python_semantic_release-10.4.1.dist-info/entry_points.txt,sha256=kzkCyDJsMOwgpFwEWKE9wxN1tXaUP6g6GIO4xtc0QuE,162
+python_semantic_release-10.4.1.dist-info/top_level.txt,sha256=qYA24nyg3eP-ti5UW7Vuj2aXVmM0wqVHx4mREdRZNAA,17
+python_semantic_release-10.4.1.dist-info/RECORD,,

semantic_release/cli/commands/version.py

@@ -710,7 +710,7 @@ def version(  # noqa: C901
     # are disabled, and the changelog generation is disabled or it's not
     # modified, then the HEAD commit will be tagged as a release commit
     # despite not being made by PSR
-    if commit_changes or create_tag:
+    if create_tag:
         project.git_tag(
             tag_name=new_version.as_tag(),
             message=new_version.as_tag(),

semantic_release/cli/config.py

@@ -39,6 +39,7 @@ from semantic_release.cli.masking_filter import MaskingFilter
 from semantic_release.commit_parser import (
     AngularCommitParser,
     CommitParser,
+    ConventionalCommitMonorepoParser,
     ConventionalCommitParser,
     EmojiCommitParser,
     ParseResult,
@@ -71,9 +72,10 @@ class HvcsClient(str, Enum):
     GITEA = "gitea"
 
 
-_known_commit_parsers: Dict[str, type[CommitParser]] = {
-    "conventional": ConventionalCommitParser,
+_known_commit_parsers: dict[str, type[CommitParser[Any, Any]]] = {
     "angular": AngularCommitParser,
+    "conventional": ConventionalCommitParser,
+    "conventional-monorepo": ConventionalCommitMonorepoParser,
     "emoji": EmojiCommitParser,
     "scipy": ScipyCommitParser,
     "tag": TagCommitParser,

semantic_release/commit_parser/__init__.py

@@ -7,6 +7,8 @@ from semantic_release.commit_parser.angular import (
     AngularParserOptions,
 )
 from semantic_release.commit_parser.conventional import (
+    ConventionalCommitMonorepoParser,
+    ConventionalCommitMonorepoParserOptions,
     ConventionalCommitParser,
     ConventionalCommitParserOptions,
 )
@@ -28,3 +30,24 @@ from semantic_release.commit_parser.token import (
     ParseResult,
     ParseResultType,
 )
+
+__all__ = [
+    "CommitParser",
+    "ParserOptions",
+    "AngularCommitParser",
+    "AngularParserOptions",
+    "ConventionalCommitParser",
+    "ConventionalCommitParserOptions",
+    "ConventionalCommitMonorepoParser",
+    "ConventionalCommitMonorepoParserOptions",
+    "EmojiCommitParser",
+    "EmojiParserOptions",
+    "ScipyCommitParser",
+    "ScipyParserOptions",
+    "TagCommitParser",
+    "TagParserOptions",
+    "ParsedCommit",
+    "ParseError",
+    "ParseResult",
+    "ParseResultType",
+]

semantic_release/commit_parser/conventional/__init__.py

@@ -0,0 +1,17 @@
+from semantic_release.commit_parser.conventional.options import (
+    ConventionalCommitParserOptions,
+)
+from semantic_release.commit_parser.conventional.options_monorepo import (
+    ConventionalCommitMonorepoParserOptions,
+)
+from semantic_release.commit_parser.conventional.parser import ConventionalCommitParser
+from semantic_release.commit_parser.conventional.parser_monorepo import (
+    ConventionalCommitMonorepoParser,
+)
+
+__all__ = [
+    "ConventionalCommitParser",
+    "ConventionalCommitParserOptions",
+    "ConventionalCommitMonorepoParser",
+    "ConventionalCommitMonorepoParserOptions",
+]

semantic_release/commit_parser/conventional/options.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+from itertools import zip_longest
+from typing import Tuple
+
+from pydantic.dataclasses import dataclass
+
+from semantic_release.commit_parser._base import ParserOptions
+from semantic_release.enums import LevelBump
+
+
+@dataclass
+class ConventionalCommitParserOptions(ParserOptions):
+    """Options dataclass for the ConventionalCommitParser."""
+
+    minor_tags: Tuple[str, ...] = ("feat",)
+    """Commit-type prefixes that should result in a minor release bump."""
+
+    patch_tags: Tuple[str, ...] = ("fix", "perf")
+    """Commit-type prefixes that should result in a patch release bump."""
+
+    other_allowed_tags: Tuple[str, ...] = (
+        "build",
+        "chore",
+        "ci",
+        "docs",
+        "style",
+        "refactor",
+        "test",
+    )
+    """Commit-type prefixes that are allowed but do not result in a version bump."""
+
+    allowed_tags: Tuple[str, ...] = (
+        *minor_tags,
+        *patch_tags,
+        *other_allowed_tags,
+    )
+    """
+    All commit-type prefixes that are allowed.
+
+    These are used to identify a valid commit message. If a commit message does not start with
+    one of these prefixes, it will not be considered a valid commit message.
+    """
+
+    default_bump_level: LevelBump = LevelBump.NO_RELEASE
+    """The minimum bump level to apply to valid commit message."""
+
+    parse_squash_commits: bool = True
+    """Toggle flag for whether or not to parse squash commits"""
+
+    ignore_merge_commits: bool = True
+    """Toggle flag for whether or not to ignore merge commits"""
+
+    @property
+    def tag_to_level(self) -> dict[str, LevelBump]:
+        """A mapping of commit tags to the level bump they should result in."""
+        return self._tag_to_level
+
+    def __post_init__(self) -> None:
+        self._tag_to_level: dict[str, LevelBump] = {
+            str(tag): level
+            for tag, level in [
+                # we have to do a type ignore as zip_longest provides a type that is not specific enough
+                # for our expected output. Due to the empty second array, we know the first is always longest
+                # and that means no values in the first entry of the tuples will ever be a LevelBump. We
+                # apply a str() to make mypy happy although it will never happen.
+                *zip_longest(self.allowed_tags, (), fillvalue=self.default_bump_level),
+                *zip_longest(self.patch_tags, (), fillvalue=LevelBump.PATCH),
+                *zip_longest(self.minor_tags, (), fillvalue=LevelBump.MINOR),
+            ]
+            if "|" not in str(tag)
+        }

semantic_release/commit_parser/conventional/options_monorepo.py

@@ -0,0 +1,90 @@
+from __future__ import annotations
+
+from pathlib import Path
+from re import compile as regexp, error as RegExpError  # noqa: N812
+from typing import TYPE_CHECKING, Any, Iterable, Tuple
+
+from pydantic import Field, field_validator
+from pydantic.dataclasses import dataclass
+
+# typing_extensions is for Python 3.8, 3.9, 3.10 compatibility
+from typing_extensions import Annotated
+
+from semantic_release.commit_parser.conventional.options import (
+    ConventionalCommitParserOptions,
+)
+
+if TYPE_CHECKING:  # pragma: no cover
+    pass
+
+
+@dataclass
+class ConventionalCommitMonorepoParserOptions(ConventionalCommitParserOptions):
+    # TODO: add example into the docstring
+    """Options dataclass for ConventionalCommitMonorepoParser."""
+
+    path_filters: Annotated[Tuple[str, ...], Field(validate_default=True)] = (".",)
+    """
+    A set of relative paths to filter commits by. Only commits with file changes that
+    match these file paths or its subdirectories will be considered valid commits.
+
+    Syntax is similar to .gitignore with file path globs and inverse file match globs
+    via `!` prefix. Paths should be relative to the current working directory.
+    """
+
+    scope_prefix: str = ""
+    """
+    A prefix that will be striped from the scope when parsing commit messages.
+
+    If set, it will cause unscoped commits to be ignored. Use this in tandem with
+    the `path_filters` option to filter commits by directory and scope. This will
+    be fed into a regular expression so you must escape any special characters that
+    are meaningful in regular expressions (e.g. `.`, `*`, `?`, `+`, etc.) if you want
+    to match them literally.
+    """
+
+    @classmethod
+    @field_validator("path_filters", mode="before")
+    def convert_strs_to_paths(cls, value: Any) -> tuple[Path, ...]:
+        values = value if isinstance(value, Iterable) else [value]
+        results: list[Path] = []
+
+        for val in values:
+            if isinstance(val, (str, Path)):
+                results.append(Path(val))
+                continue
+
+            raise TypeError(f"Invalid type: {type(val)}, expected str or Path.")
+
+        return tuple(results)
+
+    @classmethod
+    @field_validator("path_filters", mode="after")
+    def resolve_path(cls, dir_paths: tuple[Path, ...]) -> tuple[Path, ...]:
+        return tuple(
+            (
+                Path(f"!{Path(str_path[1:]).expanduser().absolute().resolve()}")
+                # maintains the negation prefix if it exists
+                if (str_path := str(path)).startswith("!")
+                # otherwise, resolve the path normally
+                else path.expanduser().absolute().resolve()
+            )
+            for path in dir_paths
+        )
+
+    @classmethod
+    @field_validator("scope_prefix", mode="after")
+    def validate_scope_prefix(cls, scope_prefix: str) -> str:
+        if not scope_prefix:
+            return ""
+
+        # Allow the special case of a plain wildcard although it's not a valid regex
+        if scope_prefix == "*":
+            return ".*"
+
+        try:
+            regexp(scope_prefix)
+        except RegExpError as err:
+            raise ValueError(f"Invalid regex {scope_prefix!r}") from err
+
+        return scope_prefix

semantic_release/commit_parser/{conventional.py → conventional/parser.py}

@@ -1,16 +1,25 @@
 from __future__ import annotations
 
-import re
 from functools import reduce
-from itertools import zip_longest
-from re import compile as regexp
+from logging import getLogger
+from re import (
+    DOTALL,
+    IGNORECASE,
+    MULTILINE,
+    Match as RegexMatch,
+    Pattern,
+    compile as regexp,
+    error as RegexError,  # noqa: N812
+)
 from textwrap import dedent
-from typing import TYPE_CHECKING, Tuple
+from typing import TYPE_CHECKING, ClassVar
 
 from git.objects.commit import Commit
-from pydantic.dataclasses import dataclass
 
-from semantic_release.commit_parser._base import CommitParser, ParserOptions
+from semantic_release.commit_parser._base import CommitParser
+from semantic_release.commit_parser.conventional.options import (
+    ConventionalCommitParserOptions,
+)
 from semantic_release.commit_parser.token import (
     ParsedCommit,
     ParsedMessageResult,
@@ -25,16 +34,10 @@ from semantic_release.commit_parser.util import (
 )
 from semantic_release.enums import LevelBump
 from semantic_release.errors import InvalidParserOptions
-from semantic_release.globals import logger
 from semantic_release.helpers import sort_numerically, text_reducer
 
-if TYPE_CHECKING:  # pragma: no cover
-    from git.objects.commit import Commit
-
-
-def _logged_parse_error(commit: Commit, error: str) -> ParseError:
-    logger.debug(error)
-    return ParseError(commit, error=error)
+if TYPE_CHECKING:
+    pass
 
 
 # TODO: Remove from here, allow for user customization instead via options
@@ -53,69 +56,6 @@ LONG_TYPE_NAMES = {
 }
 
 
-@dataclass
-class ConventionalCommitParserOptions(ParserOptions):
-    """Options dataclass for the ConventionalCommitParser."""
-
-    minor_tags: Tuple[str, ...] = ("feat",)
-    """Commit-type prefixes that should result in a minor release bump."""
-
-    patch_tags: Tuple[str, ...] = ("fix", "perf")
-    """Commit-type prefixes that should result in a patch release bump."""
-
-    other_allowed_tags: Tuple[str, ...] = (
-        "build",
-        "chore",
-        "ci",
-        "docs",
-        "style",
-        "refactor",
-        "test",
-    )
-    """Commit-type prefixes that are allowed but do not result in a version bump."""
-
-    allowed_tags: Tuple[str, ...] = (
-        *minor_tags,
-        *patch_tags,
-        *other_allowed_tags,
-    )
-    """
-    All commit-type prefixes that are allowed.
-
-    These are used to identify a valid commit message. If a commit message does not start with
-    one of these prefixes, it will not be considered a valid commit message.
-    """
-
-    default_bump_level: LevelBump = LevelBump.NO_RELEASE
-    """The minimum bump level to apply to valid commit message."""
-
-    parse_squash_commits: bool = True
-    """Toggle flag for whether or not to parse squash commits"""
-
-    ignore_merge_commits: bool = True
-    """Toggle flag for whether or not to ignore merge commits"""
-
-    @property
-    def tag_to_level(self) -> dict[str, LevelBump]:
-        """A mapping of commit tags to the level bump they should result in."""
-        return self._tag_to_level
-
-    def __post_init__(self) -> None:
-        self._tag_to_level: dict[str, LevelBump] = {
-            str(tag): level
-            for tag, level in [
-                # we have to do a type ignore as zip_longest provides a type that is not specific enough
-                # for our expected output. Due to the empty second array, we know the first is always longest
-                # and that means no values in the first entry of the tuples will ever be a LevelBump. We
-                # apply a str() to make mypy happy although it will never happen.
-                *zip_longest(self.allowed_tags, (), fillvalue=self.default_bump_level),
-                *zip_longest(self.patch_tags, (), fillvalue=LevelBump.PATCH),
-                *zip_longest(self.minor_tags, (), fillvalue=LevelBump.MINOR),
-            ]
-            if "|" not in str(tag)
-        }
-
-
 class ConventionalCommitParser(
     CommitParser[ParseResult, ConventionalCommitParserOptions]
 ):
@@ -128,14 +68,57 @@ class ConventionalCommitParser(
     # TODO: Deprecate in lieu of get_default_options()
     parser_options = ConventionalCommitParserOptions
 
+    # GitHub & Gitea use (#123), GitLab uses (!123), and BitBucket uses (pull request #123)
+    mr_selector = regexp(r"[\t ]+\((?:pull request )?(?P<mr_number>[#!]\d+)\)[\t ]*$")
+
+    issue_selector = regexp(
+        str.join(
+            "",
+            [
+                r"^(?:clos(?:e|es|ed|ing)|fix(?:es|ed|ing)?|resolv(?:e|es|ed|ing)|implement(?:s|ed|ing)?):",
+                r"[\t ]+(?P<issue_predicate>.+)[\t ]*$",
+            ],
+        ),
+        flags=MULTILINE | IGNORECASE,
+    )
+
+    notice_selector = regexp(r"^NOTICE: (?P<notice>.+)$")
+
+    common_commit_msg_filters: ClassVar[dict[str, tuple[Pattern[str], str]]] = {
+        "typo-extra-spaces": (regexp(r"(\S)  +(\S)"), r"\1 \2"),
+        "git-header-commit": (
+            regexp(r"^[\t ]*commit [0-9a-f]+$\n?", flags=MULTILINE),
+            "",
+        ),
+        "git-header-author": (
+            regexp(r"^[\t ]*Author: .+$\n?", flags=MULTILINE),
+            "",
+        ),
+        "git-header-date": (
+            regexp(r"^[\t ]*Date: .+$\n?", flags=MULTILINE),
+            "",
+        ),
+        "git-squash-heading": (
+            regexp(
+                r"^[\t ]*Squashed commit of the following:.*$\n?",
+                flags=MULTILINE,
+            ),
+            "",
+        ),
+    }
+
     def __init__(self, options: ConventionalCommitParserOptions | None = None) -> None:
         super().__init__(options)
 
+        self._logger = getLogger(
+            str.join(".", [self.__module__, self.__class__.__name__])
+        )
+
         try:
             commit_type_pattern = regexp(
                 r"(?P<type>%s)" % str.join("|", self.options.allowed_tags)
             )
-        except re.error as err:
+        except RegexError as err:
             raise InvalidParserOptions(
                 str.join(
                     "\n",
@@ -167,45 +150,11 @@ class ConventionalCommitParser(
                     r"(?:\n\n(?P<text>.+))?",  # commit body
                 ],
             ),
-            flags=re.DOTALL,
+            flags=DOTALL,
         )
 
-        # GitHub & Gitea use (#123), GitLab uses (!123), and BitBucket uses (pull request #123)
-        self.mr_selector = regexp(
-            r"[\t ]+\((?:pull request )?(?P<mr_number>[#!]\d+)\)[\t ]*$"
-        )
-        self.issue_selector = regexp(
-            str.join(
-                "",
-                [
-                    r"^(?:clos(?:e|es|ed|ing)|fix(?:es|ed|ing)?|resolv(?:e|es|ed|ing)|implement(?:s|ed|ing)?):",
-                    r"[\t ]+(?P<issue_predicate>.+)[\t ]*$",
-                ],
-            ),
-            flags=re.MULTILINE | re.IGNORECASE,
-        )
-        self.notice_selector = regexp(r"^NOTICE: (?P<notice>.+)$")
-        self.filters = {
-            "typo-extra-spaces": (regexp(r"(\S)  +(\S)"), r"\1 \2"),
-            "git-header-commit": (
-                regexp(r"^[\t ]*commit [0-9a-f]+$\n?", flags=re.MULTILINE),
-                "",
-            ),
-            "git-header-author": (
-                regexp(r"^[\t ]*Author: .+$\n?", flags=re.MULTILINE),
-                "",
-            ),
-            "git-header-date": (
-                regexp(r"^[\t ]*Date: .+$\n?", flags=re.MULTILINE),
-                "",
-            ),
-            "git-squash-heading": (
-                regexp(
-                    r"^[\t ]*Squashed commit of the following:.*$\n?",
-                    flags=re.MULTILINE,
-                ),
-                "",
-            ),
+        self.filters: dict[str, tuple[Pattern[str], str]] = {
+            **self.common_commit_msg_filters,
             "git-squash-commit-prefix": (
                 regexp(
                     str.join(
@@ -215,17 +164,20 @@ class ConventionalCommitParser(
                             commit_type_pattern.pattern + r"\b",  # prior to commit type
                         ],
                     ),
-                    flags=re.MULTILINE,
+                    flags=MULTILINE,
                 ),
                 # move commit type to the start of the line
                 r"\1",
             ),
         }
 
-    @staticmethod
-    def get_default_options() -> ConventionalCommitParserOptions:
+    def get_default_options(self) -> ConventionalCommitParserOptions:
         return ConventionalCommitParserOptions()
 
+    def log_parse_error(self, commit: Commit, error: str) -> ParseError:
+        self._logger.debug(error)
+        return ParseError(commit, error=error)
+
     def commit_body_components_separator(
         self, accumulator: dict[str, list[str]], text: str
     ) -> dict[str, list[str]]:
@@ -267,14 +219,20 @@ class ConventionalCommitParser(
         return accumulator
 
     def parse_message(self, message: str) -> ParsedMessageResult | None:
-        if not (parsed := self.commit_msg_pattern.match(message)):
-            return None
+        return (
+            self.create_parsed_message_result(match)
+            if (match := self.commit_msg_pattern.match(message))
+            else None
+        )
 
-        parsed_break = parsed.group("break")
-        parsed_scope = parsed.group("scope") or ""
-        parsed_subject = parsed.group("subject")
-        parsed_text = parsed.group("text")
-        parsed_type = parsed.group("type")
+    def create_parsed_message_result(
+        self, match: RegexMatch[str]
+    ) -> ParsedMessageResult:
+        parsed_break = match.group("break")
+        parsed_scope = match.group("scope") or ""
+        parsed_subject = match.group("subject")
+        parsed_text = match.group("text")
+        parsed_type = match.group("type")
 
         linked_merge_request = ""
         if mr_match := self.mr_selector.search(parsed_subject):
@@ -322,7 +280,7 @@ class ConventionalCommitParser(
 
     def parse_commit(self, commit: Commit) -> ParseResult:
         if not (parsed_msg_result := self.parse_message(force_str(commit.message))):
-            return _logged_parse_error(
+            return self.log_parse_error(
                 commit,
                 f"Unable to parse commit message: {commit.message!r}",
             )
@@ -342,7 +300,7 @@ class ConventionalCommitParser(
         will be returned as a list of a single ParseResult.
         """
         if self.options.ignore_merge_commits and self.is_merge_commit(commit):
-            return _logged_parse_error(
+            return self.log_parse_error(
                 commit, "Ignoring merge commit: %s" % commit.hexsha[:8]
             )
 

semantic_release/commit_parser/conventional/parser_monorepo.py

@@ -0,0 +1,467 @@
+from __future__ import annotations
+
+import os
+from fnmatch import fnmatch
+from logging import getLogger
+from pathlib import Path, PurePath, PurePosixPath, PureWindowsPath
+from re import DOTALL, compile as regexp, error as RegexError  # noqa: N812
+from typing import TYPE_CHECKING
+
+from semantic_release.commit_parser._base import CommitParser
+from semantic_release.commit_parser.conventional.options import (
+    ConventionalCommitParserOptions,
+)
+from semantic_release.commit_parser.conventional.options_monorepo import (
+    ConventionalCommitMonorepoParserOptions,
+)
+from semantic_release.commit_parser.conventional.parser import ConventionalCommitParser
+from semantic_release.commit_parser.token import (
+    ParsedCommit,
+    ParsedMessageResult,
+    ParseError,
+    ParseResult,
+)
+from semantic_release.commit_parser.util import force_str
+from semantic_release.errors import InvalidParserOptions
+
+if TYPE_CHECKING:  # pragma: no cover
+    from git.objects.commit import Commit
+
+
+class ConventionalCommitMonorepoParser(
+    CommitParser[ParseResult, ConventionalCommitMonorepoParserOptions]
+):
+    # TODO: Remove for v11 compatibility, get_default_options() will be called instead
+    parser_options = ConventionalCommitMonorepoParserOptions
+
+    def __init__(
+        self, options: ConventionalCommitMonorepoParserOptions | None = None
+    ) -> None:
+        super().__init__(options)
+
+        try:
+            commit_scope_pattern = regexp(
+                r"\(" + self.options.scope_prefix + r"(?P<scope>[^\n]+)?\)",
+            )
+        except RegexError as err:
+            raise InvalidParserOptions(
+                str.join(
+                    "\n",
+                    [
+                        f"Invalid options for {self.__class__.__name__}",
+                        "Unable to create regular expression from configured scope_prefix.",
+                        "Please check the configured scope_prefix and remove or escape any regular expression characters.",
+                    ],
+                )
+            ) from err
+
+        try:
+            commit_type_pattern = regexp(
+                r"(?P<type>%s)" % str.join("|", self.options.allowed_tags)
+            )
+        except RegexError as err:
+            raise InvalidParserOptions(
+                str.join(
+                    "\n",
+                    [
+                        f"Invalid options for {self.__class__.__name__}",
+                        "Unable to create regular expression from configured commit-types.",
+                        "Please check the configured commit-types and remove or escape any regular expression characters.",
+                    ],
+                )
+            ) from err
+
+        # This regular expression includes scope prefix into the pattern and forces a scope to be present
+        # PSR will match the full scope but we don't include it in the scope match,
+        # which implicitly strips it from being included in the returned scope.
+        self._strict_scope_pattern = regexp(
+            str.join(
+                "",
+                [
+                    r"^" + commit_type_pattern.pattern,
+                    commit_scope_pattern.pattern,
+                    r"(?P<break>!)?:\s+",
+                    r"(?P<subject>[^\n]+)",
+                    r"(?:\n\n(?P<text>.+))?",  # commit body
+                ],
+            ),
+            flags=DOTALL,
+        )
+
+        self._optional_scope_pattern = regexp(
+            str.join(
+                "",
+                [
+                    r"^" + commit_type_pattern.pattern,
+                    r"(?:\((?P<scope>[^\n]+)\))?",
+                    r"(?P<break>!)?:\s+",
+                    r"(?P<subject>[^\n]+)",
+                    r"(?:\n\n(?P<text>.+))?",  # commit body
+                ],
+            ),
+            flags=DOTALL,
+        )
+
+        file_select_filters, file_ignore_filters = self._process_path_filter_options(
+            self.options.path_filters
+        )
+        self._file_selection_filters: list[str] = file_select_filters
+        self._file_ignore_filters: list[str] = file_ignore_filters
+
+        self._logger = getLogger(
+            str.join(".", [self.__module__, self.__class__.__name__])
+        )
+
+        self._base_parser = ConventionalCommitParser(
+            options=ConventionalCommitParserOptions(
+                **{
+                    k: getattr(self.options, k)
+                    for k in ConventionalCommitParserOptions().__dataclass_fields__
+                }
+            )
+        )
+
+    def get_default_options(self) -> ConventionalCommitMonorepoParserOptions:
+        return ConventionalCommitMonorepoParserOptions()
+
+    @staticmethod
+    def _process_path_filter_options(  # noqa: C901
+        path_filters: tuple[str, ...],
+    ) -> tuple[list[str], list[str]]:
+        file_ignore_filters: list[str] = []
+        file_selection_filters: list[str] = []
+        unique_selection_filters: set[str] = set()
+        unique_ignore_filters: set[str] = set()
+
+        for str_path in path_filters:
+            str_filter = str_path[1:] if str_path.startswith("!") else str_path
+            filter_list = (
+                file_ignore_filters
+                if str_path.startswith("!")
+                else file_selection_filters
+            )
+            unique_cache = (
+                unique_ignore_filters
+                if str_path.startswith("!")
+                else unique_selection_filters
+            )
+
+            # Since fnmatch is not too flexible, we will expand the path filters to include the name and any subdirectories
+            # as this is how gitignore is interpreted. Possible scenarios:
+            # | Input      | Path Normalization | Filter List               |
+            # | ---------- | ------------------ | ------------------------- |
+            # | /          | /                  | /**                       | done
+            # | /./        | /                  | /**                       | done
+            # | /**        | /**                | /**                       | done
+            # | /./**      | /**                | /**                       | done
+            # | /*         | /*                 | /*                        | done
+            # | .          | .                  | ./**                      | done
+            # | ./         | .                  | ./**                      | done
+            # | ././       | .                  | ./**                      | done
+            # | ./**       | ./**               | ./**                      | done
+            # | ./*        | ./*                | ./*                       | done
+            # | ..         | ..                 | ../**                     | done
+            # | ../        | ..                 | ../**                     | done
+            # | ../**      | ../**              | ../**                     | done
+            # | ../*       | ../*               | ../*                      | done
+            # | ../..      | ../..              | ../../**                  | done
+            # | ../../     | ../../             | ../../**                  | done
+            # | ../../docs | ../../docs         | ../../docs, ../../docs/** | done
+            # | src        | src                | src, src/**               | done
+            # | src/       | src                | src/**                    | done
+            # | src/*      | src/*              | src/*                     | done
+            # | src/**     | src/**             | src/**                    | done
+            # | /src       | /src               | /src, /src/**             | done
+            # | /src/      | /src               | /src/**                   | done
+            # | /src/**    | /src/**            | /src/**                   | done
+            # | /src/*     | /src/*             | /src/*                    | done
+            # | ../d/f.txt | ../d/f.txt         | ../d/f.txt, ../d/f.txt/** | done
+            # This expansion will occur regardless of the negation prefix
+
+            os_path: PurePath | PurePosixPath | PureWindowsPath = PurePath(str_filter)
+
+            if r"\\" in str_filter:
+                # Windows paths were given so we convert them to posix paths
+                os_path = PureWindowsPath(str_filter)
+                os_path = (
+                    PureWindowsPath(
+                        os_path.root, *os_path.parts[1:]
+                    )  # drop any drive letter
+                    if os_path.is_absolute()
+                    else os_path
+                )
+                os_path = PurePosixPath(os_path.as_posix())
+
+            path_normalized = str(os_path)
+            if path_normalized == str(
+                Path(".").absolute().root
+            ) or path_normalized == str(Path("/**")):
+                path_normalized = "/**"
+
+            elif path_normalized == str(Path("/*")):
+                pass
+
+            elif path_normalized == str(Path(".")) or path_normalized == str(
+                Path("./**")
+            ):
+                path_normalized = "./**"
+
+            elif path_normalized == str(Path("./*")):
+                path_normalized = "./*"
+
+            elif path_normalized == str(Path("..")) or path_normalized == str(
+                Path("../**")
+            ):
+                path_normalized = "../**"
+
+            elif path_normalized == str(Path("../*")):
+                path_normalized = "../*"
+
+            elif path_normalized.endswith(("..", "../**")):
+                path_normalized = f"{path_normalized.rstrip('*')}/**"
+
+            elif str_filter.endswith(os.sep):
+                # If the path ends with a separator, it is a directory, so we add the directory and all subdirectories
+                path_normalized = f"{path_normalized}/**"
+
+            elif not path_normalized.endswith("*"):
+                all_subdirs = f"{path_normalized}/**"
+                if all_subdirs not in unique_cache:
+                    unique_cache.add(all_subdirs)
+                    filter_list.append(all_subdirs)
+                # And fall through to add the path as is
+
+            # END IF
+
+            # Add the normalized path to the filter list if it is not already present
+            if path_normalized not in unique_cache:
+                unique_cache.add(path_normalized)
+                filter_list.append(path_normalized)
+
+        return file_selection_filters, file_ignore_filters
+
+    def logged_parse_error(self, commit: Commit, error: str) -> ParseError:
+        self._logger.debug(error)
+        return ParseError(commit, error=error)
+
+    def parse(self, commit: Commit) -> ParseResult | list[ParseResult]:
+        if self.options.ignore_merge_commits and self._base_parser.is_merge_commit(
+            commit
+        ):
+            return self._base_parser.log_parse_error(
+                commit, "Ignoring merge commit: %s" % commit.hexsha[:8]
+            )
+
+        separate_commits: list[Commit] = (
+            self._base_parser.unsquash_commit(commit)
+            if self.options.parse_squash_commits
+            else [commit]
+        )
+
+        # Parse each commit individually if there were more than one
+        parsed_commits: list[ParseResult] = list(
+            map(self.parse_commit, separate_commits)
+        )
+
+        def add_linked_merge_request(
+            parsed_result: ParseResult, mr_number: str
+        ) -> ParseResult:
+            return (
+                parsed_result
+                if not isinstance(parsed_result, ParsedCommit)
+                else ParsedCommit(
+                    **{
+                        **parsed_result._asdict(),
+                        "linked_merge_request": mr_number,
+                    }
+                )
+            )
+
+        # TODO: improve this for other VCS systems other than GitHub & BitBucket
+        # Github works as the first commit in a squash merge commit has the PR number
+        # appended to the first line of the commit message
+        lead_commit = next(iter(parsed_commits))
+
+        if isinstance(lead_commit, ParsedCommit) and lead_commit.linked_merge_request:
+            # If the first commit has linked merge requests, assume all commits
+            # are part of the same PR and add the linked merge requests to all
+            # parsed commits
+            parsed_commits = [
+                lead_commit,
+                *map(
+                    lambda parsed_result, mr=lead_commit.linked_merge_request: (  # type: ignore[misc]
+                        add_linked_merge_request(parsed_result, mr)
+                    ),
+                    parsed_commits[1:],
+                ),
+            ]
+
+        elif isinstance(lead_commit, ParseError) and (
+            mr_match := self._base_parser.mr_selector.search(
+                force_str(lead_commit.message)
+            )
+        ):
+            # Handle BitBucket Squash Merge Commits (see #1085), which have non angular commit
+            # format but include the PR number in the commit subject that we want to extract
+            linked_merge_request = mr_match.group("mr_number")
+
+            # apply the linked MR to all commits
+            parsed_commits = [
+                add_linked_merge_request(parsed_result, linked_merge_request)
+                for parsed_result in parsed_commits
+            ]
+
+        return parsed_commits
+
+    def parse_message(
+        self, message: str, strict_scope: bool = False
+    ) -> ParsedMessageResult | None:
+        if (
+            not (parsed_match := self._strict_scope_pattern.match(message))
+            and strict_scope
+        ):
+            return None
+
+        if not parsed_match and not (
+            parsed_match := self._optional_scope_pattern.match(message)
+        ):
+            return None
+
+        return self._base_parser.create_parsed_message_result(parsed_match)
+
+    def parse_commit(self, commit: Commit) -> ParseResult:
+        """Attempt to parse the commit message with a regular expression into a ParseResult."""
+        # Multiple scenarios to consider when parsing a commit message [Truth table]:
+        # =======================================================================================================
+        # |    ||                         INPUTS                         ||                                     |
+        # |  # ||------------------------+----------------+--------------||                Result               |
+        # |    || Example Commit Message | Relevant Files | Scope Prefix ||                                     |
+        # |----||------------------------+----------------+--------------||-------------------------------------|
+        # |  1 || type(prefix-cli): msg  |            yes |    "prefix-" ||                        ParsedCommit |
+        # |  2 || type(prefix-cli): msg  |            yes |           "" ||                        ParsedCommit |
+        # |  3 || type(prefix-cli): msg  |             no |    "prefix-" ||                        ParsedCommit |
+        # |  4 || type(prefix-cli): msg  |             no |           "" ||                ParseError[No files] |
+        # |  5 || type(scope-cli): msg   |            yes |    "prefix-" ||                        ParsedCommit |
+        # |  6 || type(scope-cli): msg   |            yes |           "" ||                        ParsedCommit |
+        # |  7 || type(scope-cli): msg   |             no |    "prefix-" ||  ParseError[No files & wrong scope] |
+        # |  8 || type(scope-cli): msg   |             no |           "" ||                ParseError[No files] |
+        # |  9 || type(cli): msg         |            yes |    "prefix-" ||                        ParsedCommit |
+        # | 10 || type(cli): msg         |            yes |           "" ||                        ParsedCommit |
+        # | 11 || type(cli): msg         |             no |    "prefix-" ||  ParseError[No files & wrong scope] |
+        # | 12 || type(cli): msg         |             no |           "" ||                ParseError[No files] |
+        # | 13 || type: msg              |            yes |    "prefix-" ||                        ParsedCommit |
+        # | 14 || type: msg              |            yes |           "" ||                        ParsedCommit |
+        # | 15 || type: msg              |             no |    "prefix-" ||  ParseError[No files & wrong scope] |
+        # | 16 || type: msg              |             no |           "" ||                ParseError[No files] |
+        # | 17 || non-conventional msg   |            yes |    "prefix-" ||          ParseError[Invalid Syntax] |
+        # | 18 || non-conventional msg   |            yes |           "" ||          ParseError[Invalid Syntax] |
+        # | 19 || non-conventional msg   |             no |    "prefix-" ||          ParseError[Invalid Syntax] |
+        # | 20 || non-conventional msg   |             no |           "" ||          ParseError[Invalid Syntax] |
+        # =======================================================================================================
+
+        # Initial Logic Flow:
+        # [1] When there are no relevant files and a scope prefix is defined, we enforce a strict scope
+        # [2] When there are no relevant files and no scope prefix is defined, we parse scoped or unscoped commits
+        # [3] When there are relevant files, we parse scoped or unscoped commits regardless of any defined prefix
+        has_relevant_changed_files = self._has_relevant_changed_files(commit)
+        strict_scope = bool(
+            not has_relevant_changed_files and self.options.scope_prefix
+        )
+        pmsg_result = self.parse_message(
+            message=force_str(commit.message),
+            strict_scope=strict_scope,
+        )
+
+        if pmsg_result and (has_relevant_changed_files or strict_scope):
+            self._logger.debug(
+                "commit %s introduces a %s level_bump",
+                commit.hexsha[:8],
+                pmsg_result.bump,
+            )
+
+            return ParsedCommit.from_parsed_message_result(commit, pmsg_result)
+
+        if pmsg_result and not has_relevant_changed_files:
+            return self.logged_parse_error(
+                commit,
+                f"Commit {commit.hexsha[:7]} has no changed files matching the path filter(s)",
+            )
+
+        if strict_scope and self.parse_message(str(commit.message), strict_scope=False):
+            return self.logged_parse_error(
+                commit,
+                str.join(
+                    " and ",
+                    [
+                        f"Commit {commit.hexsha[:7]} has no changed files matching the path filter(s)",
+                        f"the scope does not match scope prefix '{self.options.scope_prefix}'",
+                    ],
+                ),
+            )
+
+        return self.logged_parse_error(
+            commit,
+            f"Format Mismatch! Unable to parse commit message: {commit.message!r}",
+        )
+
+    def unsquash_commit_message(self, message: str) -> list[str]:
+        return self._base_parser.unsquash_commit_message(message)
+
+    def _has_relevant_changed_files(self, commit: Commit) -> bool:
+        # Extract git root from commit
+        git_root = (
+            Path(commit.repo.working_tree_dir or commit.repo.working_dir)
+            .absolute()
+            .resolve()
+        )
+
+        cwd = Path.cwd().absolute().resolve()
+
+        rel_cwd = cwd.relative_to(git_root) if git_root in cwd.parents else Path(".")
+
+        sandboxed_selection_filters: list[str] = [
+            str(file_filter)
+            for file_filter in (
+                (
+                    git_root / select_filter.rstrip("/")
+                    if Path(select_filter).is_absolute()
+                    else git_root / rel_cwd / select_filter
+                )
+                for select_filter in self._file_selection_filters
+            )
+            if git_root in file_filter.parents
+        ]
+
+        sandboxed_ignore_filters: list[str] = [
+            str(file_filter)
+            for file_filter in (
+                (
+                    git_root / ignore_filter.rstrip("/")
+                    if Path(ignore_filter).is_absolute()
+                    else git_root / rel_cwd / ignore_filter
+                )
+                for ignore_filter in self._file_ignore_filters
+            )
+            if git_root in file_filter.parents
+        ]
+
+        # Check if the changed files of the commit that match the path filters
+        for full_path in iter(
+            str(git_root / rel_git_path) for rel_git_path in commit.stats.files
+        ):
+            # Check if the filepath matches any of the file selection filters
+            if not any(
+                fnmatch(full_path, select_filter)
+                for select_filter in sandboxed_selection_filters
+            ):
+                continue
+
+            # Pass filter matches, so now evaluate if it is supposed to be ignored
+            if not any(
+                fnmatch(full_path, ignore_filter)
+                for ignore_filter in sandboxed_ignore_filters
+            ):
+                # No ignore filter matched, so it must be a relevant file
+                return True
+
+        return False