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

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})

src/linters/dry/constant_matcher.py

@@ -0,0 +1,214 @@
+"""
+Purpose: Fuzzy matching for constant names across files
+
+Scope: Constant name matching with word-set and edit distance algorithms
+
+Overview: Implements fuzzy matching strategies to identify related constants across files. Uses
+    two matching strategies: word-set matching (same words in different order, e.g., API_TIMEOUT
+    and TIMEOUT_API) and edit distance matching (typos within Levenshtein distance <= 2, e.g.,
+    MAX_RETRYS and MAX_RETRIES). Single-word constants (e.g., MAX, TIMEOUT) only use exact
+    matching to avoid false positives. Groups related constants into ConstantGroup instances
+    for violation reporting.
+
+Dependencies: ConstantInfo, ConstantLocation, ConstantGroup from constant module
+
+Exports: ConstantMatcher class
+
+Interfaces: ConstantMatcher.find_groups(constants) -> list[ConstantGroup]
+
+Implementation: Union-Find algorithm for grouping, word-set hashing, Levenshtein distance calculation
+"""
+
+from collections.abc import Callable
+from itertools import combinations
+from pathlib import Path
+
+from .constant import ConstantGroup, ConstantInfo, ConstantLocation
+
+# Maximum edit distance for fuzzy matching
+MAX_EDIT_DISTANCE = 2
+
+# Antonym pairs that should not be fuzzy-matched
+# If one name contains a word from the left side and the other contains the right side,
+# they represent different concepts and should not be grouped together
+ANTONYM_PAIRS = frozenset(
+    (
+        frozenset(("max", "min")),
+        frozenset(("start", "end")),
+        frozenset(("first", "last")),
+        frozenset(("before", "after")),
+        frozenset(("open", "close")),
+        frozenset(("read", "write")),
+        frozenset(("get", "set")),
+        frozenset(("push", "pop")),
+        frozenset(("add", "remove")),
+        frozenset(("create", "delete")),
+        frozenset(("enable", "disable")),
+        frozenset(("show", "hide")),
+        frozenset(("up", "down")),
+        frozenset(("left", "right")),
+        frozenset(("top", "bottom")),
+        frozenset(("prev", "next")),
+        frozenset(("success", "failure")),
+        frozenset(("true", "false")),
+        frozenset(("on", "off")),
+        frozenset(("in", "out")),
+    )
+)
+
+# Minimum length for constant names (exclude single-letter type params like P, T, K, V)
+MIN_CONSTANT_NAME_LENGTH = 2
+
+
+class UnionFind:
+    """Union-Find data structure for grouping."""
+
+    def __init__(self, items: list[str]) -> None:
+        """Initialize with list of items."""
+        self._parent = {item: item for item in items}
+
+    def find(self, x: str) -> str:
+        """Find root with path compression."""
+        if self._parent[x] != x:
+            self._parent[x] = self.find(self._parent[x])
+        return self._parent[x]
+
+    def union(self, x: str, y: str) -> None:
+        """Merge two sets."""
+        px, py = self.find(x), self.find(y)
+        if px != py:
+            self._parent[px] = py
+
+
+class ConstantMatcher:
+    """Fuzzy matching for constant names."""
+
+    def find_groups(self, constants: list[tuple[Path, ConstantInfo]]) -> list[ConstantGroup]:
+        """Find groups of related constants."""
+        if not constants:
+            return []
+        locations = _build_locations(constants)
+        exact_groups = _group_by_exact_name(locations)
+        return self._merge_fuzzy_groups(exact_groups)
+
+    def _merge_fuzzy_groups(self, groups: dict[str, ConstantGroup]) -> list[ConstantGroup]:
+        """Merge groups that match via fuzzy matching."""
+        names = list(groups.keys())
+        uf = UnionFind(names)
+        _union_matching_pairs(names, uf, self._is_fuzzy_match)
+        return _build_merged_groups(names, groups, uf)
+
+    def _is_fuzzy_match(self, name1: str, name2: str) -> bool:
+        """Check if two constant names should be considered a match."""
+        if name1 == name2:
+            return True
+        return _is_fuzzy_similar(name1, name2)
+
+
+def _build_locations(constants: list[tuple[Path, ConstantInfo]]) -> list[ConstantLocation]:
+    """Build location list from constants."""
+    return [
+        ConstantLocation(
+            file_path=file_path, line_number=info.line_number, name=info.name, value=info.value
+        )
+        for file_path, info in constants
+    ]
+
+
+def _group_by_exact_name(locations: list[ConstantLocation]) -> dict[str, ConstantGroup]:
+    """Group locations by exact constant name."""
+    groups: dict[str, ConstantGroup] = {}
+    for loc in locations:
+        if loc.name not in groups:
+            groups[loc.name] = ConstantGroup(
+                canonical_name=loc.name, locations=[], all_names=set(), is_fuzzy_match=False
+            )
+        groups[loc.name].add_location(loc)
+    return groups
+
+
+def _union_matching_pairs(
+    names: list[str], uf: UnionFind, is_match: Callable[[str, str], bool]
+) -> None:
+    """Union all pairs of names that match."""
+    for name1, name2 in combinations(names, 2):
+        if is_match(name1, name2):
+            uf.union(name1, name2)
+
+
+def _build_merged_groups(
+    names: list[str], groups: dict[str, ConstantGroup], uf: UnionFind
+) -> list[ConstantGroup]:
+    """Build merged groups from union-find structure."""
+    merged: dict[str, ConstantGroup] = {}
+    for name in names:
+        root = uf.find(name)
+        if root not in merged:
+            merged[root] = ConstantGroup(
+                canonical_name=root, locations=[], all_names=set(), is_fuzzy_match=False
+            )
+        for loc in groups[name].locations:
+            merged[root].add_location(loc)
+        if name != root:
+            merged[root].is_fuzzy_match = True
+    return list(merged.values())
+
+
+def _get_words(name: str) -> list[str]:
+    """Split constant name into lowercase words."""
+    return [w.lower() for w in name.split("_") if w]
+
+
+def _is_fuzzy_similar(name1: str, name2: str) -> bool:
+    """Check if two names are fuzzy similar (word-set or edit distance)."""
+    words1, words2 = _get_words(name1), _get_words(name2)
+    if not _has_enough_words(words1, words2):
+        return False
+    if _has_antonym_conflict(set(words1), set(words2)):
+        return False
+    return _word_set_match(words1, words2) or _edit_distance_match(name1, name2)
+
+
+def _has_enough_words(words1: list[str], words2: list[str]) -> bool:
+    """Check if both word lists have at least 2 words for fuzzy matching."""
+    return len(words1) >= 2 and len(words2) >= 2
+
+
+def _word_set_match(words1: list[str], words2: list[str]) -> bool:
+    """Check if two word lists contain the same words."""
+    return set(words1) == set(words2)
+
+
+def _has_antonym_conflict(set1: set[str], set2: set[str]) -> bool:
+    """Check if word sets contain conflicting antonyms (e.g., MAX vs MIN)."""
+    return any(_is_antonym_split(pair, set1, set2) for pair in ANTONYM_PAIRS)
+
+
+def _is_antonym_split(pair: frozenset[str], set1: set[str], set2: set[str]) -> bool:
+    """Check if one set has one word of the pair and the other has the opposite."""
+    pair_list = tuple(pair)
+    word_a, word_b = pair_list[0], pair_list[1]
+    return (word_a in set1 and word_b in set2) or (word_b in set1 and word_a in set2)
+
+
+def _edit_distance_match(name1: str, name2: str) -> bool:
+    """Check if names match within edit distance threshold."""
+    return _levenshtein_distance(name1.lower(), name2.lower()) <= MAX_EDIT_DISTANCE
+
+
+def _levenshtein_distance(s1: str, s2: str) -> int:
+    """Calculate Levenshtein distance between two strings."""
+    if len(s1) < len(s2):
+        return _levenshtein_distance(s2, s1)  # pylint: disable=arguments-out-of-order
+    if len(s2) == 0:
+        return len(s1)
+    previous_row = list(range(len(s2) + 1))
+    for i, c1 in enumerate(s1):
+        current_row = [i + 1]
+        for j, c2 in enumerate(s2):
+            insertions = previous_row[j + 1] + 1
+            deletions = current_row[j] + 1
+            substitutions = previous_row[j] + (c1 != c2)
+            current_row.append(min(insertions, deletions, substitutions))
+        previous_row = current_row
+    return previous_row[-1]