crackerjack 0.33.0__py3-none-any.whl → 0.33.1__py3-none-any.whl

crackerjack/services/regex_utils.py

@@ -1,10 +1,3 @@
-"""
-Utility functions for immediate regex pattern testing and validation.
-
-Provides quick functions for testing regex patterns before adding them
-to the centralized registry, and utilities for migrating existing re.sub() calls.
-"""
-
 import re
 import typing as t
 from pathlib import Path
@@ -18,11 +11,6 @@ def test_pattern_immediately(
     test_cases: list[tuple[str, str]],
     description: str = "",
 ) -> dict[str, t.Any]:
-    """
-    Test a regex pattern immediately without adding to registry.
-
-    Returns a report of test results for quick validation.
-    """
     results: dict[str, t.Any] = {
         "pattern": pattern,
         "replacement": replacement,
@@ -33,9 +21,6 @@ def test_pattern_immediately(
         "errors": [],
     }
 
-    # Check for forbidden replacement syntax first using safe patterns\n    forbidden_checks = [\n        (r\"\\\\g\\\\s*<\\\\s*\\\\d+\\\\s*>\", \"\\\\g < 1 > with spaces\"),\n        (r\"\\\\g<\\\\s+\\\\d+>\", \"\\\\g< 1> with space after <\"),\n        (r\"\\\\g<\\\\d+\\\\s+>\", \"\\\\g<1 > with space before >\"),\n    ]
-
-    # Validate pattern compilation using safe cache
     try:
         compiled = CompiledPatternCache.get_compiled_pattern(pattern)
     except ValueError as e:
@@ -43,7 +28,6 @@ def test_pattern_immediately(
         results["all_passed"] = False
         return results
 
-    # Test all cases
     for i, (input_text, expected) in enumerate(test_cases):
         try:
             result = compiled.sub(replacement, input_text)
@@ -71,7 +55,6 @@ def test_pattern_immediately(
             )
             results["all_passed"] = False
 
-    # Safety warnings
     if ".*.*" in pattern:
         results["warnings"].append(
             "Multiple .* constructs may cause performance issues"
@@ -85,7 +68,6 @@ def test_pattern_immediately(
 
 
 def print_pattern_test_report(results: dict[str, t.Any]) -> None:
-    """Print a formatted report of pattern test results."""
     print("\n🔍 REGEX PATTERN TEST REPORT")
     print("=" * 50)
     print(f"Pattern: {results['pattern']}")
@@ -95,25 +77,25 @@ def print_pattern_test_report(results: dict[str, t.Any]) -> None:
     print()
 
     if results["errors"]:
-        print("❌ ERRORS:")
+        print("❌ ERRORS: ")
         for error in results["errors"]:
-            print(f"  • {error}")
+            print(f" • {error}")
         print()
 
     if results["warnings"]:
-        print("⚠️  WARNINGS:")
+        print("⚠️ WARNINGS: ")
         for warning in results["warnings"]:
-            print(f"  • {warning}")
+            print(f" • {warning}")
         print()
 
-    print("📋 TEST CASES:")
+    print("📋 TEST CASES: ")
     for test in results["test_results"]:
         status = "✅ PASS" if test["passed"] else "❌ FAIL"
         print(
-            f"  {status} Test {test['test_case']}: '{test['input']}' → '{test['actual']}'"
+            f" {status} Test {test['test_case']}: '{test['input']}' → '{test['actual']}'"
         )
         if not test["passed"]:
-            print(f"    Expected: '{test['expected']}'")
+            print(f" Expected: '{test['expected']}'")
 
     print(
         f"\n🎯 OVERALL: {'✅ ALL TESTS PASSED' if results['all_passed'] else '❌ TESTS FAILED'}"
@@ -127,21 +109,19 @@ def quick_pattern_test(
     test_cases: list[tuple[str, str]],
     description: str = "",
 ) -> bool:
-    """Quick test function that returns True if all tests pass."""
     results = test_pattern_immediately(pattern, replacement, test_cases, description)
     print_pattern_test_report(results)
-    return results["all_passed"]
+    passed: bool = results["all_passed"]
+    return passed
 
 
 def find_safe_pattern_for_text(text: str) -> list[str]:
-    """Find which existing safe patterns would match the given text."""
     matches = []
     for name, pattern in SAFE_PATTERNS.items():
         try:
             if pattern.test(text):
                 matches.append(name)
         except Exception:
-            # Skip patterns that error
             continue
     return matches
 
@@ -149,17 +129,6 @@ def find_safe_pattern_for_text(text: str) -> list[str]:
 def suggest_migration_for_re_sub(
     original_pattern: str, original_replacement: str, sample_text: str = ""
 ) -> dict[str, t.Any]:
-    """
-    Suggest how to migrate a raw re.sub() call to use safe patterns.
-
-    Args:
-        original_pattern: The original regex pattern
-        original_replacement: The original replacement string
-        sample_text: Optional sample text to test against
-
-    Returns:
-        Dictionary with migration suggestions
-    """
     suggestion: dict[str, t.Any] = {
         "original_pattern": original_pattern,
         "original_replacement": original_replacement,
@@ -170,10 +139,9 @@ def suggest_migration_for_re_sub(
         "test_cases_needed": [],
     }
 
-    # Check for safety issues first using safe patterns
     forbidden_checks = [
-        (r"\\g\s*<\s*\d+\s*>", "\\g < 1 > with spaces"),
-        (r"\\g<\s+\d+>", "\\g< 1> with space after <"),
+        (r"\\g\s*<\s*\d+\s*>", "\\g<1> with spaces"),
+        (r"\\g<\s+\d+>", "\\g<1> with space after <"),
         (r"\\\\g<\\d+\\s+>", "\\\\g<1 > with space before >"),
     ]
     for forbidden_pattern, _ in forbidden_checks:
@@ -183,14 +151,12 @@ def suggest_migration_for_re_sub(
                 "CRITICAL: Bad replacement syntax - spaces in \\g<1>"
             )
 
-    # Look for existing patterns that might work
     if sample_text:
         matches = find_safe_pattern_for_text(sample_text)
         suggestion["existing_matches"] = matches
         if matches:
             suggestion["needs_new_pattern"] = False
 
-    # Generate suggested pattern name based on original pattern
     if "python.*-.*m" in original_pattern:
         suggestion["suggested_name"] = "fix_python_command_spacing"
     elif r"\-\s*\-" in original_pattern:
@@ -200,7 +166,6 @@ def suggest_migration_for_re_sub(
     elif "password" in original_pattern.lower():
         suggestion["suggested_name"] = "fix_password_pattern"
     else:
-        # Generate name from pattern keywords using safe pattern
         keyword_pattern = CompiledPatternCache.get_compiled_pattern(r"[a-zA-Z]+")
         keywords = keyword_pattern.findall(original_pattern)
         if keywords:
@@ -210,17 +175,15 @@ def suggest_migration_for_re_sub(
         else:
             suggestion["suggested_name"] = "fix_custom_pattern"
 
-    # Suggest test cases based on common patterns
     if sample_text:
         suggestion["test_cases_needed"].append((sample_text, "Expected output needed"))
 
-    # Common test cases for spacing issues
     if "-" in original_pattern:
         suggestion["test_cases_needed"].extend(
             [
                 ("word - word", "word-word"),
-                ("already-good", "already-good"),  # No change
-                ("multiple - word - spacing", "multiple-word - spacing"),  # Partial fix
+                ("already-good", "already-good"),
+                ("multiple - word - spacing", "multiple-word - spacing"),
             ]
         )
 
@@ -228,7 +191,6 @@ def suggest_migration_for_re_sub(
 
 
 def print_migration_suggestion(suggestion: dict[str, t.Any]) -> None:
-    """Print a formatted migration suggestion report."""
     print("\n🔄 REGEX MIGRATION SUGGESTION")
     print("=" * 50)
     print(f"Original Pattern: {suggestion['original_pattern']}")
@@ -236,59 +198,54 @@ def print_migration_suggestion(suggestion: dict[str, t.Any]) -> None:
     print()
 
     if suggestion["safety_issues"]:
-        print("❌ SAFETY ISSUES:")
+        print("❌ SAFETY ISSUES: ")
         for issue in suggestion["safety_issues"]:
-            print(f"  • {issue}")
+            print(f" • {issue}")
         print()
 
     if suggestion["existing_matches"]:
-        print("✅ EXISTING PATTERNS AVAILABLE:")
+        print("✅ EXISTING PATTERNS AVAILABLE: ")
         for pattern_name in suggestion["existing_matches"]:
             pattern = SAFE_PATTERNS[pattern_name]
-            print(f"  • {pattern_name}: {pattern.description}")
+            print(f" • {pattern_name}: {pattern.description}")
         print("💡 Consider using existing patterns instead of creating new ones.")
         print()
 
     if suggestion["needs_new_pattern"]:
-        print("🆕 NEW PATTERN NEEDED:")
-        print(f"  Suggested Name: {suggestion['suggested_name']}")
-        print("  Add to crackerjack/services/regex_patterns.py:")
+        print("🆕 NEW PATTERN NEEDED: ")
+        print(f" Suggested Name: {suggestion['suggested_name']}")
+        print(" Add to crackerjack/services/regex_patterns.py: ")
         print()
-        print("  ```python")
-        print(f'  "{suggestion["suggested_name"]}": ValidatedPattern(')
-        print(f'      name="{suggestion["suggested_name"]}",')
-        print(f'      pattern=r"{suggestion["original_pattern"]}",')
-        print(f'      replacement=r"{suggestion["original_replacement"]}",')
-        print('      description="TODO: Add description",')
-        print("      test_cases=[")
+        print(" ```python")
+        print(f' "{suggestion["suggested_name"]}": ValidatedPattern(')
+        print(f' name="{suggestion["suggested_name"]}", ')
+        print(f' pattern=r"{suggestion["original_pattern"]}", ')
+        print(f' replacement=r"{suggestion["original_replacement"]}", ')
+        print(' description="TODO: Add description", ')
+        print(" test_cases=[")
         for test_input, test_output in suggestion["test_cases_needed"]:
-            print(f'          ("{test_input}", "{test_output}"),')
-        print("      ]")
-        print("  ),")
-        print("  ```")
+            print(f' ("{test_input}", "{test_output}"), ')
+        print(" ]")
+        print(" ), ")
+        print(" ```")
         print()
 
-    print("🔧 MIGRATION STEPS:")
-    print("  1. Fix any safety issues in replacement syntax")
+    print("🔧 MIGRATION STEPS: ")
+    print(" 1. Fix any safety issues in replacement syntax")
     if suggestion["existing_matches"]:
-        print("  2. Use existing safe patterns if possible:")
+        print(" 2. Use existing safe patterns if possible: ")
         for pattern_name in suggestion["existing_matches"]:
-            print(f"     SAFE_PATTERNS['{pattern_name}'].apply(text)")
+            print(f" SAFE_PATTERNS['{pattern_name}'].apply(text)")
     if suggestion["needs_new_pattern"]:
-        print("  3. Add new ValidatedPattern to regex_patterns.py")
-        print("  4. Test thoroughly with comprehensive test cases")
-    print("  5. Replace re.sub() call with safe pattern usage")
-    print("  6. Run pre-commit hook to validate")
+        print(" 3. Add new ValidatedPattern to regex_patterns.py")
+        print(" 4. Test thoroughly with comprehensive test cases")
+    print(" 5. Replace re.sub() call with safe pattern usage")
+    print(" 6. Run pre-commit hook to validate")
 
     print("=" * 50)
 
 
 def audit_file_for_re_sub(file_path: Path) -> list[dict[str, t.Any]]:
-    """
-    Audit a file for re.sub() calls and return migration suggestions.
-
-    Returns list of findings with line numbers and suggestions.
-    """
     findings = []
 
     try:
@@ -296,9 +253,8 @@ def audit_file_for_re_sub(file_path: Path) -> list[dict[str, t.Any]]:
         lines = content.split("\n")
 
         for i, line in enumerate(lines, 1):
-            # Look for re.sub() calls using safe pattern
             re_sub_pattern = CompiledPatternCache.get_compiled_pattern(
-                r're\.sub\s*\(\s*[r]?["\']([^"\']+)["\'],\s*[r]?["\']([^"\']*)["\']'
+                r're\.sub\s*\(\s*[r]?["\']([^"\']+)["\'], \s*[r]?["\']([^"\']*)["\']'
             )
             re_sub_match = re_sub_pattern.search(line)
             if re_sub_match:
@@ -328,18 +284,11 @@ def audit_file_for_re_sub(file_path: Path) -> list[dict[str, t.Any]]:
 
 
 def audit_codebase_re_sub() -> dict[str, list[dict[str, t.Any]]]:
-    """
-    Audit entire crackerjack codebase for re.sub() usage.
-
-    Returns dictionary mapping file paths to findings.
-    """
     findings_by_file = {}
 
-    # Audit crackerjack package
     crackerjack_dir = Path(__file__).parent.parent
 
     for py_file in crackerjack_dir.rglob("*.py"):
-        # Skip test files and __pycache__
         if "test_" in py_file.name or "__pycache__" in str(py_file):
             continue
 
@@ -351,18 +300,6 @@ def audit_codebase_re_sub() -> dict[str, list[dict[str, t.Any]]]:
 
 
 def replace_unsafe_regex_with_safe_patterns(content: str) -> str:
-    """
-    Replace unsafe regex patterns in content with safe alternatives.
-
-    This function looks for common regex patterns and replaces them with
-    calls to SAFE_PATTERNS where possible.
-
-    Args:
-        content: The source code content to fix
-
-    Returns:
-        Fixed content with safe patterns applied
-    """
     lines = content.split("\n")
     modified = False
 
@@ -371,10 +308,8 @@ def replace_unsafe_regex_with_safe_patterns(content: str) -> str:
     for i, line in enumerate(lines):
         original_line = line
 
-        # Fix critical replacement syntax issues first
         line = _fix_replacement_syntax_issues(line)
 
-        # Process re.sub patterns
         line, _, needs_import = _process_re_sub_patterns(line, has_safe_patterns_import)
 
         if needs_import and not has_safe_patterns_import:
@@ -384,9 +319,8 @@ def replace_unsafe_regex_with_safe_patterns(content: str) -> str:
                 "from crackerjack.services.regex_patterns import SAFE_PATTERNS",
             )
             has_safe_patterns_import = True
-            i += 1  # Adjust index for inserted line
+            i += 1
 
-        # Update the line if it changed
         if line != original_line:
             lines[i] = line
             modified = True
@@ -395,7 +329,6 @@ def replace_unsafe_regex_with_safe_patterns(content: str) -> str:
 
 
 def _check_for_safe_patterns_import(lines: list[str]) -> bool:
-    """Check if SAFE_PATTERNS import is already present."""
     return any(
         "from crackerjack.services.regex_patterns import SAFE_PATTERNS" in line
         or "SAFE_PATTERNS" in line
@@ -404,9 +337,7 @@ def _check_for_safe_patterns_import(lines: list[str]) -> bool:
 
 
 def _fix_replacement_syntax_issues(line: str) -> str:
-    """Fix critical replacement syntax issues in regex patterns."""
     if r"\g < " in line or r"\g< " in line or r"\g <" in line:
-        # Fix spacing in replacement groups using safe pattern
         spacing_fix_pattern = CompiledPatternCache.get_compiled_pattern(
             r"\\g\s*<\s*(\d+)\s*>"
         )
@@ -417,9 +348,8 @@ def _fix_replacement_syntax_issues(line: str) -> str:
 def _process_re_sub_patterns(
     line: str, has_safe_patterns_import: bool
 ) -> tuple[str, bool, bool]:
-    """Process re.sub patterns and replace with safe alternatives."""
     re_sub_match = CompiledPatternCache.get_compiled_pattern(
-        r're\.sub\s*\(\s*r?["\']([^"\']+)["\']\s*,\s*r?["\']([^"\']*)["\']'
+        r're\.sub\s*\(\s*r?["\']([^"\']+)["\']\s*, \s*r?["\']([^"\']*)["\']'
     ).search(line)
 
     if not re_sub_match:
@@ -436,8 +366,6 @@ def _process_re_sub_patterns(
 
 
 def _identify_safe_pattern(pattern: str, replacement: str) -> str | None:
-    """Identify which safe pattern matches the given regex pattern."""
-    # Common patterns we can automatically replace
     if pattern == r"(\w+)\s*-\s*(\w+)" and replacement in (
         r"\1-\2",
         r"\g<1>-\g<2>",
@@ -453,11 +381,9 @@ def _identify_safe_pattern(pattern: str, replacement: str) -> str | None:
 def _replace_with_safe_pattern(
     line: str, re_sub_match: re.Match[str], safe_pattern_name: str
 ) -> tuple[str, bool, bool]:
-    """Replace re.sub call with safe pattern call."""
     before_re_sub = line[: re_sub_match.start()]
     after_re_sub = line[re_sub_match.end() :]
 
-    # Look for assignment pattern: var = re.sub(...)
     assign_match = CompiledPatternCache.get_compiled_pattern(r"(\w+)\s*=\s*$").search(
         before_re_sub
     )
@@ -476,7 +402,6 @@ def _handle_assignment_pattern(
     after_re_sub: str,
     safe_pattern_name: str,
 ) -> tuple[str, bool, bool]:
-    """Handle assignment pattern replacement."""
     var_name = assign_match.group(1)
     text_var = _extract_source_variable(line)
     new_line = f"{var_name} = SAFE_PATTERNS['{safe_pattern_name}'].apply({text_var})"
@@ -486,7 +411,6 @@ def _handle_assignment_pattern(
 def _handle_direct_replacement(
     line: str, re_sub_match: re.Match[str], safe_pattern_name: str
 ) -> tuple[str, bool, bool]:
-    """Handle direct replacement of re.sub call."""
     text_var = _extract_source_variable(line)
     new_line = line.replace(
         re_sub_match.group(0),
@@ -496,15 +420,13 @@ def _handle_direct_replacement(
 
 
 def _extract_source_variable(line: str) -> str:
-    """Extract the source variable from re.sub call."""
     full_match = CompiledPatternCache.get_compiled_pattern(
-        r"re\.sub\s*\([^,]+,\s*[^,]+,\s*(\w+)"
+        r"re\.sub\s*\([^, ]+, \s*[^, ]+, \s*(\w+)"
     ).search(line)
     return full_match.group(1) if full_match else "text"
 
 
 def _find_import_insertion_point(lines: list[str]) -> int:
-    """Find the right place to insert the import statement."""
     import_index = 0
     for j, check_line in enumerate(lines):
         if check_line.strip().startswith(("import ", "from ")):
@@ -517,7 +439,6 @@ def _find_import_insertion_point(lines: list[str]) -> int:
 
 
 if __name__ == "__main__":
-    # Example usage for testing patterns
     test_result = quick_pattern_test(
         pattern=r"(\w+)\s*-\s*(\w+)",
         replacement=r"\1-\2",
@@ -529,7 +450,6 @@ if __name__ == "__main__":
         description="Fix spacing in hyphenated names",
     )
 
-    # Example migration suggestion
     print("\n" + "=" * 60)
     migration = suggest_migration_for_re_sub(
         r"python\s*-\s*m\s+", "python -m ", "python - m crackerjack"