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

src/linters/dry/violation_filter.py

@@ -0,0 +1,94 @@
+"""
+Purpose: Violation overlap filtering
+
+Scope: Filters overlapping violations within same file
+
+Overview: Filters overlapping violations by comparing line ranges. When violations are close together
+    (within 3 lines), only the first one is kept. Used by ViolationDeduplicator to remove duplicate
+    reports from rolling hash windows.
+
+Dependencies: Violation
+
+Exports: ViolationFilter class
+
+Interfaces: ViolationFilter.filter_overlapping(sorted_violations)
+
+Implementation: Iterates through sorted violations, keeps first of each overlapping group
+"""
+
+from src.core.types import Violation
+
+# Default fallback for line count when parsing fails
+DEFAULT_FALLBACK_LINE_COUNT = 5
+
+
+class ViolationFilter:
+    """Filters overlapping violations."""
+
+    def filter_overlapping(self, sorted_violations: list[Violation]) -> list[Violation]:
+        """Filter overlapping violations, keeping first occurrence.
+
+        Args:
+            sorted_violations: Violations sorted by line number
+
+        Returns:
+            Filtered list with overlaps removed
+        """
+        kept: list[Violation] = []
+        for violation in sorted_violations:
+            if not self._overlaps_any(violation, kept):
+                kept.append(violation)
+        return kept
+
+    def _overlaps_any(self, violation: Violation, kept_violations: list[Violation]) -> bool:
+        """Check if violation overlaps with any kept violations.
+
+        Args:
+            violation: Violation to check
+            kept_violations: Previously kept violations
+
+        Returns:
+            True if violation overlaps with any kept violation
+        """
+        for kept in kept_violations:
+            if self._overlaps(violation, kept):
+                return True
+        return False
+
+    def _overlaps(self, v1: Violation, v2: Violation) -> bool:
+        """Check if two violations overlap.
+
+        Args:
+            v1: First violation (later line number)
+            v2: Second violation (earlier line number)
+
+        Returns:
+            True if violations overlap based on code block size
+        """
+        line1 = v1.line or 0
+        line2 = v2.line or 0
+
+        # Extract line count from message format: "Duplicate code (N lines, ...)"
+        line_count = self._extract_line_count(v1.message)
+
+        # Blocks overlap if their line ranges intersect
+        # Block at line2 covers [line2, line2 + line_count - 1]
+        # Block at line1 overlaps if line1 < line2 + line_count
+        return line1 < line2 + line_count
+
+    def _extract_line_count(self, message: str) -> int:
+        """Extract line count from violation message.
+
+        Args:
+            message: Violation message containing line count
+
+        Returns:
+            Number of lines in the duplicate code block (default 5 if not found)
+        """
+        # Message format: "Duplicate code (5 lines, 2 occurrences)..."
+        try:
+            start = message.index("(") + 1
+            end = message.index(" lines")
+            return int(message[start:end])
+        except (ValueError, IndexError):
+            return DEFAULT_FALLBACK_LINE_COUNT  # Default fallback

src/linters/dry/violation_generator.py

