Renamed rule class methods (naming convention)

Renames
- matchyaml -> match_file
- matchtask -> match_task
- matchtasks -> match_tasks
- matcherror -> match_error
- matchvar -> match_var
- matchdir -> match_dir
- create_matcherror -> create_match_error

Author: ssbarnea

.config/dictionary.txt

@@ -64,9 +64,10 @@ repos:
     rev: v9.0.1
     hooks:
       - id: cspell
-        # entry: codespell --relative
-        args: [--relative, --no-progress, --no-summary]
-        name: Spell check with cspell
+        entry: sh
+        pass_filenames: false
+        args: ["-c", "cspell-cli . --relative --no-progress --no-summary && cspell . --disable-dictionary=words --words-only --quiet --unique | sort --ignore-case > .config/dictionary.txt"]
+        name: Spell check with cspell and remove unused dictionary entries
   - repo: https://github.com/python-jsonschema/check-jsonschema
     rev: 0.33.1
     hooks:

.pre-commit-config.yaml

@@ -23,3 +23,13 @@ ignorePaths:
   # Other
   - "*.svg"
   - ".vscode/**"
+  - build
+  - _readthedocs
+  - examples/playbooks/collections
+  - site
+  - test/schemas/node_modules
+  - .config/dictionary.txt
+  - "*.egg-info"
+  - junit.xml
+  - examples/broken/encoding.yml
+

cspell.config.yaml

@@ -17,7 +17,7 @@ Each rule definition should have the following parts:
 - `description` explains what the rule checks for.
 - `tags` specifies one or more tags for including or excluding the rule.
 
-### Match and matchtask methods
+### Match and match_task methods
 
 Each rule definition should also invoke one of the following methods:
 
@@ -26,7 +26,7 @@ Each rule definition should also invoke one of the following methods:
   - True or a custom message if the line does match the test. (This allows one
     rule to test multiple behaviors - see e.g. the
     _CommandsInsteadOfModulesRule_.)
-- `matchtask` operates on a single task or handler, such that tasks get
+- `match_task` operates on a single task or handler, such that tasks get
   standardized to always contain a _module_ key and _module_arguments_ key.
   Other common task modifiers, such as _when_, _with_items_, etc., are also
   available as keys if present in the task.
