thailint 0.12.0__py3-none-any.whl → 0.13.0__py3-none-any.whl

src/linters/lazy_ignores/skip_detector.py

@@ -0,0 +1,298 @@
+"""
+Purpose: Detect test skip patterns without proper justification in source code
+
+Scope: pytest.mark.skip, pytest.skip(), it.skip(), describe.skip(), test.skip() pattern detection
+
+Overview: Provides TestSkipDetector class that scans Python and JavaScript/TypeScript source
+    code for test skip patterns that lack proper justification. For Python, detects bare
+    @pytest.mark.skip and pytest.skip() without reason arguments. For JavaScript/TypeScript,
+    detects it.skip(), describe.skip(), and test.skip() patterns. Returns list of
+    IgnoreDirective objects with line/column positions for violation reporting.
+
+Dependencies: re for pattern matching, pathlib for file paths, types module for dataclasses
+
+Exports: TestSkipDetector
+
+Interfaces: find_skips(code: str, file_path: Path | str | None, language: str) -> list[IgnoreDirective]
+
+Implementation: Regex-based line-by-line scanning with language-specific pattern detection
+"""
+
+import re
+from collections.abc import Callable
+from pathlib import Path
+
+from src.core.constants import Language
+from src.linters.lazy_ignores.directive_utils import (
+    create_directive_no_rules,
+    normalize_path,
+)
+from src.linters.lazy_ignores.types import IgnoreDirective, IgnoreType
+
+
+def _is_comment_line(line: str) -> bool:
+    """Check if a line is a Python comment.
+
+    Args:
+        line: Line of code to check
+
+    Returns:
+        True if the line is a comment (starts with # after whitespace)
+    """
+    return line.strip().startswith("#")
+
+
+def _scan_empty(_line: str, _line_num: int, _file_path: Path) -> list[IgnoreDirective]:
+    """No-op scanner for unsupported languages.
+
+    Args:
+        _line: Unused - required for scanner interface
+        _line_num: Unused - required for scanner interface
+        _file_path: Unused - required for scanner interface
+
+    Returns:
+        Empty list
+    """
+    return []
+
+
+def _count_unescaped_triple_quotes(line: str, quote: str) -> int:
+    """Count unescaped triple-quote occurrences in a line.
+
+    Uses regex to find non-escaped triple quotes.
+
+    Args:
+        line: Line to scan
+        quote: Triple-quote pattern to count (single or double)
+
+    Returns:
+        Number of unescaped triple-quote occurrences
+    """
+    escaped_quote = re.escape(quote)
+    pattern = re.compile(rf"(?<!\\){escaped_quote}")
+    return len(pattern.findall(line))
+
+
+def _update_docstring_state(line: str, quotes: list[str], state: list[bool]) -> None:
+    """Update docstring tracking state based on quotes in line.
+
+    Args:
+        line: Line to analyze
+        quotes: List of quote patterns to check
+        state: Mutable list tracking in-docstring state for each quote type
+    """
+    for i, quote in enumerate(quotes):
+        if _count_unescaped_triple_quotes(line, quote) % 2 == 1:
+            state[i] = not state[i]
+
+
+def _get_python_scannable_lines(code: str) -> list[tuple[int, str]]:
+    """Get Python lines that are not inside docstrings.
+
+    Args:
+        code: Source code to analyze
+
+    Returns:
+        List of (line_number, line_text) tuples for scannable lines
+    """
+    in_docstring = [False, False]  # [triple_double, triple_single]
+    quotes = ['"""', "'''"]
+    scannable: list[tuple[int, str]] = []
+
+    for line_num, line in enumerate(code.splitlines(), start=1):
+        was_in_docstring = in_docstring[0] or in_docstring[1]
+        _update_docstring_state(line, quotes, in_docstring)
+        if not was_in_docstring:
+            scannable.append((line_num, line))
+
+    return scannable
+
+
+class TestSkipDetector:
+    """Detects test skip patterns without proper justification."""
+
+    # Python patterns - violations are skips WITHOUT a reason argument
+    # These patterns match skips that should be flagged
+    # Must appear at start of line (after optional whitespace), not in comments
+    PYTHON_VIOLATION_PATTERNS: dict[IgnoreType, re.Pattern[str]] = {
+        # Matches @pytest.mark.skip or @pytest.mark.skip() without reason=
+        # Requires @ at start of line (after whitespace) to avoid matching in comments
+        IgnoreType.PYTEST_SKIP: re.compile(
+            r"^\s*@pytest\.mark\.skip(?:\s*\(\s*\))?(?!\s*\(.*reason\s*=)",
+        ),
+    }
+
+    # Python patterns that indicate a properly justified skip (no violation)
+    PYTHON_ALLOWED_PATTERNS: list[re.Pattern[str]] = [
+        # @pytest.mark.skip(reason="...")
+        re.compile(r"^\s*@pytest\.mark\.skip\s*\(\s*reason\s*="),
+        # @pytest.mark.skipif(..., reason="...")
+        re.compile(r"^\s*@pytest\.mark\.skipif\s*\(.*reason\s*="),
+        # pytest.skip("reason") - positional reason argument
+        re.compile(r"pytest\.skip\s*\(\s*['\"]"),
+        # pytest.skip(reason="...")
+        re.compile(r"pytest\.skip\s*\(\s*reason\s*="),
+    ]
+
+    # Pattern for bare pytest.skip() - needs special handling
+    PYTEST_SKIP_CALL_PATTERN = re.compile(
+        r"pytest\.skip\s*\(\s*\)",
+    )
+
+    # JavaScript/TypeScript patterns - these are always violations
+    # The proper way is to remove or fix the test, not skip it
+    JS_VIOLATION_PATTERNS: dict[IgnoreType, re.Pattern[str]] = {
+        IgnoreType.JEST_SKIP: re.compile(
+            r"(?:it|test)\.skip\s*\(",
+        ),
+        IgnoreType.MOCHA_SKIP: re.compile(
+            r"describe\.skip\s*\(",
+        ),
+    }
+
+    def find_skips(
+        self,
+        code: str,
+        file_path: Path | str | None = None,
+        language: str | Language = Language.PYTHON,
+    ) -> list[IgnoreDirective]:
+        """Find test skip patterns without justification.
+
+        Tracks docstring state across lines to avoid false positives from
+        patterns mentioned in documentation.
+
+        Args:
+            code: Source code to scan
+            file_path: Optional path to the source file (Path or string)
+            language: Language of source code (Language enum or string)
+
+        Returns:
+            List of IgnoreDirective objects for detected unjustified skips
+        """
+        effective_path = normalize_path(file_path)
+        lang = Language(language) if isinstance(language, str) else language
+        scanner = self._get_line_scanner(lang)
+
+        scannable_lines = self._get_scannable_lines(code, lang)
+        directives: list[IgnoreDirective] = []
+        for line_num, line in scannable_lines:
+            directives.extend(scanner(line, line_num, effective_path))
+        return directives
+
+    def _get_scannable_lines(self, code: str, lang: Language) -> list[tuple[int, str]]:
+        """Get lines that are not inside docstrings (Python) or all lines (other).
+
+        Args:
+            code: Source code to analyze
+            lang: Programming language
+
+        Returns:
+            List of (line_number, line_text) tuples for scannable lines
+        """
+        if lang != Language.PYTHON:
+            return list(enumerate(code.splitlines(), start=1))
+        return _get_python_scannable_lines(code)
+
+    def _get_line_scanner(
+        self, lang: Language
+    ) -> Callable[[str, int, Path], list[IgnoreDirective]]:
+        """Get the appropriate line scanner for a language.
+
+        Args:
+            lang: Programming language
+
+        Returns:
+            Line scanner function for the language
+        """
+        if lang == Language.PYTHON:
+            return self._scan_python_line
+        if lang in (Language.JAVASCRIPT, Language.TYPESCRIPT):
+            return self._scan_js_line
+        return _scan_empty
+
+    def _scan_python_line(self, line: str, line_num: int, file_path: Path) -> list[IgnoreDirective]:
+        """Scan a Python line for unjustified skip patterns.
+
+        Args:
+            line: Line of code to scan
+            line_num: 1-indexed line number
+            file_path: Path to the source file
+
+        Returns:
+            List of IgnoreDirective objects found on this line
+        """
+        if _is_comment_line(line) or self._is_justified_python_skip(line):
+            return []
+
+        found = self._find_decorator_violations(line, line_num, file_path)
+        found.extend(self._find_skip_call_violations(line, line_num, file_path))
+        return found
+
+    def _find_decorator_violations(
+        self, line: str, line_num: int, file_path: Path
+    ) -> list[IgnoreDirective]:
+        """Find @pytest.mark.skip decorator violations.
+
+        Args:
+            line: Line of code to scan
+            line_num: 1-indexed line number
+            file_path: Path to source file
+
+        Returns:
+            List of IgnoreDirective for decorator violations
+        """
+        found: list[IgnoreDirective] = []
+        for ignore_type, pattern in self.PYTHON_VIOLATION_PATTERNS.items():
+            match = pattern.search(line)
+            if match:
+                found.append(create_directive_no_rules(match, ignore_type, line_num, file_path))
+        return found
+
+    def _find_skip_call_violations(
+        self, line: str, line_num: int, file_path: Path
+    ) -> list[IgnoreDirective]:
+        """Find bare pytest.skip() call violations.
+
+        Args:
+            line: Line of code to scan
+            line_num: 1-indexed line number
+            file_path: Path to source file
+
+        Returns:
+            List of IgnoreDirective for skip call violations
+        """
+        match = self.PYTEST_SKIP_CALL_PATTERN.search(line)
+        if match:
+            return [create_directive_no_rules(match, IgnoreType.PYTEST_SKIP, line_num, file_path)]
+        return []
+
+    def _is_justified_python_skip(self, line: str) -> bool:
+        """Check if a Python line contains a justified skip.
+
+        Args:
+            line: Line of code to check
+
+        Returns:
+            True if the line has a skip with proper justification
+        """
+        return any(pattern.search(line) for pattern in self.PYTHON_ALLOWED_PATTERNS)
+
+    def _scan_js_line(self, line: str, line_num: int, file_path: Path) -> list[IgnoreDirective]:
+        """Scan a JavaScript/TypeScript line for skip patterns.
+
+        Args:
+            line: Line of code to scan
+            line_num: 1-indexed line number
+            file_path: Path to the source file
+
+        Returns:
+            List of IgnoreDirective objects found on this line
+        """
+        found: list[IgnoreDirective] = []
+
+        for ignore_type, pattern in self.JS_VIOLATION_PATTERNS.items():
+            match = pattern.search(line)
+            if match:
+                found.append(create_directive_no_rules(match, ignore_type, line_num, file_path))
+
+        return found

