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

src/linter_config/ignore.py

@@ -5,18 +5,18 @@ Scope: Multi-level ignore system across repository, directory, file, method, and
 
 Overview: Implements a sophisticated ignore directive system that allows developers to suppress
     linting violations at five different granularity levels, from entire repository patterns down
-    to individual lines of code. Repository level uses .thailintignore file with gitignore-style
-    glob patterns for excluding files like build artifacts and dependencies. File level scans the
-    first 10 lines for ignore-file directives (performance optimization). Method level supports
-    ignore-next-line directives placed before functions. Line level enables inline ignore comments
-    at the end of code lines. All levels support rule-specific ignores using bracket syntax
-    [rule-id] and wildcard rule matching (literals.* matches literals.magic-number). The
-    should_ignore_violation() method provides unified checking across all levels, integrating
+    to individual lines of code. Repository level uses global ignore patterns from .thailint.yaml
+    with gitignore-style glob patterns for excluding files like build artifacts and dependencies.
+    File level scans the first 10 lines for ignore-file directives (performance optimization).
+    Method level supports ignore-next-line directives placed before functions. Line level enables
+    inline ignore comments at the end of code lines. All levels support rule-specific ignores
+    using bracket syntax [rule-id] and wildcard rule matching (literals.* matches literals.magic-number).
+    The should_ignore_violation() method provides unified checking across all levels, integrating
     with the violation reporting system to filter out suppressed violations before displaying
     results to users.
 
 Dependencies: fnmatch for gitignore-style pattern matching, re for regex-based directive parsing,
-    pathlib for file operations, Violation type for violation checking
+    pathlib for file operations, Violation type for violation checking, yaml for config loading
 
 Exports: IgnoreDirectiveParser class
 
@@ -25,9 +25,9 @@ Interfaces: is_ignored(file_path: Path) -> bool for repo-level checking,
     has_line_ignore(code: str, line_num: int, rule_id: str | None) -> bool for line-level,
     should_ignore_violation(violation: Violation, file_content: str) -> bool for unified checking
 
-Implementation: Gitignore-style pattern matching with fnmatch, first-10-lines scanning for
-    performance, regex-based directive parsing with rule ID extraction, wildcard rule matching
-    with prefix comparison, graceful error handling for malformed directives
+Implementation: Gitignore-style pattern matching with fnmatch, YAML config loading for global patterns,
+    first-10-lines scanning for performance, regex-based directive parsing with rule ID extraction,
+    wildcard rule matching with prefix comparison, graceful error handling for malformed directives
 """
 
 import fnmatch
@@ -35,6 +35,8 @@ import re
 from pathlib import Path
 from typing import TYPE_CHECKING
 
+import yaml
+
 if TYPE_CHECKING:
     from src.core.types import Violation
 
@@ -56,22 +58,58 @@ class IgnoreDirectiveParser:
         self.repo_patterns = self._load_repo_ignores()
 
     def _load_repo_ignores(self) -> list[str]:
-        """Load .thailintignore file patterns.
+        """Load global ignore patterns from .thailintignore or .thailint.yaml."""
+        # First, try to load from .thailintignore (gitignore-style)
+        thailintignore = self.project_root / ".thailintignore"
+        if thailintignore.exists():
+            return self._parse_thailintignore_file(thailintignore)
+
+        # Fall back to .thailint.yaml
+        config_file = self.project_root / ".thailint.yaml"
+        if config_file.exists():
+            return self._parse_config_file(config_file)
+
+        return []
+
+    def _parse_thailintignore_file(self, ignore_file: Path) -> list[str]:
+        """Parse .thailintignore file (gitignore-style).
+
+        Args:
+            ignore_file: Path to .thailintignore file
 
         Returns:
-            List of gitignore-style patterns.
+            List of ignore patterns
         """
-        ignore_file = self.project_root / ".thailintignore"
-        if not ignore_file.exists():
+        try:
+            content = ignore_file.read_text(encoding="utf-8")
+            patterns = []
+            for line in content.splitlines():
+                line = line.strip()
+                # Skip empty lines and comments
+                if line and not line.startswith("#"):
+                    patterns.append(line)
+            return patterns
+        except (OSError, UnicodeDecodeError):
             return []
 
