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

src/linters/dry/typescript_statement_detector.py

@@ -10,246 +10,246 @@ Overview: Provides sophisticated single-statement pattern detection to filter fa
 
 Dependencies: tree-sitter for TypeScript AST parsing
 
-Exports: TypeScriptStatementDetector class
+Exports: is_single_statement, should_include_block functions
 
-Interfaces: TypeScriptStatementDetector.is_single_statement(content, start_line, end_line) -> bool
+Interfaces: is_single_statement(content, start_line, end_line) -> bool,
+    should_include_block(content, start_line, end_line) -> bool
 
 Implementation: Tree-sitter AST walking with pattern matching for TypeScript constructs
 
-SRP Exception: TypeScriptStatementDetector has 20 methods (exceeds max 8 methods)
-    Justification: Complex tree-sitter AST analysis algorithm for single-statement pattern detection.
-    Methods form tightly coupled algorithm pipeline: decorator detection, call expression analysis,
-    declaration patterns, JSX element handling, class body field definitions, and interface filtering.
-    Similar to parser or compiler pass architecture where algorithmic cohesion is critical. Splitting
-    would fragment the algorithm logic and make maintenance harder by separating interdependent
-    tree-sitter AST analysis steps. All methods contribute to single responsibility: accurately
-    detecting single-statement patterns to prevent false positives in TypeScript duplicate detection.
+Suppressions:
+    - type:ignore[assignment,misc]: Tree-sitter Node type alias (optional dependency fallback)
 """
 
 from collections.abc import Generator
+from typing import Any
 
 from src.analyzers.typescript_base import TREE_SITTER_AVAILABLE
 
 if TREE_SITTER_AVAILABLE:
     from tree_sitter import Node
 else:
-    Node = None  # type: ignore[assignment,misc]  # pylint: disable=invalid-name
+    Node = Any  # type: ignore[assignment,misc]
 
 
-class TypeScriptStatementDetector:  # thailint: ignore[srp.violation]
-    """Detects single-statement patterns in TypeScript/JavaScript for duplicate filtering.
+def is_single_statement(content: str, start_line: int, end_line: int) -> bool:
+    """Check if a line range is a single logical statement.
 
-    SRP suppression: Complex tree-sitter AST analysis algorithm requires 20 methods to implement
-    sophisticated single-statement detection. See file header for justification.
+    Args:
+        content: TypeScript source code
+        start_line: Starting line number (1-indexed)
+        end_line: Ending line number (1-indexed)
+
+    Returns:
+        True if this range represents a single logical statement/expression
     """
+    if not TREE_SITTER_AVAILABLE:
+        return False
 
-    def is_single_statement(self, content: str, start_line: int, end_line: int) -> bool:
-        """Check if a line range is a single logical statement.
+    from src.analyzers.typescript_base import TypeScriptBaseAnalyzer
 
-        Args:
-            content: TypeScript source code
-            start_line: Starting line number (1-indexed)
-            end_line: Ending line number (1-indexed)
+    analyzer = TypeScriptBaseAnalyzer()
+    root = analyzer.parse_typescript(content)
+    if not root:
+        return False
 
-        Returns:
-            True if this range represents a single logical statement/expression
-        """
-        if not TREE_SITTER_AVAILABLE:
-            return False
+    return _check_overlapping_nodes(root, start_line, end_line)
 
-        from src.analyzers.typescript_base import TypeScriptBaseAnalyzer
 
-        analyzer = TypeScriptBaseAnalyzer()
-        root = analyzer.parse_typescript(content)
-        if not root:
-            return False
+def should_include_block(content: str, start_line: int, end_line: int) -> bool:
+    """Check if block should be included (not overlapping interface definitions).
 
-        return self._check_overlapping_nodes(root, start_line, end_line)
+    Args:
+        content: File content
+        start_line: Block start line
+        end_line: Block end line
 
-    def _check_overlapping_nodes(self, root: Node, start_line: int, end_line: int) -> bool:
-        """Check if any AST node overlaps and matches single-statement pattern."""
-        ts_start = start_line - 1  # Convert to 0-indexed
-        ts_end = end_line - 1
+    Returns:
+        False if block overlaps interface definition, True otherwise
+    """
+    interface_ranges = _find_interface_ranges(content)
+    return not _overlaps_interface(start_line, end_line, interface_ranges)
 
