thailint 0.10.0__py3-none-any.whl → 0.12.0__py3-none-any.whl

src/linter_config/ignore.py

@@ -56,6 +56,7 @@ class IgnoreDirectiveParser:
         """
         self.project_root = project_root or Path.cwd()
         self.repo_patterns = self._load_repo_ignores()
+        self._ignore_cache: dict[str, bool] = {}  # Cache for is_ignored results
 
     def _load_repo_ignores(self) -> list[str]:
         """Load global ignore patterns from .thailintignore or .thailint.yaml."""
@@ -112,26 +113,20 @@ class IgnoreDirectiveParser:
         return []
 
     def is_ignored(self, file_path: Path) -> bool:
-        """Check if file matches repository-level ignore patterns.
+        """Check if file matches repository-level ignore patterns (cached)."""
+        path_str = str(file_path)
+        if path_str in self._ignore_cache:
+            return self._ignore_cache[path_str]
 
-        Args:
-            file_path: Path to check against ignore patterns.
-
-        Returns:
-            True if file should be ignored.
-        """
-        # Convert to string relative to project root if possible
+        # Convert to relative path for pattern matching
         try:
-            relative_path = file_path.relative_to(self.project_root)
-            path_str = str(relative_path)
+            check_path = str(file_path.relative_to(self.project_root))
         except ValueError:
-            # Path is not relative to project root
-            path_str = str(file_path)
+            check_path = path_str
 
-        for pattern in self.repo_patterns:
-            if self._matches_pattern(path_str, pattern):
-                return True
-        return False
+        result = any(self._matches_pattern(check_path, p) for p in self.repo_patterns)
+        self._ignore_cache[path_str] = result
+        return result
 
     def _matches_pattern(self, path: str, pattern: str) -> bool:
         """Check if path matches gitignore-style pattern.
@@ -473,3 +468,24 @@ class IgnoreDirectiveParser:
 
 # Alias for backwards compatibility
 IgnoreParser = IgnoreDirectiveParser
+
+# Singleton pattern for performance: YAML parsing repeated 9x consumed 44% overhead
+_CACHED_PARSER: IgnoreDirectiveParser | None = None
+_CACHED_PROJECT_ROOT: Path | None = None
+
+
+def get_ignore_parser(project_root: Path | None = None) -> IgnoreDirectiveParser:
+    """Get cached ignore parser instance (singleton pattern for performance)."""
+    global _CACHED_PARSER, _CACHED_PROJECT_ROOT  # pylint: disable=global-statement
+    effective_root = project_root or Path.cwd()
+    if _CACHED_PARSER is None or _CACHED_PROJECT_ROOT != effective_root:
+        _CACHED_PARSER = IgnoreDirectiveParser(effective_root)
+        _CACHED_PROJECT_ROOT = effective_root
+    return _CACHED_PARSER
+
+
+def clear_ignore_parser_cache() -> None:
+    """Clear cached parser for test isolation or project root changes."""
+    global _CACHED_PARSER, _CACHED_PROJECT_ROOT  # pylint: disable=global-statement
+    _CACHED_PARSER = None
+    _CACHED_PROJECT_ROOT = None

src/linters/collection_pipeline/linter.py

@@ -27,7 +27,7 @@ from pathlib import Path
 
 from src.core.base import BaseLintContext, BaseLintRule
 from src.core.types import Severity, Violation
-from src.linter_config.ignore import IgnoreDirectiveParser
+from src.linter_config.ignore import get_ignore_parser
 
 from .config import CollectionPipelineConfig
 from .detector import PatternMatch, PipelinePatternDetector
@@ -38,7 +38,7 @@ class CollectionPipelineRule(BaseLintRule):  # thailint: ignore[srp,dry]
 
     def __init__(self) -> None:
         """Initialize the rule with ignore parser."""
-        self._ignore_parser = IgnoreDirectiveParser()
+        self._ignore_parser = get_ignore_parser()
 
     @property
     def rule_id(self) -> str:

