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

src/linters/dry/constant_matcher.py

@@ -0,0 +1,223 @@
+"""
+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: find_constant_groups function
+
+Interfaces: find_constant_groups(constants) -> list[ConstantGroup]
+
+Implementation: Union-Find algorithm for grouping, word-set hashing, Levenshtein distance calculation
+
+Suppressions:
+    - arguments-out-of-order: Named arguments used for clarity in ConstantLocation
+"""
+
+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
+
+
+def find_constant_groups(constants: list[tuple[Path, ConstantInfo]]) -> list[ConstantGroup]:
+    """Find groups of related constants.
+
+    Args:
+        constants: List of (file_path, ConstantInfo) tuples
+
+    Returns:
+        List of ConstantGroup instances representing related constants
+    """
+    if not constants:
+        return []
+    locations = _build_locations(constants)
+    exact_groups = _group_by_exact_name(locations)
+    return _merge_fuzzy_groups(exact_groups)
+
+
+def _merge_fuzzy_groups(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, _is_fuzzy_match)
+    return _build_merged_groups(names, groups, uf)
+
+
+def _is_fuzzy_match(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]

src/linters/dry/constant_violation_builder.py

@@ -0,0 +1,98 @@
+"""
+Purpose: Build violation messages for duplicate constants
+
+Scope: Violation message formatting for constant duplication detection
+
+Overview: Formats detailed violation messages for duplicate constant detection. Creates messages
+    that include the constant name(s), all file locations with line numbers, and the values
+    assigned at each location. Distinguishes between exact matches (same constant name) and
+    fuzzy matches (similar names like API_TIMEOUT and TIMEOUT_API). Provides actionable guidance
+    to consolidate constants into a shared module.
+
+Dependencies: ConstantGroup from constant module, Violation from core.types
+
+Exports: ConstantViolationBuilder class
+
+Interfaces: ConstantViolationBuilder.build_violations(groups, rule_id) -> list[Violation]
+
+Implementation: Message template formatting with location enumeration and fuzzy match indication
+"""
+
+from src.core.types import Severity, Violation
+
+from .constant import ConstantGroup, ConstantLocation
+
+# Maximum other locations to show in violation message
+MAX_DISPLAYED_LOCATIONS = 3
+
+
+class ConstantViolationBuilder:
+    """Builds violation messages for duplicate constants."""
+
+    def __init__(self, min_occurrences: int = 2) -> None:
+        """Initialize with minimum occurrence threshold."""
+        self.min_occurrences = min_occurrences
+
+    def build_violations(self, groups: list[ConstantGroup], rule_id: str) -> list[Violation]:
+        """Build violations from constant groups."""
+        violations = []
+        for group in groups:
+            if group.file_count >= self.min_occurrences:
+                violations.extend(self._violations_for_group(group, rule_id))
+        return violations
+
+    def _violations_for_group(self, group: ConstantGroup, rule_id: str) -> list[Violation]:
+        """Create violations for all locations in a group."""
+        return [
+            Violation(
+                rule_id=rule_id,
+                file_path=str(loc.file_path),
+                line=loc.line_number,
+                column=1,
+                message=self._format_message(group, loc),
+                severity=Severity.ERROR,
+            )
+            for loc in group.locations
+        ]
+
+    def _format_message(self, group: ConstantGroup, current: ConstantLocation) -> str:
+        """Format the violation message based on match type."""
+        others = _get_other_locations(group, current)
+        locations_text = _format_locations_text(others)
+        if group.is_fuzzy_match:
+            names_str = " ≈ ".join(f"'{n}'" for n in sorted(group.all_names))
+            return (
+                f"Similar constants found: {names_str} in {group.file_count} files. "
+                f"{locations_text} "
+                f"These appear to represent the same concept - consider standardizing the name."
+            )
+        return (
+            f"Duplicate constant '{group.canonical_name}' defined in {group.file_count} files. "
+            f"{locations_text} "
+            f"Consider consolidating to a shared constants module."
+        )
+
+
+def _get_other_locations(group: ConstantGroup, current: ConstantLocation) -> list[ConstantLocation]:
+    """Get locations excluding current (module-level helper)."""
+    return [
+        loc
+        for loc in group.locations
+        if loc.file_path != current.file_path or loc.line_number != current.line_number
+    ]
+
+
+def _format_locations_text(others: list[ConstantLocation]) -> str:
+    """Format other locations as text (module-level helper)."""
+    if not others:
+        return ""
+    parts = [_format_single_location(loc) for loc in others[:MAX_DISPLAYED_LOCATIONS]]
+    result = "Also found in: " + ", ".join(parts)
+    extra = len(others) - MAX_DISPLAYED_LOCATIONS
+    return result + (f" and {extra} more." if extra > 0 else ".")
+
+
+def _format_single_location(loc: ConstantLocation) -> str:
+    """Format a single location for display (module-level helper)."""
+    value_str = f" = {loc.value}" if loc.value else ""
+    return f"{loc.file_path.name}:{loc.line_number} ({loc.name}{value_str})"

src/linters/dry/duplicate_storage.py

@@ -1,21 +1,20 @@
 """
-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
 
 Exports: DuplicateStorage class
 
-Interfaces: DuplicateStorage.add_blocks(file_path, blocks), get_duplicate_hashes(),
+Interfaces: DuplicateStorage.add_blocks(file_path, blocks), duplicate_hashes property,
     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,37 @@ 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)
+        if blocks:
+            self._cache.add_blocks(file_path, 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)
-
-    def get_duplicate_hashes(self) -> list[int]:
-        """Get all hash values with 2+ occurrences from memory.
+    @property
+    def duplicate_hashes(self) -> list[int]:
+        """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.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 +61,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,34 @@
 """
 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 src.core.constants import Language
+
 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,51 +66,27 @@ 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":
+        if language == Language.PYTHON:
             return self._python_analyzer.analyze(file_path, content, config)
-        if language in ("typescript", "javascript"):
+        if language in (Language.TYPESCRIPT, Language.JAVASCRIPT):
             return self._typescript_analyzer.analyze(file_path, content, config)
         return []

src/linters/dry/inline_ignore.py

@@ -50,14 +50,11 @@ class InlineIgnoreParser:
         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
+        return [
+            ignore_range
+            for i, line in enumerate(lines, start=1)
+            if (ignore_range := self._parse_ignore_directive(line, i, len(lines)))
+        ]
 
     def _parse_ignore_directive(
         self, line: str, line_num: int, total_lines: int
@@ -115,10 +112,7 @@ class InlineIgnoreParser:
         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
+        return any(line <= ign_end and end_line >= ign_start for ign_start, ign_end in ranges)
 
     def _check_single_line(self, line: int, ranges: list[tuple[int, int]]) -> bool:
         """Check if single line is in any ignore range.
@@ -130,10 +124,7 @@ class InlineIgnoreParser:
         Returns:
             True if line is in any range
         """
-        for start, end in ranges:
-            if start <= line <= end:
-                return True
-        return False
+        return any(start <= line <= end for start, end in ranges)
 
     def clear(self) -> None:
         """Clear all stored ignore ranges."""