@@ -0,0 +1,174 @@
+"""
+Purpose: Violation generation from duplicate code blocks
+
+Scope: Generates violations from duplicate hashes
+
+Overview: Handles violation generation for duplicate code blocks. Queries storage for duplicate
+    hashes, retrieves blocks for each hash, deduplicates overlapping blocks, builds violations
+    using ViolationBuilder, and filters violations based on ignore patterns. Separates violation
+    generation logic from main linter rule to maintain SRP compliance.
+
+Dependencies: DuplicateStorage, ViolationDeduplicator, DRYViolationBuilder, Violation, DRYConfig
+
+Exports: ViolationGenerator class
+
+Interfaces: ViolationGenerator.generate_violations(storage, rule_id, config) -> list[Violation]
+
+Implementation: Queries storage, deduplicates blocks, builds violations, filters by ignore patterns
+"""
+
+from pathlib import Path
+
+from src.core.types import Violation
+from src.orchestrator.language_detector import detect_language
+
+from .config import DRYConfig
+from .deduplicator import ViolationDeduplicator
+from .duplicate_storage import DuplicateStorage
+from .inline_ignore import InlineIgnoreParser
+from .violation_builder import DRYViolationBuilder
+
+
+class ViolationGenerator:
+    """Generates violations from duplicate code blocks."""
+
+    def __init__(self) -> None:
+        """Initialize with deduplicator and violation builder."""
+        self._deduplicator = ViolationDeduplicator()
+        self._violation_builder = DRYViolationBuilder()
+
+    def generate_violations(
+        self,
+        storage: DuplicateStorage,
+        rule_id: str,
+        config: DRYConfig,
+        inline_ignore: InlineIgnoreParser,
+    ) -> list[Violation]:
+        """Generate violations from storage.
+
+        Args:
+            storage: Duplicate storage instance
+            rule_id: Rule identifier for violations
+            config: DRY configuration with ignore patterns
+            inline_ignore: Parser with inline ignore directives
+
+        Returns:
+            List of violations filtered by ignore patterns and inline directives
+        """
+        duplicate_hashes = storage.get_duplicate_hashes()
+        violations = []
+
+        for hash_value in duplicate_hashes:
+            blocks = storage.get_blocks_for_hash(hash_value)
+            dedup_blocks = self._deduplicator.deduplicate_blocks(blocks)
+
+            # Check min_occurrences threshold (language-aware)
+            if not self._meets_min_occurrences(dedup_blocks, config):
+                continue
+
+            for block in dedup_blocks:
+                violation = self._violation_builder.build_violation(block, dedup_blocks, rule_id)
+                violations.append(violation)
+
+        deduplicated = self._deduplicator.deduplicate_violations(violations)
+        pattern_filtered = self._filter_ignored(deduplicated, config.ignore_patterns)
+        return self._filter_inline_ignored(pattern_filtered, inline_ignore)
+
+    def _meets_min_occurrences(self, blocks: list, config: DRYConfig) -> bool:
+        """Check if blocks meet minimum occurrence threshold for the language.
+
+        Args:
+            blocks: List of duplicate code blocks
+            config: DRY configuration with min_occurrences settings
+
+        Returns:
+            True if blocks meet or exceed minimum occurrence threshold
+        """
+        if len(blocks) == 0:
+            return False
+
+        # Get language from first block's file extension
+        first_block = blocks[0]
+        language = detect_language(first_block.file_path)
+
+        # Get language-specific threshold
+        min_occurrences = config.get_min_occurrences_for_language(language)
+
+        return len(blocks) >= min_occurrences
+
+    def _filter_ignored(
+        self, violations: list[Violation], ignore_patterns: list[str]
+    ) -> list[Violation]:
+        """Filter violations based on ignore patterns.
+
+        Args:
+            violations: List of violations to filter
+            ignore_patterns: List of path patterns to ignore
+
+        Returns:
+            Filtered list of violations
+        """
+        if not ignore_patterns:
+            return violations
+
+        filtered = []
+        for violation in violations:
+            if not self._is_ignored(violation.file_path, ignore_patterns):
+                filtered.append(violation)
+        return filtered
+
+    def _is_ignored(self, file_path: str, ignore_patterns: list[str]) -> bool:
+        """Check if file path matches any ignore pattern.
+
+        Args:
+            file_path: Path to check
+            ignore_patterns: List of patterns to match against
+
+        Returns:
+            True if file should be ignored
+        """
+        path_str = str(Path(file_path))
+        for pattern in ignore_patterns:
+            if pattern in path_str:
+                return True
+        return False
+
+    def _filter_inline_ignored(
+        self, violations: list[Violation], inline_ignore: InlineIgnoreParser
+    ) -> list[Violation]:
+        """Filter violations based on inline ignore directives.
+
+        Args:
+            violations: List of violations to filter
+            inline_ignore: Parser with inline ignore directives
+
+        Returns:
+            Filtered list of violations
+        """
+        filtered = []
+        for violation in violations:
+            start_line = violation.line or 0
+            # Extract line count from message to calculate end_line
+            line_count = self._extract_line_count(violation.message)
+            end_line = start_line + line_count - 1
+
+            if not inline_ignore.should_ignore(violation.file_path, start_line, end_line):
+                filtered.append(violation)
+        return filtered
+
+    def _extract_line_count(self, message: str) -> int:
+        """Extract line count from violation message.
+
+        Args:
+            message: Violation message
+
+        Returns:
+            Number of lines (default 1)
+        """
+        # Message format: "Duplicate code (N lines, ...)"
+        try:
+            start = message.index("(") + 1
+            end = message.index(" lines")
+            return int(message[start:end])
+        except (ValueError, IndexError):
+            return 1