src/linters/lazy_ignores/types.py

@@ -0,0 +1,67 @@
+"""
+Purpose: Type definitions for lazy-ignores linter
+
+Scope: Data structures for ignore directives and suppression entries
+
+Overview: Defines core types for the lazy-ignores linter including IgnoreType enum for
+    categorizing different suppression patterns, IgnoreDirective dataclass for representing
+    detected ignores in code, and SuppressionEntry dataclass for representing declared
+    suppressions in file headers. Supports Python (noqa, type:ignore, pylint, nosec),
+    TypeScript (@ts-ignore, eslint-disable), thai-lint (thailint:ignore), and test skip
+    patterns (pytest.mark.skip, it.skip, describe.skip).
+
+Dependencies: dataclasses, enum, pathlib
+
+Exports: IgnoreType, IgnoreDirective, SuppressionEntry
+
+Interfaces: Frozen dataclasses for immutable ignore representation
+
+Implementation: Enum-based categorization with frozen dataclasses for thread safety
+"""
+
+from dataclasses import dataclass
+from enum import Enum
+from pathlib import Path
+
+
+class IgnoreType(Enum):
+    """Type of linting ignore directive."""
+
+    NOQA = "noqa"
+    TYPE_IGNORE = "type:ignore"
+    PYLINT_DISABLE = "pylint:disable"
+    NOSEC = "nosec"
+    TS_IGNORE = "ts-ignore"
+    TS_NOCHECK = "ts-nocheck"
+    TS_EXPECT_ERROR = "ts-expect-error"
+    ESLINT_DISABLE = "eslint-disable"
+    THAILINT_IGNORE = "thailint:ignore"
+    THAILINT_IGNORE_FILE = "thailint:ignore-file"
+    THAILINT_IGNORE_NEXT = "thailint:ignore-next-line"
+    THAILINT_IGNORE_BLOCK = "thailint:ignore-start"
+    # Test skip patterns
+    PYTEST_SKIP = "pytest:skip"
+    PYTEST_SKIPIF = "pytest:skipif"
+    JEST_SKIP = "jest:skip"
+    MOCHA_SKIP = "mocha:skip"
+
+
+@dataclass(frozen=True)
+class IgnoreDirective:
+    """Represents a linting ignore found in code."""
+
+    ignore_type: IgnoreType
+    rule_ids: tuple[str, ...]  # Can have multiple: noqa: PLR0912, PLR0915
+    line: int
+    column: int
+    raw_text: str  # Original comment text
+    file_path: Path
+
+
+@dataclass(frozen=True)
+class SuppressionEntry:
+    """Represents a suppression declared in file header."""
+
+    rule_id: str  # Normalized rule ID
+    justification: str
+    raw_text: str  # Original header line