@@ -50,13 +50,13 @@ class DeprecatedVariableRule(AnsibleLintRule):
         return '${' in line
 ```
 
-The following is an example rule that uses the `matchtask` method:
+The following is an example rule that uses the `match_task` method:
 
 ```python
 {!../examples/rules/task_has_tag.py!}
 ```
 
-The task argument to `matchtask` contains a number of keys - the critical one is
+The task argument to `match_task` contains a number of keys - the critical one is
 _action_. The value of `task['action']` contains the module being used, and the
 arguments passed, both as key-value pairs and a list of other arguments (e.g.
 the command used with shell).

docs/custom-rules.md

@@ -18,7 +18,7 @@ class TaskHasTag(AnsibleLintRule):
     description = "Tasks must have tag"
     tags = ["productivity", "tags"]
 
-    def matchtask(
+    def match_task(
         self,
         task: Task,
         file: Lintable | None = None,

examples/rules/task_has_tag.py

@@ -13,7 +13,7 @@
 
 if TYPE_CHECKING:
     from ansiblelint.config import Options
-    from ansiblelint.errors import MatchError
+    from ansiblelint.errors import match_error
     from ansiblelint.file_utils import Lintable
     from ansiblelint.rules import RulesCollection
     from ansiblelint.utils import Task
@@ -96,11 +96,11 @@ def shortdesc(self) -> str:
         """Return the short description of the rule, basically the docstring."""
         return self._shortdesc or self.__doc__ or ""
 
-    def getmatches(self, file: Lintable) -> list[MatchError]:
+    def getmatches(self, file: Lintable) -> list[match_error]:
         """Return all matches while ignoring exceptions."""
         matches = []
         if not file.path.is_dir():
-            for method in [self.matchlines, self.matchtasks, self.matchyaml]:
+            for method in [self.match_lines, self.match_tasks, self.match_file]:
                 try:
                     matches.extend(method(file))
                 except Exception as exc:  # pylint: disable=broad-except # noqa: BLE001
@@ -113,18 +113,18 @@ def getmatches(self, file: Lintable) -> list[MatchError]:
                     )
                     _logger.debug("Ignored exception details", exc_info=True)
         else:
-            matches.extend(self.matchdir(file))
+            matches.extend(self.match_dir(file))
         return matches
 
-    def matchlines(self, file: Lintable) -> list[MatchError]:
+    def match_lines(self, file: Lintable) -> list[match_error]:
         """Return matches found for a specific line."""
         return []
 
-    def matchtask(
+    def match_task(
         self,
         task: Task,
         file: Lintable | None = None,
-    ) -> bool | str | MatchError | list[MatchError]:
+    ) -> bool | str | match_error | list[match_error]:
         """Confirm if current rule is matching a specific task.
 
         If ``needs_raw_task`` (a class level attribute) is ``True``, then
@@ -133,19 +133,19 @@ def matchtask(
         """
         return False
 
-    def matchtasks(self, file: Lintable) -> list[MatchError]:
+    def match_tasks(self, file: Lintable) -> list[match_error]:
         """Return matches for a tasks file."""
         return []
 
-    def matchyaml(self, file: Lintable) -> list[MatchError]:
+    def match_file(self, file: Lintable) -> list[match_error]:
         """Return matches found for a specific YAML text."""
         return []
 
-    def matchplay(self, file: Lintable, data: dict[str, Any]) -> list[MatchError]:
+    def matchplay(self, file: Lintable, data: dict[str, Any]) -> list[match_error]:
         """Return matches found for a specific playbook."""
         return []
 
-    def matchdir(self, lintable: Lintable) -> list[MatchError]:
+    def match_dir(self, lintable: Lintable) -> list[match_error]:
         """Return matches for lintable folders."""
         return []
 

src/ansiblelint/_internal/rules.py

@@ -25,7 +25,7 @@
 
 if TYPE_CHECKING:
     from ansiblelint._internal.rules import BaseRule
-    from ansiblelint.errors import MatchError
+    from ansiblelint.errors import match_error
     from ansiblelint.file_utils import Lintable
     from ansiblelint.runner import LintResult
 
@@ -68,7 +68,7 @@ def __init__(self, options: Options):
 
         self.yamllint_config = load_yamllint_config()
 
-    def render_matches(self, matches: list[MatchError]) -> None:
+    def render_matches(self, matches: list[match_error]) -> None:
         """Display given matches (if they are not fixed)."""
         matches = [match for match in matches if not match.fixed]
 
@@ -129,7 +129,7 @@ def render_matches(self, matches: list[MatchError]) -> None:
                 encoding="utf-8",
             )
 
-    def count_results(self, matches: list[MatchError]) -> SummarizedResults:
+    def count_results(self, matches: list[match_error]) -> SummarizedResults:
         """Count failures and warnings in matches."""
         result = SummarizedResults()
 
@@ -175,7 +175,7 @@ def count_lintables(files: set[Lintable]) -> tuple[int, int]:
 
     @staticmethod
     def _get_matched_skippable_rules(
-        matches: list[MatchError],
+        matches: list[match_error],
     ) -> dict[str, BaseRule]:
         """Extract the list of matched rules, if skippable, from the list of matches."""
         matches_unignored = [match for match in matches if not match.ignored]

src/ansiblelint/app.py

@@ -19,7 +19,7 @@ class LintWarning(Warning):
 
 @dataclass
 class WarnSource:
-    """Container for warning information, so we can later create a MatchError from it."""
+    """Container for warning information, so we can later create a match_error from it."""
 
     filename: Lintable
     lineno: int
@@ -35,7 +35,7 @@ class RuleMatchTransformMeta:
 # pylint: disable=too-many-instance-attributes
 @dataclass(unsafe_hash=True)
 @functools.total_ordering
-class MatchError(ValueError):
+class match_error(ValueError):
     """Rule violation detected during linting.
 
     It can be raised as Exception but also just added to the list of found
@@ -57,14 +57,14 @@ class MatchError(ValueError):
     # of the same rule, but we use the 'tag' to identify the rule.
     rule: BaseRule = field(hash=False, default=RuntimeErrorRule())
     ignored: bool = False
-    fixed: bool = False  # True when a transform has resolved this MatchError
+    fixed: bool = False  # True when a transform has resolved this match_error
     transform_meta: RuleMatchTransformMeta | None = None
 
     def __post_init__(self) -> None:
         """Can be use by rules that can report multiple errors type, so we can still filter by them."""
         self.filename = self.lintable.name
 
-        # We want to catch accidental MatchError() which contains no useful
+        # We want to catch accidental match_error() which contains no useful
         # information. When no arguments are passed, the '_message' field is
         # set to 'property', only if passed it becomes a string.
         if self.rule.__class__ is RuntimeErrorRule:
@@ -89,10 +89,10 @@ def __post_init__(self) -> None:
 
         # Safety measure to ensure we do not end-up with incorrect indexes
         if self.lineno == 0:  # pragma: no cover
-            msg = "MatchError called incorrectly as line numbers start with 1"
+            msg = "match_error called incorrectly as line numbers start with 1"
             raise RuntimeError(msg)
         if self.column == 0:  # pragma: no cover
-            msg = "MatchError called incorrectly as column numbers start with 1"
+            msg = "match_error called incorrectly as column numbers start with 1"
             raise RuntimeError(msg)
 
         self.lineno += self.lintable.line_offset
@@ -116,7 +116,7 @@ def level(self) -> str:
         return "warning"
 
     def __repr__(self) -> str:
-        """Return a MatchError instance representation."""
+        """Return a match_error instance representation."""
         formatstr = "[{0}] ({1}) matched {2}:{3} {4}"
         # note that `rule.id` can be int, str or even missing, as users
         # can defined their own custom rules.
@@ -131,7 +131,7 @@ def __repr__(self) -> str:
         )
 
     def __str__(self) -> str:
-        """Return a MatchError instance string representation."""
+        """Return a match_error instance string representation."""
         return self.__repr__()
 
     @property

src/ansiblelint/errors.py

@@ -24,7 +24,7 @@
 if TYPE_CHECKING:
     from collections.abc import Iterator, Sequence
 
-    from ansiblelint.errors import MatchError
+    from ansiblelint.errors import match_error
 
 
 _logger = logging.getLogger(__package__)
@@ -204,7 +204,7 @@ def __init__(
         self.line_offset = (
             0  # Amount to offset line numbers by to get accurate position
         )
-        self.matches: list[MatchError] = []
+        self.matches: list[match_error] = []
 
         if isinstance(name, str):
             name = Path(name)

src/ansiblelint/file_utils.py

@@ -12,7 +12,7 @@
 from ansiblelint.version import __version__
 
 if TYPE_CHECKING:
-    from ansiblelint.errors import MatchError
+    from ansiblelint.errors import match_error
     from ansiblelint.rules import BaseRule  # type: ignore[attr-defined]
 
 T = TypeVar("T", bound="BaseFormatter")  # type: ignore[type-arg]
@@ -49,7 +49,7 @@ def _format_path(self, path: str | Path) -> str | Path:
             return path
         return rel_path
 
-    def apply(self, match: MatchError) -> str:
+    def apply(self, match: match_error) -> str:
         """Format a match error."""
         return str(match)
 
@@ -62,7 +62,7 @@ def escape(text: str) -> str:
 class Formatter(BaseFormatter):  # type: ignore[type-arg]
     """Default output formatter of ansible-lint."""
 
-    def apply(self, match: MatchError) -> str:
+    def apply(self, match: match_error) -> str:
         _id = getattr(match.rule, "id", "000")
         result = f"[{match.level}][link={match.rule.url}]{match.tag}[/link][dim]:[/] [{match.level}]{self.escape(match.message)}[/]"
         if match.level != "error":
@@ -82,7 +82,7 @@ def apply(self, match: MatchError) -> str:
 class QuietFormatter(BaseFormatter[Any]):
     """Brief output formatter for ansible-lint."""
 
-    def apply(self, match: MatchError) -> str:
+    def apply(self, match: match_error) -> str:
         return (
             f"[{match.level}]{match.rule.id}[/] "
             f"[repr.path]{self._format_path(match.filename or '')}[/]:{match.position}"
@@ -92,7 +92,7 @@ def apply(self, match: MatchError) -> str:
 class ParseableFormatter(BaseFormatter[Any]):
     """Parseable uses PEP8 compatible format."""
 
-    def apply(self, match: MatchError) -> str:
+    def apply(self, match: match_error) -> str:
         result = (
             f"[repr.path]{self._format_path(match.filename or '')}[/][dim]:{match.position}:[/] "
             f"[{match.level}][bold]{self.escape(match.tag)}[/]"
@@ -119,7 +119,7 @@ class AnnotationsFormatter(BaseFormatter):  # type: ignore[type-arg]
     Supported levels: debug, warning, error
     """
 
-    def apply(self, match: MatchError) -> str:
+    def apply(self, match: match_error) -> str:
         """Prepare a match instance for reporting as a GitHub Actions annotation."""
         file_path = self._format_path(match.filename or "")
         line_num = match.lineno
@@ -135,15 +135,15 @@ def apply(self, match: MatchError) -> str:
 class CodeclimateJSONFormatter(BaseFormatter[Any]):
     """Formatter for emitting violations in Codeclimate JSON report format.
 
-    The formatter expects a list of MatchError objects and returns a JSON formatted string.
+    The formatter expects a list of match_error objects and returns a JSON formatted string.
     The spec for the codeclimate report can be found here:
     https://github.com/codeclimate/platform/blob/master/spec/analyzers/SPEC.md#user-content-data-types
     """
 
-    def format_result(self, matches: list[MatchError]) -> str:
+    def format_result(self, matches: list[match_error]) -> str:
         """Format a list of match errors as a JSON string."""
         if not isinstance(matches, list):
-            msg = f"The {self.__class__} was expecting a list of MatchError."
+            msg = f"The {self.__class__} was expecting a list of match_error."
             raise TypeError(msg)
 
         result = []
@@ -180,7 +180,7 @@ def format_result(self, matches: list[MatchError]) -> str:
         return json.dumps(result, sort_keys=False)
 
     @staticmethod
-    def _remap_severity(match: MatchError) -> str:
+    def _remap_severity(match: match_error) -> str:
         # level is not part of CodeClimate specification, but there is
         # no other way to expose that info. We recommend switching to
         # SARIF format which is better suited for interoperability.
@@ -207,10 +207,10 @@ class SarifFormatter(BaseFormatter[Any]):
         "https://schemastore.azurewebsites.net/schemas/json/sarif-2.1.0-rtm.5.json"
     )
 
-    def format_result(self, matches: list[MatchError]) -> str:
+    def format_result(self, matches: list[match_error]) -> str:
         """Format a list of match errors as a JSON string."""
         if not isinstance(matches, list):
-            msg = f"The {self.__class__} was expecting a list of MatchError."
+            msg = f"The {self.__class__} was expecting a list of match_error."
             raise TypeError(msg)
 
         root_path = Path(str(self.base_dir)).as_uri()
@@ -247,7 +247,7 @@ def format_result(self, matches: list[MatchError]) -> str:
 
     def _extract_results(
         self,
-        matches: list[MatchError],
+        matches: list[match_error],
     ) -> tuple[list[Any], list[Any]]:
         rules = {}
         results = []
@@ -257,7 +257,7 @@ def _extract_results(
             results.append(self._to_sarif_result(match))
         return list(rules.values()), results
 
-    def _to_sarif_rule(self, match: MatchError) -> dict[str, Any]:
+    def _to_sarif_rule(self, match: match_error) -> dict[str, Any]:
         rule: dict[str, Any] = {
             "id": match.tag,
             "name": match.tag,
@@ -275,7 +275,7 @@ def _to_sarif_rule(self, match: MatchError) -> dict[str, Any]:
         }
         return rule
 
-    def _to_sarif_result(self, match: MatchError) -> dict[str, Any]:
+    def _to_sarif_result(self, match: match_error) -> dict[str, Any]:
         # https://docs.oasis-open.org/sarif/sarif/v2.1.0/errata01/os/sarif-v2.1.0-errata01-os-complete.html#_Toc141790898
         if match.level not in ("warning", "error", "note", "none"):
             msg = "Unexpected failure to map '%s' level to SARIF."
@@ -333,7 +333,7 @@ def get_sarif_rule_severity_level(rule: BaseRule) -> str:
         return "none"
 
     @staticmethod
-    def get_sarif_result_severity_level(match: MatchError) -> str:
+    def get_sarif_result_severity_level(match: match_error) -> str:
         """SARIF severity level for an actual result/match.
 
         Possible values: "none", "note", "warning", "error"