thailint 0.9.0__py3-none-any.whl → 0.11.0__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: TypeScriptStatementDetector class
+
+Interfaces: TypeScriptStatementDetector.is_single_statement(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.
+"""
+
+from collections.abc import Generator
+
+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
+
+
+class TypeScriptStatementDetector:  # thailint: ignore[srp.violation]
+    """Detects single-statement patterns in TypeScript/JavaScript for duplicate filtering.
+
+    SRP suppression: Complex tree-sitter AST analysis algorithm requires 20 methods to implement
+    sophisticated single-statement detection. See file header for justification.
+    """
+
+    def is_single_statement(self, 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 self._check_overlapping_nodes(root, start_line, 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
+
+        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
+
+        return contains
+
+    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
+
+        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 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 False

src/linters/dry/typescript_value_extractor.py

@@ -0,0 +1,66 @@
+"""
+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
+"""
+
+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)
+        if node.type in self.FIXED_REPRESENTATIONS:
+            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/file_header/linter.py

@@ -28,7 +28,7 @@ from typing import Protocol
 from src.core.base import BaseLintContext, BaseLintRule
 from src.core.linter_utils import load_linter_config
 from src.core.types import Violation
-from src.linter_config.ignore import IgnoreDirectiveParser
+from src.linter_config.ignore import get_ignore_parser
 
 from .atemporal_detector import AtemporalDetector
 from .bash_parser import BashHeaderParser
@@ -73,7 +73,7 @@ class FileHeaderRule(BaseLintRule):  # thailint: ignore[srp]
     def __init__(self) -> None:
         """Initialize the file header rule."""
         self._violation_builder = ViolationBuilder(self.rule_id)
-        self._ignore_parser = IgnoreDirectiveParser()
+        self._ignore_parser = get_ignore_parser()
 
     @property
     def rule_id(self) -> str:
@@ -273,17 +273,13 @@ class FileHeaderRule(BaseLintRule):  # thailint: ignore[srp]
         file_content = context.file_content or ""
         lines = file_content.splitlines()
 
-        filtered = []
-        for v in violations:
-            if self._ignore_parser.should_ignore_violation(v, file_content):
-                continue
-
-            if self._has_line_level_ignore(lines, v):
-                continue
-
-            filtered.append(v)
-
-        return filtered
+        non_ignored = (
+            v
+            for v in violations
+            if not self._ignore_parser.should_ignore_violation(v, file_content)
+            and not self._has_line_level_ignore(lines, v)
+        )
+        return list(non_ignored)
 
     def _has_line_level_ignore(self, lines: list[str], violation: Violation) -> bool:
         """Check for thailint-ignore-line directive."""

src/linters/file_placement/linter.py

@@ -124,20 +124,40 @@ class FilePlacementLinter:
         Returns:
             List of all violations found
         """
-        from src.linter_config.ignore import IgnoreDirectiveParser
+        valid_files = self._get_valid_files(dir_path, recursive)
+        return self._lint_files(valid_files)
 
-        ignore_parser = IgnoreDirectiveParser(self.project_root)
+    def _get_valid_files(self, dir_path: Path, recursive: bool) -> list[Path]:
+        """Get list of valid files to lint from directory.
+
+        Args:
+            dir_path: Directory to scan
+            recursive: Scan recursively
+
+        Returns:
+            List of file paths to lint
+        """
+        from src.linter_config.ignore import get_ignore_parser
+
+        ignore_parser = get_ignore_parser(self.project_root)
         pattern = "**/*" if recursive else "*"
 
-        violations = []
-        for file_path in dir_path.glob(pattern):
-            if not file_path.is_file():
-                continue
-            if ignore_parser.is_ignored(file_path):
-                continue
-            file_violations = self.lint_path(file_path)
-            violations.extend(file_violations)
+        return [
+            f for f in dir_path.glob(pattern) if f.is_file() and not ignore_parser.is_ignored(f)
+        ]
+
+    def _lint_files(self, file_paths: list[Path]) -> list[Violation]:
+        """Lint multiple files and collect violations.
+
+        Args:
+            file_paths: List of file paths to lint
 
+        Returns:
+            List of all violations found
+        """
+        violations = []
+        for file_path in file_paths:
+            violations.extend(self.lint_path(file_path))
         return violations
 
 

src/linters/file_placement/pattern_matcher.py

@@ -18,14 +18,28 @@ Implementation: Uses re.search() for pattern matching with IGNORECASE flag
 """
 
 import re
+from re import Pattern
 
 
 class PatternMatcher:
     """Handles regex pattern matching for file paths."""
 
     def __init__(self) -> None:
-        """Initialize the pattern matcher."""
-        pass  # Stateless matcher for regex patterns
+        """Initialize the pattern matcher with compiled regex cache."""
+        self._compiled_patterns: dict[str, Pattern[str]] = {}
+
+    def _get_compiled(self, pattern: str) -> Pattern[str]:
+        """Get compiled regex pattern, caching for reuse.
+
+        Args:
+            pattern: Regex pattern string
+
+        Returns:
+            Compiled regex Pattern object
+        """
+        if pattern not in self._compiled_patterns:
+            self._compiled_patterns[pattern] = re.compile(pattern, re.IGNORECASE)
+        return self._compiled_patterns[pattern]
 
     def match_deny_patterns(
         self, path_str: str, deny_patterns: list[dict[str, str]]
@@ -40,8 +54,8 @@ class PatternMatcher:
             Tuple of (is_denied, reason)
         """
         for deny_item in deny_patterns:
-            pattern = deny_item["pattern"]
-            if re.search(pattern, path_str, re.IGNORECASE):
+            compiled = self._get_compiled(deny_item["pattern"])
+            if compiled.search(path_str):
                 reason = deny_item.get("reason", "File not allowed in this location")
                 return True, reason
         return False, None
@@ -56,4 +70,4 @@ class PatternMatcher:
         Returns:
             True if path matches any pattern
         """
-        return any(re.search(pattern, path_str, re.IGNORECASE) for pattern in allow_patterns)
+        return any(self._get_compiled(pattern).search(path_str) for pattern in allow_patterns)

src/linters/magic_numbers/linter.py

@@ -29,12 +29,14 @@ from pathlib import Path
 from src.core.base import BaseLintContext, MultiLanguageLintRule
 from src.core.linter_utils import load_linter_config
 from src.core.types import Violation
-from src.linter_config.ignore import IgnoreDirectiveParser
+from src.core.violation_utils import get_violation_line, has_python_noqa
+from src.linter_config.ignore import get_ignore_parser
 
 from .config import MagicNumberConfig
 from .context_analyzer import ContextAnalyzer
 from .python_analyzer import PythonMagicNumberAnalyzer
 from .typescript_analyzer import TypeScriptMagicNumberAnalyzer
+from .typescript_ignore_checker import TypeScriptIgnoreChecker
 from .violation_builder import ViolationBuilder
 
 
@@ -43,9 +45,10 @@ class MagicNumberRule(MultiLanguageLintRule):  # thailint: ignore[srp]
 
     def __init__(self) -> None:
         """Initialize the magic numbers rule."""
-        self._ignore_parser = IgnoreDirectiveParser()
+        self._ignore_parser = get_ignore_parser()
         self._violation_builder = ViolationBuilder(self.rule_id)
         self._context_analyzer = ContextAnalyzer()
+        self._typescript_ignore_checker = TypeScriptIgnoreChecker()
 
     @property
     def rule_id(self) -> str:
@@ -282,28 +285,17 @@ class MagicNumberRule(MultiLanguageLintRule):  # thailint: ignore[srp]
         Returns:
             True if line has generic ignore directive
         """
-        line_text = self._get_violation_line(violation, context)
+        line_text = get_violation_line(violation, context)
         if line_text is None:
             return False
 
         return self._has_generic_ignore_directive(line_text)
 
-    def _get_violation_line(self, violation: Violation, context: BaseLintContext) -> str | None:
-        """Get the line text for a violation."""
-        if not context.file_content:
-            return None
-
-        lines = context.file_content.splitlines()
-        if violation.line <= 0 or violation.line > len(lines):
-            return None
-
-        return lines[violation.line - 1].lower()
-
     def _has_generic_ignore_directive(self, line_text: str) -> bool:
         """Check if line has generic ignore directive."""
         if self._has_generic_thailint_ignore(line_text):
             return True
-        return self._has_noqa_directive(line_text)
+        return has_python_noqa(line_text)
 
     def _has_generic_thailint_ignore(self, line_text: str) -> bool:
         """Check for generic thailint: ignore (no brackets)."""
@@ -312,10 +304,6 @@ class MagicNumberRule(MultiLanguageLintRule):  # thailint: ignore[srp]
         after_ignore = line_text.split("# thailint: ignore")[1].split("#")[0]
         return "[" not in after_ignore
 
-    def _has_noqa_directive(self, line_text: str) -> bool:
-        """Check for noqa-style comments."""
-        return "# noqa" in line_text
-
     def _check_typescript(
         self, context: BaseLintContext, config: MagicNumberConfig
     ) -> list[Violation]:
@@ -466,51 +454,4 @@ class MagicNumberRule(MultiLanguageLintRule):  # thailint: ignore[srp]
         Returns:
             True if should ignore
         """
-        # Check standard ignore directives
-        if self._ignore_parser.should_ignore_violation(violation, context.file_content or ""):
-            return True
-
-        # Check TypeScript-style comments
-        return self._check_typescript_ignore(violation, context)
-
-    def _check_typescript_ignore(self, violation: Violation, context: BaseLintContext) -> bool:
-        """Check for TypeScript-style ignore directives.
-
-        Args:
-            violation: Violation to check
-            context: Lint context
-
-        Returns:
-            True if line has ignore directive
-        """
-        line_text = self._get_violation_line(violation, context)
-        if line_text is None:
-            return False
-
-        # Check for // thailint: ignore or // noqa
-        return self._has_typescript_ignore_directive(line_text)
-
-    def _has_typescript_ignore_directive(self, line_text: str) -> bool:
-        """Check if line has TypeScript-style ignore directive.
-
-        Args:
-            line_text: Line text to check
-
-        Returns:
-            True if has ignore directive
-        """
-        # Check for // thailint: ignore[magic-numbers]
-        if "// thailint: ignore[magic-numbers]" in line_text:
-            return True
-
-        # Check for // thailint: ignore (generic)
-        if "// thailint: ignore" in line_text:
-            after_ignore = line_text.split("// thailint: ignore")[1].split("//")[0]
-            if "[" not in after_ignore:
-                return True
-
-        # Check for // noqa
-        if "// noqa" in line_text:
-            return True
-
-        return False
+        return self._typescript_ignore_checker.should_ignore(violation, context)

src/linters/magic_numbers/typescript_ignore_checker.py

@@ -0,0 +1,81 @@
+"""
+Purpose: TypeScript-specific ignore directive checking for magic numbers linter
+
+Scope: Ignore directive detection for TypeScript/JavaScript files
+
+Overview: Provides ignore directive checking functionality specifically for TypeScript and JavaScript
+    files in the magic numbers linter. Handles both thailint-style and noqa-style ignore comments
+    using TypeScript comment syntax (// instead of #). Extracted from linter.py to reduce file
+    size and improve modularity.
+
+Dependencies: IgnoreDirectiveParser from src.linter_config.ignore, Violation type, violation_utils
+
+Exports: TypeScriptIgnoreChecker class
+
+Interfaces: TypeScriptIgnoreChecker.should_ignore(violation, context) -> bool
+
+Implementation: Comment parsing with TypeScript-specific syntax handling, uses shared utilities
+"""
+
+from src.core.base import BaseLintContext
+from src.core.types import Violation
+from src.core.violation_utils import get_violation_line, has_typescript_noqa
+from src.linter_config.ignore import get_ignore_parser
+
+
+class TypeScriptIgnoreChecker:
+    """Checks for TypeScript-style ignore directives in magic numbers linter."""
+
+    def __init__(self) -> None:
+        """Initialize with standard ignore parser."""
+        self._ignore_parser = get_ignore_parser()
+
+    def should_ignore(self, violation: Violation, context: BaseLintContext) -> bool:
+        """Check if TypeScript violation should be ignored.
+
+        Args:
+            violation: Violation to check
+            context: Lint context
+
+        Returns:
+            True if should ignore
+        """
+        if self._ignore_parser.should_ignore_violation(violation, context.file_content or ""):
+            return True
+
+        return self._check_typescript_ignore(violation, context)
+
+    def _check_typescript_ignore(self, violation: Violation, context: BaseLintContext) -> bool:
+        """Check for TypeScript-style ignore directives.
+
+        Args:
+            violation: Violation to check
+            context: Lint context
+
+        Returns:
+            True if line has ignore directive
+        """
+        line_text = get_violation_line(violation, context)
+        if line_text is None:
+            return False
+
+        return self._has_typescript_ignore_directive(line_text)
+
+    def _has_typescript_ignore_directive(self, line_text: str) -> bool:
+        """Check if line has TypeScript-style ignore directive.
+
+        Args:
+            line_text: Line text to check
+
+        Returns:
+            True if has ignore directive
+        """
+        if "// thailint: ignore[magic-numbers]" in line_text:
+            return True
+
+        if "// thailint: ignore" in line_text:
+            after_ignore = line_text.split("// thailint: ignore")[1].split("//")[0]
+            if "[" not in after_ignore:
+                return True
+
+        return has_typescript_noqa(line_text)