src/linters/dry/block_filter.py

@@ -10,7 +10,8 @@ Overview: Provides an extensible architecture for filtering duplicate code block
 
 Dependencies: ast, re, typing
 
-Exports: BaseBlockFilter, BlockFilterRegistry, KeywordArgumentFilter, ImportGroupFilter
+Exports: BaseBlockFilter, BlockFilterRegistry, KeywordArgumentFilter, ImportGroupFilter,
+    LoggerCallFilter, ExceptionReraiseFilter
 
 Interfaces: BaseBlockFilter.should_filter(code_block, file_content) -> bool
 
@@ -196,6 +197,99 @@ class ImportGroupFilter(BaseBlockFilter):
         return "import_group_filter"
 
 
+class LoggerCallFilter(BaseBlockFilter):
+    """Filters single-line logger calls that are idiomatic but appear similar.
+
+    Detects patterns like:
+        logger.debug(f"Command: {cmd}")
+        logger.info("Starting process...")
+        logging.warning("...")
+
+    These are contextually different despite structural similarity.
+    """
+
+    def __init__(self) -> None:
+        """Initialize the logger call filter."""
+        # Pattern matches: logger.level(...) or logging.level(...)
+        self._logger_pattern = re.compile(
+            r"^\s*(self\.)?(logger|logging|log)\."
+            r"(debug|info|warning|error|critical|exception|log)\s*\("
+        )
+
+    def should_filter(self, block: CodeBlock, file_content: str) -> bool:
+        """Check if block is primarily single-line logger calls.
+
+        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]
+        non_empty = [s for line in lines if (s := line.strip())]
+
+        if not non_empty:
+            return False
+
+        # Filter if it's a single line that's a logger call
+        if len(non_empty) == 1:
+            return bool(self._logger_pattern.match(non_empty[0]))
+
+        return False
+
+    @property
+    def name(self) -> str:
+        """Filter name."""
+        return "logger_call_filter"
+
+
+class ExceptionReraiseFilter(BaseBlockFilter):
+    """Filters idiomatic exception re-raising patterns.
+
+    Detects patterns like:
+        except SomeError as e:
+            raise NewError(...) from e
+
+    These are Python best practices for exception chaining.
+    """
+
+    def __init__(self) -> None:
+        """Initialize the exception reraise filter."""
+        pass  # Stateless filter
+
+    def should_filter(self, block: CodeBlock, file_content: str) -> bool:
+        """Check if block is an exception re-raise pattern.
+
+        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]
+        stripped_lines = [s for line in lines if (s := line.strip())]
+
+        if len(stripped_lines) != 2:
+            return False
+
+        return self._is_except_raise_pattern(stripped_lines)
+
+    @staticmethod
+    def _is_except_raise_pattern(lines: list[str]) -> bool:
+        """Check if lines form an except/raise pattern."""
+        first, second = lines[0], lines[1]
+        is_except = first.startswith("except ") and first.endswith(":")
+        is_raise = second.startswith("raise ") and " from " in second
+        return is_except and is_raise
+
+    @property
+    def name(self) -> str:
+        """Filter name."""
+        return "exception_reraise_filter"
+
+
 class BlockFilterRegistry:
     """Registry for managing duplicate block filters."""
 
@@ -262,5 +356,7 @@ def create_default_registry() -> BlockFilterRegistry:
     # Register built-in filters
     registry.register(KeywordArgumentFilter(threshold=DEFAULT_KEYWORD_ARG_THRESHOLD))
     registry.register(ImportGroupFilter())
+    registry.register(LoggerCallFilter())
+    registry.register(ExceptionReraiseFilter())
 
     return registry

src/linters/dry/cache.py

