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

src/linters/dry/file_analyzer.py

@@ -1,45 +1,32 @@
 """
 Purpose: File analysis orchestration for duplicate detection
 
-Scope: Coordinates language-specific analyzers and cache checking
+Scope: Coordinates language-specific analyzers
 
-Overview: Orchestrates file analysis by delegating to language-specific analyzers (Python, TypeScript)
-    and checking cache freshness. Handles cache hits by loading from cache, and cache misses by
-    analyzing files. Separates file analysis orchestration from main linter rule logic to maintain
-    SRP compliance.
+Overview: Orchestrates file analysis by delegating to language-specific analyzers (Python, TypeScript).
+    Analyzes files fresh every run - no cache loading. Separates file analysis orchestration from
+    main linter rule logic to maintain SRP compliance.
 
-Dependencies: PythonDuplicateAnalyzer, TypeScriptDuplicateAnalyzer, DRYCache, DRYConfig, CodeBlock
+Dependencies: PythonDuplicateAnalyzer, TypeScriptDuplicateAnalyzer, DRYConfig, CodeBlock
 
 Exports: FileAnalyzer class
 
-Interfaces: FileAnalyzer.analyze_or_load(file_path, content, language, config, cache)
+Interfaces: FileAnalyzer.analyze(file_path, content, language, config)
 
-Implementation: Delegates to language-specific analyzers, checks cache freshness
+Implementation: Delegates to language-specific analyzers, always performs fresh analysis
 """
 
-from dataclasses import dataclass
 from pathlib import Path
 
 from .block_filter import BlockFilterRegistry, create_default_registry
-from .cache import CodeBlock, DRYCache
+from .cache import CodeBlock
 from .config import DRYConfig
 from .python_analyzer import PythonDuplicateAnalyzer
 from .typescript_analyzer import TypeScriptDuplicateAnalyzer
 
 
-@dataclass
-class FileAnalysisContext:
-    """Context for file analysis."""
-
-    file_path: Path
-    content: str
-    language: str
-    config: DRYConfig
-    cache: DRYCache | None
-
-
 class FileAnalyzer:
-    """Orchestrates file analysis with cache support."""
+    """Orchestrates file analysis for duplicate detection."""
 
     def __init__(self, config: DRYConfig | None = None) -> None:
         """Initialize with language-specific analyzers.
@@ -77,49 +64,25 @@ class FileAnalyzer:
 
         return registry
 
-    def analyze_or_load(  # pylint: disable=too-many-arguments,too-many-positional-arguments
+    def analyze(
         self,
         file_path: Path,
         content: str,
         language: str,
         config: DRYConfig,
-        cache: DRYCache | None = None,
     ) -> list[CodeBlock]:
-        """Analyze file or load from cache.
+        """Analyze file for duplicate code blocks.
 
         Args:
             file_path: Path to file
             content: File content
             language: File language
             config: DRY configuration
-            cache: Optional cache instance
 
         Returns:
             List of CodeBlock instances
         """
-        # Check if file is fresh in cache
-        if cache:
-            mtime = file_path.stat().st_mtime
-            if cache.is_fresh(file_path, mtime):
-                return cache.load(file_path)
-
         # Analyze file based on language
-        return self._analyze_file(file_path, content, language, config)
-
-    def _analyze_file(
-        self, file_path: Path, content: str, language: str, config: DRYConfig
-    ) -> list[CodeBlock]:
-        """Analyze file based on language.
-
-        Args:
-            file_path: Path to file
-            content: File content
-            language: File language
-            config: DRY configuration
-
-        Returns:
-            List of CodeBlock instances
-        """
         if language == "python":
             return self._python_analyzer.analyze(file_path, content, config)
         if language in ("typescript", "javascript"):

src/linters/dry/linter.py

@@ -37,7 +37,7 @@ from .storage_initializer import StorageInitializer
 from .violation_generator import ViolationGenerator
 
 if TYPE_CHECKING:
-    from .cache import CodeBlock, DRYCache
+    from .cache import CodeBlock
 
 
 @dataclass
@@ -132,24 +132,17 @@ class DRYRule(BaseLintRule):
             return  # Should never happen after initialization
 
         file_path = Path(context.file_path)