-        for node in self._walk_nodes(root):
-            if self._node_overlaps_and_matches(node, ts_start, ts_end):
-                return True
-        return False
 
-    def _walk_nodes(self, node: Node) -> Generator[Node, None, None]:
-        """Generator to walk all nodes in tree."""
-        yield node
-        for child in node.children:
-            yield from self._walk_nodes(child)
-
-    def _node_overlaps_and_matches(self, node: Node, ts_start: int, ts_end: int) -> bool:
-        """Check if node overlaps with range and matches single-statement pattern."""
-        node_start = node.start_point[0]
-        node_end = node.end_point[0]
-
-        overlaps = not (node_end < ts_start or node_start > ts_end)
-        if not overlaps:
-            return False
-
-        return self._is_single_statement_pattern(node, ts_start, ts_end)
-
-    def _is_single_statement_pattern(self, node: Node, ts_start: int, ts_end: int) -> bool:
-        """Check if an AST node represents a single-statement pattern to filter."""
-        node_start = node.start_point[0]
-        node_end = node.end_point[0]
-        contains = (node_start <= ts_start) and (node_end >= ts_end)
-
-        matchers = [
-            self._matches_simple_container_pattern(node, contains),
-            self._matches_call_expression_pattern(node, ts_start, ts_end, contains),
-            self._matches_declaration_pattern(node, contains),
-            self._matches_jsx_pattern(node, contains),
-            self._matches_class_body_pattern(node, ts_start, ts_end),
-        ]
-        return any(matchers)
-
-    def _matches_simple_container_pattern(self, node: Node, contains: bool) -> bool:
-        """Check if node is a simple container pattern (decorator, object, etc.)."""
-        simple_types = (
-            "decorator",
-            "object",
-            "member_expression",
-            "as_expression",
-            "array_pattern",
-        )
-        return node.type in simple_types and contains
-
-    def _matches_call_expression_pattern(
-        self, node: Node, ts_start: int, ts_end: int, contains: bool
-    ) -> bool:
-        """Check if node is a call expression pattern."""
-        if node.type != "call_expression":
-            return False
-
-        node_start = node.start_point[0]
-        node_end = node.end_point[0]
-        is_multiline = node_start < node_end
-        if is_multiline and node_start <= ts_start <= node_end:
-            return True
+def _check_overlapping_nodes(root: Node, start_line: int, end_line: int) -> bool:
+    """Check if any AST node overlaps and matches single-statement pattern."""
+    ts_start = start_line - 1  # Convert to 0-indexed
+    ts_end = end_line - 1
 
-        return contains
+    return any(_node_overlaps_and_matches(node, ts_start, ts_end) for node in _walk_nodes(root))
 
-    def _matches_declaration_pattern(self, node: Node, contains: bool) -> bool:
-        """Check if node is a lexical declaration pattern."""
-        if node.type != "lexical_declaration" or not contains:
-            return False
 
-        if self._contains_function_body(node):
-            return False
+def _walk_nodes(node: Node) -> Generator[Node, None, None]:
+    """Generator to walk all nodes in tree."""
+    yield node
+    for child in node.children:
+        yield from _walk_nodes(child)
+
+
+def _node_overlaps_and_matches(node: Node, ts_start: int, ts_end: int) -> bool:
+    """Check if node overlaps with range and matches single-statement pattern."""
+    node_start = node.start_point[0]
+    node_end = node.end_point[0]
+
+    overlaps = not (node_end < ts_start or node_start > ts_end)
+    if not overlaps:
+        return False
+
+    return _is_single_statement_pattern(node, ts_start, ts_end)
+
+
+def _is_single_statement_pattern(node: Node, ts_start: int, ts_end: int) -> bool:
+    """Check if an AST node represents a single-statement pattern to filter."""
+    node_start = node.start_point[0]
+    node_end = node.end_point[0]
+    contains = (node_start <= ts_start) and (node_end >= ts_end)
+
+    matchers = [
+        _matches_simple_container_pattern(node, contains),
+        _matches_call_expression_pattern(node, ts_start, ts_end, contains),
+        _matches_declaration_pattern(node, contains),
+        _matches_jsx_pattern(node, contains),
+        _matches_class_body_pattern(node, ts_start, ts_end),
+    ]
+    return any(matchers)
+
+
+def _matches_simple_container_pattern(node: Node, contains: bool) -> bool:
+    """Check if node is a simple container pattern (decorator, object, etc.)."""
+    simple_types = (
+        "decorator",
+        "object",
+        "member_expression",
+        "as_expression",
+        "array_pattern",
+    )
+    return node.type in simple_types and contains
+
+
+def _matches_call_expression_pattern(
+    node: Node, ts_start: int, ts_end: int, contains: bool
+) -> bool:
+    """Check if node is a call expression pattern."""
+    if node.type != "call_expression":
+        return False
 
