Fix rule hierarchy bug: FLY is not a subrule of F, require digit boundary

Copilot · nathanjmcdougall · Copilot · commit 794435e0483d · 2026-03-25T20:11:14.000Z
Co-authored-by: nathanjmcdougall <18602289+nathanjmcdougall@users.noreply.github.com> Agent-Logs-Url: https://github.com/usethis-python/usethis-python/sessions/94e8b825-bb91-4ef3-9763-5f4a59375e86
diff --git a/src/usethis/_tool/rule.py b/src/usethis/_tool/rule.py
@@ -21,14 +21,24 @@ def is_rule_covered_by(rule: Rule, parent: Rule) -> bool:
     For example, "TC001" is covered by "TC", and any rule is covered by "ALL".
 
     A rule does not cover itself. "ALL" is never covered by a specific rule.
+
+    Rule codes consist of a letter prefix (the group) followed by optional digits
+    (the specific rule). A parent only covers a child if they share the same letter
+    prefix; for example, "F" covers "F101" but not "FLY" or "FLY001".
     """
     if parent == rule:
         return False
     if parent == "ALL":
         return True
     if rule == "ALL":
         return False
-    return rule.startswith(parent)
+    if not rule.startswith(parent):
+        return False
+    # After the parent prefix, the next character in the child (if any) must be a
+    # digit. This prevents "F" from covering "FLY" (next char 'L' is a letter,
+    # meaning FLY is a separate rule group).
+    rest = rule[len(parent) :]
+    return rest == "" or rest[0].isdigit()
 
 
 @dataclass(frozen=True)
diff --git a/tests/usethis/_tool/test_rule.py b/tests/usethis/_tool/test_rule.py
@@ -23,6 +23,22 @@ def test_partial_prefix(self):
     def test_unrelated(self):
         assert not is_rule_covered_by("E501", "TC")
 
+    def test_different_group_same_first_letter(self):
+        # FLY is a separate rule group from F
+        assert not is_rule_covered_by("FLY", "F")
+
+    def test_different_group_specific_rule(self):
+        # FLY001 belongs to FLY, not F
+        assert not is_rule_covered_by("FLY001", "F")
+
+    def test_same_group_digit_prefix(self):
+        # F101 is a subrule of F1
+        assert is_rule_covered_by("F101", "F1")
+
+    def test_same_group_specific_from_group(self):
+        # F101 is a subrule of F
+        assert is_rule_covered_by("F101", "F")
+
     def test_all_does_not_cover_itself(self):
         assert not is_rule_covered_by("ALL", "ALL")
 
@@ -93,6 +109,24 @@ def test_preserves_unrelated_existing(self):
         assert result.to_add == ["C"]
         assert result.to_remove == []
 
+    def test_different_group_same_first_letter_not_absorbed(self):
+        # "FLY" should not be absorbed by existing "F"
+        result = reconcile_rules(["F"], ["FLY"])
+        assert result.to_add == ["FLY"]
+        assert result.to_remove == []
+
+    def test_group_does_not_replace_different_group(self):
+        # "F" should not replace existing "FLY001"
+        result = reconcile_rules(["FLY001"], ["F"])
+        assert result.to_add == ["F"]
+        assert result.to_remove == []
+
+    def test_incoming_dedup_different_groups(self):
+        # "F" and "FLY" incoming; both should survive since they're different groups
+        result = reconcile_rules([], ["F", "FLY"])
+        assert result.to_add == ["F", "FLY"]
+        assert result.to_remove == []
+
     def test_is_noop_when_no_changes(self):
         result = reconcile_rules(["A"], ["A"])
         assert result.is_noop