-        patterns = []
-        for line in ignore_file.read_text(encoding="utf-8").splitlines():
-            line = line.strip()
-            # Skip comments and blank lines
-            if line and not line.startswith("#"):
-                patterns.append(line)
-        return patterns
+    def _parse_config_file(self, config_file: Path) -> list[str]:
+        """Parse YAML config file and extract ignore patterns."""
+        try:
+            config = yaml.safe_load(config_file.read_text(encoding="utf-8"))
+            return self._extract_ignore_patterns(config)
+        except (yaml.YAMLError, OSError, UnicodeDecodeError):
+            return []
+
+    @staticmethod
+    def _extract_ignore_patterns(config: dict | None) -> list[str]:
+        """Extract ignore patterns from config dict."""
+        if not config or not isinstance(config, dict):
+            return []
+
+        ignore_patterns = config.get("ignore", [])
+        if isinstance(ignore_patterns, list):
+            return [str(pattern) for pattern in ignore_patterns]
+        return []
 
     def is_ignored(self, file_path: Path) -> bool:
         """Check if file matches repository-level ignore patterns.
@@ -122,13 +160,33 @@ class IgnoreDirectiveParser:
 
     def _has_ignore_directive_marker(self, line: str) -> bool:
         """Check if line contains an ignore directive marker."""
-        return "# thailint: ignore-file" in line or "# design-lint: ignore-file" in line
+        line_lower = line.lower()
+        return "# thailint: ignore-file" in line_lower or "# design-lint: ignore-file" in line_lower
 
     def _check_specific_rule_ignore(self, line: str, rule_id: str) -> bool:
         """Check if line ignores a specific rule."""
-        match = re.search(r"ignore-file\[([^\]]+)\]", line)
-        if match:
-            ignored_rules = [r.strip() for r in match.group(1).split(",")]
+        # Check for bracket syntax: # thailint: ignore-file[rule1, rule2]
+        if self._check_bracket_syntax_file_ignore(line, rule_id):
+            return True
+
+        # Check for space-separated syntax: # thailint: ignore-file rule1 rule2
+        return self._check_space_syntax_file_ignore(line, rule_id)
+
+    def _check_bracket_syntax_file_ignore(self, line: str, rule_id: str) -> bool:
+        """Check bracket syntax for file-level ignore."""
+        bracket_match = re.search(r"ignore-file\[([^\]]+)\]", line, re.IGNORECASE)
+        if bracket_match:
+            ignored_rules = [r.strip() for r in bracket_match.group(1).split(",")]
+            return any(self._rule_matches(rule_id, r) for r in ignored_rules)
+        return False
+
+    def _check_space_syntax_file_ignore(self, line: str, rule_id: str) -> bool:
+        """Check space-separated syntax for file-level ignore."""
+        space_match = re.search(r"ignore-file\s+([^\s#]+(?:\s+[^\s#]+)*)", line, re.IGNORECASE)
+        if space_match:
+            ignored_rules = [
+                r.strip() for r in re.split(r"[,\s]+", space_match.group(1)) if r.strip()
+            ]
             return any(self._rule_matches(rule_id, r) for r in ignored_rules)
         return False
 
@@ -171,27 +229,28 @@ class IgnoreDirectiveParser:
 
     def _has_line_ignore_marker(self, code: str) -> bool:
         """Check if code line has ignore marker."""
+        code_lower = code.lower()
         return (
-            "# thailint: ignore" in code
-            or "# design-lint: ignore" in code
-            or "// thailint: ignore" in code
-            or "// design-lint: ignore" in code
+            "# thailint: ignore" in code_lower
+            or "# design-lint: ignore" in code_lower
+            or "// thailint: ignore" in code_lower
+            or "// design-lint: ignore" in code_lower
         )
 
     def _check_specific_rule_in_line(self, code: str, rule_id: str) -> bool:
         """Check if line's ignore directive matches specific rule."""
         # Check for bracket syntax: # thailint: ignore[rule1, rule2]
