crackerjack 0.37.9__py3-none-any.whl → 0.45.2__py3-none-any.whl

crackerjack/services/patterns/tool_output/other.py

@@ -0,0 +1,97 @@
+"""Additional tool output parsing patterns.
+
+This module provides regex patterns for parsing output from various development tools
+including mypy (type checking), vulture (dead code detection), and complexipy (complexity analysis).
+"""
+
+from ..core import ValidatedPattern
+
+PATTERNS = {
+    "complexipy_complex": ValidatedPattern(
+        name="complexipy_complex",
+        pattern=r"^(.+?): (\d+): (\d+) - (.+) is too complex \((\d+)\)",
+        replacement=r"File: \1, Line: \2, Col: \3, Function: \4, Complexity: \5",
+        description="Parse complexipy complexity detection: file: line: col - function "
+        "is too complex (score)",
+        test_cases=[
+            (
+                "src/main.py: 42: 1 - process_data is too complex (16)",
+                "File: src/main.py, Line: 42, Col: 1, Function: process_data, "
+                "Complexity: 16",
+            ),
+            (
+                "crackerjack/core.py: 100: 5 - calculate_metrics is too complex (25)",
+                "File: crackerjack/core.py, Line: 100, Col: 5, Function: "
+                "calculate_metrics, Complexity: 25",
+            ),
+            (
+                "./utils.py: 200: 1 - complex_function is too complex (18)",
+                "File: ./utils.py, Line: 200, Col: 1, Function: complex_function, "
+                "Complexity: 18",
+            ),
+        ],
+    ),
+    "mypy_error": ValidatedPattern(
+        name="mypy_error",
+        pattern=r"^(.+?): (\d+): error: (.+)$",
+        replacement=r"File: \1, Line: \2, Error: \3",
+        description="Parse mypy error output: file: line: error: message",
+        test_cases=[
+            (
+                "src/main.py: 42: error: Incompatible types in assignment",
+                "File: src/main.py, Line: 42, Error: Incompatible types in assignment",
+            ),
+            (
+                "crackerjack/core.py: 123: error: Name 'undefined' is not defined",
+                "File: crackerjack/core.py, Line: 123, Error: Name 'undefined' is not "
+                "defined",
+            ),
+            (
+                "./main.py: 999: error: Argument has incompatible type",
+                "File: ./main.py, Line: 999, Error: Argument has incompatible type",
+            ),
+        ],
+    ),
+    "mypy_note": ValidatedPattern(
+        name="mypy_note",
+        pattern=r"^(.+?): (\d+): note: (.+)$",
+        replacement=r"File: \1, Line: \2, Note: \3",
+        description="Parse mypy note output: file: line: note: message",
+        test_cases=[
+            (
+                "src/main.py: 42: note: See https://mypy.rtfd.io/...",
+                "File: src/main.py, Line: 42, Note: See https://mypy.rtfd.io/...",
+            ),
+            (
+                "crackerjack/core.py: 123: note: Consider using a type annotation",
+                "File: crackerjack/core.py, Line: 123, Note: Consider using a type "
+                "annotation",
+            ),
+            (
+                "./main.py: 999: note: Consider using Optional[...]",
+                "File: ./main.py, Line: 999, Note: Consider using Optional[...]",
+            ),
+        ],
+    ),
+    "vulture_unused": ValidatedPattern(
+        name="vulture_unused",
+        pattern=r"^(.+?): (\d+): unused (.+) '(.+)'",
+        replacement=r"File: \1, Line: \2, Unused \3: '\4'",
+        description="Parse vulture unused code detection: file: line: unused type"
+        " 'name'",
+        test_cases=[
+            (
+                "src/main.py: 42: unused function 'helper'",
+                "File: src/main.py, Line: 42, Unused function: 'helper'",
+            ),
+            (
+                "crackerjack/core.py: 123: unused variable 'result'",
+                "File: crackerjack/core.py, Line: 123, Unused variable: 'result'",
+            ),
+            (
+                "./main.py: 999: unused import 'os'",
+                "File: ./main.py, Line: 999, Unused import: 'os'",
+            ),
+        ],
+    ),
+}

