thailint 0.2.1__py3-none-any.whl → 0.3.1__py3-none-any.whl

src/linters/dry/duplicate_storage.py

@@ -1,12 +1,11 @@
 """
-Purpose: Storage management for duplicate code blocks with cache and memory fallback
+Purpose: Storage management for duplicate code blocks in SQLite
 
-Scope: Manages storage of code blocks in SQLite cache or in-memory dict
+Scope: Manages storage of code blocks in SQLite for duplicate detection
 
-Overview: Provides unified storage interface for code blocks supporting both SQLite-backed caching
-    and in-memory fallback when cache disabled. Handles block insertion, retrieval, and duplicate
-    hash queries. Encapsulates Decision 6 (in-memory fallback) implementation. Separates storage
-    concerns from linting logic to maintain SRP compliance.
+Overview: Provides storage interface for code blocks using SQLite (in-memory or tempfile mode).
+    Handles block insertion and duplicate hash queries. Delegates all storage operations to
+    DRYCache SQLite layer. Separates storage concerns from linting logic to maintain SRP compliance.
 
 Dependencies: DRYCache, CodeBlock, Path
 
@@ -15,7 +14,7 @@ Exports: DuplicateStorage class
 Interfaces: DuplicateStorage.add_blocks(file_path, blocks), get_duplicate_hashes(),
     get_blocks_for_hash(hash_value)
 
-Implementation: Delegates to either SQLite cache or in-memory dict based on cache_enabled setting
+Implementation: Delegates to SQLite cache for all storage operations
 """
 
 from pathlib import Path
@@ -24,82 +23,36 @@ from .cache import CodeBlock, DRYCache
 
 
 class DuplicateStorage:
-    """Manages storage of code blocks in cache or memory."""
+    """Manages storage of code blocks in SQLite."""
 
-    def __init__(self, cache: DRYCache | None) -> None:
-        """Initialize storage with optional cache.
+    def __init__(self, cache: DRYCache) -> None:
+        """Initialize storage with SQLite cache.
 
         Args:
-            cache: SQLite cache instance (None for in-memory mode)
+            cache: SQLite cache instance (in-memory or tempfile mode)
         """
         self._cache = cache
-        self._memory_store: dict[int, list[CodeBlock]] = {}
 
     def add_blocks(self, file_path: Path, blocks: list[CodeBlock]) -> None:
-        """Add code blocks to storage and cache.
+        """Add code blocks to SQLite storage.
 
         Args:
             file_path: Path to source file
             blocks: List of code blocks to store
         """
-        # Always add to memory for duplicate detection
-        self._add_to_memory(blocks)
-
-        # Also persist to cache if available
-        if self._cache:
-            self._add_to_cache(file_path, blocks)
-
-    def add_blocks_to_memory(self, file_path: Path, blocks: list[CodeBlock]) -> None:
-        """Add code blocks to in-memory storage only (for cache hits).
-
-        Args:
-            file_path: Path to source file (used for cache persistence check)
-            blocks: List of code blocks to store
-        """
-        # Add to memory for duplicate detection this run
-        self._add_to_memory(blocks)
-
-        # Guard clauses - early returns for skip conditions
-        if not self._cache:
-            return
-
-        if not blocks:
-            return
-
-        # Update cache with new blocks if needed (for fresh analysis)
-        self._update_cache_if_fresh(file_path, blocks)
-
-    def _update_cache_if_fresh(self, file_path: Path, blocks: list[CodeBlock]) -> None:
-        """Update cache if file analysis is fresh (not from cache).
-
-        Args:
-            file_path: Path to source file
-            blocks: List of code blocks to store
-        """
-        if not self._cache:
-            return
-
-        try:
-            mtime = file_path.stat().st_mtime
-        except OSError:
-            # File doesn't exist, skip cache
-            return
-
-        # File was analyzed (not cached), so persist if not fresh
-        if not self._cache.is_fresh(file_path, mtime):
-            self._add_to_cache(file_path, blocks)
+        if blocks:
+            self._cache.add_blocks(file_path, blocks)
 
     def get_duplicate_hashes(self) -> list[int]:
-        """Get all hash values with 2+ occurrences from memory.
+        """Get all hash values with 2+ occurrences from SQLite.
 
         Returns:
             List of hash values that appear in multiple blocks
         """
-        # Always query from in-memory store for this run's files
-        return [h for h, blocks in self._memory_store.items() if len(blocks) >= 2]
+        return self._cache.get_duplicate_hashes()
 
     def get_blocks_for_hash(self, hash_value: int) -> list[CodeBlock]:
-        """Get all blocks with given hash value from memory.
+        """Get all blocks with given hash value from SQLite.
 
         Args:
             hash_value: Hash to search for
@@ -107,20 +60,4 @@ class DuplicateStorage:
         Returns:
             List of code blocks with this hash
         """
