thailint 0.5.0__py3-none-any.whl → 0.15.3__py3-none-any.whl

src/linters/lazy_ignores/python_analyzer.py

@@ -0,0 +1,209 @@
+"""
+Purpose: Detect Python linting ignore directives in source code
+
+Scope: noqa, type:ignore, pylint:disable, nosec, pyright:ignore, dry:ignore-block 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.PYRIGHT_IGNORE: re.compile(
+            r"#\s*pyright:\s*ignore(?:\[([^\]]+)\])?",
+            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,
+        ),
+        IgnoreType.DRY_IGNORE_BLOCK: re.compile(
+            r"#\s*dry:\s*ignore-block\b",
+            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, full_line=line))
+        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
+    )

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