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

src/linters/lazy_ignores/linter.py

@@ -0,0 +1,158 @@
+"""
+Purpose: Main LazyIgnoresRule class for detecting unjustified linting suppressions
+
+Scope: Orchestration of ignore detection and header suppression validation
+
+Overview: Provides LazyIgnoresRule that cross-references linting ignore directives found
+    in code (noqa, type:ignore, pylint:disable, nosec) and test skip patterns with
+    Suppressions entries declared in file headers. Detects two types of violations:
+    unjustified ignores/skips (directive without header declaration) and orphaned
+    suppressions (header declaration without matching ignore in code). Enforces the
+    header-based suppression model requiring human approval for all linting bypasses.
+
+Dependencies: PythonIgnoreDetector, TestSkipDetector, SuppressionsParser, IgnoreSuppressionMatcher
+
+Exports: LazyIgnoresRule
+
+Interfaces: check(context: BaseLintContext) -> list[Violation]
+
+Implementation: Delegation to matcher for cross-reference logic, violation builder for messages
+"""
+
+from pathlib import Path
+
+from src.core.base import BaseLintContext, BaseLintRule
+from src.core.constants import Language
+from src.core.types import Violation
+
+from .header_parser import SuppressionsParser
+from .matcher import IgnoreSuppressionMatcher
+from .python_analyzer import PythonIgnoreDetector
+from .skip_detector import TestSkipDetector
+from .types import IgnoreDirective
+from .violation_builder import build_orphaned_violation, build_unjustified_violation
+
+
+class LazyIgnoresRule(BaseLintRule):
+    """Detects unjustified linting suppressions and orphaned header entries."""
+
+    def __init__(self, check_test_skips: bool = True) -> None:
+        """Initialize the lazy ignores rule with detection components.
+
+        Args:
+            check_test_skips: Whether to check for unjustified test skips.
+        """
+        self._python_detector = PythonIgnoreDetector()
+        self._test_skip_detector = TestSkipDetector()
+        self._suppression_parser = SuppressionsParser()
+        self._matcher = IgnoreSuppressionMatcher(self._suppression_parser)
+        self._check_test_skips = check_test_skips
+
+    @property
+    def rule_id(self) -> str:
+        """Unique identifier for this rule."""
+        return "lazy-ignores"
+
+    @property
+    def rule_name(self) -> str:
+        """Human-readable name for this rule."""
+        return "Lazy Ignores"
+
+    @property
+    def description(self) -> str:
+        """Description of what this rule checks."""
+        return (
+            "Detects linting suppressions (noqa, type:ignore, pylint:disable, nosec) "
+            "and test skips without corresponding entries in the file header's "
+            "Suppressions section."
+        )
+
+    def check(self, context: BaseLintContext) -> list[Violation]:
+        """Check for violations in the given context.
+
+        Args:
+            context: The lint context containing file information.
+
+        Returns:
+            List of violations for unjustified and orphaned suppressions.
+        """
+        if context.language != Language.PYTHON:
+            return []
+
+        if not context.file_content:
+            return []
+
+        file_path = str(context.file_path) if context.file_path else "unknown"
+        return self.check_content(context.file_content, file_path)
+
+    def check_content(self, code: str, file_path: str) -> list[Violation]:
+        """Check code for unjustified ignores and orphaned suppressions.
+
+        Args:
+            code: Source code content to analyze.
+            file_path: Path to the file being analyzed.
+
+        Returns:
+            List of violations for unjustified and orphaned suppressions.
+        """
+        # Extract and parse header suppressions
+        header = self._suppression_parser.extract_header(code, "python")
+        suppressions = self._suppression_parser.parse(header)
+
+        # Find all ignore directives in code
+        ignores = self._python_detector.find_ignores(code, Path(file_path))
+
+        # Find test skip directives if enabled
+        if self._check_test_skips:
+            test_skips = self._test_skip_detector.find_skips(code, Path(file_path), "python")
+            ignores = list(ignores) + list(test_skips)
+
+        # Build set of normalized rule IDs used in code
+        used_rule_ids = self._matcher.collect_used_rule_ids(ignores)
+
+        # Find violations
+        violations: list[Violation] = []
+        violations.extend(self._find_unjustified(ignores, suppressions, file_path))
+        violations.extend(self._find_orphaned(suppressions, used_rule_ids, file_path))
+
+        return violations
+
+    def _find_unjustified(
+        self, ignores: list[IgnoreDirective], suppressions: dict[str, str], file_path: str
+    ) -> list[Violation]:
+        """Find ignore directives without matching header suppressions."""
+        violations: list[Violation] = []
+
+        for ignore in ignores:
+            unjustified = self._matcher.find_unjustified_rule_ids(ignore, suppressions)
+            if unjustified:
+                violations.append(
+                    build_unjustified_violation(
+                        file_path=file_path,
+                        line=ignore.line,
+                        column=ignore.column,
+                        rule_id=", ".join(unjustified),
+                        raw_text=ignore.raw_text,
+                    )
+                )
+
+        return violations
+
+    def _find_orphaned(
+        self, suppressions: dict[str, str], used_rule_ids: set[str], file_path: str
+    ) -> list[Violation]:
+        """Find header suppressions without matching code ignores."""
+        violations: list[Violation] = []
+        orphaned = self._matcher.find_orphaned_rule_ids(suppressions, used_rule_ids)
+
+        for rule_id, justification in orphaned:
+            violations.append(
+                build_orphaned_violation(
+                    file_path=file_path,
+                    header_line=1,  # Header entries are at file start
+                    rule_id=rule_id,
+                    justification=justification,
+                )
+            )
+
+        return violations

