feat(version-scanner): implement targeted namespaced ignore pragmas (#17540)

This PR implements ignore pragmas to allow granular and self-expiring
ignores to help fend off false positives in places where we need to
leave references to specific strings:

`# version-scanner: ignore-rule=rule_name:version`

### Example:
Imagine searching for "Python 3.7". We have a variety of rules to cover
multiple circumstances. One rule matches solely on the version number
(e.g. "3.7" in case the reference is an edge case not covered by other
more specific and complicated rules).

Thus if we find "3.7" in a situation unrelated to Python, we will have a
false positive such as this:
`matplotlib==3.7.2`

We can flag a line like this to be ignored under one of the numerous
rules we have for categorizing matches (e.g `explicit_version_string`,
`dependency_requirement`, `combined_version_string`, etc.) so that it
does not trigger a false positive in the future. In this case we
detected it under the `explicit_version_string` pattern so we flag it to
be ignored under that rule, if the search is for 3.7.

`matplotlib==3.7.2 # version-scanner:
ignore-rule=explicit_version_string:3.7`

You might ask: **but what about when we need to find versions of
matplotlib so we can update references to them?**

If instead of Python, we were to search for "matplotlib 3.7.2" we would
get a match. As a non-Python match, it would be caught under the
`dependency_requirement` rule instead of the `explicit_*` rule.

Author: chalmerlowe

scripts/version_scanner/tests/unit/test_version_scanner.py

@@ -148,6 +148,56 @@ def test_scan_file_ignores_pragma(tmp_path):
     results = scan_file(str(test_file), rules)
     assert len(results) == 0
 
+
+def test_scan_file_ignores_targeted_pragma(tmp_path):
+    test_file = tmp_path / "test.py"
+    test_file.write_text("python_requires = '>=3.7'  # version-scanner: ignore-rule=python_requires_check:3.7\n")
+    
+    rules = [
+        {
+            "name": "python_requires_check", 
+            "pattern": re.compile(r"python_requires\s*=\s*['\"]>=3\.7['\"]"),
+            "version": "3.7"
+        }
+    ]
+    
+    results = scan_file(str(test_file), rules)
+    assert len(results) == 0
+
+
+def test_scan_file_handles_non_string_rule_name_and_version(tmp_path):
+    test_file = tmp_path / "test.py"
+    test_file.write_text("python_requires = '>=3.7'  # version-scanner: ignore-rule=123:3.7\n")
+    
+    rules = [
+        {
+            "name": 123,  # Integer rule name
+            "pattern": re.compile(r"python_requires\s*=\s*['\"]>=3\.7['\"]"),
+            "version": 3.7 # Float version
+        }
+    ]
+    
+    # This should not raise TypeError
+    results = scan_file(str(test_file), rules)
+    assert len(results) == 0
+
+
+
+def test_scan_file_does_not_ignore_mismatched_targeted_pragma(tmp_path):
+    test_file = tmp_path / "test.py"
+    test_file.write_text("python_requires = '>=3.7'  # version-scanner: ignore-rule=python_requires_check:3.8\n")
+    
+    rules = [
+        {
+            "name": "python_requires_check", 
+            "pattern": re.compile(r"python_requires\s*=\s*['\"]>=3\.7['\"]"),
+            "version": "3.7"
+        }
+    ]
+    
+    results = scan_file(str(test_file), rules)
+    assert len(results) == 1
+
 def test_scan_file_ignores_next_line(tmp_path):
     test_file = tmp_path / "test.py"
     test_file.write_text("# version-scanner: ignore-next-line\npython_requires = '>=3.7'\n")

scripts/version_scanner/version_scanner.py

@@ -214,11 +214,16 @@ def scan_file(file_path: str, compiled_rules: List[Dict[str, re.Pattern]]) -> Li
                 if "version-scanner: ignore-next-line" in line:
                     skip_next = True
                     continue
-                if "version-scanner: ignore" in line:
+                if "version-scanner: ignore" in line and "version-scanner: ignore-rule" not in line and "version-scanner: ignore-next-line" not in line:
                     continue
                 for rule in compiled_rules:
                     match = rule["pattern"].search(line)
                     if match:
+                        version = rule.get("version")
+                        if version:
+                            pragma_pattern = rf"version-scanner\s*:\s*ignore-rule\s*=\s*{re.escape(str(rule['name']))}\s*:\s*{re.escape(str(version))}"
+                            if re.search(pragma_pattern, line, re.IGNORECASE):
+                                continue
                         results.append({
                             "rule_name": rule["name"],
                             "line_number": line_num,