-        bracket_match = re.search(r"ignore\[([^\]]+)\]", code)
+        bracket_match = re.search(r"ignore\[([^\]]+)\]", code, re.IGNORECASE)
         if bracket_match:
             return self._check_bracket_rules(bracket_match.group(1), rule_id)
 
         # Check for space-separated syntax: # thailint: ignore rule1 rule2
-        space_match = re.search(r"ignore\s+([^\s#]+(?:\s+[^\s#]+)*)", code)
+        space_match = re.search(r"ignore\s+([^\s#]+(?:\s+[^\s#]+)*)", code, re.IGNORECASE)
         if space_match:
             return self._check_space_separated_rules(space_match.group(1), rule_id)
 
         # No specific rules - check for "ignore-all"
-        return "ignore-all" in code
+        return "ignore-all" in code.lower()
 
     def _check_bracket_rules(self, rules_text: str, rule_id: str) -> bool:
         """Check if bracketed rules match the rule ID."""
@@ -231,17 +290,21 @@ class IgnoreDirectiveParser:
         Returns:
             True if rule matches pattern.
         """
-        if pattern.endswith("*"):
+        # Case-insensitive comparison
+        rule_id_lower = rule_id.lower()
+        pattern_lower = pattern.lower()
+
+        if pattern_lower.endswith("*"):
             # Wildcard match: literals.* matches literals.magic-number
-            prefix = pattern[:-1]
-            return rule_id.startswith(prefix)
+            prefix = pattern_lower[:-1]
+            return rule_id_lower.startswith(prefix)
 
         # Exact match
-        if rule_id == pattern:
+        if rule_id_lower == pattern_lower:
             return True
 
         # Prefix match: "nesting" matches "nesting.excessive-depth"
-        if rule_id.startswith(pattern + "."):
+        if rule_id_lower.startswith(pattern_lower + "."):
             return True
 
         return False
@@ -293,18 +356,27 @@ class IgnoreDirectiveParser:
         file_path = Path(violation.file_path)
 
         # Repository and file level checks
-        if self._is_ignored_at_file_level(file_path, violation.rule_id):
+        if self._is_ignored_at_file_level(file_path, violation.rule_id, file_content):
             return True
 
         # Line-based checks
         return self._is_ignored_in_content(file_content, violation)
 
-    def _is_ignored_at_file_level(self, file_path: Path, rule_id: str) -> bool:
+    def _is_ignored_at_file_level(self, file_path: Path, rule_id: str, file_content: str) -> bool:
         """Check repository and file level ignores."""
         if self.is_ignored(file_path):
             return True
+        # Check content first (for tests with in-memory content)
+        if self._has_file_ignore_in_content(file_content, rule_id):
+            return True
+        # Fall back to reading from disk if file exists
         return self.has_file_ignore(file_path, rule_id)
 
+    def _has_file_ignore_in_content(self, file_content: str, rule_id: str | None) -> bool:
+        """Check if file content has ignore-file directive."""
+        lines = file_content.splitlines()[:10]  # Check first 10 lines
+        return any(self._check_line_for_ignore(line, rule_id) for line in lines)
+
     def _is_ignored_in_content(self, file_content: str, violation: "Violation") -> bool:
         """Check content-based ignores (block, line, method level)."""
         lines = file_content.splitlines()

src/linter_config/loader.py

@@ -25,11 +25,10 @@ Implementation: Extension-based format detection (.yaml/.yml vs .json), yaml.saf
     for security, empty dict handling for null YAML, ValueError for unsupported formats
 """
 
-import json
 from pathlib import Path
 from typing import Any
 
-import yaml
+from src.core.config_parser import parse_config_file
 
 
 class LinterConfigLoader:
@@ -49,21 +48,12 @@ class LinterConfigLoader:
             Configuration dictionary.
 
         Raises:
-            ValueError: If file format is unsupported.
-            yaml.YAMLError: If YAML is malformed.
-            json.JSONDecodeError: If JSON is malformed.
+            ConfigParseError: If file format is unsupported or parsing fails.
         """
         if not config_path.exists():
             return self.get_defaults()
 
-        suffix = config_path.suffix.lower()
-
-        with config_path.open(encoding="utf-8") as f:
-            if suffix in [".yaml", ".yml"]:
-                return yaml.safe_load(f) or {}
-            if suffix == ".json":
-                return json.load(f)
-            raise ValueError(f"Unsupported config format: {suffix}")
+        return parse_config_file(config_path)
 
     def get_defaults(self) -> dict[str, Any]:
         """Get default configuration.

src/linters/dry/__init__.py

@@ -0,0 +1,23 @@
+"""
+Purpose: DRY (Don't Repeat Yourself) linter module exports
+
+Scope: Module-level exports for DRY linter components
+
+Overview: Provides centralized exports for the DRY linter module components. Exposes the main
+    DRYRule class for duplicate code detection, configuration dataclass, and analyzer components.
+    Simplifies imports for consumers by providing a single import point for all DRY linter
+    functionality. Follows the established pattern from nesting and SRP linters.
+
+Dependencies: linter.DRYRule, config.DRYConfig
+
+Exports: DRYRule (main rule class), DRYConfig (configuration)
+
+Interfaces: Module-level __all__ list defining public API
+
+Implementation: Standard Python module with explicit exports via __all__
+"""
+
+from .config import DRYConfig
+from .linter import DRYRule
+
+__all__ = ["DRYRule", "DRYConfig"]

src/linters/dry/base_token_analyzer.py

@@ -0,0 +1,76 @@
+"""
+Purpose: Base class for token-based duplicate code analysis
+
+Scope: Common duplicate detection workflow for Python and TypeScript analyzers
+
+Overview: Provides shared infrastructure for token-based duplicate code detection across different
+    programming languages. Implements common workflow of tokenization, rolling hash window generation,
+    and CodeBlock creation. Subclasses provide language-specific filtering (e.g., interface filtering
+    for TypeScript). Eliminates duplication between PythonDuplicateAnalyzer and TypeScriptDuplicateAnalyzer
+    by extracting shared analyze() method pattern and CodeBlock creation logic.
+
+Dependencies: TokenHasher, CodeBlock, DRYConfig, pathlib.Path
+
+Exports: BaseTokenAnalyzer class
+
+Interfaces: BaseTokenAnalyzer.analyze(file_path: Path, content: str, config: DRYConfig) -> list[CodeBlock]
+
+Implementation: Template method pattern with extension point for language-specific block filtering
+"""
+
+from pathlib import Path
+
+from .cache import CodeBlock
+from .config import DRYConfig
+from .token_hasher import TokenHasher
+
+
+class BaseTokenAnalyzer:
+    """Base analyzer for token-based duplicate detection."""
+
+    def __init__(self) -> None:
+        """Initialize analyzer with token hasher."""
+        self._hasher = TokenHasher()
+
+    def analyze(self, file_path: Path, content: str, config: DRYConfig) -> list[CodeBlock]:
+        """Analyze file for duplicate code blocks.
+
+        Args:
+            file_path: Path to source file
+            content: File content
+            config: DRY configuration
+
+        Returns:
+            List of CodeBlock instances with hash values
+        """
+        lines = self._hasher.tokenize(content)
+        windows = self._hasher.rolling_hash(lines, config.min_duplicate_lines)
+
+        blocks = []
+        for hash_val, start_line, end_line, snippet in windows:
+            if self._should_include_block(content, start_line, end_line):
+                block = CodeBlock(
+                    file_path=file_path,
+                    start_line=start_line,
+                    end_line=end_line,
+                    snippet=snippet,
+                    hash_value=hash_val,
+                )
+                blocks.append(block)
+
+        return blocks
+
+    def _should_include_block(self, content: str, start_line: int, end_line: int) -> bool:
+        """Determine if block should be included.
+
+        Extension point for language-specific filtering.
+
+        Args:
+            content: File content
+            start_line: Block start line
+            end_line: Block end line
+
+        Returns:
+            True if block should be included, False to filter out
+        """
+        return True