src/linters/lazy_ignores/matcher.py

@@ -0,0 +1,135 @@
+"""
+Purpose: Cross-reference matcher for lazy-ignores linter
+
+Scope: Matching ignore directives with header suppressions
+
+Overview: Provides IgnoreSuppressionMatcher class that cross-references linting ignore
+    directives found in code with Suppressions entries declared in file headers. Handles
+    case-insensitive rule ID normalization and special patterns like type:ignore[code].
+    Identifies unjustified ignores (code ignores without header entries) and orphaned
+    suppressions (header entries without matching code ignores).
+
+Dependencies: SuppressionsParser for normalization, types for IgnoreDirective and IgnoreType,
+    rule_id_utils for pure parsing functions
+
+Exports: IgnoreSuppressionMatcher
+
+Interfaces: find_unjustified(), find_orphaned()
+
+Implementation: Set-based matching with rule ID normalization for case-insensitive comparison
+"""
+
+from .header_parser import SuppressionsParser
+from .rule_id_utils import (
+    comma_list_has_used_rule,
+    find_rule_in_suppressions,
+    is_type_ignore_format_in_suppressions,
+    type_ignore_bracket_has_used_rule,
+)
+from .types import IgnoreDirective, IgnoreType
+
+
+class IgnoreSuppressionMatcher:
+    """Matches ignore directives with header suppressions."""
+
+    def __init__(self, parser: SuppressionsParser) -> None:
+        """Initialize the matcher.
+
+        Args:
+            parser: SuppressionsParser for rule ID normalization.
+        """
+        self._parser = parser
+
+    def collect_used_rule_ids(self, ignores: list[IgnoreDirective]) -> set[str]:
+        """Collect all normalized rule IDs used in ignore directives.
+
+        Args:
+            ignores: List of ignore directives from code.
+
+        Returns:
+            Set of normalized rule IDs that have ignore directives.
+        """
+        used: set[str] = set()
+        for ignore in ignores:
+            used.update(self._get_matchable_rule_ids(ignore))
+        return used
+
+    def _get_matchable_rule_ids(self, ignore: IgnoreDirective) -> list[str]:
+        """Get normalized rule IDs for matching, handling special formats."""
+        if not ignore.rule_ids:
+            return [self._normalize(ignore.ignore_type.value)]
+
+        ids: list[str] = []
+        for rule_id in ignore.rule_ids:
+            normalized = self._normalize(rule_id)
+            ids.append(normalized)
+            if ignore.ignore_type == IgnoreType.TYPE_IGNORE:
+                ids.append(f"type:ignore[{normalized}]")
+        return ids
+
+    def find_unjustified_rule_ids(
+        self, ignore: IgnoreDirective, suppressions: dict[str, str]
+    ) -> list[str]:
+        """Find which rule IDs in an ignore are not justified.
+
+        Args:
+            ignore: The ignore directive to check.
+            suppressions: Dict of normalized rule IDs to justifications.
+
+        Returns:
+            List of unjustified rule IDs (original case preserved).
+        """
+        if not ignore.rule_ids:
+            type_key = self._normalize(ignore.ignore_type.value)
+            if type_key not in suppressions:
+                return [ignore.ignore_type.value]
+            return []
+
+        unjustified: list[str] = []
+        for rule_id in ignore.rule_ids:
+            if not self._is_rule_justified(ignore, rule_id, suppressions):
+                unjustified.append(rule_id)
+        return unjustified
+
+    def _is_rule_justified(
+        self, ignore: IgnoreDirective, rule_id: str, suppressions: dict[str, str]
+    ) -> bool:
+        """Check if a specific rule ID is justified in suppressions."""
+        normalized = self._normalize(rule_id)
+        is_type_ignore = ignore.ignore_type == IgnoreType.TYPE_IGNORE
+
+        if normalized in suppressions:
+            return True
+        if is_type_ignore and is_type_ignore_format_in_suppressions(normalized, suppressions):
+            return True
+        return find_rule_in_suppressions(normalized, suppressions, is_type_ignore)
+
+    def find_orphaned_rule_ids(
+        self, suppressions: dict[str, str], used_rule_ids: set[str]
+    ) -> list[tuple[str, str]]:
+        """Find header suppressions without matching code ignores.
+
+        Args:
+            suppressions: Dict mapping normalized rule IDs to justifications.
+            used_rule_ids: Set of normalized rule IDs used in code.
+
+        Returns:
+            List of (rule_id, justification) tuples for orphaned suppressions.
+        """
+        orphaned: list[tuple[str, str]] = []
+        for rule_id, justification in suppressions.items():
+            if not self._suppression_is_used(rule_id, used_rule_ids):
+                orphaned.append((rule_id.upper(), justification))
+        return orphaned
+
+    def _suppression_is_used(self, suppression_key: str, used_rule_ids: set[str]) -> bool:
+        """Check if a suppression key is used by any code ignores."""
+        if suppression_key in used_rule_ids:
+            return True
+        if comma_list_has_used_rule(suppression_key, used_rule_ids):
+            return True
+        return type_ignore_bracket_has_used_rule(suppression_key, used_rule_ids)
+
+    def _normalize(self, rule_id: str) -> str:
+        """Normalize a rule ID for case-insensitive matching."""
+        return self._parser.normalize_rule_id(rule_id)