@@ -1,32 +1,40 @@
 """
 Purpose: SQLite storage manager for DRY linter duplicate detection
 
-Scope: Code block storage and duplicate detection queries
+Scope: Code block storage, constant storage, and duplicate detection queries
 
-Overview: Implements in-memory or temporary-file SQLite storage for duplicate code detection.
-    Stores code blocks with hash values, file locations, and metadata during a single linter run.
+Overview: Implements in-memory or temporary-file SQLite storage for duplicate code detection
+    and duplicate constants detection. Stores code blocks with hash values and constants with
+    name/value pairs, enabling cross-file duplicate detection during a single linter run.
     Supports both :memory: mode (fast, RAM-only) and tempfile mode (disk-backed for large projects).
     No persistence between runs - storage is cleared when linter completes. Includes indexes for
-    fast hash lookups enabling cross-file duplicate detection with minimal overhead.
+    fast hash lookups and constant name lookups enabling efficient cross-file detection.
 
 Dependencies: Python sqlite3 module (stdlib), tempfile module (stdlib), pathlib.Path, dataclasses
 
 Exports: CodeBlock dataclass, DRYCache class
 
 Interfaces: DRYCache.__init__(storage_mode), add_blocks(file_path, blocks),
-    find_duplicates_by_hash(hash_value), get_duplicate_hashes(), close()
+    find_duplicates_by_hash(hash_value), duplicate_hashes, add_constants(file_path, constants),
+    all_constants, get_duplicate_constant_names(), close()
 
-Implementation: SQLite with two tables (files, code_blocks), indexed on hash_value for performance,
+Implementation: SQLite with three tables (files, code_blocks, constants), indexed for performance,
     storage_mode determines :memory: vs tempfile location, ACID transactions for reliability
 """
 
+from __future__ import annotations
+
 import sqlite3
 import tempfile
 from dataclasses import dataclass
 from pathlib import Path
+from typing import TYPE_CHECKING
 
 from .cache_query import CacheQueryService
 
+if TYPE_CHECKING:
+    from .constant import ConstantInfo
+
 
 @dataclass
 class CodeBlock:
@@ -93,6 +101,19 @@ class DRYCache:
         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)")
 
+        # Constants table for duplicate constant detection
+        self.db.execute(
+            """CREATE TABLE IF NOT EXISTS constants (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                file_path TEXT NOT NULL,
+                name TEXT NOT NULL,
+                line_number INTEGER NOT NULL,
+                value TEXT,
+                FOREIGN KEY (file_path) REFERENCES files(file_path) ON DELETE CASCADE
+            )"""
+        )
+        self.db.execute("CREATE INDEX IF NOT EXISTS idx_constant_name ON constants(name)")
+
         self.db.commit()
 
     def add_blocks(self, file_path: Path, blocks: list[CodeBlock]) -> None:
