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

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]

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/linter.py

@@ -1,15 +1,18 @@
 """
 Purpose: Main DRY linter rule implementation with stateful caching
 
-Scope: DRYRule class implementing BaseLintRule interface for duplicate code detection
+Scope: DRYRule class implementing BaseLintRule interface for duplicate code and constant detection
 
 Overview: Implements DRY linter rule following BaseLintRule interface with stateful caching design.
     Orchestrates duplicate detection by delegating to specialized classes: ConfigLoader for config,
     StorageInitializer for storage setup, FileAnalyzer for file analysis, and ViolationGenerator
-    for violation creation. Maintains minimal orchestration logic to comply with SRP (8 methods total).
+    for violation creation. Also supports duplicate constant detection (opt-in) to identify when
+    the same constant is defined in multiple files. Maintains minimal orchestration logic to comply
+    with SRP.
 
 Dependencies: BaseLintRule, BaseLintContext, ConfigLoader, StorageInitializer, FileAnalyzer,
-    DuplicateStorage, ViolationGenerator
+    DuplicateStorage, ViolationGenerator, PythonConstantExtractor, TypeScriptConstantExtractor,
+    ConstantMatcher, ConstantViolationBuilder
 
 Exports: DRYRule class
 
@@ -22,7 +25,6 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 from pathlib import Path
-from typing import TYPE_CHECKING
 
 from src.core.base import BaseLintContext, BaseLintRule
 from src.core.linter_utils import should_process_file
@@ -30,18 +32,20 @@ from src.core.types import Violation
 
 from .config import DRYConfig
 from .config_loader import ConfigLoader
+from .constant import ConstantInfo
+from .constant_matcher import ConstantMatcher
+from .constant_violation_builder import ConstantViolationBuilder
 from .duplicate_storage import DuplicateStorage
 from .file_analyzer import FileAnalyzer
 from .inline_ignore import InlineIgnoreParser
+from .python_constant_extractor import PythonConstantExtractor
 from .storage_initializer import StorageInitializer
+from .typescript_constant_extractor import TypeScriptConstantExtractor
 from .violation_generator import ViolationGenerator
 
-if TYPE_CHECKING:
-    from .cache import CodeBlock
-
 
 @dataclass
-class DRYComponents:
+class DRYComponents:  # pylint: disable=too-many-instance-attributes
     """Component dependencies for DRY linter."""
 
     config_loader: ConfigLoader
@@ -49,6 +53,10 @@ class DRYComponents:
     file_analyzer: FileAnalyzer
     violation_generator: ViolationGenerator
     inline_ignore: InlineIgnoreParser
+    python_extractor: PythonConstantExtractor
+    typescript_extractor: TypeScriptConstantExtractor
+    constant_matcher: ConstantMatcher
+    constant_violation_builder: ConstantViolationBuilder
 
 
 class DRYRule(BaseLintRule):
@@ -61,6 +69,9 @@ class DRYRule(BaseLintRule):
         self._config: DRYConfig | None = None
         self._file_analyzer: FileAnalyzer | None = None
 
+        # Collected constants for cross-file detection: list of (file_path, ConstantInfo)
+        self._constants: list[tuple[Path, ConstantInfo]] = []
+
         # Helper components grouped to reduce instance attributes
         self._helpers = DRYComponents(
             config_loader=ConfigLoader(),
@@ -68,6 +79,10 @@ class DRYRule(BaseLintRule):
             file_analyzer=FileAnalyzer(),  # Placeholder, will be replaced with configured one
             violation_generator=ViolationGenerator(),
             inline_ignore=InlineIgnoreParser(),
+            python_extractor=PythonConstantExtractor(),
+            typescript_extractor=TypeScriptConstantExtractor(),
+            constant_matcher=ConstantMatcher(),
+            constant_violation_builder=ConstantViolationBuilder(),
         )
 
     @property
@@ -86,14 +101,7 @@ class DRYRule(BaseLintRule):
         return "Detects duplicate code blocks across the project"
 
     def check(self, context: BaseLintContext) -> list[Violation]:
-        """Analyze file and store blocks (collection phase).
-
-        Args:
-            context: Lint context with file information
-
-        Returns:
-            Empty list (violations returned in finalize())
-        """
+        """Analyze file and store blocks (collection phase)."""
         if not should_process_file(context):
             return []
 
@@ -101,18 +109,18 @@ class DRYRule(BaseLintRule):
         if not config.enabled:
             return []
 
-        # Store config for finalize()
-        if self._config is None:
-            self._config = config
+        self._config = self._config or config
+        self._process_file(context, config)
+        return []
 
-        # Parse inline ignore directives from this file
+    def _process_file(self, context: BaseLintContext, config: DRYConfig) -> None:
+        """Process a single file for duplicates and constants."""
         file_path = Path(context.file_path)  # type: ignore[arg-type]
         self._helpers.inline_ignore.parse_file(file_path, context.file_content or "")
-
         self._ensure_storage_initialized(context, config)
         self._analyze_and_store(context, config)
-
-        return []
+        if config.detect_duplicate_constants:
+            self._extract_and_store_constants(context)
 
     def _ensure_storage_initialized(self, context: BaseLintContext, config: DRYConfig) -> None:
         """Initialize storage and file analyzer on first call."""
@@ -124,40 +132,73 @@ class DRYRule(BaseLintRule):
 
     def _analyze_and_store(self, context: BaseLintContext, config: DRYConfig) -> None:
         """Analyze file and store blocks."""
-        # Guaranteed by _should_process_file check
-        if context.file_path is None or context.file_content is None:
-            return  # Should never happen due to should_process_file check
-
-        if not self._file_analyzer:
-            return  # Should never happen after initialization
-
-        file_path = Path(context.file_path)
-        blocks = self._file_analyzer.analyze(
-            file_path, context.file_content, context.language, config
+        if not self._can_analyze(context):
+            return
+        file_path = Path(context.file_path)  # type: ignore[arg-type]
+        blocks = self._file_analyzer.analyze(  # type: ignore[union-attr]
+            file_path,
+            context.file_content,  # type: ignore[arg-type]
+            context.language,
+            config,
         )
-
         if blocks:
-            self._store_blocks(file_path, blocks)
+            self._storage.add_blocks(file_path, blocks)  # type: ignore[union-attr]
+
+    def _can_analyze(self, context: BaseLintContext) -> bool:
+        """Check if context is ready for analysis."""
+        return (
+            context.file_path is not None
+            and context.file_content is not None
+            and self._file_analyzer is not None
+            and self._storage is not None
+        )
 
-    def _store_blocks(self, file_path: Path, blocks: list[CodeBlock]) -> None:
-        """Store blocks in SQLite if storage available."""
-        if self._storage:
-            self._storage.add_blocks(file_path, blocks)
+    def _extract_and_store_constants(self, context: BaseLintContext) -> None:
+        """Extract constants from file and store for cross-file detection."""
+        if context.file_path is None or context.file_content is None:
+            return
+        file_path = Path(context.file_path)
+        extractor = _get_extractor_for_language(context.language, self._helpers)
+        if extractor:
+            self._constants.extend((file_path, c) for c in extractor.extract(context.file_content))
 
     def finalize(self) -> list[Violation]:
-        """Generate violations after all files processed.
-
-        Returns:
-            List of all violations found across all files
-        """
+        """Generate violations after all files processed."""
         if not self._storage or not self._config:
             return []
-
         violations = self._helpers.violation_generator.generate_violations(
             self._storage, self.rule_id, self._config, self._helpers.inline_ignore
         )
-
-        # Clear inline ignore cache for next run
+        if self._config.detect_duplicate_constants and self._constants:
+            violations.extend(
+                _generate_constant_violations(
+                    self._constants, self._config, self._helpers, self.rule_id
+                )
+            )
         self._helpers.inline_ignore.clear()
-
+        self._constants = []
         return violations
+
+
+def _get_extractor_for_language(
+    language: str | None, helpers: DRYComponents
+) -> PythonConstantExtractor | TypeScriptConstantExtractor | None:
+    """Get the appropriate constant extractor for a language."""
+    extractors: dict[str, PythonConstantExtractor | TypeScriptConstantExtractor] = {
+        "python": helpers.python_extractor,
+        "typescript": helpers.typescript_extractor,
+        "javascript": helpers.typescript_extractor,
+    }
+    return extractors.get(language or "")
+
+
+def _generate_constant_violations(
+    constants: list[tuple[Path, ConstantInfo]],
+    config: DRYConfig,
+    helpers: DRYComponents,
+    rule_id: str,
+) -> list[Violation]:
+    """Generate violations for duplicate constants."""
+    groups = helpers.constant_matcher.find_groups(constants)
+    helpers.constant_violation_builder.min_occurrences = config.min_constant_occurrences
+    return helpers.constant_violation_builder.build_violations(groups, rule_id)