Source code for semantic_release.commit_parser._base

from __future__ import annotations

from abc import ABC, abstractmethod
from typing import TYPE_CHECKING, Any, Generic, TypeVar

from semantic_release.commit_parser.token import ParseResultType

if TYPE_CHECKING:
    from git.objects.commit import Commit


[docs] class ParserOptions(dict): """ ParserOptions should accept the keyword arguments they are interested in from configuration and process them as desired, ultimately creating attributes on an instance which can be accessed by the corresponding commit parser. For example: >>> class MyParserOptions(ParserOptions): ... def __init__(self, message_prefix: str) -> None: ... self.prefix = message_prefix * 2 >>> class MyCommitParser(AbstractCommitParser): ... parser_options = MyParserOptions ... ... def parse(self, Commit): ... print(self.options.prefix) ... ... Any defaults that need to be set should also be done in this class too. Invalid options should be signalled by raising an ``InvalidOptionsException`` within the ``__init__`` method of the options class. A dataclass is also well suited to this; if type-checking of input is desired, a ``pydantic.dataclasses.dataclass`` works well and is used internally by python-semantic-release. Parser options are not validated in the configuration and passed directly to the appropriate class to handle. """ def __init__(self, **_: Any) -> None: pass
# TT = TokenType, a subclass of ParsedCommit _TT = TypeVar("_TT", bound=ParseResultType) _OPTS = TypeVar("_OPTS", bound=ParserOptions)
[docs] class CommitParser(ABC, Generic[_TT, _OPTS]): """ Abstract base class for all commit parsers. Custom commit parsers should inherit from this class. A class-level ``parser_options`` attribute should be set to a subclass of ``BaseParserOptions``; this will be used to provide the default options to the parser. Note that a nested class can be used directly, if preferred: >>> class MyParser(CommitParser): @dataclass class parser_options(ParserOptions): allowed_types: Tuple[str] = ("feat", "fix", "docs") major_types: Tuple[str] = ("breaking",) minor_types: Tuple[str] = ("fix", "patch") ... def __init__(self, options: parser_options) -> None: ... """ # TODO: Deprecate in lieu of get_default_options() parser_options: type[ParserOptions] = ParserOptions def __init__(self, options: _OPTS | None = None) -> None: self.options: _OPTS = ( options if options is not None else self.get_default_options() ) # TODO: BREAKING CHANGE v10, add abstract method for all custom parsers # @staticmethod # @abstractmethod
[docs] def get_default_options(self) -> _OPTS: return self.parser_options() # type: ignore[return-value]
[docs] @abstractmethod def parse(self, commit: Commit) -> _TT: ...