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

src/linter_config/loader.py

@@ -25,11 +25,10 @@ Implementation: Extension-based format detection (.yaml/.yml vs .json), yaml.saf
     for security, empty dict handling for null YAML, ValueError for unsupported formats
 """
 
-import json
 from pathlib import Path
 from typing import Any
 
-import yaml
+from src.core.config_parser import parse_config_file
 
 
 class LinterConfigLoader:
@@ -49,21 +48,12 @@ class LinterConfigLoader:
             Configuration dictionary.
 
         Raises:
-            ValueError: If file format is unsupported.
-            yaml.YAMLError: If YAML is malformed.
-            json.JSONDecodeError: If JSON is malformed.
+            ConfigParseError: If file format is unsupported or parsing fails.
         """
         if not config_path.exists():
             return self.get_defaults()
 
-        suffix = config_path.suffix.lower()
-
-        with config_path.open(encoding="utf-8") as f:
-            if suffix in [".yaml", ".yml"]:
-                return yaml.safe_load(f) or {}
-            if suffix == ".json":
-                return json.load(f)
-            raise ValueError(f"Unsupported config format: {suffix}")
+        return parse_config_file(config_path)
 
     def get_defaults(self) -> dict[str, Any]:
         """Get default configuration.

src/linters/dry/__init__.py

@@ -0,0 +1,23 @@
+"""
+Purpose: DRY (Don't Repeat Yourself) linter module exports
+
+Scope: Module-level exports for DRY linter components
+
+Overview: Provides centralized exports for the DRY linter module components. Exposes the main
+    DRYRule class for duplicate code detection, configuration dataclass, and analyzer components.
+    Simplifies imports for consumers by providing a single import point for all DRY linter
+    functionality. Follows the established pattern from nesting and SRP linters.
+
+Dependencies: linter.DRYRule, config.DRYConfig
+
+Exports: DRYRule (main rule class), DRYConfig (configuration)
+
+Interfaces: Module-level __all__ list defining public API
+
+Implementation: Standard Python module with explicit exports via __all__
+"""
+
+from .config import DRYConfig
+from .linter import DRYRule
+
+__all__ = ["DRYRule", "DRYConfig"]

src/linters/dry/base_token_analyzer.py

@@ -0,0 +1,76 @@
+"""
+Purpose: Base class for token-based duplicate code analysis
+
+Scope: Common duplicate detection workflow for Python and TypeScript analyzers
+
+Overview: Provides shared infrastructure for token-based duplicate code detection across different
+    programming languages. Implements common workflow of tokenization, rolling hash window generation,
+    and CodeBlock creation. Subclasses provide language-specific filtering (e.g., interface filtering
+    for TypeScript). Eliminates duplication between PythonDuplicateAnalyzer and TypeScriptDuplicateAnalyzer
+    by extracting shared analyze() method pattern and CodeBlock creation logic.
+
+Dependencies: TokenHasher, CodeBlock, DRYConfig, pathlib.Path
+
+Exports: BaseTokenAnalyzer class
+
+Interfaces: BaseTokenAnalyzer.analyze(file_path: Path, content: str, config: DRYConfig) -> list[CodeBlock]
+
+Implementation: Template method pattern with extension point for language-specific block filtering
+"""
+
+from pathlib import Path
+
+from .cache import CodeBlock
+from .config import DRYConfig
+from .token_hasher import TokenHasher
+
+
+class BaseTokenAnalyzer:
+    """Base analyzer for token-based duplicate detection."""
+
+    def __init__(self) -> None:
+        """Initialize analyzer with token hasher."""
+        self._hasher = TokenHasher()
+
+    def analyze(self, file_path: Path, content: str, config: DRYConfig) -> list[CodeBlock]:
+        """Analyze file for duplicate code blocks.
+
+        Args:
+            file_path: Path to source file
+            content: File content
+            config: DRY configuration
+
+        Returns:
+            List of CodeBlock instances with hash values
+        """
+        lines = self._hasher.tokenize(content)
+        windows = self._hasher.rolling_hash(lines, config.min_duplicate_lines)
+
+        blocks = []
+        for hash_val, start_line, end_line, snippet in windows:
+            if self._should_include_block(content, start_line, end_line):
+                block = CodeBlock(
+                    file_path=file_path,
+                    start_line=start_line,
+                    end_line=end_line,
+                    snippet=snippet,
+                    hash_value=hash_val,
+                )
+                blocks.append(block)
+
+        return blocks
+
+    def _should_include_block(self, content: str, start_line: int, end_line: int) -> bool:
+        """Determine if block should be included.
+
+        Extension point for language-specific filtering.
+
+        Args:
+            content: File content
+            start_line: Block start line
+            end_line: Block end line
+
+        Returns:
+            True if block should be included, False to filter out
+        """
+        return True

src/linters/dry/block_filter.py

@@ -0,0 +1,262 @@
+"""
+Purpose: Extensible filter system for DRY duplicate detection
+
+Scope: Filters out false positive duplications (API boilerplate, keyword arguments, etc.)
+
+Overview: Provides an extensible architecture for filtering duplicate code blocks that are
+    not meaningful duplications. Includes base filter interface and built-in filters for
+    common false positive patterns like keyword-only function arguments, import groups,
+    and API call boilerplate. New filters can be added by subclassing BaseBlockFilter.
+
+Dependencies: ast, re, typing
+
+Exports: BaseBlockFilter, BlockFilterRegistry, KeywordArgumentFilter, ImportGroupFilter
+
+Interfaces: BaseBlockFilter.should_filter(code_block, file_content) -> bool
+
+Implementation: Strategy pattern with filter registry for extensibility
+"""
+
+import ast
+import re
+from abc import ABC, abstractmethod
+from pathlib import Path
+from typing import Protocol
+
+
+class CodeBlock(Protocol):
+    """Protocol for code blocks (matches cache.CodeBlock)."""
+
+    file_path: Path
+    start_line: int
+    end_line: int
+    snippet: str
+    hash_value: int
+
+
+class BaseBlockFilter(ABC):
+    """Base class for duplicate block filters."""
+
+    @abstractmethod
+    def should_filter(self, block: CodeBlock, file_content: str) -> bool:
+        """Determine if a code block should be filtered out.
+
+        Args:
+            block: Code block to evaluate
+            file_content: Full file content for context
+
+        Returns:
+            True if block should be filtered (not reported as duplicate)
+        """
+        pass
+
+    @abstractmethod
+    def get_name(self) -> str:
+        """Get filter name for configuration and logging."""
+        pass
+
+
+class KeywordArgumentFilter(BaseBlockFilter):
+    """Filters blocks that are primarily keyword arguments in function calls.
+
+    Detects patterns like:
+        message=message,
+        severity=Severity.ERROR,
+        suggestion=suggestion,
+
+    These are common in builder patterns and API calls.
+    """
+
+    def __init__(self, threshold: float = 0.8):
+        """Initialize filter.
+
+        Args:
+            threshold: Minimum percentage of lines that must be keyword args (0.0-1.0)
+        """
+        self.threshold = threshold
+        # Pattern: optional whitespace, identifier, =, value, optional comma
+        self._kwarg_pattern = re.compile(r"^\s*\w+\s*=\s*.+,?\s*$")
+
+    def should_filter(self, block: CodeBlock, file_content: str) -> bool:
+        """Check if block is primarily keyword arguments.
+
+        Args:
+            block: Code block to evaluate
+            file_content: Full file content for context
+
+        Returns:
+            True if block should be filtered
+        """
+        lines = file_content.split("\n")[block.start_line - 1 : block.end_line]
+
+        if not lines:
+            return False
+
+        # Count lines that match keyword argument pattern
+        kwarg_lines = sum(1 for line in lines if self._kwarg_pattern.match(line))
+
+        # Filter if most lines are keyword arguments
+        ratio = kwarg_lines / len(lines)
+        if ratio >= self.threshold:
+            return self._is_inside_function_call(block, file_content)
+
+        return False
+
+    def _is_inside_function_call(self, block: CodeBlock, file_content: str) -> bool:
+        """Verify the block is inside a function call, not standalone code."""
+        try:
+            tree = ast.parse(file_content)
+        except SyntaxError:
+            return False
+
+        # Find if any Call node contains the block
+        for node in ast.walk(tree):
+            if isinstance(node, ast.Call) and self._check_multiline_containment(node, block):
+                return True
+        return False
+
+    @staticmethod
+    def _check_multiline_containment(node: ast.Call, block: CodeBlock) -> bool:
+        """Check if Call node is multiline and contains block."""
+        if not KeywordArgumentFilter._has_valid_line_info(node):
+            return False
+
+        # After validation, these are guaranteed to be non-None integers
+        # Use type: ignore to suppress MyPy's inability to understand runtime validation
+        is_multiline = node.lineno < node.end_lineno  # type: ignore[operator]
+        contains_block = (
+            node.lineno <= block.start_line and node.end_lineno >= block.end_line  # type: ignore[operator]
+        )
+        return is_multiline and contains_block
+
+    @staticmethod
+    def _has_valid_line_info(node: ast.Call) -> bool:
+        """Check if node has valid line information.
+
+        Args:
+            node: AST Call node to check
+
+        Returns:
+            True if node has valid line number attributes
+        """
+        if not hasattr(node, "lineno"):
+            return False
+        if not hasattr(node, "end_lineno"):
+            return False
+        if node.lineno is None:
+            return False
+        if node.end_lineno is None:
+            return False
+        return True
+
+    def get_name(self) -> str:
+        """Get filter name."""
+        return "keyword_argument_filter"
+
+
+class ImportGroupFilter(BaseBlockFilter):
+    """Filters blocks that are just import statements.
+
+    Import organization often creates similar patterns that aren't meaningful duplication.
+    """
+
+    def should_filter(self, block: CodeBlock, file_content: str) -> bool:
+        """Check if block is only import statements.
+
+        Args:
+            block: Code block to evaluate
+            file_content: Full file content
+
+        Returns:
+            True if block should be filtered
+        """
+        lines = file_content.split("\n")[block.start_line - 1 : block.end_line]
+
+        for line in lines:
+            stripped = line.strip()
+            if not stripped:
+                continue
+            if not (stripped.startswith("import ") or stripped.startswith("from ")):
+                return False
+
+        return True
+
+    def get_name(self) -> str:
+        """Get filter name."""
+        return "import_group_filter"
+
+
+class BlockFilterRegistry:
+    """Registry for managing duplicate block filters."""
+
+    def __init__(self) -> None:
+        """Initialize empty registry."""
+        self._filters: list[BaseBlockFilter] = []
+        self._enabled_filters: set[str] = set()
+
+    def register(self, filter_instance: BaseBlockFilter) -> None:
+        """Register a filter.
+
+        Args:
+            filter_instance: Filter to register
+        """
+        self._filters.append(filter_instance)
+        self._enabled_filters.add(filter_instance.get_name())
+
+    def enable_filter(self, filter_name: str) -> None:
+        """Enable a specific filter by name.
+
+        Args:
+            filter_name: Name of filter to enable
+        """
+        self._enabled_filters.add(filter_name)
+
+    def disable_filter(self, filter_name: str) -> None:
+        """Disable a specific filter by name.
+
+        Args:
+            filter_name: Name of filter to disable
+        """
+        self._enabled_filters.discard(filter_name)
+
+    def should_filter_block(self, block: CodeBlock, file_content: str) -> bool:
+        """Check if any enabled filter wants to filter this block.
+
+        Args:
+            block: Code block to evaluate
+            file_content: Full file content
+
+        Returns:
+            True if block should be filtered out
+        """
+        for filter_instance in self._filters:
+            if filter_instance.get_name() not in self._enabled_filters:
+                continue
+
+            if filter_instance.should_filter(block, file_content):
+                return True
+
+        return False
+
+    def get_enabled_filters(self) -> list[str]:
+        """Get list of enabled filter names.
+
+        Returns:
+            List of enabled filter names
+        """
+        return sorted(self._enabled_filters)
+
+
+def create_default_registry() -> BlockFilterRegistry:
+    """Create registry with default filters.
+
+    Returns:
+        BlockFilterRegistry with common filters registered
+    """
+    registry = BlockFilterRegistry()
+
+    # Register built-in filters
+    registry.register(KeywordArgumentFilter(threshold=0.8))
+    registry.register(ImportGroupFilter())
+
+    return registry

src/linters/dry/block_grouper.py

@@ -0,0 +1,59 @@
+"""
+Purpose: Block grouping utilities for duplicate detection
+
+Scope: Groups code blocks by file path
+
+Overview: Provides grouping utilities for organizing code blocks by file. Used by ViolationDeduplicator
+    to process blocks on a per-file basis for overlap detection. Separates grouping logic to maintain
+    SRP compliance.
+
+Dependencies: CodeBlock, Violation
+
+Exports: BlockGrouper class
+
+Interfaces: BlockGrouper.group_blocks_by_file(blocks), group_violations_by_file(violations)
+
+Implementation: Simple dictionary-based grouping by file path
+"""
+
+from pathlib import Path
+
+from src.core.types import Violation
+
+from .cache import CodeBlock
+
+
+class BlockGrouper:
+    """Groups blocks and violations by file path."""
+
+    def group_blocks_by_file(self, blocks: list[CodeBlock]) -> dict[Path, list[CodeBlock]]:
+        """Group blocks by file path.
+
+        Args:
+            blocks: List of code blocks
+
+        Returns:
+            Dictionary mapping file paths to lists of blocks
+        """
+        grouped: dict[Path, list[CodeBlock]] = {}
+        for block in blocks:
+            if block.file_path not in grouped:
+                grouped[block.file_path] = []
+            grouped[block.file_path].append(block)
+        return grouped
+
+    def group_violations_by_file(self, violations: list[Violation]) -> dict[str, list[Violation]]:
+        """Group violations by file path.
+
+        Args:
+            violations: List of violations
+
+        Returns:
+            Dictionary mapping file paths to lists of violations
+        """
+        grouped: dict[str, list[Violation]] = {}
+        for violation in violations:
+            if violation.file_path not in grouped:
+                grouped[violation.file_path] = []
+            grouped[violation.file_path].append(violation)
+        return grouped

src/linters/dry/cache.py

@@ -0,0 +1,218 @@
+"""
+Purpose: SQLite cache manager for DRY linter with mtime-based invalidation
+
+Scope: Code block storage, cache operations, and duplicate detection queries
+
+Overview: Implements persistent caching layer for duplicate code detection using SQLite database.
+    Stores code blocks with hash values, file locations, and metadata. Provides mtime-based cache
+    invalidation to detect stale entries. Serves dual purpose as both cache (avoid re-hashing) and
+    hash table (query duplicates across project). Includes indexes for fast hash lookups enabling
+    cross-file duplicate detection with minimal overhead.
+
+Dependencies: Python sqlite3 module (stdlib), pathlib.Path, dataclasses
+
+Exports: CodeBlock dataclass, DRYCache class
+
+Interfaces: DRYCache.__init__, is_fresh, load, save, find_duplicates_by_hash, get_blocks_for_file,
+    add_blocks, cleanup_stale, close
+
+Implementation: SQLite with two tables (files, code_blocks), indexed on hash_value for performance,
+    ACID transactions for reliability, foreign key constraints for data integrity
+"""
+
+import sqlite3
+from dataclasses import dataclass
+from pathlib import Path
+
+from .cache_query import CacheQueryService
+
+
+@dataclass
+class CodeBlock:
+    """Represents a code block location with hash."""
+
+    file_path: Path
+    start_line: int
+    end_line: int
+    snippet: str
+    hash_value: int
+
+
+class DRYCache:
+    """SQLite-backed cache for duplicate detection."""
+
+    SCHEMA_VERSION = 1
+
+    def __init__(self, cache_path: Path) -> None:
+        """Initialize cache with SQLite database.
+
+        Args:
+            cache_path: Path to SQLite database file
+        """
+        # Ensure parent directory exists
+        cache_path.parent.mkdir(parents=True, exist_ok=True)
+
+        self.db = sqlite3.connect(str(cache_path))
+        self._query_service = CacheQueryService()
+
+        # Create schema
+        self.db.execute(
+            """CREATE TABLE IF NOT EXISTS files (
+                file_path TEXT PRIMARY KEY,
+                mtime REAL NOT NULL,
+                hash_count INTEGER,
+                last_scanned TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+            )"""
+        )
+
+        self.db.execute(
+            """CREATE TABLE IF NOT EXISTS code_blocks (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                file_path TEXT NOT NULL,
+                hash_value INTEGER NOT NULL,
+                start_line INTEGER NOT NULL,
+                end_line INTEGER NOT NULL,
+                snippet TEXT NOT NULL,
+                FOREIGN KEY (file_path) REFERENCES files(file_path) ON DELETE CASCADE
+            )"""
+        )
+
+        self.db.execute("CREATE INDEX IF NOT EXISTS idx_hash_value ON code_blocks(hash_value)")
+        self.db.execute("CREATE INDEX IF NOT EXISTS idx_file_path ON code_blocks(file_path)")
+
+        self.db.commit()
+
+    def is_fresh(self, file_path: Path, current_mtime: float) -> bool:
+        """Check if cached data is fresh (mtime matches).
+
+        Args:
+            file_path: Path to file
+            current_mtime: Current modification time
+
+        Returns:
+            True if cache is fresh, False if stale or missing
+        """
+        cursor = self.db.execute("SELECT mtime FROM files WHERE file_path = ?", (str(file_path),))
+        row = cursor.fetchone()
+
+        if not row:
+            return False  # Not in cache
+
+        cached_mtime = row[0]
+        return cached_mtime == current_mtime
+
+    def load(self, file_path: Path) -> list[CodeBlock]:
+        """Load cached code blocks for file.
+
+        Args:
+            file_path: Path to file
+
+        Returns:
+            List of CodeBlock instances from cache
+        """
+        cursor = self.db.execute(
+            """SELECT hash_value, start_line, end_line, snippet
+               FROM code_blocks
+               WHERE file_path = ?""",
+            (str(file_path),),
+        )
+
+        blocks = []
+        for hash_val, start, end, snippet in cursor:
+            block = CodeBlock(
+                file_path=file_path,
+                start_line=start,
+                end_line=end,
+                snippet=snippet,
+                hash_value=hash_val,
+            )
+            blocks.append(block)
+
+        return blocks
+
+    def save(self, file_path: Path, mtime: float, blocks: list[CodeBlock]) -> None:
+        """Save code blocks to cache.
+
+        Args:
+            file_path: Path to file
+            mtime: File modification time
+            blocks: List of CodeBlock instances to cache
+        """
+        # Delete old data for this file
+        self.db.execute("DELETE FROM files WHERE file_path = ?", (str(file_path),))
+
+        # Insert file metadata
+        self.db.execute(
+            "INSERT INTO files (file_path, mtime, hash_count) VALUES (?, ?, ?)",
+            (str(file_path), mtime, len(blocks)),
+        )
+
+        # Insert code blocks
+        for block in blocks:
+            self.db.execute(
+                """INSERT INTO code_blocks
+                   (file_path, hash_value, start_line, end_line, snippet)
+                   VALUES (?, ?, ?, ?, ?)""",
+                (
+                    str(file_path),
+                    block.hash_value,
+                    block.start_line,
+                    block.end_line,
+                    block.snippet,
+                ),
+            )
+
+        self.db.commit()
+
+    def cleanup_stale(self, max_age_days: int) -> None:
+        """Remove cache entries older than max_age_days.
+
+        Args:
+            max_age_days: Maximum age in days for cache entries
+        """
+        # Use parameterized query to prevent SQL injection
+        self.db.execute(
+            """DELETE FROM files
+               WHERE last_scanned < datetime('now', ? || ' days')""",
+            (f"-{max_age_days}",),
+        )
+
+        # Vacuum to reclaim space
+        self.db.execute("VACUUM")
+        self.db.commit()
+
+    def find_duplicates_by_hash(self, hash_value: int) -> list[CodeBlock]:
+        """Find all code blocks with the given hash value.
+
+        Args:
+            hash_value: Hash value to search for
+
+        Returns:
+            List of ALL CodeBlock instances with this hash (from all files)
+        """
+        rows = self._query_service.find_blocks_by_hash(self.db, hash_value)
+
+        blocks = []
+        for file_path_str, start, end, snippet, hash_val in rows:
+            block = CodeBlock(
+                file_path=Path(file_path_str),
+                start_line=start,
+                end_line=end,
+                snippet=snippet,
+                hash_value=hash_val,
+            )
+            blocks.append(block)
+
+        return blocks
+
+    def get_duplicate_hashes(self) -> list[int]:
+        """Get all hash values that appear 2+ times.
+
+        Returns:
+            List of hash values with 2 or more occurrences
+        """
+        return self._query_service.get_duplicate_hashes(self.db)
+
+    def close(self) -> None:
+        """Close database connection."""
+        self.db.close()