src/linters/lazy_ignores/typescript_analyzer.py

@@ -0,0 +1,146 @@
+"""
+Purpose: Detect TypeScript/JavaScript linting ignore directives in source code
+
+Scope: @ts-ignore, @ts-nocheck, @ts-expect-error, eslint-disable pattern detection
+
+Overview: Provides TypeScriptIgnoreDetector class that scans TypeScript and JavaScript source
+    code for common linting ignore patterns. Detects TypeScript-specific patterns (@ts-ignore,
+    @ts-nocheck, @ts-expect-error) and ESLint patterns (eslint-disable-next-line, eslint-disable
+    block comments, eslint-disable-line). Handles both single-line (//) and block (/* */)
+    comment styles. Returns list of IgnoreDirective objects with line/column positions for
+    violation reporting.
+
+Dependencies: re for pattern matching, pathlib for file paths, types module for dataclasses
+
+Exports: TypeScriptIgnoreDetector
+
+Interfaces: find_ignores(code: str, file_path: Path | str | None) -> list[IgnoreDirective]
+
+Implementation: Regex-based line-by-line scanning with pattern-specific rule ID extraction
+"""
+
+import re
+from pathlib import Path
+
+from src.linters.lazy_ignores.directive_utils import create_directive, normalize_path
+from src.linters.lazy_ignores.types import IgnoreDirective, IgnoreType
+
+
+class TypeScriptIgnoreDetector:
+    """Detects TypeScript/JavaScript linting ignore directives in source code."""
+
+    # Regex patterns for each ignore type
+    # Single-line comment patterns (//)
+    SINGLE_LINE_PATTERNS: dict[IgnoreType, re.Pattern[str]] = {
+        IgnoreType.TS_IGNORE: re.compile(
+            r"//\s*@ts-ignore(?:\s|$)",
+        ),
+        IgnoreType.TS_NOCHECK: re.compile(
+            r"//\s*@ts-nocheck(?:\s|$)",
+        ),
+        IgnoreType.TS_EXPECT_ERROR: re.compile(
+            r"//\s*@ts-expect-error(?:\s|$)",
+        ),
+        IgnoreType.THAILINT_IGNORE: re.compile(
+            r"//\s*thailint:\s*ignore(?!-)(?:\[([^\]]+)\])?",
+            re.IGNORECASE,
+        ),
+        IgnoreType.THAILINT_IGNORE_FILE: re.compile(
+            r"//\s*thailint:\s*ignore-file(?:\[([^\]]+)\])?",
+            re.IGNORECASE,
+        ),
+    }
+
+    # ESLint patterns (can be single-line or inline)
+    ESLINT_PATTERNS: dict[str, re.Pattern[str]] = {
+        "next-line": re.compile(
+            r"//\s*eslint-disable-next-line(?:\s+([a-zA-Z0-9\-/,\s]+))?(?:\s|$)",
+        ),
+        "inline": re.compile(
+            r"//\s*eslint-disable-line(?:\s+([a-zA-Z0-9\-/,\s]+))?(?:\s|$)",
+        ),
+        "block-start": re.compile(
+            r"/\*\s*eslint-disable(?:\s+([a-zA-Z0-9\-/,\s]+))?\s*\*/",
+        ),
+    }
+
+    def find_ignores(self, code: str, file_path: Path | str | None = None) -> list[IgnoreDirective]:
+        """Find all TypeScript/JavaScript ignore directives in code.
+
+        Args:
+            code: TypeScript/JavaScript source code to scan
+            file_path: Optional path to the source file (Path or string)
+
+        Returns:
+            List of IgnoreDirective objects for each detected ignore pattern
+        """
+        directives: list[IgnoreDirective] = []
+        effective_path = normalize_path(file_path)
+
+        for line_num, line in enumerate(code.splitlines(), start=1):
+            directives.extend(self._scan_line(line, line_num, effective_path))
+
+        return directives
+
+    def _scan_line(self, line: str, line_num: int, file_path: Path) -> list[IgnoreDirective]:
+        """Scan a single line for ignore patterns.
+
+        Args:
+            line: Line of code to scan
+            line_num: 1-indexed line number
+            file_path: Path to the source file
+
+        Returns:
+            List of IgnoreDirective objects found on this line
+        """
+        found: list[IgnoreDirective] = []
+
+        # Check TypeScript-specific patterns
+        found.extend(self._scan_typescript_patterns(line, line_num, file_path))
+
+        # Check ESLint patterns
+        found.extend(self._scan_eslint_patterns(line, line_num, file_path))
+
+        return found
+
+    def _scan_typescript_patterns(
+        self, line: str, line_num: int, file_path: Path
+    ) -> list[IgnoreDirective]:
+        """Scan for TypeScript-specific ignore patterns.
+
+        Args:
+            line: Line of code to scan
+            line_num: 1-indexed line number
+            file_path: Path to the source file
+
+        Returns:
+            List of IgnoreDirective objects for TypeScript patterns
+        """
+        found: list[IgnoreDirective] = []
+        for ignore_type, pattern in self.SINGLE_LINE_PATTERNS.items():
+            match = pattern.search(line)
+            if match:
+                found.append(create_directive(match, ignore_type, line_num, file_path))
+        return found
+
+    def _scan_eslint_patterns(
+        self, line: str, line_num: int, file_path: Path
+    ) -> list[IgnoreDirective]:
+        """Scan for ESLint disable patterns.
+
+        Args:
+            line: Line of code to scan
+            line_num: 1-indexed line number
+            file_path: Path to the source file
+
+        Returns:
+            List of IgnoreDirective objects for ESLint patterns
+        """
+        found: list[IgnoreDirective] = []
+        for pattern in self.ESLINT_PATTERNS.values():
+            match = pattern.search(line)
+            if match:
+                found.append(
+                    create_directive(match, IgnoreType.ESLINT_DISABLE, line_num, file_path)
+                )
+        return found

