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

src/linters/dry/typescript_statement_detector.py

@@ -0,0 +1,255 @@
+"""
+Purpose: Detects single-statement patterns in TypeScript/JavaScript code for DRY linter filtering
+
+Scope: Tree-sitter AST analysis to identify single logical statements that should not be flagged
+
+Overview: Provides sophisticated single-statement pattern detection to filter false positives in the
+    DRY linter for TypeScript/JavaScript code. Uses tree-sitter AST to identify when a code block
+    represents a single logical statement (decorators, call expressions, object literals, class fields,
+    JSX elements, interface definitions) that should not be flagged as duplicate code.
+
+Dependencies: tree-sitter for TypeScript AST parsing
+
+Exports: is_single_statement, should_include_block functions
+
+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
+
+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 = Any  # type: ignore[assignment,misc]
+
+
+def is_single_statement(content: str, start_line: int, end_line: int) -> bool:
+    """Check if a line range is a single logical statement.
+
+    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
+
+    from src.analyzers.typescript_base import TypeScriptBaseAnalyzer
+
+    analyzer = TypeScriptBaseAnalyzer()
+    root = analyzer.parse_typescript(content)
+    if not root:
+        return False
+
+    return _check_overlapping_nodes(root, start_line, end_line)
+
+
+def should_include_block(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 = _find_interface_ranges(content)
+    return not _overlaps_interface(start_line, end_line, interface_ranges)
+
+
+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 any(_node_overlaps_and_matches(node, ts_start, ts_end) for node in _walk_nodes(root))
+
+
+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
+
+    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
+
+    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

@@ -0,0 +1,70 @@
+"""
+Purpose: Extract value representations from TypeScript AST nodes
+
+Scope: Helper for TypeScript constant extraction to extract value strings
+
+Overview: Provides utility methods to extract string representations from tree-sitter AST nodes
+    for TypeScript value types (numbers, strings, booleans, arrays, objects, call expressions).
+    Used by TypeScriptConstantExtractor to get value context for duplicate constant detection.
+
+Dependencies: tree-sitter, tree-sitter-typescript, src.analyzers.typescript_base
+
+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 contextlib import suppress
+from typing import Any
+
+from src.analyzers.typescript_base import TREE_SITTER_AVAILABLE
+
+if TREE_SITTER_AVAILABLE:
+    from tree_sitter import Node
+else:
+    Node = Any  # type: ignore[assignment,misc]
+
+
+class TypeScriptValueExtractor:
+    """Extracts value representations from TypeScript AST nodes."""
+
+    # Types that return their literal text
+    LITERAL_TYPES = frozenset(("number", "string", "true", "false", "null", "identifier"))
+
+    # Types with fixed representations
+    FIXED_REPRESENTATIONS = {"array": "[...]", "object": "{...}"}
+
+    def get_node_text(self, node: Node, content: str) -> str:
+        """Get text content of a node."""
+        return content[node.start_byte : node.end_byte]
+
+    def get_value_string(self, node: Node, content: str) -> str | None:
+        """Get string representation of a value node."""
+        if node.type in self.LITERAL_TYPES:
+            return self.get_node_text(node, content)
+        with suppress(KeyError):
+            return self.FIXED_REPRESENTATIONS[node.type]
+        if node.type == "call_expression":
+            return self._get_call_string(node, content)
+        return None
+
+    def _get_call_string(self, node: Node, content: str) -> str:
+        """Get string representation of a call expression.
+
+        Args:
+            node: call_expression node
+            content: Original source content
+
+        Returns:
+            String like "functionName(...)"
+        """
+        for child in node.children:
+            if child.type == "identifier":
+                func_name = self.get_node_text(child, content)
+                return f"{func_name}(...)"
+        return "call(...)"

src/linters/dry/violation_builder.py

@@ -27,6 +27,10 @@ from .cache import CodeBlock
 class DRYViolationBuilder:
     """Builds violation messages for duplicate code."""
 
+    def __init__(self) -> None:
+        """Initialize the DRY violation builder."""
+        pass  # Stateless builder for duplicate code violations
+
     def build_violation(
         self, block: CodeBlock, all_duplicates: list[CodeBlock], rule_id: str
     ) -> Violation:

src/linters/dry/violation_filter.py

@@ -25,6 +25,10 @@ DEFAULT_FALLBACK_LINE_COUNT = 5
 class ViolationFilter:
     """Filters overlapping violations."""
 
+    def __init__(self) -> None:
+        """Initialize the violation filter."""
+        pass  # Stateless filter for overlapping violations
+
     def filter_overlapping(self, sorted_violations: list[Violation]) -> list[Violation]:
         """Filter overlapping violations, keeping first occurrence.
 
@@ -50,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

@@ -10,14 +10,16 @@ Overview: Handles violation generation for duplicate code blocks. Queries storag
 
 Dependencies: DuplicateStorage, ViolationDeduplicator, DRYViolationBuilder, Violation, DRYConfig
 
-Exports: ViolationGenerator class
+Exports: ViolationGenerator class, IgnoreContext dataclass
 
 Interfaces: ViolationGenerator.generate_violations(storage, rule_id, config) -> list[Violation]
 
 Implementation: Queries storage, deduplicates blocks, builds violations, filters by ignore patterns
 """
 
+from dataclasses import dataclass
 from pathlib import Path
+from typing import TYPE_CHECKING
 
 from src.core.types import Violation
 from src.orchestrator.language_detector import detect_language
@@ -28,6 +30,18 @@ from .duplicate_storage import DuplicateStorage
 from .inline_ignore import InlineIgnoreParser
 from .violation_builder import DRYViolationBuilder
 
+if TYPE_CHECKING:
+    from src.linter_config.ignore import IgnoreDirectiveParser
+
+
+@dataclass
+class IgnoreContext:
+    """Context for ignore directive filtering."""
+
+    inline_ignore: InlineIgnoreParser
+    shared_parser: "IgnoreDirectiveParser | None" = None
+    file_contents: dict[str, str] | None = None
+
 
 class ViolationGenerator:
     """Generates violations from duplicate code blocks."""
@@ -42,7 +56,7 @@ class ViolationGenerator:
         storage: DuplicateStorage,
         rule_id: str,
         config: DRYConfig,
-        inline_ignore: InlineIgnoreParser,
+        ignore_ctx: IgnoreContext,
     ) -> list[Violation]:
         """Generate violations from storage.
 
@@ -50,19 +64,42 @@ class ViolationGenerator:
             storage: Duplicate storage instance
             rule_id: Rule identifier for violations
             config: DRY configuration with ignore patterns
-            inline_ignore: Parser with inline ignore directives
+            ignore_ctx: Context containing ignore parsers and file contents
 
         Returns:
             List of violations filtered by ignore patterns and inline directives
         """
-        duplicate_hashes = storage.get_duplicate_hashes()
-        violations = []
+        raw_violations = self._collect_violations(storage, rule_id, config)
+        deduplicated = self._deduplicator.deduplicate_violations(raw_violations)
+        pattern_filtered = self._filter_ignored(deduplicated, config.ignore_patterns)
+        inline_filtered = self._filter_inline_ignored(pattern_filtered, ignore_ctx.inline_ignore)
+
+        # Apply shared ignore directive filtering for block and line directives
+        if ignore_ctx.shared_parser and ignore_ctx.file_contents:
+            return self._filter_shared_ignored(
+                inline_filtered, ignore_ctx.shared_parser, ignore_ctx.file_contents
+            )
+
+        return inline_filtered
 
-        for hash_value in duplicate_hashes:
+    def _collect_violations(
+        self, storage: DuplicateStorage, rule_id: str, config: DRYConfig
+    ) -> list[Violation]:
+        """Collect raw violations from storage duplicate hashes.
+
+        Args:
+            storage: Duplicate storage instance
+            rule_id: Rule identifier for violations
+            config: DRY configuration
+
+        Returns:
+            List of raw violations before filtering
+        """
+        violations = []
+        for hash_value in storage.duplicate_hashes:
             blocks = storage.get_blocks_for_hash(hash_value)
             dedup_blocks = self._deduplicator.deduplicate_blocks(blocks)
 
-            # Check min_occurrences threshold (language-aware)
             if not self._meets_min_occurrences(dedup_blocks, config):
                 continue
 
@@ -70,9 +107,7 @@ class ViolationGenerator:
                 violation = self._violation_builder.build_violation(block, dedup_blocks, rule_id)
                 violations.append(violation)
 
-        deduplicated = self._deduplicator.deduplicate_violations(violations)
-        pattern_filtered = self._filter_ignored(deduplicated, config.ignore_patterns)
-        return self._filter_inline_ignored(pattern_filtered, inline_ignore)
+        return violations
 
     def _meets_min_occurrences(self, blocks: list, config: DRYConfig) -> bool:
         """Check if blocks meet minimum occurrence threshold for the language.
@@ -128,10 +163,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
@@ -172,3 +204,28 @@ class ViolationGenerator:
             return int(message[start:end])
         except (ValueError, IndexError):
             return 1
+
+    def _filter_shared_ignored(
+        self,
+        violations: list[Violation],
+        ignore_parser: "IgnoreDirectiveParser",
+        file_contents: dict[str, str],
+    ) -> list[Violation]:
+        """Filter violations using the shared ignore directive parser.
+
+        This enables standard # thailint: ignore-start/end directives for DRY linter.
+
+        Args:
+            violations: List of violations to filter
+            ignore_parser: Shared ignore directive parser
+            file_contents: Cached file contents for ignore checking
+
+        Returns:
+            Filtered list of violations
+        """
+        filtered = []
+        for violation in violations:
+            file_content = file_contents.get(violation.file_path, "")
+            if not ignore_parser.should_ignore_violation(violation, file_content):
+                filtered.append(violation)
+        return filtered

src/linters/file_header/atemporal_detector.py

@@ -1,64 +1,82 @@
 """
-File: src/linters/file_header/atemporal_detector.py
 Purpose: Detects temporal language patterns in file headers
-Exports: AtemporalDetector class
-Depends: re module for regex matching
-Implements: Regex-based pattern matching with configurable patterns
-Related: linter.py for detector usage, violation_builder.py for violation creation
 
-Overview:
-    Implements pattern-based detection of temporal language that violates atemporal
+Scope: File header validation for atemporal language compliance
+
+Overview: Implements pattern-based detection of temporal language that violates atemporal
     documentation requirements. Detects dates, temporal qualifiers, state change language,
     and future references using regex patterns. Provides violation details for each pattern match.
+    Uses four pattern categories (dates, temporal qualifiers, state changes, future references)
+    to identify violations and returns detailed information for each match.
+
+Dependencies: re module for regex-based pattern matching
+
+Exports: AtemporalDetector class with detect_violations method
 
-Usage:
-    detector = AtemporalDetector()
-    violations = detector.detect_violations(header_text)
+Interfaces: detect_violations(text) -> list[tuple[str, str, int]] returns pattern matches with line numbers
 
-Notes: Four pattern categories - dates, temporal qualifiers, state changes, future references
+Implementation: Regex-based pattern matching with pre-compiled patterns organized by category
+
+Suppressions:
+    - nesting: detect_violations iterates over pattern categories and their patterns.
+        Natural grouping by category requires nested loops.
 """
 
 import re
+from re import Pattern
+
+
+def _compile_patterns(patterns: list[tuple[str, str]]) -> list[tuple[Pattern[str], str]]:
+    """Compile regex patterns for efficient reuse."""
+    return [(re.compile(pattern, re.IGNORECASE), desc) for pattern, desc in patterns]
 
 
 class AtemporalDetector:
     """Detects temporal language patterns in text."""
 
-    # Date patterns
-    DATE_PATTERNS = [
-        (r"\d{4}-\d{2}-\d{2}", "ISO date format (YYYY-MM-DD)"),
-        (
-            r"(?:January|February|March|April|May|June|July|August|September|October|November|December)\s+\d{4}",
-            "Month Year format",
-        ),
-        (r"(?:Created|Updated|Modified):\s*\d{4}", "Date metadata"),
-    ]
-
-    # Temporal qualifiers
-    TEMPORAL_QUALIFIERS = [
-        (r"\bcurrently\b", 'temporal qualifier "currently"'),
-        (r"\bnow\b", 'temporal qualifier "now"'),
-        (r"\brecently\b", 'temporal qualifier "recently"'),
-        (r"\bsoon\b", 'temporal qualifier "soon"'),
-        (r"\bfor now\b", 'temporal qualifier "for now"'),
-    ]
-
-    # State change language
-    STATE_CHANGE = [
-        (r"\breplaces?\b", 'state change "replaces"'),
-        (r"\bmigrated from\b", 'state change "migrated from"'),
-        (r"\bformerly\b", 'state change "formerly"'),
-        (r"\bold implementation\b", 'state change "old"'),
-        (r"\bnew implementation\b", 'state change "new"'),
-    ]
-
-    # Future references
-    FUTURE_REFS = [
-        (r"\bwill be\b", 'future reference "will be"'),
-        (r"\bplanned\b", 'future reference "planned"'),
-        (r"\bto be added\b", 'future reference "to be added"'),
-        (r"\bcoming soon\b", 'future reference "coming soon"'),
-    ]
+    # Pre-compiled date patterns
+    DATE_PATTERNS = _compile_patterns(
+        [
+            (r"\d{4}-\d{2}-\d{2}", "ISO date format (YYYY-MM-DD)"),
+            (
+                r"(?:January|February|March|April|May|June|July|August|September|October|November|December)\s+\d{4}",
+                "Month Year format",
+            ),
+            (r"(?:Created|Updated|Modified):\s*\d{4}", "Date metadata"),
+        ]
+    )
+
+    # Pre-compiled temporal qualifiers
+    TEMPORAL_QUALIFIERS = _compile_patterns(
+        [
+            (r"\bcurrently\b", 'temporal qualifier "currently"'),
+            (r"\bnow\b", 'temporal qualifier "now"'),
+            (r"\brecently\b", 'temporal qualifier "recently"'),
+            (r"\bsoon\b", 'temporal qualifier "soon"'),
+            (r"\bfor now\b", 'temporal qualifier "for now"'),
+        ]
+    )
+
+    # Pre-compiled state change language
+    STATE_CHANGE = _compile_patterns(
+        [
+            (r"\breplaces?\b", 'state change "replaces"'),
+            (r"\bmigrated from\b", 'state change "migrated from"'),
+            (r"\bformerly\b", 'state change "formerly"'),
+            (r"\bold implementation\b", 'state change "old"'),
+            (r"\bnew implementation\b", 'state change "new"'),
+        ]
+    )
+
+    # Pre-compiled future references
+    FUTURE_REFS = _compile_patterns(
+        [
+            (r"\bwill be\b", 'future reference "will be"'),
+            (r"\bplanned\b", 'future reference "planned"'),
+            (r"\bto be added\b", 'future reference "to be added"'),
+            (r"\bcoming soon\b", 'future reference "coming soon"'),
+        ]
+    )
 
     def detect_violations(  # thailint: ignore[nesting]
         self, text: str
@@ -73,15 +91,15 @@ class AtemporalDetector:
         """
         violations = []
 
-        # Check all pattern categories
+        # Check all pattern categories (patterns are pre-compiled)
         all_patterns = (
             self.DATE_PATTERNS + self.TEMPORAL_QUALIFIERS + self.STATE_CHANGE + self.FUTURE_REFS
         )
 
         lines = text.split("\n")
         for line_num, line in enumerate(lines, start=1):
-            for pattern, description in all_patterns:
-                if re.search(pattern, line, re.IGNORECASE):
-                    violations.append((pattern, description, line_num))
+            for compiled_pattern, description in all_patterns:
+                if compiled_pattern.search(line):
+                    violations.append((compiled_pattern.pattern, description, line_num))
 
         return violations