src/linters/lazy_ignores/python_analyzer.py

@@ -0,0 +1,201 @@
+"""
+Purpose: Detect Python linting ignore directives in source code
+
+Scope: noqa, type:ignore, pylint:disable, nosec pattern detection
+
+Overview: Provides PythonIgnoreDetector class that scans Python source code for common
+    linting ignore patterns. Detects bare patterns (e.g., # noqa) and rule-specific
+    patterns (e.g., # noqa: PLR0912). Handles case-insensitive matching and extracts
+    rule IDs from comma-separated lists. Returns list of IgnoreDirective objects with
+    line/column positions for violation reporting. Skips patterns inside docstrings
+    and string literals to avoid false positives.
+
+Dependencies: re for pattern matching, pathlib for file paths, types module for dataclasses
+
+Exports: PythonIgnoreDetector
+
+Interfaces: find_ignores(code: str, file_path: Path | None) -> list[IgnoreDirective]
+
+Implementation: Regex-based line-by-line scanning with docstring-aware state tracking
+"""
+
+import re
+from pathlib import Path
+
+from src.linters.lazy_ignores.directive_utils import create_directive
+from src.linters.lazy_ignores.types import IgnoreDirective, IgnoreType
+
+
+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
+    """
+    # Pattern matches triple quotes not preceded by odd number of backslashes
+    # Escape the quote for regex
+    escaped_quote = re.escape(quote)
+    pattern = re.compile(rf"(?<!\\){escaped_quote}")
+    return len(pattern.findall(line))
+
+
+def _count_unescaped_single_quotes(text: str, quote_char: str) -> int:
+    """Count unescaped single quote characters in text.
+
+    Args:
+        text: Text to scan
+        quote_char: The quote character (' or ")
+
+    Returns:
+        Number of unescaped quote characters
+    """
+    count = 0
+    escaped = False
+    for char in text:
+        if escaped:
+            escaped = False
+            continue
+        if char == "\\":
+            escaped = True
+            continue
+        if char == quote_char:
+            count += 1
+    return count
+
+
+def _is_pattern_in_string_literal(line: str, match_start: int) -> bool:
+    """Check if a match position is inside a string literal.
+
+    Args:
+        line: The line of code
+        match_start: The start position of the pattern match
+
+    Returns:
+        True if the match is inside a string literal
+    """
+    before_match = line[:match_start]
+    single_count = _count_unescaped_single_quotes(before_match, "'")
+    double_count = _count_unescaped_single_quotes(before_match, '"')
+    return (single_count % 2 == 1) or (double_count % 2 == 1)
+
+
+class PythonIgnoreDetector:
+    """Detects Python linting ignore directives in source code."""
+
+    # Regex patterns for each ignore type
+    # Each pattern captures optional rule IDs in group 1
+    PATTERNS: dict[IgnoreType, re.Pattern[str]] = {
+        IgnoreType.NOQA: re.compile(
+            r"#\s*noqa(?::\s*([A-Z0-9,\s]+))?(?:\s|$)",
+            re.IGNORECASE,
+        ),
+        IgnoreType.TYPE_IGNORE: re.compile(
+            r"#\s*type:\s*ignore(?:\[([^\]]+)\])?",
+        ),
+        IgnoreType.PYLINT_DISABLE: re.compile(
+            r"#\s*pylint:\s*disable=([a-z0-9\-,\s]+)",
+            re.IGNORECASE,
+        ),
+        IgnoreType.NOSEC: re.compile(
+            r"#\s*nosec(?:\s+([A-Z0-9,\s]+))?(?:\s|$)",
+            re.IGNORECASE,
+        ),
+        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,
+        ),
+        IgnoreType.THAILINT_IGNORE_NEXT: re.compile(
+            r"#\s*thailint:\s*ignore-next-line(?:\[([^\]]+)\])?",
+            re.IGNORECASE,
+        ),
+        IgnoreType.THAILINT_IGNORE_BLOCK: re.compile(
+            r"#\s*thailint:\s*ignore-start(?:\[([^\]]+)\])?",
+            re.IGNORECASE,
+        ),
+    }
+
+    def find_ignores(self, code: str, file_path: Path | None = None) -> list[IgnoreDirective]:
+        """Find all Python ignore directives in code.
+
+        Tracks docstring state across lines to avoid false positives from
+        patterns mentioned in documentation.
+
+        Args:
+            code: Python source code to scan
+            file_path: Optional path to the source file
+
+        Returns:
+            List of IgnoreDirective objects for each detected ignore pattern
+        """
+        effective_path = file_path or Path("unknown")
+        scannable_lines = self._get_scannable_lines(code)
+        directives: list[IgnoreDirective] = []
+        for line_num, line in scannable_lines:
+            directives.extend(self._scan_line(line, line_num, effective_path))
+        return directives
+
+    def _get_scannable_lines(self, code: str) -> list[tuple[int, str]]:
+        """Get 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]
+            self._update_docstring_state(line, quotes, in_docstring)
+            if not was_in_docstring:
+                scannable.append((line_num, line))
+
+        return scannable
+
+    def _update_docstring_state(self, 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 _scan_line(self, line: str, line_num: int, file_path: Path) -> list[IgnoreDirective]:
+        """Scan a single line for ignore patterns.
+
+        Skips patterns that appear inside string literals.
+
+        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.PATTERNS.items():
+            match = pattern.search(line)
+            if not match:
+                continue
+            if _is_pattern_in_string_literal(line, match.start()):
+                continue
+            found.append(create_directive(match, ignore_type, line_num, file_path))
+        return found

src/linters/lazy_ignores/rule_id_utils.py

@@ -0,0 +1,180 @@
+"""
+Purpose: Pure utility functions for rule ID parsing and matching
+
+Scope: String parsing utilities for comma-separated rule lists and type:ignore formats
+
+Overview: Provides pure functions for parsing and matching rule IDs in various formats
+    used by the lazy-ignores linter. Handles comma-separated rule lists (e.g.,
+    "too-many-arguments,too-many-positional-arguments") and type:ignore bracket
+    formats (e.g., "type:ignore[arg-type,return-value]"). Functions are stateless
+    and can be easily tested in isolation.
+
+Dependencies: None (pure Python string operations)
+
+Exports: extract_type_ignore_bracket, split_comma_list, rule_in_comma_list,
+    rule_in_type_ignore_bracket, any_part_in_set, comma_list_has_used_rule,
+    type_ignore_bracket_has_used_rule
+
+Interfaces: All functions take strings/sets and return strings/bools
+
+Implementation: String parsing with early returns for invalid formats
+"""
+
+TYPE_IGNORE_PREFIX = "type:ignore["
+
+
+def extract_type_ignore_bracket(suppression_key: str) -> str | None:
+    """Extract content from type:ignore[...] format.
+
+    Args:
+        suppression_key: String that may be in type:ignore[rules] format
+
+    Returns:
+        Content between brackets, or None if not valid format
+    """
+    if not suppression_key.startswith(TYPE_IGNORE_PREFIX):
+        return None
+    if not suppression_key.endswith("]"):
+        return None
+    return suppression_key[len(TYPE_IGNORE_PREFIX) : -1]
+
+
+def split_comma_list(content: str) -> list[str]:
+    """Split comma-separated string into stripped parts.
+
+    Args:
+        content: Comma-separated string
+
+    Returns:
+        List of stripped parts, or empty list if no commas
+    """
+    if "," not in content:
+        return []
+    return [p.strip() for p in content.split(",")]
+
+
+def rule_in_comma_list(rule_id: str, suppression_key: str) -> bool:
+    """Check if rule_id is in a plain comma-separated list.
+
+    Args:
+        rule_id: Normalized rule ID to find
+        suppression_key: String that may contain comma-separated rules
+
+    Returns:
+        True if rule_id is found in the comma-separated parts
+    """
+    parts = split_comma_list(suppression_key)
+    return rule_id in parts
+
+
+def rule_in_type_ignore_bracket(rule_id: str, suppression_key: str) -> bool:
+    """Check if rule_id is in type:ignore[rule1,rule2] format.
+
+    Args:
+        rule_id: Normalized rule ID to find
+        suppression_key: String that may be in type:ignore[rules] format
+
+    Returns:
+        True if rule_id is found in the bracket content
+    """
+    bracket_content = extract_type_ignore_bracket(suppression_key)
+    if bracket_content is None:
+        return False
+    parts = split_comma_list(bracket_content)
+    return rule_id in parts
+
+
+def any_part_in_set(content: str, rule_ids: set[str]) -> bool:
+    """Check if any comma-separated part of content is in rule_ids.
+
+    Args:
+        content: Comma-separated string
+        rule_ids: Set of rule IDs to check against
+
+    Returns:
+        True if any part is in the set
+    """
+    parts = split_comma_list(content)
+    return any(p in rule_ids for p in parts)
+
+
+def comma_list_has_used_rule(suppression_key: str, used_rule_ids: set[str]) -> bool:
+    """Check if any rule in a comma-separated suppression is used.
+
+    Args:
+        suppression_key: Comma-separated suppression key
+        used_rule_ids: Set of rule IDs used in code
+
+    Returns:
+        True if any comma-separated rule is in used_rule_ids
+    """
+    parts = split_comma_list(suppression_key)
+    return any(p in used_rule_ids for p in parts)
+
+
+def type_ignore_bracket_has_used_rule(suppression_key: str, used_rule_ids: set[str]) -> bool:
+    """Check if type:ignore[rules] suppression has any used rule.
+
+    Args:
+        suppression_key: String in type:ignore[rules] format
+        used_rule_ids: Set of rule IDs used in code
+
+    Returns:
+        True if bracket content or any comma part is in used_rule_ids
+    """
+    bracket_content = extract_type_ignore_bracket(suppression_key)
+    if bracket_content is None:
+        return False
+    if bracket_content in used_rule_ids:
+        return True
+    return any_part_in_set(bracket_content, used_rule_ids)
+
+
+def is_type_ignore_format_in_suppressions(normalized: str, suppressions: dict[str, str]) -> bool:
+    """Check if type:ignore[rule] format is in suppressions.
+
+    Args:
+        normalized: Normalized rule ID
+        suppressions: Dict of suppression keys to justifications
+
+    Returns:
+        True if type:ignore[normalized] is in suppressions
+    """
+    return f"type:ignore[{normalized}]" in suppressions
+
+
+def rule_matches_suppression(rule_id: str, suppression_key: str, is_type_ignore: bool) -> bool:
+    """Check if rule_id matches a suppression key (plain or type:ignore format).
+
+    Args:
+        rule_id: Normalized rule ID to find
+        suppression_key: Suppression key to check
+        is_type_ignore: True if this is a type:ignore directive
+
+    Returns:
+        True if rule_id is found in the suppression key
+    """
+    if rule_in_comma_list(rule_id, suppression_key):
+        return True
+    if is_type_ignore:
+        return rule_in_type_ignore_bracket(rule_id, suppression_key)
+    return False
+
+
+def find_rule_in_suppressions(
+    normalized: str, suppressions: dict[str, str], is_type_ignore: bool
+) -> bool:
+    """Check if rule appears in any comma-separated suppression entry.
+
+    Args:
+        normalized: Normalized rule ID to find
+        suppressions: Dict of suppression keys to justifications
+        is_type_ignore: True if this is a type:ignore directive
+
+    Returns:
+        True if rule is found in any suppression's comma list
+    """
+    return any(
+        rule_matches_suppression(normalized, suppression_key, is_type_ignore)
+        for suppression_key in suppressions
+    )