path: root/gitlint-core/gitlint/config.py

import copy
import os
import re
import shutil
from collections import OrderedDict
from configparser import ConfigParser
from configparser import Error as ConfigParserError
from dataclasses import dataclass, field
from typing import ClassVar, Optional
from typing import OrderedDict as OrderedDictType

from gitlint import (
    options,
    rule_finder,
    rules,
)
from gitlint.contrib import rules as contrib_rules
from gitlint.exception import GitlintError
from gitlint.utils import FILE_ENCODING


def handle_option_error(func):
    """Decorator that calls given method/function and handles any RuleOptionError gracefully by converting it to a
    LintConfigError."""

    def wrapped(*args):
        try:
            return func(*args)
        except options.RuleOptionError as e:
            raise LintConfigError(str(e)) from e

    return wrapped


class LintConfigError(GitlintError):
    pass


class LintConfig:
    """Class representing gitlint configuration.
    Contains active config as well as number of methods to easily get/set the config.
    """

    # Default tuple of rule classes (tuple because immutable).
    default_rule_classes = (
        rules.IgnoreByTitle,
        rules.IgnoreByBody,
        rules.IgnoreBodyLines,
        rules.IgnoreByAuthorName,
        rules.TitleMaxLength,
        rules.TitleTrailingWhitespace,
        rules.TitleLeadingWhitespace,
        rules.TitleTrailingPunctuation,
        rules.TitleHardTab,
        rules.TitleMustNotContainWord,
        rules.TitleRegexMatches,
        rules.TitleMinLength,
        rules.BodyMaxLineLength,
        rules.BodyMinLength,
        rules.BodyMissing,
        rules.BodyTrailingWhitespace,
        rules.BodyHardTab,
        rules.BodyFirstLineEmpty,
        rules.BodyChangedFileMention,
        rules.BodyRegexMatches,
        rules.AuthorValidEmail,
    )

    def __init__(self):
        self.rules = RuleCollection(self.default_rule_classes)
        self._verbosity = options.IntOption("verbosity", 3, "Verbosity")
        self._ignore_merge_commits = options.BoolOption("ignore-merge-commits", True, "Ignore merge commits")
        self._ignore_fixup_commits = options.BoolOption("ignore-fixup-commits", True, "Ignore fixup commits")
        self._ignore_fixup_amend_commits = options.BoolOption(
            "ignore-fixup-amend-commits", True, "Ignore fixup amend commits"
        )
        self._ignore_squash_commits = options.BoolOption("ignore-squash-commits", True, "Ignore squash commits")
        self._ignore_revert_commits = options.BoolOption("ignore-revert-commits", True, "Ignore revert commits")
        self._debug = options.BoolOption("debug", False, "Enable debug mode")
        self._extra_path = None
        target_description = "Path of the target git repository (default=current working directory)"
        self._target = options.PathOption("target", os.path.realpath(os.getcwd()), target_description)
        self._ignore = options.ListOption("ignore", [], "List of rule-ids to ignore")
        self._contrib = options.ListOption("contrib", [], "List of contrib-rules to enable")
        self._config_path = None
        ignore_stdin_description = "Ignore any stdin data. Useful for running in CI server."
        self._ignore_stdin = options.BoolOption("ignore-stdin", False, ignore_stdin_description)
        self._staged = options.BoolOption("staged", False, "Read staged commit meta-info from the local repository.")
        self._fail_without_commits = options.BoolOption(
            "fail-without-commits", False, "Hard fail when the target commit range is empty"
        )
        self._regex_style_search = options.BoolOption(
            "regex-style-search", True, "Use `search` instead of `match` semantics for regex rules"
        )

    @property
    def target(self):
        return self._target.value if self._target else None

    @target.setter
    @handle_option_error
    def target(self, value):
        return self._target.set(value)

    @property
    def verbosity(self):
        return self._verbosity.value

    @verbosity.setter
    @handle_option_error
    def verbosity(self, value):
        self._verbosity.set(value)
        if self.verbosity < 0 or self.verbosity > 3:  # noqa: PLR2004 (Magic value used in comparison)
            raise LintConfigError("Option 'verbosity' must be set between 0 and 3")

    @property
    def ignore_merge_commits(self):
        return self._ignore_merge_commits.value

    @ignore_merge_commits.setter
    @handle_option_error
    def ignore_merge_commits(self, value):
        return self._ignore_merge_commits.set(value)

    @property
    def ignore_fixup_commits(self):
        return self._ignore_fixup_commits.value

    @ignore_fixup_commits.setter
    @handle_option_error
    def ignore_fixup_commits(self, value):
        return self._ignore_fixup_commits.set(value)

    @property
    def ignore_fixup_amend_commits(self):
        return self._ignore_fixup_amend_commits.value

    @ignore_fixup_amend_commits.setter
    @handle_option_error
    def ignore_fixup_amend_commits(self, value):
        return self._ignore_fixup_amend_commits.set(value)

    @property
    def ignore_squash_commits(self):
        return self._ignore_squash_commits.value

    @ignore_squash_commits.setter
    @handle_option_error
    def ignore_squash_commits(self, value):
        return self._ignore_squash_commits.set(value)

    @property
    def ignore_revert_commits(self):
        return self._ignore_revert_commits.value

    @ignore_revert_commits.setter
    @handle_option_error
    def ignore_revert_commits(self, value):
        return self._ignore_revert_commits.set(value)

    @property
    def debug(self):
        return self._debug.value

    @debug.setter
    @handle_option_error
    def debug(self, value):
        return self._debug.set(value)

    @property
    def ignore(self):
        return self._ignore.value

    @ignore.setter
    def ignore(self, value):
        if value == "all":
            value = [rule.id for rule in self.rules]
        return self._ignore.set(value)

    @property
    def ignore_stdin(self):
        return self._ignore_stdin.value

    @ignore_stdin.setter
    @handle_option_error
    def ignore_stdin(self, value):
        return self._ignore_stdin.set(value)

    @property
    def staged(self):
        return self._staged.value

    @staged.setter
    @handle_option_error
    def staged(self, value):
        return self._staged.set(value)

    @property
    def fail_without_commits(self):
        return self._fail_without_commits.value

    @fail_without_commits.setter
    @handle_option_error
    def fail_without_commits(self, value):
        return self._fail_without_commits.set(value)

    @property
    def regex_style_search(self):
        return self._regex_style_search.value

    @regex_style_search.setter
    @handle_option_error
    def regex_style_search(self, value):
        return self._regex_style_search.set(value)

    @property
    def extra_path(self):
        return self._extra_path.value if self._extra_path else None

    @extra_path.setter
    def extra_path(self, value):
        try:
            if self.extra_path:
                self._extra_path.set(value)
            else:
                self._extra_path = options.PathOption(
                    "extra-path", value, "Path to a directory or module with extra user-defined rules", type="both"
                )

            # Make sure we unload any previously loaded extra-path rules
            self.rules.delete_rules_by_attr("is_user_defined", True)

            # Find rules in the new extra-path and add them to the existing rules
            rule_classes = rule_finder.find_rule_classes(self.extra_path)
            self.rules.add_rules(rule_classes, {"is_user_defined": True})

        except (options.RuleOptionError, rules.UserRuleError) as e:
            raise LintConfigError(str(e)) from e

    @property
    def contrib(self):
        return self._contrib.value

    @contrib.setter
    def contrib(self, value):
        try:
            self._contrib.set(value)

            # Make sure we unload any previously loaded contrib rules when re-setting the value
            self.rules.delete_rules_by_attr("is_contrib", True)

            # Load all classes from the contrib directory
            contrib_dir_path = os.path.dirname(os.path.realpath(contrib_rules.__file__))
            rule_classes = rule_finder.find_rule_classes(contrib_dir_path)

            # For each specified contrib rule, check whether it exists among the contrib classes
            for rule_id_or_name in self.contrib:
                rule_class = next((rc for rc in rule_classes if rule_id_or_name in (rc.id, rc.name)), False)

                # If contrib rule exists, instantiate it and add it to the rules list
                if rule_class:
                    self.rules.add_rule(rule_class, rule_class.