-        # Always query from in-memory store for this run's files
-        return self._memory_store.get(hash_value, [])
-
-    def _add_to_cache(self, file_path: Path, blocks: list[CodeBlock]) -> None:
-        """Add blocks to SQLite cache."""
-        if not self._cache or not blocks:
-            return
-
-        mtime = file_path.stat().st_mtime
-        self._cache.save(file_path, mtime, blocks)
-
-    def _add_to_memory(self, blocks: list[CodeBlock]) -> None:
-        """Add blocks to in-memory store."""
-        for block in blocks:
-            if block.hash_value not in self._memory_store:
-                self._memory_store[block.hash_value] = []
-            self._memory_store[block.hash_value].append(block)
+        return self._cache.find_duplicates_by_hash(hash_value)

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
@@ -514,4 +518,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/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/magic_numbers/__init__.py

@@ -0,0 +1,48 @@
+"""
+Purpose: Magic numbers linter package exports and convenience functions
+
+Scope: Public API for magic numbers linter module
+
+Overview: Provides the public interface for the magic numbers linter package. Exports main
+    MagicNumberRule class for use by the orchestrator and MagicNumberConfig for configuration.
+    Includes lint() convenience function that provides a simple API for running the magic numbers
+    linter on a file or directory without directly interacting with the orchestrator. This module
+    serves as the entry point for users of the magic numbers linter, hiding implementation details
+    and exposing only the essential components needed for linting operations.
+
+Dependencies: .linter for MagicNumberRule, .config for MagicNumberConfig
+
+Exports: MagicNumberRule class, MagicNumberConfig dataclass, lint() convenience function
+
+Interfaces: lint(path, config) -> list[Violation] for simple linting operations
+
+Implementation: Module-level exports with __all__ definition, convenience function wrapper
+"""
+
+from .config import MagicNumberConfig
+from .linter import MagicNumberRule
+
+__all__ = ["MagicNumberRule", "MagicNumberConfig", "lint"]
+
+
+def lint(file_path: str, config: dict | None = None) -> list:
+    """Convenience function for linting a file for magic numbers.
+
+    Args:
+        file_path: Path to the file to lint
+        config: Optional configuration dictionary
+
+    Returns:
+        List of violations found
+    """
+    from pathlib import Path
+
+    from src.orchestrator.core import FileLintContext
+
+    rule = MagicNumberRule()
+    context = FileLintContext(
+        path=Path(file_path),
+        lang="python",
+    )
+
+    return rule.check(context)

src/linters/magic_numbers/config.py

@@ -0,0 +1,71 @@
+"""
+Purpose: Configuration schema for magic numbers linter
+
+Scope: MagicNumberConfig dataclass with allowed_numbers and max_small_integer settings
+
+Overview: Defines configuration schema for magic numbers linter. Provides MagicNumberConfig dataclass
+    with allowed_numbers set (default includes common acceptable numbers like 0, 1, 2, -1, 10, 100, 1000)
+    and max_small_integer threshold (default 10) for range() contexts. Supports per-file and per-directory
+    config overrides through from_dict class method. Validates that configuration values are appropriate
+    types. Integrates with orchestrator's configuration system to allow users to customize allowed numbers
+    via .thailint.yaml configuration files.
+
+Dependencies: dataclasses for class definition, typing for type hints
+
+Exports: MagicNumberConfig dataclass
+
+Interfaces: MagicNumberConfig(allowed_numbers: set, max_small_integer: int, enabled: bool),
+    from_dict class method for loading configuration from dictionary
+
+Implementation: Dataclass with validation and defaults, matches reference implementation patterns
+"""
+
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass
+class MagicNumberConfig:
+    """Configuration for magic numbers linter."""
+
+    enabled: bool = True
+    allowed_numbers: set[int | float] = field(default_factory=lambda: {-1, 0, 1, 2, 10, 100, 1000})
+    max_small_integer: int = 10
+
+    def __post_init__(self) -> None:
+        """Validate configuration values."""
+        if self.max_small_integer <= 0:
+            raise ValueError(f"max_small_integer must be positive, got {self.max_small_integer}")
+
+    @classmethod
+    def from_dict(cls, config: dict[str, Any], language: str | None = None) -> "MagicNumberConfig":
+        """Load configuration from dictionary with language-specific overrides.
+
+        Args:
+            config: Dictionary containing configuration values
+            language: Programming language (python, typescript, javascript)
+                for language-specific settings
+
+        Returns:
+            MagicNumberConfig instance with values from dictionary
+        """
+        # Get language-specific config if available
+        if language and language in config:
+            lang_config = config[language]
+            allowed_numbers = set(
+                lang_config.get(
+                    "allowed_numbers", config.get("allowed_numbers", {-1, 0, 1, 2, 10, 100, 1000})
+                )
+            )
+            max_small_integer = lang_config.get(
+                "max_small_integer", config.get("max_small_integer", 10)
+            )
+        else:
+            allowed_numbers = set(config.get("allowed_numbers", {-1, 0, 1, 2, 10, 100, 1000}))
+            max_small_integer = config.get("max_small_integer", 10)
+
+        return cls(
+            enabled=config.get("enabled", True),
+            allowed_numbers=allowed_numbers,
+            max_small_integer=max_small_integer,
+        )