crackerjack/services/patterns/tool_output/pyright.py

@@ -0,0 +1,67 @@
+"""Pyright type checker output parsing patterns.
+
+This module provides regex patterns for parsing Pyright static type checker output,
+including errors, warnings, and summary information.
+"""
+
+from ..core import ValidatedPattern
+
+PATTERNS = {
+    "pyright_error": ValidatedPattern(
+        name="pyright_error",
+        pattern=r"^(.+?): (\d+): (\d+) - error: (.+)$",
+        replacement=r"File: \1, Line: \2, Col: \3, Error: \4",
+        description="Parse pyright error output: file: line: col - error: message",
+        test_cases=[
+            (
+                "src/main.py: 42: 10 - error: Type 'str' is not assignable to type "
+                "'int'",
+                "File: src/main.py, Line: 42, Col: 10, Error: Type 'str' is not "
+                "assignable to type 'int'",
+            ),
+            (
+                "crackerjack/core.py: 123: 5 - error: Cannot assign to None",
+                "File: crackerjack/core.py, Line: 123, Col: 5, Error: Cannot assign "
+                "to None",
+            ),
+            (
+                "./main.py: 999: 50 - error: Missing return statement",
+                "File: ./main.py, Line: 999, Col: 50, Error: Missing return statement",
+            ),
+        ],
+    ),
+    "pyright_warning": ValidatedPattern(
+        name="pyright_warning",
+        pattern=r"^(.+?): (\d+): (\d+) - warning: (.+)$",
+        replacement=r"File: \1, Line: \2, Col: \3, Warning: \4",
+        description="Parse pyright warning output: file: line: col - warning: message",
+        test_cases=[
+            (
+                "src/main.py: 42: 10 - warning: Type 'Any' is not specific enough",
+                "File: src/main.py, Line: 42, Col: 10, Warning: Type 'Any' is not "
+                "specific enough",
+            ),
+            (
+                "crackerjack/core.py: 123: 5 - warning: Variable is untyped",
+                "File: crackerjack/core.py, Line: 123, Col: 5, Warning: Variable is "
+                "untyped",
+            ),
+            (
+                "./main.py: 999: 50 - warning: Type could be more specific",
+                "File: ./main.py, Line: 999, Col: 50, Warning: Type could be more"
+                " specific",
+            ),
+        ],
+    ),
+    "pyright_summary": ValidatedPattern(
+        name="pyright_summary",
+        pattern=r"(\d+) error[s]?, (\d+) warning[s]?",
+        replacement=r"\1 errors, \2 warnings",
+        description="Parse pyright summary with error and warning counts",
+        test_cases=[
+            ("5 errors, 3 warnings", "5 errors, 3 warnings"),
+            ("1 error, 1 warning", "1 errors, 1 warnings"),
+            ("0 errors, 10 warnings found", "0 errors, 10 warnings found"),
+        ],
+    ),
+}

crackerjack/services/patterns/tool_output/ruff.py

@@ -0,0 +1,44 @@
+"""Ruff linter output parsing patterns.
+
+This module provides regex patterns for parsing Ruff static analysis tool output,
+including error messages and summary lines.
+"""
+
+from ..core import ValidatedPattern
+
+PATTERNS = {
+    "ruff_check_error": ValidatedPattern(
+        name="ruff_check_error",
+        pattern=r"^(.+?): (\d+): (\d+): ([A-Z]\d+) (.+)$",
+        replacement=r"File: \1, Line: \2, Col: \3, Code: \4, Message: \5",
+        description="Parse ruff-check error output: file: line: col: code message",
+        test_cases=[
+            (
+                "src/main.py: 42: 10: E501 Line too long (88 > 79 characters)",
+                "File: src/main.py, Line: 42, Col: 10, Code: E501, Message: Line too "
+                "long (88 > 79 characters)",
+            ),
+            (
+                "crackerjack/core.py: 123: 5: F401 'os' imported but unused",
+                "File: crackerjack/core.py, Line: 123, Col: 5, Code: F401, Message: "
+                "'os' imported but unused",
+            ),
+            (
+                "src/main.py: 999: 80: W291 trailing whitespace",
+                "File: src/main.py, Line: 999, Col: 80, Code: W291, Message: trailing "
+                "whitespace",
+            ),
+        ],
+    ),
+    "ruff_check_summary": ValidatedPattern(
+        name="ruff_check_summary",
+        pattern=r"Found (\d+) error",
+        replacement=r"Found \1 error(s)",
+        description="Parse ruff-check summary line for error count",
+        test_cases=[
+            ("Found 5 error", "Found 5 error(s)"),
+            ("Found 1 error in 3 files", "Found 1 error(s) in 3 files"),
+            ("Found 42 error detected", "Found 42 error(s) detected"),
+        ],
+    ),
+}

