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

src/linters/dry/inline_ignore.py

@@ -0,0 +1,140 @@
+"""
+Purpose: Inline ignore directive parsing for DRY linter
+
+Scope: Parses and tracks inline ignore directives in source files
+
+Overview: Parses source code for inline ignore directives (# dry: ignore-block, # dry: ignore-next).
+    Tracks line ranges that should be ignored based on directives. Used by violation_generator
+    to filter violations that fall within ignored ranges. Supports both block-level ignores
+    (entire block) and next-line ignores (next statement only).
+
+Dependencies: None (standalone utility)
+
+Exports: InlineIgnoreParser class
+
+Interfaces: InlineIgnoreParser.parse(content) -> dict, should_ignore(file_path, line) -> bool
+
+Implementation: Regex-based comment parsing, line range tracking
+"""
+
+import re
+from pathlib import Path
+
+
+class InlineIgnoreParser:
+    """Parses inline ignore directives from source code."""
+
+    def __init__(self) -> None:
+        """Initialize parser with ignore ranges tracking."""
+        self._ignore_ranges: dict[str, list[tuple[int, int]]] = {}
+
+    def parse_file(self, file_path: Path, content: str) -> None:
+        """Parse file for ignore directives and store ranges.
+
+        Args:
+            file_path: Path to the file
+            content: File content to parse
+        """
+        lines = content.split("\n")
+        ranges = self._extract_ignore_ranges(lines)
+
+        if ranges:
+            self._ignore_ranges[str(file_path)] = ranges
+
+    def _extract_ignore_ranges(self, lines: list[str]) -> list[tuple[int, int]]:
+        """Extract ignore ranges from lines.
+
+        Args:
+            lines: List of lines to process
+
+        Returns:
+            List of (start, end) tuples for ignore ranges
+        """
+        ranges = []
+
+        for i, line in enumerate(lines, start=1):
+            ignore_range = self._parse_ignore_directive(line, i, len(lines))
+            if ignore_range:
+                ranges.append(ignore_range)
+
+        return ranges
+
+    def _parse_ignore_directive(
+        self, line: str, line_num: int, total_lines: int
+    ) -> tuple[int, int] | None:
+        """Parse a single line for ignore directives.
+
+        Args:
+            line: Line content
+            line_num: Current line number
+            total_lines: Total number of lines
+
+        Returns:
+            (start, end) tuple if directive found, None otherwise
+        """
+        # Check for ignore-block directive
+        if re.search(r"#\s*dry:\s*ignore-block", line):
+            start = line_num + 1
+            end = min(line_num + 10, total_lines)
+            return (start, end)
+
+        # Check for ignore-next directive
+        if re.search(r"#\s*dry:\s*ignore-next", line):
+            return (line_num + 1, line_num + 1)
+
+        return None
+
+    def should_ignore(self, file_path: str, line: int, end_line: int | None = None) -> bool:
+        """Check if a line or range should be ignored.
+
+        Args:
+            file_path: Path to the file
+            line: Starting line number to check
+            end_line: Optional ending line number (for range check)
+
+        Returns:
+            True if line/range should be ignored
+        """
+        ranges = self._ignore_ranges.get(str(Path(file_path)), [])
+        if not ranges:
+            return False
+
+        if end_line is not None:
+            return self._check_range_overlap(line, end_line, ranges)
+
+        return self._check_single_line(line, ranges)
+
+    def _check_range_overlap(self, line: int, end_line: int, ranges: list[tuple[int, int]]) -> bool:
+        """Check if range overlaps with any ignore range.
+
+        Args:
+            line: Starting line number
+            end_line: Ending line number
+            ranges: List of ignore ranges
+
+        Returns:
+            True if ranges overlap
+        """
+        for ign_start, ign_end in ranges:
+            if line <= ign_end and end_line >= ign_start:
+                return True
+        return False
+
+    def _check_single_line(self, line: int, ranges: list[tuple[int, int]]) -> bool:
+        """Check if single line is in any ignore range.
+
+        Args:
+            line: Line number to check
+            ranges: List of ignore ranges
+
+        Returns:
+            True if line is in any range
+        """
+        for start, end in ranges:
+            if start <= line <= end:
+                return True
+        return False
+
+    def clear(self) -> None:
+        """Clear all stored ignore ranges."""
+        self._ignore_ranges.clear()

src/linters/dry/linter.py