src/linters/file_header/__init__.py

@@ -0,0 +1,24 @@
+"""
+File: src/linters/file_header/__init__.py
+Purpose: File header linter module initialization
+Exports: FileHeaderRule
+Depends: linter.FileHeaderRule
+Implements: Module-level exports for clean API
+Related: linter.py for main rule implementation
+
+Overview:
+    Initializes the file header linter module providing multi-language file header
+    validation with mandatory field checking, atemporal language detection, and configuration
+    support. Main entry point for file header linting functionality.
+
+Usage:
+    from src.linters.file_header import FileHeaderRule
+    rule = FileHeaderRule()
+    violations = rule.check(context)
+
+Notes: Follows standard Python module initialization pattern with __all__ export control
+"""
+
+from .linter import FileHeaderRule
+
+__all__ = ["FileHeaderRule"]

src/linters/file_header/atemporal_detector.py

@@ -0,0 +1,87 @@
+"""
+File: src/linters/file_header/atemporal_detector.py
+Purpose: Detects temporal language patterns in file headers
+Exports: AtemporalDetector class
+Depends: re module for regex matching
+Implements: Regex-based pattern matching with configurable patterns
+Related: linter.py for detector usage, violation_builder.py for violation creation
+
+Overview:
+    Implements pattern-based detection of temporal language that violates atemporal
+    documentation requirements. Detects dates, temporal qualifiers, state change language,
+    and future references using regex patterns. Provides violation details for each pattern match.
+
+Usage:
+    detector = AtemporalDetector()
+    violations = detector.detect_violations(header_text)
+
+Notes: Four pattern categories - dates, temporal qualifiers, state changes, future references
+"""
+
+import re
+
+
+class AtemporalDetector:
+    """Detects temporal language patterns in text."""
+
+    # Date patterns
+    DATE_PATTERNS = [
+        (r"\d{4}-\d{2}-\d{2}", "ISO date format (YYYY-MM-DD)"),
+        (
+            r"(?:January|February|March|April|May|June|July|August|September|October|November|December)\s+\d{4}",
+            "Month Year format",
+        ),
+        (r"(?:Created|Updated|Modified):\s*\d{4}", "Date metadata"),
+    ]
+
+    # Temporal qualifiers
+    TEMPORAL_QUALIFIERS = [
+        (r"\bcurrently\b", 'temporal qualifier "currently"'),
+        (r"\bnow\b", 'temporal qualifier "now"'),
+        (r"\brecently\b", 'temporal qualifier "recently"'),
+        (r"\bsoon\b", 'temporal qualifier "soon"'),
+        (r"\bfor now\b", 'temporal qualifier "for now"'),
+    ]
+
+    # State change language
+    STATE_CHANGE = [
+        (r"\breplaces?\b", 'state change "replaces"'),
+        (r"\bmigrated from\b", 'state change "migrated from"'),
+        (r"\bformerly\b", 'state change "formerly"'),
+        (r"\bold implementation\b", 'state change "old"'),
+        (r"\bnew implementation\b", 'state change "new"'),
+    ]
+
+    # Future references
+    FUTURE_REFS = [
+        (r"\bwill be\b", 'future reference "will be"'),
+        (r"\bplanned\b", 'future reference "planned"'),
+        (r"\bto be added\b", 'future reference "to be added"'),
+        (r"\bcoming soon\b", 'future reference "coming soon"'),
+    ]
+
+    def detect_violations(  # thailint: ignore[nesting]
+        self, text: str
+    ) -> list[tuple[str, str, int]]:
+        """Detect all temporal language violations in text.
+
+        Args:
+            text: Text to check for temporal language
+
+        Returns:
+            List of (pattern, description, line_number) tuples for each violation
+        """
+        violations = []
+
+        # Check all pattern categories
+        all_patterns = (
+            self.DATE_PATTERNS + self.TEMPORAL_QUALIFIERS + self.STATE_CHANGE + self.FUTURE_REFS
+        )
+
+        lines = text.split("\n")
+        for line_num, line in enumerate(lines, start=1):
+            for pattern, description in all_patterns:
+                if re.search(pattern, line, re.IGNORECASE):
+                    violations.append((pattern, description, line_num))
+
+        return violations