+    node_start = node.start_point[0]
+    node_end = node.end_point[0]
+    is_multiline = node_start < node_end
+    if is_multiline and node_start <= ts_start <= node_end:
         return True
 
-    def _matches_jsx_pattern(self, node: Node, contains: bool) -> bool:
-        """Check if node is a JSX element pattern."""
-        jsx_types = ("jsx_opening_element", "jsx_self_closing_element")
-        return node.type in jsx_types and contains
-
-    def _matches_class_body_pattern(self, node: Node, ts_start: int, ts_end: int) -> bool:
-        """Check if node is a class body field definition pattern."""
-        if node.type != "class_body":
-            return False
-
-        return self._is_in_class_field_area(node, ts_start, ts_end)
-
-    def _contains_function_body(self, node: Node) -> bool:
-        """Check if node contains an arrow function or function expression."""
-        for child in node.children:
-            if child.type in ("arrow_function", "function", "function_expression"):
-                return True
-            if self._contains_function_body(child):
-                return True
+    return contains
+
+
+def _matches_declaration_pattern(node: Node, contains: bool) -> bool:
+    """Check if node is a lexical declaration pattern."""
+    if node.type != "lexical_declaration" or not contains:
+        return False
+
+    if _contains_function_body(node):
         return False
 
-    def _find_first_method_line(self, class_body: Node) -> int | None:
-        """Find line number of first method in class body."""
-        for child in class_body.children:
-            if child.type in ("method_definition", "function_declaration"):
-                return child.start_point[0]
-        return None
-
-    def _is_in_class_field_area(self, class_body: Node, ts_start: int, ts_end: int) -> bool:
-        """Check if range is in class field definition area (before methods)."""
-        first_method_line = self._find_first_method_line(class_body)
-        class_start = class_body.start_point[0]
-        class_end = class_body.end_point[0]
-
-        if first_method_line is None:
-            return class_start <= ts_start and class_end >= ts_end
-
-        return class_start <= ts_start and ts_end < first_method_line
-
-    def should_include_block(self, content: str, start_line: int, end_line: int) -> bool:
-        """Check if block should be included (not overlapping interface definitions).
-
-        Args:
-            content: File content
-            start_line: Block start line
-            end_line: Block end line
-
-        Returns:
-            False if block overlaps interface definition, True otherwise
-        """
-        interface_ranges = self._find_interface_ranges(content)
-        return not self._overlaps_interface(start_line, end_line, interface_ranges)
-
-    def _find_interface_ranges(self, content: str) -> list[tuple[int, int]]:
-        """Find line ranges of interface/type definitions."""
-        ranges: list[tuple[int, int]] = []
-        lines = content.split("\n")
-        state = {"in_interface": False, "start_line": 0, "brace_count": 0}
-
-        for i, line in enumerate(lines, start=1):
-            stripped = line.strip()
-            self._process_line_for_interface(stripped, i, state, ranges)
-
-        return ranges
-
-    def _process_line_for_interface(
-        self, stripped: str, line_num: int, state: dict, ranges: list[tuple[int, int]]
-    ) -> None:
-        """Process single line for interface detection."""
-        if self._is_interface_start(stripped):
-            self._handle_interface_start(stripped, line_num, state, ranges)
-            return
-
-        if state["in_interface"]:
-            self._handle_interface_continuation(stripped, line_num, state, ranges)
-
-    def _is_interface_start(self, stripped: str) -> bool:
-        """Check if line starts interface/type definition."""
-        return stripped.startswith(("interface ", "type ")) and "{" in stripped
-
-    def _handle_interface_start(
-        self, stripped: str, line_num: int, state: dict, ranges: list[tuple[int, int]]
-    ) -> None:
-        """Handle start of interface definition."""
-        state["in_interface"] = True
-        state["start_line"] = line_num
-        state["brace_count"] = stripped.count("{") - stripped.count("}")
-
-        if state["brace_count"] == 0:
-            ranges.append((line_num, line_num))
-            state["in_interface"] = False
-
-    def _handle_interface_continuation(
-        self, stripped: str, line_num: int, state: dict, ranges: list[tuple[int, int]]
-    ) -> None:
-        """Handle continuation of interface definition."""
-        state["brace_count"] += stripped.count("{") - stripped.count("}")
-        if state["brace_count"] == 0:
-            ranges.append((state["start_line"], line_num))
-            state["in_interface"] = False
-
-    def _overlaps_interface(
-        self, start: int, end: int, interface_ranges: list[tuple[int, int]]
-    ) -> bool:
-        """Check if block overlaps with any interface range."""
-        for if_start, if_end in interface_ranges:
-            if start <= if_end and end >= if_start:
-                return True
+    return True
+
+
+def _matches_jsx_pattern(node: Node, contains: bool) -> bool:
+    """Check if node is a JSX element pattern."""
+    jsx_types = ("jsx_opening_element", "jsx_self_closing_element")
+    return node.type in jsx_types and contains
+
+
+def _matches_class_body_pattern(node: Node, ts_start: int, ts_end: int) -> bool:
+    """Check if node is a class body field definition pattern."""
+    if node.type != "class_body":
         return False