crackerjack/services/patterns/url_sanitization.py

@@ -0,0 +1,114 @@
+"""URL sanitization patterns for security."""
+
+from .core import ValidatedPattern
+
+PATTERNS: dict[str, ValidatedPattern] = {
+    "sanitize_localhost_urls": ValidatedPattern(
+        name="sanitize_localhost_urls",
+        pattern=r"https?: //localhost: \d+[^\s]*",
+        replacement="[INTERNAL_URL]",
+        description="Sanitize localhost URLs with ports for security",
+        global_replace=True,
+        test_cases=[
+            ("http: //localhost: 8000/api/test", "[INTERNAL_URL]"),
+            ("https: //localhost: 3000/dashboard", "[INTERNAL_URL]"),
+            (
+                "Visit http: //localhost: 8080/admin for details",
+                "Visit [INTERNAL_URL] for details",
+            ),
+            ("https: //example.com/test", "https: //example.com/test"),
+        ],
+    ),
+    "sanitize_127_urls": ValidatedPattern(
+        name="sanitize_127_urls",
+        pattern=r"https?: //127\.0\.0\.1: \d+[^\s]*",
+        replacement="[INTERNAL_URL]",
+        description="Sanitize 127.0.0.1 URLs with ports for security",
+        global_replace=True,
+        test_cases=[
+            ("http: //127.0.0.1: 8000/api", "[INTERNAL_URL]"),
+            ("https: //127.0.0.1: 3000/test", "[INTERNAL_URL]"),
+            ("Connect to http: //127.0.0.1: 5000/status", "Connect to [INTERNAL_URL]"),
+            (
+                "https: //192.168.1.1: 8080/test",
+                "https: //192.168.1.1: 8080/test",
+            ),
+        ],
+    ),
+    "sanitize_any_localhost_urls": ValidatedPattern(
+        name="sanitize_any_localhost_urls",
+        pattern=r"https?: //0\.0\.0\.0: \d+[^\s]*",
+        replacement="[INTERNAL_URL]",
+        description="Sanitize 0.0.0.0 URLs with ports for security",
+        global_replace=True,
+        test_cases=[
+            ("http: //0.0.0.0: 8000/api", "[INTERNAL_URL]"),
+            ("https: //0.0.0.0: 3000/test", "[INTERNAL_URL]"),
+            ("https: //1.1.1.1: 8080/test", "https: //1.1.1.1: 8080/test"),
+        ],
+    ),
+    "sanitize_ws_localhost_urls": ValidatedPattern(
+        name="sanitize_ws_localhost_urls",
+        pattern=r"ws: //localhost: \d+[^\s]*",
+        replacement="[INTERNAL_URL]",
+        description="Sanitize WebSocket localhost URLs with ports for security",
+        global_replace=True,
+        test_cases=[
+            ("ws: //localhost: 8675/websocket", "[INTERNAL_URL]"),
+            ("ws: //localhost: 3000/socket", "[INTERNAL_URL]"),
+            ("Connect to ws: //localhost: 8000/ws", "Connect to [INTERNAL_URL]"),
+            (
+                "wss: //example.com: 443/socket",
+                "wss: //example.com: 443/socket",
+            ),
+        ],
+    ),
+    "sanitize_ws_127_urls": ValidatedPattern(
+        name="sanitize_ws_127_urls",
+        pattern=r"ws: //127\.0\.0\.1: \d+[^\s]*",
+        replacement="[INTERNAL_URL]",
+        description="Sanitize WebSocket 127.0.0.1 URLs with ports for security",
+        global_replace=True,
+        test_cases=[
+            ("ws: //127.0.0.1: 8675/websocket", "[INTERNAL_URL]"),
+            ("ws: //127.0.0.1: 3000/socket", "[INTERNAL_URL]"),
+            (
+                "ws: //192.168.1.1: 8080/socket",
+                "ws: //192.168.1.1: 8080/socket",
+            ),
+        ],
+    ),
+    "sanitize_simple_localhost_urls": ValidatedPattern(
+        name="sanitize_simple_localhost_urls",
+        pattern=r"http: //localhost[^\s]*",
+        replacement="[INTERNAL_URL]",
+        description="Sanitize simple localhost URLs without explicit ports for security",
+        global_replace=True,
+        test_cases=[
+            ("http: //localhost/api/test", "[INTERNAL_URL]"),
+            ("http: //localhost/dashboard", "[INTERNAL_URL]"),
+            ("Visit http: //localhost/admin", "Visit [INTERNAL_URL]"),
+            (
+                "https: //localhost: 443/test",
+                "https: //localhost: 443/test",
+            ),
+        ],
+    ),
+    "sanitize_simple_ws_localhost_urls": ValidatedPattern(
+        name="sanitize_simple_ws_localhost_urls",
+        pattern=r"ws: //localhost[^\s]*",
+        replacement="[INTERNAL_URL]",
+        description="Sanitize simple WebSocket localhost URLs without explicit ports"
+        " for security",
+        global_replace=True,
+        test_cases=[
+            ("ws: //localhost/websocket", "[INTERNAL_URL]"),
+            ("ws: //localhost/socket", "[INTERNAL_URL]"),
+            ("Connect to ws: //localhost/ws", "Connect to [INTERNAL_URL]"),
+            (
+                "wss: //localhost: 443/socket",
+                "wss: //localhost: 443/socket",
+            ),
+        ],
+    ),
+}

