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

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,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

@@ -11,7 +11,7 @@ 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 SQLite cache for all storage operations
@@ -43,13 +43,14 @@ class DuplicateStorage:
         if blocks:
             self._cache.add_blocks(file_path, blocks)
 
-    def get_duplicate_hashes(self) -> list[int]:
-        """Get all hash values with 2+ occurrences from SQLite.
+    @property
+    def duplicate_hashes(self) -> list[int]:
+        """Hash values with 2+ occurrences from SQLite.
 
         Returns:
             List of hash values that appear in multiple blocks
         """
-        return self._cache.get_duplicate_hashes()
+        return self._cache.duplicate_hashes
 
     def get_blocks_for_hash(self, hash_value: int) -> list[CodeBlock]:
         """Get all blocks with given hash value from SQLite.

src/linters/dry/file_analyzer.py

@@ -18,6 +18,8 @@ Implementation: Delegates to language-specific analyzers, always performs fresh
 
 from pathlib import Path
 
+from src.core.constants import Language
+
 from .block_filter import BlockFilterRegistry, create_default_registry
 from .cache import CodeBlock
 from .config import DRYConfig
@@ -83,8 +85,8 @@ class FileAnalyzer:
             List of CodeBlock instances
         """
         # Analyze file based on language
-        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."""