@@ -166,6 +187,73 @@ class DRYCache:
         """
         return self._query_service.get_duplicate_hashes(self.db)
 
+    def add_constants(
+        self,
+        file_path: Path,
+        constants: list[ConstantInfo],
+    ) -> None:
+        """Add constants to storage.
+
+        Args:
+            file_path: Path to source file
+            constants: List of ConstantInfo instances to store
+        """
+        if not constants:
+            return
+
+        for const in constants:
+            self.db.execute(
+                """INSERT INTO constants
+                   (file_path, name, line_number, value)
+                   VALUES (?, ?, ?, ?)""",
+                (
+                    str(file_path),
+                    const.name,
+                    const.line_number,
+                    const.value,
+                ),
+            )
+
+        self.db.commit()
+
+    @property
+    def all_constants(self) -> list[tuple[str, str, int, str | None]]:
+        """All constants from storage.
+
+        Returns:
+            List of tuples: (file_path, name, line_number, value)
+        """
+        cursor = self.db.execute("SELECT file_path, name, line_number, value FROM constants")
+        return cursor.fetchall()
+
+    def get_duplicate_constant_names(self) -> list[str]:
+        """Get constant names that appear in 2+ files.
+
+        Returns:
+            List of constant names appearing in multiple files
+        """
+        cursor = self.db.execute(
+            """SELECT name FROM constants
+               GROUP BY name
+               HAVING COUNT(DISTINCT file_path) >= 2"""
+        )
+        return [row[0] for row in cursor.fetchall()]
+
+    def get_constants_by_name(self, name: str) -> list[tuple[str, int, str | None]]:
+        """Get all locations of a constant by name.
+
+        Args:
+            name: The constant name to search for
+
+        Returns:
+            List of tuples: (file_path, line_number, value)
+        """
+        cursor = self.db.execute(
+            "SELECT file_path, line_number, value FROM constants WHERE name = ?",
+            (name,),
+        )
+        return cursor.fetchall()
+
     def close(self) -> None:
         """Close database connection and cleanup tempfile if used."""
         self.db.close()

src/linters/dry/config.py

@@ -23,6 +23,7 @@ from typing import Any
 # Default configuration constants
 DEFAULT_MIN_DUPLICATE_LINES = 3
 DEFAULT_MIN_DUPLICATE_TOKENS = 30
+DEFAULT_DETECT_DUPLICATE_CONSTANTS = True
 
 
 @dataclass
@@ -60,23 +61,34 @@ class DRYConfig:  # pylint: disable=too-many-instance-attributes
         }
     )
 
+    # Duplicate constants detection
+    detect_duplicate_constants: bool = DEFAULT_DETECT_DUPLICATE_CONSTANTS
+    min_constant_occurrences: int = 2  # Minimum files with same constant to report
+
+    # Language-specific overrides for constant detection
+    python_min_constant_occurrences: int | None = None
+    typescript_min_constant_occurrences: int | None = None
+
     def __post_init__(self) -> None:
         """Validate configuration values."""
-        if self.min_duplicate_lines <= 0:
-            raise ValueError(
-                f"min_duplicate_lines must be positive, got {self.min_duplicate_lines}"
-            )
-        if self.min_duplicate_tokens <= 0:
-            raise ValueError(
-                f"min_duplicate_tokens must be positive, got {self.min_duplicate_tokens}"
-            )
-        if self.min_occurrences <= 0:
-            raise ValueError(f"min_occurrences must be positive, got {self.min_occurrences}")
+        self._validate_positive_fields()
         if self.storage_mode not in ("memory", "tempfile"):
             raise ValueError(
                 f"storage_mode must be 'memory' or 'tempfile', got '{self.storage_mode}'"
             )
 
+    def _validate_positive_fields(self) -> None:
+        """Validate that required fields are positive."""
+        positive_fields = [
+            ("min_duplicate_lines", self.min_duplicate_lines),
+            ("min_duplicate_tokens", self.min_duplicate_tokens),
+            ("min_occurrences", self.min_occurrences),
+            ("min_constant_occurrences", self.min_constant_occurrences),
+        ]
+        for name, value in positive_fields:
+            if value <= 0:
+                raise ValueError(f"{name} must be positive, got {value}")
+
     def get_min_occurrences_for_language(self, language: str) -> int:
         """Get minimum occurrences threshold for a specific language.
 
@@ -97,6 +109,25 @@ class DRYConfig:  # pylint: disable=too-many-instance-attributes
         override = language_overrides.get(language_lower)
         return override if override is not None else self.min_occurrences
 