crackerjack/services/patterns/utilities.py

@@ -0,0 +1,42 @@
+"""General utility patterns for extraction and manipulation."""
+
+from .core import ValidatedPattern
+
+PATTERNS: dict[str, ValidatedPattern] = {
+    "extract_coverage_percentage": ValidatedPattern(
+        name="extract_coverage_percentage",
+        pattern=r"coverage-([\d\.]+)%25",
+        replacement="",  # Not used for extraction, just validation
+        description="Search for coverage percentage in badge URL",
+        test_cases=[
+            ("coverage-85.0%25", ""),  # Will use search() to get group(1)
+            ("coverage-75.5%25", ""),
+            ("coverage-100.0%25", ""),
+            ("no coverage here", "no coverage here"),  # No match
+        ],
+    ),
+    "extract_range_size": ValidatedPattern(
+        name="extract_range_size",
+        pattern=r"range\((\d+)\)",
+        replacement=r"\1",
+        description="Extract numeric size from range() calls",
+        test_cases=[
+            ("range(1000)", "1000"),
+            ("range(50)", "50"),
+            ("for i in range(100): ", "for i in 100: "),
+            ("other_func(10)", "other_func(10)"),
+        ],
+    ),
+    "extract_variable_name_from_assignment": ValidatedPattern(
+        name="extract_variable_name_from_assignment",
+        pattern=r"\s*(\w+)\s*=.*",
+        replacement=r"\1",
+        description="Extract variable name from assignment statement",
+        test_cases=[
+            ("password = 'secret'", "password"),
+            ("api_key = 'value'", "api_key"),
+            (" token =", "token"),
+            ("complex_variable_name = value", "complex_variable_name"),
+        ],
+    ),
+}