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

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)