src/linters/lazy_ignores/violation_builder.py

@@ -0,0 +1,131 @@
+"""
+Purpose: Build agent-friendly violation messages for lazy-ignores linter
+
+Scope: Violation construction for unjustified ignores and orphaned header suppressions
+
+Overview: Provides functions to construct Violation objects with AI-agent-friendly error
+    messages. Messages include explicit guidance for adding Suppressions section entries to
+    file headers and emphasize the requirement for human approval before adding suppressions.
+    Designed to help AI coding assistants understand the proper workflow for handling linting
+    suppressions rather than blindly adding ignore directives.
+
+Dependencies: src.core.types for Violation dataclass
+
+Exports: build_unjustified_violation, build_orphaned_violation
+
+Interfaces: Two builder functions returning Violation objects
+
+Implementation: Template-based message construction with rule ID formatting
+"""
+
+from src.core.types import Severity, Violation
+
+
+def build_unjustified_violation(
+    file_path: str,
+    line: int,
+    column: int,
+    rule_id: str,
+    raw_text: str,
+) -> Violation:
+    """Create violation for an ignore directive without header justification.
+
+    Args:
+        file_path: Path to the file containing the violation.
+        line: Line number where the ignore was found (1-indexed).
+        column: Column number where the ignore starts (0-indexed).
+        rule_id: The rule ID(s) being suppressed (e.g., "PLR0912").
+        raw_text: The raw ignore directive text found in code.
+
+    Returns:
+        Violation object with agent-friendly guidance message.
+    """
+    message = (
+        f"Unjustified suppression found: {raw_text} "
+        f"(ASK PERMISSION before adding Suppressions header)"
+    )
+
+    suggestion = _build_unjustified_suggestion(rule_id)
+
+    return Violation(
+        rule_id="lazy-ignores.unjustified",
+        file_path=file_path,
+        line=line,
+        column=column,
+        message=message,
+        severity=Severity.ERROR,
+        suggestion=suggestion,
+    )
+
+
+def _build_unjustified_suggestion(rule_id: str) -> str:
+    """Build the suggestion text for unjustified violations.
+
+    Args:
+        rule_id: The rule ID(s) being suppressed.
+
+    Returns:
+        Formatted suggestion string with header instructions.
+    """
+    # Handle multiple rules (e.g., "PLR0912, PLR0915")
+    rule_ids = [r.strip() for r in rule_id.split(",")]
+
+    suppression_entries = "\n".join(f"    {rid}: [Your justification here]" for rid in rule_ids)
+
+    return f"""To fix, add an entry to the file header Suppressions section:
+
+    Suppressions:
+{suppression_entries}
+
+IMPORTANT: Adding suppressions requires human approval.
+Do not add this entry without explicit permission from a human reviewer.
+Ask first, then add if approved."""
+
+
+def build_orphaned_violation(
+    file_path: str,
+    header_line: int,
+    rule_id: str,
+    justification: str,
+) -> Violation:
+    """Create violation for a header entry without matching code ignore.
+
+    Args:
+        file_path: Path to the file containing the orphaned entry.
+        header_line: Line number of the suppression in the header (1-indexed).
+        rule_id: The orphaned rule ID from the header.
+        justification: The justification text from the header.
+
+    Returns:
+        Violation object suggesting removal of the orphaned entry.
+    """
+    message = f"Orphaned suppression in header: {rule_id}: {justification}"
+
+    suggestion = _build_orphaned_suggestion(rule_id)
+
+    return Violation(
+        rule_id="lazy-ignores.orphaned",
+        file_path=file_path,
+        line=header_line,
+        column=0,
+        message=message,
+        severity=Severity.ERROR,
+        suggestion=suggestion,
+    )
+
+
+def _build_orphaned_suggestion(rule_id: str) -> str:
+    """Build the suggestion text for orphaned violations.
+
+    Args:
+        rule_id: The orphaned rule ID.
+
+    Returns:
+        Formatted suggestion string with removal instructions.
+    """
+    return f"""This rule is declared in the Suppressions section but no matching
+ignore directive was found in the code.
+
+Either:
+1. Remove the entry for {rule_id} from the Suppressions section if the ignore was removed from code
+2. Add the ignore directive if it's missing from the code"""

src/linters/lbyl/__init__.py

@@ -0,0 +1,29 @@
+"""
+Purpose: LBYL (Look Before You Leap) linter package exports
+
+Scope: Detect LBYL anti-patterns in Python code and suggest EAFP alternatives
+
+Overview: Package providing LBYL pattern detection for Python code. Identifies common
+    anti-patterns where explicit checks are performed before operations (e.g., if key in
+    dict before dict[key]) and suggests EAFP (Easier to Ask Forgiveness than Permission)
+    alternatives using try/except blocks. Supports 8 pattern types including dict key
+    checking, hasattr, isinstance, file exists, length checks, None checks, string
+    validation, and division safety checks.
+
+Dependencies: ast module for Python parsing, src.core for base classes
+
+Exports: LBYLConfig, LBYLPattern, BaseLBYLDetector
+
+Interfaces: LBYLConfig.from_dict() for YAML configuration loading
+
+Implementation: AST-based pattern detection with configurable pattern toggles
+"""
+
+from .config import LBYLConfig
+from .pattern_detectors.base import BaseLBYLDetector, LBYLPattern
+
+__all__ = [
+    "LBYLConfig",
+    "LBYLPattern",
+    "BaseLBYLDetector",
+]