Add hook for checking that a rule has a certain tag (#98)

Author: hofbi

.pre-commit-hooks.yaml

@@ -142,6 +142,20 @@
   language: python
   types:
     - bazel
+- id: check-rule-has-tag
+  name: Check that a Bazel rule has a specific tag
+  description: |-
+    Check that a Bazel rule contains a specific tag in its `tags` attribute.
+
+    Use `--rule-name` to select the rule and `--tag` to define the required tag.
+    Example args in the pre-commit config: `args: [--rule-name=py_venv, --tag=manual]`
+
+    This is useful for checks such as: `py_venv(..., tags = ["manual"])` or `pkg_tar(..., tags = ["no-remote"])`.
+    An alternative would be <https://github.com/bazel-contrib/tar.bzl?tab=readme-ov-file#remote-cache-and-rbe> making use of Bazel's `--modify_execution_info` flag.
+  entry: check-rule-has-tag
+  language: python
+  types:
+    - bazel
 - id: check-non-existing-and-duplicate-excludes
   name: Check non-existing and duplicate excludes in pre-commit-config
   description: |-

README.md

@@ -30,6 +30,7 @@ These tools are used to help developers in their day-to-day tasks.
   - [`check-shellscript-set-options`](#check-shellscript-set-options)
   - [`check-jira-reference-in-todo`](#check-jira-reference-in-todo)
   - [`check-load-statement`](#check-load-statement)
+  - [`check-rule-has-tag`](#check-rule-has-tag)
   - [`check-non-existing-and-duplicate-excludes`](#check-non-existing-and-duplicate-excludes)
   - [`print-pre-commit-metrics`](#print-pre-commit-metrics)
   - [`sync-vscode-config`](#sync-vscode-config)
@@ -119,6 +120,16 @@ Both arguments are required.
 Make sure you't put any ticks around the rule path and rule name.
 This hook can be used multiple times to check different rules.
 
+### `check-rule-has-tag`
+
+Check that a Bazel rule contains a specific tag in its `tags` attribute.
+
+Use `--rule-name` to select the rule and `--tag` to define the required tag.
+Example args in the pre-commit config: `args: [--rule-name=py_venv, --tag=manual]`
+
+This is useful for checks such as: `py_venv(..., tags = ["manual"])` or `pkg_tar(..., tags = ["no-remote"])`.
+An alternative would be <https://github.com/bazel-contrib/tar.bzl?tab=readme-ov-file#remote-cache-and-rbe> making use of Bazel's `--modify_execution_info` flag.
+
 ### `check-non-existing-and-duplicate-excludes`
 
 Check for non existing and duplicate paths in `.pre-commit-config.yaml`.

dev_tools/check_rule_has_tag.py

@@ -0,0 +1,81 @@
+from __future__ import annotations
+
+import re
+import sys
+from typing import TYPE_CHECKING
+
+from dev_tools.git_hook_utils import create_default_parser
+
+if TYPE_CHECKING:
+    import argparse
+    from collections.abc import Sequence
+    from pathlib import Path
+
+
+def parse_arguments(argv: Sequence[str] | None = None) -> argparse.Namespace:
+    parser = create_default_parser()
+    parser.add_argument("--rule-name", type=str, required=True)
+    parser.add_argument("--tag", type=str, required=True)
+    return parser.parse_args(argv)
+
+
+def _remove_comments(content: str) -> str:
+    return re.sub(r"(?m)#.*$", "", content)
+
+
+def find_rule_calls(content: str, rule_name: str) -> list[str]:
+    content_without_comments = _remove_comments(content)
+    rule_pattern = re.compile(rf"(?m)(?<![A-Za-z0-9_]){re.escape(rule_name)}\s*\(")
+    rule_calls: list[str] = []
+
+    for match in rule_pattern.finditer(content_without_comments):
+        open_parens_count = 1
+        current_index = match.end()
+
+        while current_index < len(content_without_comments) and open_parens_count > 0:
+            character = content_without_comments[current_index]
+            if character == "(":
+                open_parens_count += 1
+            elif character == ")":
+                open_parens_count -= 1
+            current_index += 1
+
+        if open_parens_count == 0:
+            rule_calls.append(content_without_comments[match.end() : current_index - 1])
+
+    return rule_calls
+
+
+def rule_has_tag(rule_body: str, tag: str) -> bool:
+    tags_pattern = re.compile(r'(?ms)(?<![A-Za-z0-9_])tags\s*=\s*\[[^\]]*["\']' + re.escape(tag) + r'["\']')
+    return bool(tags_pattern.search(_remove_comments(rule_body)))
+
+
+def is_rule_missing_tag(rule_body: str, tag: str) -> bool:
+    return not rule_has_tag(rule_body, tag)
+
+
+def find_invalid_files(filenames: Sequence[Path], rule_name: str, tag: str) -> list[Path]:
+    return [
+        filename
+        for filename in filenames
+        if (rule_calls := find_rule_calls(filename.read_text(), rule_name))
+        and any(is_rule_missing_tag(rule_body, tag) for rule_body in rule_calls)
+    ]
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    args = parse_arguments(argv)
+    invalid_files = find_invalid_files(args.filenames, args.rule_name, args.tag)
+
+    for filename in invalid_files:
+        print(
+            f"Error: {filename} contains a `{args.rule_name}` rule without `tags` containing `{args.tag}`. "
+            f"Make sure you tag this rule with `{args.tag}`."
+        )
+
+    return 1 if invalid_files else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

pyproject.toml

@@ -31,6 +31,7 @@ dev = [
 [project.scripts]
 check-jira-reference-in-todo = "dev_tools.check_jira_reference_in_todo:main"
 check-load-statement = "dev_tools.check_load_statement:main"
+check-rule-has-tag = "dev_tools.check_rule_has_tag:main"
 check-max-one-sentence-per-line = "dev_tools.check_max_one_sentence_per_line:main"
 check-number-of-lines-count = "dev_tools.check_number_of_lines_count:main"
 check-ownership = "dev_tools.check_ownership:main"

tests/test_check_rule_has_tag.py

@@ -0,0 +1,117 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+import pytest
+
+from dev_tools.check_rule_has_tag import find_invalid_files, find_rule_calls, rule_has_tag
+
+if TYPE_CHECKING:
+    from pyfakefs.fake_filesystem import FakeFilesystem
+
+
+@pytest.mark.parametrize(
+    ("content", "expected_rule_count"),
+    [
+        ('py_venv(name = "venv")', 1),
+        ('other_rule(name = "x")', 0),
+        (
+            """
+py_venv(name = "venv")
+pkg_tar(name = "archive")
+py_venv(
+    name = "second",
+)
+""",
+            2,
+        ),
+        (
+            """
+py_venv(
+    name = name + "_venv",
+    deps = [":{}_foo".format(name)],
+    package_collisions = "ignore",
+    tags = ["manual"],
+)
+""",
+            1,
+        ),
+    ],
+)
+def test_find_rule_calls_for_content_should_return_expected_rule_count(content: str, expected_rule_count: int) -> None:
+    assert len(find_rule_calls(content, "py_venv")) == expected_rule_count
+
+
+@pytest.mark.parametrize(
+    ("rule_body", "tag"),
+    [
+        ('name = "venv", tags = ["manual"]', "manual"),
+        ('name = "venv", tags = ["manual", "no-remote"]', "manual"),
+        ('name = "venv", tags = [\n    "manual",\n]', "manual"),
+        ('name = "archive", tags = ["no-remote"]', "no-remote"),
+    ],
+)
+def test_rule_has_tag_for_matching_tag_should_return_true(rule_body: str, tag: str) -> None:
+    assert rule_has_tag(rule_body, tag) is True
+
+
+@pytest.mark.parametrize(
+    ("rule_body", "tag"),
+    [
+        ('name = "venv"', "manual"),
+        ('name = "venv", tags = ["not-manual"]', "manual"),
+        ('name = "venv", tags = []  # manual', "manual"),
+        ('name = "archive", tags = ["remote"]', "no-remote"),
+        ('name = "thing", package_collisions = "ignore"', "manual"),
+    ],
+)
+def test_rule_has_tag_for_non_matching_tag_should_return_false(rule_body: str, tag: str) -> None:
+    assert rule_has_tag(rule_body, tag) is False
+
+
+def test_find_invalid_files_for_rule_without_tag_should_return_file(fs: FakeFilesystem) -> None:
+    fs.create_file(
+        Path("repo/BUILD.bazel"),
+        contents="""
+py_venv(
+    name = "bad",
+)
+py_venv(
+    name = "good",
+    tags = ["manual"],
+)
+""",
+    )
+
+    assert find_invalid_files([Path("repo/BUILD.bazel")], "py_venv", "manual") == [Path("repo/BUILD.bazel")]
+
+
+def test_find_invalid_files_for_file_without_target_rule_should_return_empty_list(fs: FakeFilesystem) -> None:
+    fs.create_file(
+        Path("repo/BUILD.bazel"),
+        contents="""
+pkg_tar(
+    name = "archive",
+    tags = ["no-remote"],
+)
+""",
+    )
+
+    assert find_invalid_files([Path("repo/BUILD.bazel")], "py_venv", "manual") == []
+
+
+def test_find_invalid_files_for_rule_with_nested_parentheses_should_return_empty_list(fs: FakeFilesystem) -> None:
+    fs.create_file(
+        Path("repo/BUILD.bazel"),
+        contents="""
+py_venv(
+    name = name + "_venv",
+    deps = [":{}_foo".format(name)],
+    package_collisions = "ignore",
+    tags = ["manual"],
+)
+""",
+    )
+
+    assert find_invalid_files([Path("repo/BUILD.bazel")], "py_venv", "manual") == []