+    def get_min_constant_occurrences_for_language(self, language: str) -> int:
+        """Get minimum constant occurrences threshold for a specific language.
+
+        Args:
+            language: Language identifier (e.g., "python", "typescript")
+
+        Returns:
+            Minimum constant occurrences threshold for the language, or global default
+        """
+        language_lower = language.lower()
+
+        language_overrides = {
+            "python": self.python_min_constant_occurrences,
+            "typescript": self.typescript_min_constant_occurrences,
+        }
+
+        override = language_overrides.get(language_lower)
+        return override if override is not None else self.min_constant_occurrences
+
     @classmethod
     def from_dict(cls, config: dict[str, Any]) -> "DRYConfig":
         """Load configuration from dictionary.
@@ -131,4 +162,10 @@ class DRYConfig:  # pylint: disable=too-many-instance-attributes
             storage_mode=config.get("storage_mode", "memory"),
             ignore_patterns=config.get("ignore", []),
             filters=filters,
+            detect_duplicate_constants=config.get(
+                "detect_duplicate_constants", DEFAULT_DETECT_DUPLICATE_CONSTANTS
+            ),
+            min_constant_occurrences=config.get("min_constant_occurrences", 2),
+            python_min_constant_occurrences=python_config.get("min_constant_occurrences"),
+            typescript_min_constant_occurrences=typescript_config.get("min_constant_occurrences"),
         )

src/linters/dry/constant.py

@@ -0,0 +1,92 @@
+"""
+Purpose: Dataclasses for duplicate constants detection in DRY linter
+
+Scope: Data structures for constant extraction and cross-file detection
+
+Overview: Provides dataclasses for representing constants extracted from source code and their
+    locations across multiple files. ConstantInfo stores extracted constant metadata (name, line,
+    value) from a single file. ConstantLocation represents where a constant appears across the
+    project. ConstantGroup represents a group of related constants (exact or fuzzy matches) for
+    violation reporting. These structures support the duplicate constants detection feature that
+    identifies when the same constant name appears in multiple files.
+
+Dependencies: Python dataclasses module, pathlib for Path types
+
+Exports: ConstantInfo, ConstantLocation, ConstantGroup dataclasses
+
+Interfaces: Dataclass constructors with named fields
+
+Implementation: Immutable dataclasses with optional fields for extracted value context
+"""
+
+import re
+from dataclasses import dataclass, field
+from pathlib import Path
+
+# Shared pattern for ALL_CAPS constant names (public only, no leading underscore)
+# Used by both Python and TypeScript constant extractors
+# Requires at least 2 characters to exclude single-letter type params (P, T, K, V)
+CONSTANT_NAME_PATTERN = re.compile(r"^[A-Z][A-Z0-9_]+$")
+
+
+@dataclass
+class ConstantInfo:
+    """Information about a constant extracted from source code.
+
+    Represents a single constant definition found during file analysis.
+    Used during the collection phase before cross-file matching.
+    """
+
+    name: str  # Constant name (e.g., "API_TIMEOUT")
+    line_number: int  # Line where constant is defined
+    value: str | None = None  # Optional: the value (for violation message context)
+
+
+@dataclass
+class ConstantLocation:
+    """Location of a constant in the project.
+
+    Represents where a specific constant appears, including file path,
+    line number, and the value assigned. Used for cross-file reporting.
+    """
+
+    file_path: Path
+    line_number: int
+    name: str
+    value: str | None = None
+
+
+@dataclass
+class ConstantGroup:
+    """A group of related constants for violation reporting.
+
+    Groups constants that match (either exactly or via fuzzy matching)
+    across multiple files. Used by the violation builder to generate
+    comprehensive violation messages.
+    """
+
+    # The canonical name (first seen or most common)
+    canonical_name: str
+
+    # All locations where this constant (or fuzzy match) appears
+    locations: list[ConstantLocation] = field(default_factory=list)
+
+    # All names in this group (for fuzzy matches, may include variants)
+    all_names: set[str] = field(default_factory=set)
+
+    # Whether this is a fuzzy match (True) or exact match (False)
+    is_fuzzy_match: bool = False
+
+    def add_location(self, location: ConstantLocation) -> None:
+        """Add a location to this group.
+
+        Args:
+            location: The constant location to add
+        """
+        self.locations.append(location)
+        self.all_names.add(location.name)
+
+    @property
+    def file_count(self) -> int:
+        """Number of unique files containing this constant."""
+        return len({loc.file_path for loc in self.locations})