src/linters/file_header/config.py

@@ -0,0 +1,66 @@
+"""
+File: src/linters/file_header/config.py
+Purpose: Configuration model for file header linter
+Exports: FileHeaderConfig dataclass
+Depends: dataclasses, pathlib
+Implements: Configuration with validation and defaults
+Related: linter.py for configuration usage
+
+Overview:
+    Defines configuration structure for file header linter including required fields
+    per language, ignore patterns, and validation options. Provides defaults matching
+    ai-doc-standard.md requirements and supports loading from .thailint.yaml configuration.
+
+Usage:
+    config = FileHeaderConfig()
+    config = FileHeaderConfig.from_dict(config_dict, "python")
+
+Notes: Dataclass with validation and language-specific defaults
+"""
+
+from dataclasses import dataclass, field
+
+
+@dataclass
+class FileHeaderConfig:
+    """Configuration for file header linting."""
+
+    # Required fields by language
+    required_fields_python: list[str] = field(
+        default_factory=lambda: [
+            "Purpose",
+            "Scope",
+            "Overview",
+            "Dependencies",
+            "Exports",
+            "Interfaces",
+            "Implementation",
+        ]
+    )
+
+    # Enforce atemporal language checking
+    enforce_atemporal: bool = True
+
+    # Patterns to ignore (file paths)
+    ignore: list[str] = field(
+        default_factory=lambda: ["test/**", "**/migrations/**", "**/__init__.py"]
+    )
+
+    @classmethod
+    def from_dict(cls, config_dict: dict, language: str) -> "FileHeaderConfig":
+        """Create config from dictionary.
+
+        Args:
+            config_dict: Dictionary of configuration values
+            language: Programming language for language-specific config
+
+        Returns:
+            FileHeaderConfig instance with values from dictionary
+        """
+        return cls(
+            required_fields_python=config_dict.get("required_fields", {}).get(
+                "python", cls().required_fields_python
+            ),
+            enforce_atemporal=config_dict.get("enforce_atemporal", True),
+            ignore=config_dict.get("ignore", cls().ignore),
+        )

src/linters/file_header/field_validator.py

@@ -0,0 +1,69 @@
+"""
+File: src/linters/file_header/field_validator.py
+Purpose: Validates mandatory fields in file headers
+Exports: FieldValidator class
+Depends: FileHeaderConfig for field requirements
+Implements: Configuration-driven validation with field presence checking
+Related: linter.py for validator usage, config.py for configuration
+
+Overview:
+    Validates presence and quality of mandatory header fields. Checks that all
+    required fields are present, non-empty, and meet minimum content requirements.
+    Supports language-specific required fields and provides detailed violation messages.
+
+Usage:
+    validator = FieldValidator(config)
+    violations = validator.validate_fields(fields, "python")
+
+Notes: Language-specific field requirements defined in config
+"""
+
+from .config import FileHeaderConfig
+
+
+class FieldValidator:
+    """Validates mandatory fields in headers."""
+
+    def __init__(self, config: FileHeaderConfig):
+        """Initialize validator with configuration.
+
+        Args:
+            config: File header configuration with required fields
+        """
+        self.config = config
+
+    def validate_fields(  # thailint: ignore[nesting]
+        self, fields: dict[str, str], language: str
+    ) -> list[tuple[str, str]]:
+        """Validate all required fields are present.
+
+        Args:
+            fields: Dictionary of parsed header fields
+            language: File language (python, typescript, etc.)
+
+        Returns:
+            List of (field_name, error_message) tuples for missing/invalid fields
+        """
+        violations = []
+        required_fields = self._get_required_fields(language)
+
+        for field_name in required_fields:
+            if field_name not in fields:
+                violations.append((field_name, f"Missing mandatory field: {field_name}"))
+            elif not fields[field_name] or len(fields[field_name].strip()) == 0:
+                violations.append((field_name, f"Empty mandatory field: {field_name}"))
+
+        return violations
+
+    def _get_required_fields(self, language: str) -> list[str]:
+        """Get required fields for language.
+
+        Args:
+            language: Programming language
+
+        Returns:
+            List of required field names for the language
+        """
+        if language == "python":
+            return self.config.required_fields_python
+        return []  # Other languages in PR5