thailint 0.1.6__py3-none-any.whl → 0.2.1__py3-none-any.whl

src/linters/dry/violation_filter.py

@@ -0,0 +1,91 @@
+"""
+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
+
+
+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 5  # 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_placement/config_loader.py

@@ -0,0 +1,86 @@
+"""
+Purpose: Configuration file loading for file placement linter
+
+Scope: Handles loading and parsing of JSON/YAML configuration files
+
+Overview: Provides configuration file loading functionality for the file placement linter.
+    Supports both JSON and YAML config formats, handles path resolution relative to project
+    root, and provides safe defaults when config files are missing or invalid. Isolates
+    file I/O concerns from business logic to maintain single responsibility.
+
+Dependencies: pathlib, json, yaml
+
+Exports: ConfigLoader
+
+Interfaces: load_config_file(config_file, project_root) -> dict
+
+Implementation: Uses standard library JSON and PyYAML for parsing, returns empty dict on errors
+"""
+
+import json
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+
+class ConfigLoader:
+    """Loads configuration files for file placement linter."""
+
+    def __init__(self, project_root: Path):
+        """Initialize config loader.
+
+        Args:
+            project_root: Project root directory
+        """
+        self.project_root = project_root
+
+    def load_config_file(self, config_file: str) -> dict[str, Any]:
+        """Load configuration from file.
+
+        Args:
+            config_file: Path to config file
+
+        Returns:
+            Loaded configuration dict, or empty dict if file doesn't exist
+
+        Raises:
+            ValueError: If config file format is unsupported
+        """
+        config_path = self._resolve_path(config_file)
+        if not config_path.exists():
+            return {}
+        return self._parse_file(config_path)
+
+    def _resolve_path(self, config_file: str) -> Path:
+        """Resolve config file path relative to project root.
+
+        Args:
+            config_file: Config file path (relative or absolute)
+
+        Returns:
+            Resolved absolute path
+        """
+        config_path = Path(config_file)
+        if not config_path.is_absolute():
+            config_path = self.project_root / config_path
+        return config_path
+
+    def _parse_file(self, config_path: Path) -> dict[str, Any]:
+        """Parse config file based on extension.
+
+        Args:
+            config_path: Path to config file
+
+        Returns:
+            Parsed configuration dict
+
+        Raises:
+            ValueError: If file format is unsupported
+        """
+        with config_path.open(encoding="utf-8") as f:
+            if config_path.suffix in [".yaml", ".yml"]:
+                return yaml.safe_load(f) or {}
+            if config_path.suffix == ".json":
+                return json.load(f)
+            raise ValueError(f"Unsupported config format: {config_path.suffix}")

src/linters/file_placement/directory_matcher.py

@@ -0,0 +1,80 @@
+"""
+Purpose: Directory rule matching for file placement linter
+
+Scope: Finds most specific directory rule matching a file path
+
+Overview: Provides directory matching functionality for the file placement linter. Implements
+    most-specific-directory matching logic by comparing path prefixes and calculating directory
+    depth. Handles special case of root directory matching. Returns matched rule and path for
+    further processing. Isolates directory matching logic from rule checking and pattern matching.
+
+Dependencies: typing
+
+Exports: DirectoryMatcher
+
+Interfaces: find_matching_rule(path_str, directories) -> (rule_dict, matched_path)
+
+Implementation: Prefix matching with depth-based precedence, root directory special case
+"""
+
+from typing import Any
+
+
+class DirectoryMatcher:
+    """Finds matching directory rules based on path prefixes."""
+
+    def find_matching_rule(
+        self, path_str: str, directories: dict[str, Any]
+    ) -> tuple[dict[str, Any] | None, str | None]:
+        """Find most specific directory rule matching the path.
+
+        Args:
+            path_str: File path string
+            directories: Directory rules
+
+        Returns:
+            Tuple of (rule_dict, matched_path)
+        """
+        best_match = None
+        best_path = None
+        best_depth = -1
+
+        for dir_path, rules in directories.items():
+            matches, depth = self._check_path_match(dir_path, path_str)
+            if matches and depth > best_depth:
+                best_match = rules
+                best_path = dir_path
+                best_depth = depth
+
+        return best_match, best_path
+
+    def _check_path_match(self, dir_path: str, path_str: str) -> tuple[bool, int]:
+        """Check if path matches directory rule.
+
+        Args:
+            dir_path: Directory path pattern
+            path_str: File path string
+
+        Returns:
+            Tuple of (matches, depth) where depth is directory nesting level
+        """
+        if dir_path == "/":
+            return self._check_root_match(dir_path, path_str)
+        if path_str.startswith(dir_path):
+            depth = len(dir_path.split("/"))
+            return True, depth
+        return False, -1
+
+    def _check_root_match(self, dir_path: str, path_str: str) -> tuple[bool, int]:
+        """Check if path matches root directory rule.
+
+        Args:
+            dir_path: Directory path (should be "/")
+            path_str: File path string
+
+        Returns:
+            Tuple of (matches, depth)
+        """
+        if dir_path == "/" and "/" not in path_str:
+            return True, 0
+        return False, -1