@@ -0,0 +1,170 @@
+"""
+Purpose: Main DRY linter rule implementation with stateful caching
+
+Scope: DRYRule class implementing BaseLintRule interface for duplicate code detection
+
+Overview: Implements DRY linter rule following BaseLintRule interface with stateful caching design.
+    Orchestrates duplicate detection by delegating to specialized classes: ConfigLoader for config,
+    StorageInitializer for storage setup, FileAnalyzer for file analysis, and ViolationGenerator
+    for violation creation. Maintains minimal orchestration logic to comply with SRP (8 methods total).
+
+Dependencies: BaseLintRule, BaseLintContext, ConfigLoader, StorageInitializer, FileAnalyzer,
+    DuplicateStorage, ViolationGenerator
+
+Exports: DRYRule class
+
+Interfaces: DRYRule.check(context) -> list[Violation], finalize() -> list[Violation]
+
+Implementation: Delegates all logic to helper classes, maintains only orchestration and state
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from src.core.base import BaseLintContext, BaseLintRule
+from src.core.linter_utils import should_process_file
+from src.core.types import Violation
+
+from .config import DRYConfig
+from .config_loader import ConfigLoader
+from .duplicate_storage import DuplicateStorage
+from .file_analyzer import FileAnalyzer
+from .inline_ignore import InlineIgnoreParser
+from .storage_initializer import StorageInitializer
+from .violation_generator import ViolationGenerator
+
+if TYPE_CHECKING:
+    from .cache import CodeBlock, DRYCache
+
+
+@dataclass
+class DRYComponents:
+    """Component dependencies for DRY linter."""
+
+    config_loader: ConfigLoader
+    storage_initializer: StorageInitializer
+    file_analyzer: FileAnalyzer
+    violation_generator: ViolationGenerator
+    inline_ignore: InlineIgnoreParser
+
+
+class DRYRule(BaseLintRule):
+    """Detects duplicate code across project files."""
+
+    def __init__(self) -> None:
+        """Initialize the DRY rule with helper components."""
+        self._storage: DuplicateStorage | None = None
+        self._initialized = False
+        self._config: DRYConfig | None = None
+        self._file_analyzer: FileAnalyzer | None = None
+
+        # Helper components grouped to reduce instance attributes
+        self._helpers = DRYComponents(
+            config_loader=ConfigLoader(),
+            storage_initializer=StorageInitializer(),
+            file_analyzer=FileAnalyzer(),  # Placeholder, will be replaced with configured one
+            violation_generator=ViolationGenerator(),
+            inline_ignore=InlineIgnoreParser(),
+        )
+
+    @property
+    def rule_id(self) -> str:
+        """Unique identifier for this rule."""
+        return "dry.duplicate-code"
+
+    @property
+    def rule_name(self) -> str:
+        """Human-readable name for this rule."""
+        return "Duplicate Code"
+
+    @property
+    def description(self) -> str:
+        """Description of what this rule checks."""
+        return "Detects duplicate code blocks across the project"
+
+    def check(self, context: BaseLintContext) -> list[Violation]:
+        """Analyze file and store blocks (collection phase).
+
+        Args:
+            context: Lint context with file information
+
+        Returns:
+            Empty list (violations returned in finalize())
+        """
+        if not should_process_file(context):
+            return []
+
+        config = self._helpers.config_loader.load_config(context)
+        if not config.enabled:
+            return []
+
+        # Store config for finalize()
+        if self._config is None:
+            self._config = config
+
+        # Parse inline ignore directives from this file
+        file_path = Path(context.file_path)  # type: ignore[arg-type]
+        self._helpers.inline_ignore.parse_file(file_path, context.file_content or "")
+
+        self._ensure_storage_initialized(context, config)
+        self._analyze_and_store(context, config)
+
+        return []
+
+    def _ensure_storage_initialized(self, context: BaseLintContext, config: DRYConfig) -> None:
+        """Initialize storage and file analyzer on first call."""
+        if not self._initialized:
+            self._storage = self._helpers.storage_initializer.initialize(context, config)
+            # Create file analyzer with config for filter configuration
+            self._file_analyzer = FileAnalyzer(config)
+            self._initialized = True
+
+    def _analyze_and_store(self, context: BaseLintContext, config: DRYConfig) -> None:
+        """Analyze file and store blocks."""
+        # Guaranteed by _should_process_file check
+        if context.file_path is None or context.file_content is None:
+            return  # Should never happen due to should_process_file check
+
+        if not self._file_analyzer:
+            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
+        )
+
+        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."""
+        if self._storage:
+            self._storage.add_blocks_to_memory(file_path, blocks)
+
+    def finalize(self) -> list[Violation]:
+        """Generate violations after all files processed.
+
+        Returns:
+            List of all violations found across all files
+        """
+        if not self._storage or not self._config:
+            return []
+
+        violations = self._helpers.violation_generator.generate_violations(
+            self._storage, self.rule_id, self._config, self._helpers.inline_ignore
+        )
+
+        # Clear inline ignore cache for next run
+        self._helpers.inline_ignore.clear()
+
+        return violations