+
+    return _is_in_class_field_area(node, ts_start, ts_end)
+
+
+def _contains_function_body(node: Node) -> bool:
+    """Check if node contains an arrow function or function expression."""
+    for child in node.children:
+        if child.type in ("arrow_function", "function", "function_expression"):
+            return True
+        if _contains_function_body(child):
+            return True
+    return False
+
+
+def _find_first_method_line(class_body: Node) -> int | None:
+    """Find line number of first method in class body."""
+    for child in class_body.children:
+        if child.type in ("method_definition", "function_declaration"):
+            return child.start_point[0]
+    return None
+
+
+def _is_in_class_field_area(class_body: Node, ts_start: int, ts_end: int) -> bool:
+    """Check if range is in class field definition area (before methods)."""
+    first_method_line = _find_first_method_line(class_body)
+    class_start = class_body.start_point[0]
+    class_end = class_body.end_point[0]
+
+    if first_method_line is None:
+        return class_start <= ts_start and class_end >= ts_end
+
+    return class_start <= ts_start and ts_end < first_method_line
+
+
+def _find_interface_ranges(content: str) -> list[tuple[int, int]]:
+    """Find line ranges of interface/type definitions."""
+    ranges: list[tuple[int, int]] = []
+    lines = content.split("\n")
+    state = {"in_interface": False, "start_line": 0, "brace_count": 0}
+
+    for i, line in enumerate(lines, start=1):
+        stripped = line.strip()
+        _process_line_for_interface(stripped, i, state, ranges)
+
+    return ranges
+
+
+def _process_line_for_interface(
+    stripped: str, line_num: int, state: dict[str, Any], ranges: list[tuple[int, int]]
+) -> None:
+    """Process single line for interface detection."""
+    if _is_interface_start(stripped):
+        _handle_interface_start(stripped, line_num, state, ranges)
+        return
+
+    if state["in_interface"]:
+        _handle_interface_continuation(stripped, line_num, state, ranges)
+
+
+def _is_interface_start(stripped: str) -> bool:
+    """Check if line starts interface/type definition."""
+    return stripped.startswith(("interface ", "type ")) and "{" in stripped
+
+
+def _handle_interface_start(
+    stripped: str, line_num: int, state: dict[str, Any], ranges: list[tuple[int, int]]
+) -> None:
+    """Handle start of interface definition."""
+    state["in_interface"] = True
+    state["start_line"] = line_num
+    state["brace_count"] = stripped.count("{") - stripped.count("}")
+
+    if state["brace_count"] == 0:
+        ranges.append((line_num, line_num))
+        state["in_interface"] = False
+
+
+def _handle_interface_continuation(
+    stripped: str, line_num: int, state: dict[str, Any], ranges: list[tuple[int, int]]
+) -> None:
+    """Handle continuation of interface definition."""
+    state["brace_count"] += stripped.count("{") - stripped.count("}")
+    if state["brace_count"] == 0:
+        ranges.append((state["start_line"], line_num))
+        state["in_interface"] = False
+
+
+def _overlaps_interface(start: int, end: int, interface_ranges: list[tuple[int, int]]) -> bool:
+    """Check if block overlaps with any interface range."""
+    return any(start <= if_end and end >= if_start for if_start, if_end in interface_ranges)