-        cache = self._get_cache()
-        blocks = self._file_analyzer.analyze_or_load(
-            file_path, context.file_content, context.language, config, cache
+        blocks = self._file_analyzer.analyze(
+            file_path, context.file_content, context.language, config
         )
 
         if blocks:
             self._store_blocks(file_path, blocks)
 
-    def _get_cache(self) -> DRYCache | None:
-        """Get cache from storage if available."""
-        if not self._storage:
-            return None
-        return self._storage._cache  # pylint: disable=protected-access
-
     def _store_blocks(self, file_path: Path, blocks: list[CodeBlock]) -> None:
-        """Store blocks in memory if storage available."""
+        """Store blocks in SQLite if storage available."""
         if self._storage:
-            self._storage.add_blocks_to_memory(file_path, blocks)
+            self._storage.add_blocks(file_path, blocks)
 
     def finalize(self) -> list[Violation]:
         """Generate violations after all files processed.

src/linters/dry/python_analyzer.py

@@ -38,6 +38,10 @@ from .block_filter import BlockFilterRegistry, create_default_registry
 from .cache import CodeBlock
 from .config import DRYConfig
 
+# AST context checking constants
+AST_LOOKBACK_LINES = 10
+AST_LOOKFORWARD_LINES = 5
+
 # Type alias for AST nodes that have line number attributes
 # All stmt and expr nodes have lineno and end_lineno after parsing
 ASTWithLineNumbers = ast.stmt | ast.expr
@@ -58,8 +62,15 @@ class PythonDuplicateAnalyzer(BaseTokenAnalyzer):  # thailint: ignore[srp.violat
         """
         super().__init__()
         self._filter_registry = filter_registry or create_default_registry()
-
-    def analyze(self, file_path: Path, content: str, config: DRYConfig) -> list[CodeBlock]:
+        # Performance optimization: Cache parsed AST to avoid re-parsing for each hash window
+        self._cached_ast: ast.Module | None = None
+        self._cached_content: str | None = None
+        # Performance optimization: Line-to-node index for O(1) lookups instead of O(n) ast.walk()
+        self._line_to_nodes: dict[int, list[ast.AST]] | None = None
+
+    def analyze(  # thailint: ignore[nesting.excessive-depth]
+        self, file_path: Path, content: str, config: DRYConfig
+    ) -> list[CodeBlock]:
         """Analyze Python file for duplicate code blocks, excluding docstrings.
 
         Args:
@@ -70,37 +81,73 @@ class PythonDuplicateAnalyzer(BaseTokenAnalyzer):  # thailint: ignore[srp.violat
         Returns:
             List of CodeBlock instances with hash values
         """
-        # Get docstring line ranges
-        docstring_ranges = self._get_docstring_ranges_from_content(content)
+        # Performance optimization: Parse AST once and cache for _is_single_statement_in_source() calls
+        self._cached_ast = self._parse_content_safe(content)
+        self._cached_content = content
+
+        # Performance optimization: Build line-to-node index for O(1) lookups
+        self._line_to_nodes = self._build_line_to_node_index(self._cached_ast)
+
+        try:
+            # Get docstring line ranges
+            docstring_ranges = self._get_docstring_ranges_from_content(content)
+
+            # Tokenize with line number tracking
+            lines_with_numbers = self._tokenize_with_line_numbers(content, docstring_ranges)
 
-        # Tokenize with line number tracking
-        lines_with_numbers = self._tokenize_with_line_numbers(content, docstring_ranges)
+            # Generate rolling hash windows
+            windows = self._rolling_hash_with_tracking(
+                lines_with_numbers, config.min_duplicate_lines
+            )
 
-        # Generate rolling hash windows
-        windows = self._rolling_hash_with_tracking(lines_with_numbers, config.min_duplicate_lines)
+            return self._filter_valid_blocks(windows, file_path, content)
+        finally:
+            # Clear cache after analysis to avoid memory leaks
+            self._cached_ast = None
+            self._cached_content = None
+            self._line_to_nodes = None
 
+    def _filter_valid_blocks(
+        self,
+        windows: list[tuple[int, int, int, str]],
+        file_path: Path,
+        content: str,
+    ) -> list[CodeBlock]:
+        """Filter hash windows and create valid CodeBlock instances."""
         blocks = []
         for hash_val, start_line, end_line, snippet in windows:
-            # Skip blocks that are single logical statements
-            # Check the original source code, not the normalized snippet
-            if self._is_single_statement_in_source(content, start_line, end_line):
-                continue
-
-            block = CodeBlock(
-                file_path=file_path,
-                start_line=start_line,
-                end_line=end_line,
-                snippet=snippet,
-                hash_value=hash_val,
+            block = self._create_block_if_valid(
+                file_path, content, hash_val, start_line, end_line, snippet
             )
+            if block:
+                blocks.append(block)
+        return blocks
 
-            # Apply extensible filters (keyword arguments, imports, etc.)
-            if self._filter_registry.should_filter_block(block, content):
-                continue
+    def _create_block_if_valid(  # pylint: disable=too-many-arguments,too-many-positional-arguments
+        self,
+        file_path: Path,
+        content: str,
+        hash_val: int,
+        start_line: int,
+        end_line: int,
+        snippet: str,
+    ) -> CodeBlock | None:
+        """Create CodeBlock if it passes all validation checks."""
+        if self._is_single_statement_in_source(content, start_line, end_line):
+            return None
 
-            blocks.append(block)
+        block = CodeBlock(
+            file_path=file_path,
+            start_line=start_line,
+            end_line=end_line,
+            snippet=snippet,
+            hash_value=hash_val,
+        )
 
-        return blocks
+        if self._filter_registry.should_filter_block(block, content):
+            return None
+
+        return block
 
     def _get_docstring_ranges_from_content(self, content: str) -> set[int]:
         """Extract line numbers that are part of docstrings.
@@ -168,20 +215,21 @@ class PythonDuplicateAnalyzer(BaseTokenAnalyzer):  # thailint: ignore[srp.violat
             List of (original_line_number, normalized_code) tuples
         """
         lines_with_numbers = []
+        in_multiline_import = False
 
         for line_num, line in enumerate(content.split("\n"), start=1):
-            # Skip docstring lines
             if line_num in docstring_lines:
                 continue
 
-            # Use hasher's existing tokenization logic
-            line = self._hasher._strip_comments(line)  # pylint: disable=protected-access
-            line = " ".join(line.split())
-
+            line = self._hasher._normalize_line(line)  # pylint: disable=protected-access
             if not line:
                 continue
 
-            if self._hasher._is_import_statement(line):  # pylint: disable=protected-access
+            # Update multi-line import state and check if line should be skipped
+            in_multiline_import, should_skip = self._hasher._should_skip_import_line(  # pylint: disable=protected-access
+                line, in_multiline_import
+            )
+            if should_skip:
                 continue
 
             lines_with_numbers.append((line_num, line))
@@ -221,10 +269,20 @@ class PythonDuplicateAnalyzer(BaseTokenAnalyzer):  # thailint: ignore[srp.violat
         return hashes
 
     def _is_single_statement_in_source(self, content: str, start_line: int, end_line: int) -> bool:
-        """Check if a line range in the original source is a single logical statement."""
-        tree = self._parse_content_safe(content)
-        if tree is None:
-            return False
+        """Check if a line range in the original source is a single logical statement.
+
+        Performance optimization: Uses cached AST if available (set by analyze() method)
+        to avoid re-parsing the entire file for each hash window check.
+        """
+        # Use cached AST if available and content matches
+        tree: ast.Module | None
+        if self._cached_ast is not None and content == self._cached_content:
+            tree = self._cached_ast
+        else:
+            # Fallback: parse content (used by tests or standalone calls)
+            tree = self._parse_content_safe(content)
+            if tree is None:
+                return False
 
         return self._check_overlapping_nodes(tree, start_line, end_line)
 
@@ -236,13 +294,99 @@ class PythonDuplicateAnalyzer(BaseTokenAnalyzer):  # thailint: ignore[srp.violat
         except SyntaxError:
             return None
 
+    @staticmethod
+    def _build_line_to_node_index(tree: ast.Module | None) -> dict[int, list[ast.AST]] | None:
+        """Build an index mapping each line number to overlapping AST nodes.
+
+        Performance optimization: This allows O(1) lookups instead of O(n) ast.walk() calls.
+        For a file with 5,144 nodes and 673 hash windows, this reduces 3.46M node operations
+        to just ~3,365 relevant node checks (99.9% reduction).
+
+        Args:
+            tree: Parsed AST tree (None if parsing failed)
+
+        Returns:
+            Dictionary mapping line numbers to list of AST nodes overlapping that line,
+            or None if tree is None
+        """
+        if tree is None:
+            return None
+
+        line_to_nodes: dict[int, list[ast.AST]] = {}
+        for node in ast.walk(tree):
+            if PythonDuplicateAnalyzer._node_has_line_info(node):
+                PythonDuplicateAnalyzer._add_node_to_index(node, line_to_nodes)
+
+        return line_to_nodes
+
+    @staticmethod
+    def _node_has_line_info(node: ast.AST) -> bool:
+        """Check if node has valid line number information."""
+        if not hasattr(node, "lineno") or not hasattr(node, "end_lineno"):
+            return False
+        return node.lineno is not None and node.end_lineno is not None
+
+    @staticmethod
+    def _add_node_to_index(node: ast.AST, line_to_nodes: dict[int, list[ast.AST]]) -> None:
+        """Add node to all lines it overlaps in the index."""
+        for line_num in range(node.lineno, node.end_lineno + 1):  # type: ignore[attr-defined]
+            if line_num not in line_to_nodes:
+                line_to_nodes[line_num] = []
+            line_to_nodes[line_num].append(node)
+
     def _check_overlapping_nodes(self, tree: ast.Module, start_line: int, end_line: int) -> bool:
-        """Check if any AST node overlaps and matches single-statement pattern."""
+        """Check if any AST node overlaps and matches single-statement pattern.
+
+        Performance optimization: Use line-to-node index for O(1) lookups instead of O(n) ast.walk().
+        """
+        if self._line_to_nodes is not None:
+            return self._check_nodes_via_index(start_line, end_line)
+        return self._check_nodes_via_walk(tree, start_line, end_line)
+
+    def _check_nodes_via_index(self, start_line: int, end_line: int) -> bool:
+        """Check nodes using line-to-node index for O(1) lookups."""
+        candidates = self._collect_candidate_nodes_from_index(start_line, end_line)
+        return self._any_node_matches_pattern(candidates, start_line, end_line)
+
+    def _collect_candidate_nodes_from_index(self, start_line: int, end_line: int) -> set[ast.AST]:
+        """Collect unique nodes that overlap with the line range from index."""
+        candidate_nodes: set[ast.AST] = set()
+        for line_num in range(start_line, end_line + 1):
+            if self._line_to_nodes and line_num in self._line_to_nodes:
+                candidate_nodes.update(self._line_to_nodes[line_num])
+        return candidate_nodes
+
+    def _any_node_matches_pattern(
+        self, nodes: set[ast.AST], start_line: int, end_line: int
+    ) -> bool:
+        """Check if any node matches single-statement pattern."""
+        for node in nodes:
+            if self._is_single_statement_pattern(node, start_line, end_line):
+                return True
+        return False
+
+    def _check_nodes_via_walk(self, tree: ast.Module, start_line: int, end_line: int) -> bool:
+        """Check nodes using ast.walk() fallback for tests or standalone calls."""
         for node in ast.walk(tree):
-            if self._node_overlaps_and_matches(node, start_line, end_line):
+            if self._node_matches_via_walk(node, start_line, end_line):
                 return True
         return False
 
+    def _node_matches_via_walk(self, node: ast.AST, start_line: int, end_line: int) -> bool:
+        """Check if a single node overlaps and matches pattern."""
+        if not self._node_overlaps_range(node, start_line, end_line):
+            return False
+        return self._is_single_statement_pattern(node, start_line, end_line)
+
+    @staticmethod
+    def _node_overlaps_range(node: ast.AST, start_line: int, end_line: int) -> bool:
+        """Check if node overlaps with the given line range."""
+        if not hasattr(node, "lineno") or not hasattr(node, "end_lineno"):
+            return False
+        node_end = node.end_lineno
+        node_start = node.lineno
+        return not (node_end < start_line or node_start > end_line)
+
     def _node_overlaps_and_matches(self, node: ast.AST, start_line: int, end_line: int) -> bool:
         """Check if node overlaps with range and matches single-statement pattern."""
         if not hasattr(node, "lineno") or not hasattr(node, "end_lineno"):
@@ -514,4 +658,11 @@ class PythonDuplicateAnalyzer(BaseTokenAnalyzer):  # thailint: ignore[srp.violat
                     return True
             return False
 
-        return self._check_ast_context(lines, start_line, end_line, 10, 5, is_within_class_body)
+        return self._check_ast_context(
+            lines,
+            start_line,
+            end_line,
+            AST_LOOKBACK_LINES,
+            AST_LOOKFORWARD_LINES,
+            is_within_class_body,
+        )

src/linters/dry/storage_initializer.py

@@ -1,23 +1,21 @@
 """
 Purpose: Storage initialization for DRY linter
 
-Scope: Initializes DuplicateStorage with cache or in-memory fallback
+Scope: Initializes DuplicateStorage with SQLite storage
 
-Overview: Handles storage initialization based on DRY configuration. Creates SQLite cache when
-    cache_enabled is true, or triggers in-memory fallback when false (Decision 6). Separates
-    initialization logic from main linter rule to maintain SRP compliance.
+Overview: Handles storage initialization based on DRY configuration. Creates SQLite storage in
+    either memory or tempfile mode based on config.storage_mode. Separates initialization logic
+    from main linter rule to maintain SRP compliance.
 
-Dependencies: BaseLintContext, DRYConfig, DRYCache, DuplicateStorage, Path
+Dependencies: BaseLintContext, DRYConfig, DRYCache, DuplicateStorage
 
 Exports: StorageInitializer class
 
 Interfaces: StorageInitializer.initialize(context, config) -> DuplicateStorage
 
-Implementation: Creates cache if enabled, delegates to DuplicateStorage for storage management
+Implementation: Creates DRYCache with storage_mode, delegates to DuplicateStorage for management
 """
 
-from pathlib import Path
-
 from src.core.base import BaseLintContext
 
 from .cache import DRYCache
@@ -36,16 +34,9 @@ class StorageInitializer:
             config: DRY configuration
 
         Returns:
-            DuplicateStorage instance
+            DuplicateStorage instance with SQLite storage
         """
-        cache = None
-        if config.cache_enabled:
-            # Use SQLite cache
-            metadata = getattr(context, "metadata", {})
-            project_root = metadata.get("_project_root", Path.cwd())
-            cache_path = project_root / config.cache_path
-            cache_path.parent.mkdir(parents=True, exist_ok=True)
-            cache = DRYCache(cache_path)
-        # else: cache = None triggers in-memory fallback in DuplicateStorage
+        # Create SQLite storage (in-memory or tempfile based on config)
+        cache = DRYCache(storage_mode=config.storage_mode)
 
         return DuplicateStorage(cache)

src/linters/dry/token_hasher.py

@@ -33,26 +33,80 @@ class TokenHasher:
             List of normalized code lines (non-empty, comments removed, imports filtered)
         """
         lines = []
+        in_multiline_import = False
 
         for line in code.split("\n"):
-            # Remove comments (language-specific logic can be added)
-            line = self._strip_comments(line)
-
-            # Normalize whitespace (collapse to single space)
-            line = " ".join(line.split())
-
-            # Skip empty lines
+            line = self._normalize_line(line)
             if not line:
                 continue
 
-            # Skip import statements (common false positive)
-            if self._is_import_statement(line):
+            # Update multi-line import state and check if line should be skipped
+            in_multiline_import, should_skip = self._should_skip_import_line(
+                line, in_multiline_import
+            )
+            if should_skip:
                 continue
 
             lines.append(line)
 
         return lines
 
+    def _normalize_line(self, line: str) -> str:
+        """Normalize a line by removing comments and excess whitespace.
+
+        Args:
+            line: Raw source code line
+
+        Returns:
+            Normalized line (empty string if line has no content)
+        """
+        line = self._strip_comments(line)
+        return " ".join(line.split())
+
+    def _should_skip_import_line(self, line: str, in_multiline_import: bool) -> tuple[bool, bool]:
+        """Determine if an import line should be skipped.
+
+        Args:
+            line: Normalized code line
+            in_multiline_import: Whether we're currently inside a multi-line import
+
+        Returns:
+            Tuple of (new_in_multiline_import_state, should_skip_line)
+        """
+        if self._is_multiline_import_start(line):
+            return True, True
+
+        if in_multiline_import:
+            return self._handle_multiline_import_continuation(line)
+
+        if self._is_import_statement(line):
+            return False, True
+
+        return False, False
+
+    def _is_multiline_import_start(self, line: str) -> bool:
+        """Check if line starts a multi-line import statement.
+
+        Args:
+            line: Normalized code line
+
+        Returns:
+            True if line starts a multi-line import (has opening paren but no closing)
+        """
+        return self._is_import_statement(line) and "(" in line and ")" not in line
+
+    def _handle_multiline_import_continuation(self, line: str) -> tuple[bool, bool]:
+        """Handle a line that's part of a multi-line import.
+
+        Args:
+            line: Normalized code line inside a multi-line import
+
+        Returns:
+            Tuple of (still_in_import, should_skip)
+        """
+        closes_import = ")" in line
+        return not closes_import, True
+
     def _strip_comments(self, line: str) -> str:
         """Remove comments from line (Python # and // style).
 

src/linters/dry/typescript_analyzer.py

@@ -186,20 +186,22 @@ class TypeScriptDuplicateAnalyzer(BaseTokenAnalyzer):  # thailint: ignore[srp.vi
             List of (original_line_number, normalized_code) tuples
         """
         lines_with_numbers = []
+        in_multiline_import = False
 
         for line_num, line in enumerate(content.split("\n"), start=1):
             # Skip JSDoc comment lines
             if line_num in jsdoc_lines:
                 continue
 
-            # Use hasher's existing tokenization logic
-            line = self._hasher._strip_comments(line)  # pylint: disable=protected-access
-            line = " ".join(line.split())
-
+            line = self._hasher._normalize_line(line)  # pylint: disable=protected-access
             if not line:
                 continue
 
-            if self._hasher._is_import_statement(line):  # pylint: disable=protected-access
+            # Update multi-line import state and check if line should be skipped
+            in_multiline_import, should_skip = self._hasher._should_skip_import_line(  # pylint: disable=protected-access
+                line, in_multiline_import
+            )
+            if should_skip:
                 continue
 
             lines_with_numbers.append((line_num, line))

src/linters/dry/violation_filter.py

@@ -18,6 +18,9 @@ Implementation: Iterates through sorted violations, keeps first of each overlapp
 
 from src.core.types import Violation
 
+# Default fallback for line count when parsing fails
+DEFAULT_FALLBACK_LINE_COUNT = 5
+
 
 class ViolationFilter:
     """Filters overlapping violations."""
@@ -88,4 +91,4 @@ class ViolationFilter:
             end = message.index(" lines")
             return int(message[start:end])
         except (ValueError, IndexError):
-            return 5  # Default fallback
+            return DEFAULT_FALLBACK_LINE_COUNT  # Default fallback

src/linters/file_header/__init__.py

@@ -0,0 +1,24 @@
+"""
+File: src/linters/file_header/__init__.py
+Purpose: File header linter module initialization
+Exports: FileHeaderRule
+Depends: linter.FileHeaderRule
+Implements: Module-level exports for clean API
+Related: linter.py for main rule implementation
+
+Overview:
+    Initializes the file header linter module providing multi-language file header
+    validation with mandatory field checking, atemporal language detection, and configuration
+    support. Main entry point for file header linting functionality.
+
+Usage:
+    from src.linters.file_header import FileHeaderRule
+    rule = FileHeaderRule()
+    violations = rule.check(context)
+
+Notes: Follows standard Python module initialization pattern with __all__ export control
+"""
+
+from .linter import FileHeaderRule
+
+__all__ = ["FileHeaderRule"]