src/linters/dry/block_filter.py

@@ -0,0 +1,265 @@
+"""
+Purpose: Extensible filter system for DRY duplicate detection
+
+Scope: Filters out false positive duplications (API boilerplate, keyword arguments, etc.)
+
+Overview: Provides an extensible architecture for filtering duplicate code blocks that are
+    not meaningful duplications. Includes base filter interface and built-in filters for
+    common false positive patterns like keyword-only function arguments, import groups,
+    and API call boilerplate. New filters can be added by subclassing BaseBlockFilter.
+
+Dependencies: ast, re, typing
+
+Exports: BaseBlockFilter, BlockFilterRegistry, KeywordArgumentFilter, ImportGroupFilter
+
+Interfaces: BaseBlockFilter.should_filter(code_block, file_content) -> bool
+
+Implementation: Strategy pattern with filter registry for extensibility
+"""
+
+import ast
+import re
+from abc import ABC, abstractmethod
+from pathlib import Path
+from typing import Protocol
+
+# Default filter threshold constants
+DEFAULT_KEYWORD_ARG_THRESHOLD = 0.8
+
+
+class CodeBlock(Protocol):
+    """Protocol for code blocks (matches cache.CodeBlock)."""
+
+    file_path: Path
+    start_line: int
+    end_line: int
+    snippet: str
+    hash_value: int
+
+
+class BaseBlockFilter(ABC):
+    """Base class for duplicate block filters."""
+
+    @abstractmethod
+    def should_filter(self, block: CodeBlock, file_content: str) -> bool:
+        """Determine if a code block should be filtered out.
+
+        Args:
+            block: Code block to evaluate
+            file_content: Full file content for context
+
+        Returns:
+            True if block should be filtered (not reported as duplicate)
+        """
+        pass
+
+    @abstractmethod
+    def get_name(self) -> str:
+        """Get filter name for configuration and logging."""
+        pass
+
+
+class KeywordArgumentFilter(BaseBlockFilter):
+    """Filters blocks that are primarily keyword arguments in function calls.
+
+    Detects patterns like:
+        message=message,
+        severity=Severity.ERROR,
+        suggestion=suggestion,
+
+    These are common in builder patterns and API calls.
+    """
+
+    def __init__(self, threshold: float = DEFAULT_KEYWORD_ARG_THRESHOLD):
+        """Initialize filter.
+
+        Args:
+            threshold: Minimum percentage of lines that must be keyword args (0.0-1.0)
+        """
+        self.threshold = threshold
+        # Pattern: optional whitespace, identifier, =, value, optional comma
+        self._kwarg_pattern = re.compile(r"^\s*\w+\s*=\s*.+,?\s*$")
+
+    def should_filter(self, block: CodeBlock, file_content: str) -> bool:
+        """Check if block is primarily keyword arguments.
+
+        Args:
+            block: Code block to evaluate
+            file_content: Full file content for context
+
+        Returns:
+            True if block should be filtered
+        """
+        lines = file_content.split("\n")[block.start_line - 1 : block.end_line]
+
+        if not lines:
+            return False
+
+        # Count lines that match keyword argument pattern
+        kwarg_lines = sum(1 for line in lines if self._kwarg_pattern.match(line))
+
+        # Filter if most lines are keyword arguments
+        ratio = kwarg_lines / len(lines)
+        if ratio >= self.threshold:
+            return self._is_inside_function_call(block, file_content)
+
+        return False
+
+    def _is_inside_function_call(self, block: CodeBlock, file_content: str) -> bool:
+        """Verify the block is inside a function call, not standalone code."""
+        try:
+            tree = ast.parse(file_content)
+        except SyntaxError:
+            return False
+
+        # Find if any Call node contains the block
+        for node in ast.walk(tree):
+            if isinstance(node, ast.Call) and self._check_multiline_containment(node, block):
+                return True
+        return False
+
+    @staticmethod
+    def _check_multiline_containment(node: ast.Call, block: CodeBlock) -> bool:
+        """Check if Call node is multiline and contains block."""
+        if not KeywordArgumentFilter._has_valid_line_info(node):
+            return False
+
+        # After validation, these are guaranteed to be non-None integers
+        # Use type: ignore to suppress MyPy's inability to understand runtime validation
+        is_multiline = node.lineno < node.end_lineno  # type: ignore[operator]
+        contains_block = (
+            node.lineno <= block.start_line and node.end_lineno >= block.end_line  # type: ignore[operator]
+        )
+        return is_multiline and contains_block
+
+    @staticmethod
+    def _has_valid_line_info(node: ast.Call) -> bool:
+        """Check if node has valid line information.
+
+        Args:
+            node: AST Call node to check
+
+        Returns:
+            True if node has valid line number attributes
+        """
+        if not hasattr(node, "lineno"):
+            return False
+        if not hasattr(node, "end_lineno"):
+            return False
+        if node.lineno is None:
+            return False
+        if node.end_lineno is None:
+            return False
+        return True
+
+    def get_name(self) -> str:
+        """Get filter name."""
+        return "keyword_argument_filter"
+
+
+class ImportGroupFilter(BaseBlockFilter):
+    """Filters blocks that are just import statements.
+
+    Import organization often creates similar patterns that aren't meaningful duplication.
+    """
+
+    def should_filter(self, block: CodeBlock, file_content: str) -> bool:
+        """Check if block is only import statements.
+
+        Args:
+            block: Code block to evaluate
+            file_content: Full file content
+
+        Returns:
+            True if block should be filtered
+        """
+        lines = file_content.split("\n")[block.start_line - 1 : block.end_line]
+
+        for line in lines:
+            stripped = line.strip()
+            if not stripped:
+                continue
+            if not (stripped.startswith("import ") or stripped.startswith("from ")):
+                return False
+
+        return True
+
+    def get_name(self) -> str:
+        """Get filter name."""
+        return "import_group_filter"
+
+
+class BlockFilterRegistry:
+    """Registry for managing duplicate block filters."""
+
+    def __init__(self) -> None:
+        """Initialize empty registry."""
+        self._filters: list[BaseBlockFilter] = []
+        self._enabled_filters: set[str] = set()
+
+    def register(self, filter_instance: BaseBlockFilter) -> None:
+        """Register a filter.
+
+        Args:
+            filter_instance: Filter to register
+        """
+        self._filters.append(filter_instance)
+        self._enabled_filters.add(filter_instance.get_name())
+
+    def enable_filter(self, filter_name: str) -> None:
+        """Enable a specific filter by name.
+
+        Args:
+            filter_name: Name of filter to enable
+        """
+        self._enabled_filters.add(filter_name)
+
+    def disable_filter(self, filter_name: str) -> None:
+        """Disable a specific filter by name.
+
+        Args:
+            filter_name: Name of filter to disable
+        """
+        self._enabled_filters.discard(filter_name)
+
+    def should_filter_block(self, block: CodeBlock, file_content: str) -> bool:
+        """Check if any enabled filter wants to filter this block.
+
+        Args:
+            block: Code block to evaluate
+            file_content: Full file content
+
+        Returns:
+            True if block should be filtered out
+        """
+        for filter_instance in self._filters:
+            if filter_instance.get_name() not in self._enabled_filters:
+                continue
+
+            if filter_instance.should_filter(block, file_content):
+                return True
+
+        return False
+
+    def get_enabled_filters(self) -> list[str]:
+        """Get list of enabled filter names.
+
+        Returns:
+            List of enabled filter names
+        """
+        return sorted(self._enabled_filters)
+
+
+def create_default_registry() -> BlockFilterRegistry:
+    """Create registry with default filters.
+
+    Returns:
+        BlockFilterRegistry with common filters registered
+    """
+    registry = BlockFilterRegistry()
+
+    # Register built-in filters
+    registry.register(KeywordArgumentFilter(threshold=DEFAULT_KEYWORD_ARG_THRESHOLD))
+    registry.register(ImportGroupFilter())
+
+    return registry