src/linters/dry/typescript_value_extractor.py

@@ -14,6 +14,9 @@ Exports: TypeScriptValueExtractor class
 Interfaces: TypeScriptValueExtractor.get_value_string(node, content) -> str | None
 
 Implementation: Tree-sitter node traversal with type-specific string formatting
+
+Suppressions:
+    - type:ignore[assignment,misc]: Tree-sitter Node type alias (optional dependency fallback)
 """
 
 from typing import Any

src/linters/dry/violation_filter.py

@@ -54,10 +54,7 @@ class ViolationFilter:
         Returns:
             True if violation overlaps with any kept violation
         """
-        for kept in kept_violations:
-            if self._overlaps(violation, kept):
-                return True
-        return False
+        return any(self._overlaps(violation, kept) for kept in kept_violations)
 
     def _overlaps(self, v1: Violation, v2: Violation) -> bool:
         """Check if two violations overlap.

src/linters/dry/violation_generator.py

@@ -128,10 +128,7 @@ class ViolationGenerator:
             True if file should be ignored
         """
         path_str = str(Path(file_path))
-        for pattern in ignore_patterns:
-            if pattern in path_str:
-                return True
-        return False
+        return any(pattern in path_str for pattern in ignore_patterns)
 
     def _filter_inline_ignored(
         self, violations: list[Violation], inline_ignore: InlineIgnoreParser

src/linters/file_header/atemporal_detector.py

@@ -16,6 +16,10 @@ Exports: AtemporalDetector class with detect_violations method
 Interfaces: detect_violations(text) -> list[tuple[str, str, int]] returns pattern matches with line numbers
 
 Implementation: Regex-based pattern matching with predefined patterns organized by category
+
+Suppressions:
+    - nesting: detect_violations iterates over pattern categories and their patterns.
+        Natural grouping by category requires nested loops.
 """
 
 import re

src/linters/file_header/base_parser.py

@@ -16,6 +16,10 @@ Exports: BaseHeaderParser abstract base class
 Interfaces: extract_header(code) abstract method, parse_fields(header) -> dict[str, str] for field extraction
 
 Implementation: Template method pattern with shared field parsing and language-specific extraction
+
+Suppressions:
+    - nesting: parse_fields uses nested loops for multi-line field processing. Extracting
+        would fragment the field-building logic without improving clarity.
 """
 
 import re

src/linters/file_header/bash_parser.py

@@ -16,6 +16,10 @@ Exports: BashHeaderParser class
 Interfaces: extract_header(code) -> str | None for comment extraction, parse_fields(header) inherited from base
 
 Implementation: Skips shebang and preamble, then extracts contiguous hash comment block
+
+Suppressions:
+    - nesting: _skip_preamble uses conditional loops for shebang/preamble detection.
+        Sequential line processing requires nested state checks.
 """
 
 from src.linters.file_header.base_parser import BaseHeaderParser

src/linters/file_header/field_validator.py

@@ -42,15 +42,12 @@ class FieldValidator:
         Returns:
             List of (field_name, error_message) tuples for missing/invalid fields
         """
-        violations = []
         required_fields = self._get_required_fields(language)
-
-        for field_name in required_fields:
-            error = self._check_field(fields, field_name)
-            if error:
-                violations.append(error)
-
-        return violations
+        return [
+            error
+            for field_name in required_fields
+            if (error := self._check_field(fields, field_name))
+        ]
 
     def _check_field(self, fields: dict[str, str], field_name: str) -> tuple[str, str] | None:
         """Check a single field for presence and content."""

src/linters/file_header/linter.py

@@ -20,15 +20,22 @@ Interfaces: check(context) -> list[Violation] for rule validation, standard rule
 
 Implementation: Composition pattern with helper classes for parsing, validation,
     and violation building
+
+Suppressions:
+    - type:ignore[type-var]: Protocol pattern with generic type matching
+    - srp: Rule class coordinates parsing, validation, and violation building for multiple
+        languages. Methods support single responsibility of file header validation.
 """
 
 from pathlib import Path
 from typing import Protocol
 
 from src.core.base import BaseLintContext, BaseLintRule
+from src.core.constants import HEADER_SCAN_LINES, Language
 from src.core.linter_utils import load_linter_config
 from src.core.types import Violation
-from src.linter_config.ignore import get_ignore_parser
+from src.linter_config.directive_markers import check_general_ignore, has_ignore_directive_marker
+from src.linter_config.ignore import _check_specific_rule_ignore, get_ignore_parser
 
 from .atemporal_detector import AtemporalDetector
 from .bash_parser import BashHeaderParser
@@ -111,7 +118,7 @@ class FileHeaderRule(BaseLintRule):  # thailint: ignore[srp]
             return []
 
         # Markdown has special atemporal handling
-        if context.language == "markdown":
+        if context.language == Language.MARKDOWN:
             return self._check_markdown_header(parser, context, config)
 
         return self._check_header_with_parser(parser, context, config)
@@ -158,20 +165,20 @@ class FileHeaderRule(BaseLintRule):  # thailint: ignore[srp]
 
         return self._has_custom_ignore_syntax(file_content)
 
-    def _has_standard_ignore(self, file_content: str) -> bool:  # thailint: ignore[nesting]
+    def _has_standard_ignore(self, file_content: str) -> bool:
         """Check standard ignore parser for file-level ignores."""
-        first_lines = file_content.splitlines()[:10]
-        for line in first_lines:
-            if self._ignore_parser._has_ignore_directive_marker(line):  # pylint: disable=protected-access
-                if self._ignore_parser._check_specific_rule_ignore(line, self.rule_id):  # pylint: disable=protected-access
-                    return True
-                if self._ignore_parser._check_general_ignore(line):  # pylint: disable=protected-access
-                    return True
-        return False
+        first_lines = file_content.splitlines()[:HEADER_SCAN_LINES]
+        return any(self._line_has_matching_ignore(line) for line in first_lines)
+
+    def _line_has_matching_ignore(self, line: str) -> bool:
+        """Check if line has matching ignore directive for this rule."""
+        if not has_ignore_directive_marker(line):
+            return False
+        return _check_specific_rule_ignore(line, self.rule_id) or check_general_ignore(line)
 
     def _has_custom_ignore_syntax(self, file_content: str) -> bool:
         """Check custom file-level ignore syntax."""
-        first_lines = file_content.splitlines()[:10]
+        first_lines = file_content.splitlines()[:HEADER_SCAN_LINES]
         return any(self._is_ignore_line(line) for line in first_lines)
 
     def _is_ignore_line(self, line: str) -> bool:

src/linters/file_header/markdown_parser.py

@@ -17,6 +17,12 @@ Interfaces: extract_header(code) -> str | None for frontmatter extraction,
     parse_fields(header) -> dict[str, str] for field parsing
 
 Implementation: YAML frontmatter extraction with PyYAML parsing and regex fallback for robustness
+
+Suppressions:
+    - BLE001: Broad exception catch for YAML parsing fallback (any exception triggers regex fallback)
+    - srp: Class coordinates YAML extraction, parsing, and field validation for Markdown.
+        Method count exceeds limit due to complexity refactoring.
+    - nesting,dry: _parse_simple_yaml uses nested loops for YAML structure traversal.
 """
 
 import logging

src/linters/file_placement/config_loader.py

@@ -23,6 +23,8 @@ from typing import Any
 
 import yaml
 
+from src.core.constants import CONFIG_EXTENSIONS
+
 
 class ConfigLoader:
     """Loads configuration files for file placement linter."""
@@ -79,7 +81,7 @@ class ConfigLoader:
             ValueError: If file format is unsupported
         """
         with config_path.open(encoding="utf-8") as f:
-            if config_path.suffix in [".yaml", ".yml"]:
+            if config_path.suffix in CONFIG_EXTENSIONS:
                 return yaml.safe_load(f) or {}
             if config_path.suffix == ".json":
                 return json.load(f)