fix: implement precise filtering for bracketed sub-tags (#4892)

Co-authored-by: Sorin Sbarnea <[email protected]>

Author: Jkhall81

src/ansiblelint/rules/__init__.py

@@ -504,27 +504,48 @@ def run(
         for rule in self.rules:
             if rule.id == "syntax-check":
                 continue
+
+            is_targeted = any(t.startswith(f"{rule.id}[") for t in tags)
+            is_skipped = any(t.startswith(f"{rule.id}[") for t in skip_list)
+
+            # rule selection logic
             if (
                 not tags
                 or rule.has_dynamic_tags
                 or not set(rule.tags).union([rule.id]).isdisjoint(tags)
+                or is_targeted
             ):
-                if tags and set(rule.tags).union(list(rule.ids().keys())).isdisjoint(
-                    tags,
+                # specific tag targeting override
+                if (
+                    tags
+                    and not is_targeted
+                    and set(rule.tags).union(list(rule.ids().keys())).isdisjoint(tags)
                 ):
-                    _logger.debug("Skipping rule %s", rule.id)
-                else:
-                    _logger.debug("Running rule %s", rule.id)
-                    rule_definition = set(rule.tags)
-                    rule_definition.add(rule.id)
-                    if set(rule_definition).isdisjoint(skip_list):
-                        matches.extend(rule.getmatches(file))
-            else:
-                _logger.debug("Skipping rule %s", rule.id)
+                    continue
 
-        # some rules can produce matches with tags that are inside our
-        # skip_list, so we need to cleanse the matches
-        matches = [m for m in matches if m.tag not in skip_list]
+                # rule-level skip check
+                rule_definition = set(rule.tags) | {rule.id}
+                if rule_definition.isdisjoint(skip_list) and not is_skipped:
+                    matches.extend(rule.getmatches(file))
+
+        if tags or skip_list:
+            filtered_matches = []
+            for m in matches:
+                # inclusion logic (if tags are provided)
+                if tags:
+                    if (
+                        m.tag in tags
+                        or m.rule.id in tags
+                        or (
+                            not set(m.rule.tags).isdisjoint(tags)
+                            and not any(t.startswith(f"{m.rule.id}[") for t in tags)
+                        )
+                    ):
+                        filtered_matches.append(m)
+                else:
+                    # no tags requested, so keep everything that wasn't skipped
+                    filtered_matches.append(m)
+            matches = filtered_matches
 
         return matches
 

test/test_rules_collection.py

@@ -179,3 +179,48 @@ def test_rules_id_format(config_options: Options, app: App) -> None:
     assert "yaml" in keys, "yaml rule is missing"
     assert len(rules) == 51  # update this number when adding new rules!
     assert len(keys) == len(rules), "Duplicate rule ids?"
+
+
+def test_tag_inclusion(
+    test_rules_collection: RulesCollection,
+    ematchtestfile: Lintable,
+) -> None:
+    """Test that bracketed sub-tags are treated surgically for inclusion."""
+    all_matches = test_rules_collection.run(ematchtestfile)
+
+    if not all_matches:
+        pytest.fail("No matches found in ematchtestfile!")
+
+    target_tag = all_matches[0].tag
+    matches = test_rules_collection.run(ematchtestfile, tags={target_tag})
+
+    assert len(matches) > 0
+    for m in matches:
+        assert m.tag == target_tag
+
+
+def test_tag_exclusion(
+    test_rules_collection: RulesCollection,
+    ematchtestfile: Lintable,
+) -> None:
+    """Test that bracketed sub-tags are treated surgically for exclusion."""
+    target_tag = "TEST0001[BANNED]"
+
+    matches = test_rules_collection.run(ematchtestfile, skip_list=[target_tag])
+
+    tag_results = [m.tag for m in matches]
+    assert target_tag not in tag_results
+
+
+def test_category_tag_override(
+    test_rules_collection: RulesCollection,
+    ematchtestfile: Lintable,
+) -> None:
+    """Test that specific sub-tag requests override broad category inclusion."""
+    matches = test_rules_collection.run(
+        ematchtestfile, tags={"test1", "TEST0001[BANNED]"}
+    )
+
+    for m in matches:
+        if m.rule.id == "TEST0001":
+            assert m.tag == "TEST0001[BANNED]"