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

src/core/registry.py

@@ -3,36 +3,24 @@ Purpose: Rule registry with automatic plugin discovery and registration
 
 Scope: Dynamic rule management and discovery across all linter plugin packages
 
-Overview: Implements the plugin discovery system that enables the extensible architecture by
-    automatically finding and registering linting rules from specified packages without requiring
-    explicit registration code. The RuleRegistry maintains a collection of discovered rules indexed
-    by rule_id, providing methods to register individual rules, retrieve rules by identifier, and
-    list all available rules. Auto-discovery works by scanning Python packages for classes that
-    inherit from BaseLintRule, filtering out abstract base classes, instantiating concrete rule
-    classes, and registering them for use by the orchestrator. This enables developers to add new
-    rules simply by creating a class in the appropriate package structure without modifying any
-    framework code. The registry handles import errors gracefully and supports both package-level
-    and module-level discovery patterns.
-
-Dependencies: importlib for dynamic module loading, inspect for class introspection,
-    pkgutil for package traversal, BaseLintRule for type checking
+Overview: Implements rule registry that maintains a collection of registered linting rules indexed
+    by rule_id. Provides methods to register individual rules, retrieve rules by identifier, list
+    all available rules, and discover rules from packages using the RuleDiscovery helper. Enables
+    the extensible plugin architecture by allowing rules to be added dynamically without framework
+    modifications. Validates rule uniqueness and handles registration errors gracefully.
+
+Dependencies: BaseLintRule, RuleDiscovery
 
 Exports: RuleRegistry class with register(), get(), list_all(), and discover_rules() methods
 
 Interfaces: register(rule: BaseLintRule) -> None, get(rule_id: str) -> BaseLintRule | None,
     list_all() -> list[BaseLintRule], discover_rules(package_path: str) -> int
 
-Implementation: Package scanning with pkgutil.iter_modules(), class introspection with inspect,
-    subclass detection for BaseLintRule, abstract class filtering, graceful error handling for
-    failed imports, duplicate rule_id validation
+Implementation: Dictionary-based registry with RuleDiscovery delegation, duplicate validation
 """
 
-import importlib
-import inspect
-import pkgutil
-from typing import Any
-
 from .base import BaseLintRule
+from .rule_discovery import RuleDiscovery
 
 
 class RuleRegistry:
@@ -45,6 +33,7 @@ class RuleRegistry:
     def __init__(self) -> None:
         """Initialize empty registry."""
         self._rules: dict[str, BaseLintRule] = {}
+        self._discovery = RuleDiscovery()
 
     def register(self, rule: BaseLintRule) -> None:
         """Register a new rule.
@@ -93,78 +82,14 @@ class RuleRegistry:
         Returns:
             Number of rules discovered and registered.
         """
-        try:
-            package = importlib.import_module(package_path)
-        except ImportError:
-            return 0
-
-        if not hasattr(package, "__path__"):
-            return self._discover_from_module(package_path)
-
-        return self._discover_from_package_modules(package_path, package)
-
-    def _discover_from_package_modules(self, package_path: str, package: Any) -> int:
-        """Discover rules from all modules in a package."""
-        discovered_count = 0
-        for _, module_name, _ in pkgutil.iter_modules(package.__path__):
-            full_module_name = f"{package_path}.{module_name}"
-            discovered_count += self._try_discover_from_module(full_module_name)
-        return discovered_count
-
-    def _try_discover_from_module(self, module_name: str) -> int:
-        """Try to discover rules from a module, return 0 on error."""
-        try:
-            return self._discover_from_module(module_name)
-        except (ImportError, AttributeError):
-            return 0
-
-    def _discover_from_module(self, module_path: str) -> int:
-        """Discover rules from a specific module.
-
-        Args:
-            module_path: Full module path to search.
+        discovered_rules = self._discovery.discover_from_package(package_path)
+        return sum(1 for rule in discovered_rules if self._try_register(rule))
 
-        Returns:
-            Number of rules discovered from this module.
-        """
+    def _try_register(self, rule: BaseLintRule) -> bool:
+        """Try to register a rule, return True if successful."""
         try:
-            module = importlib.import_module(module_path)
-        except (ImportError, AttributeError):
-            return 0
-
-        return self._register_rules_from_module(module)
-
-    def _register_rules_from_module(self, module: Any) -> int:
-        """Register all rule classes from a module."""
-        discovered_count = 0
-        for _name, obj in inspect.getmembers(module):
-            if not self._is_rule_class(obj):
-                continue
-            if self._try_register_rule_class(obj):
-                discovered_count += 1
-        return discovered_count
-
-    def _try_register_rule_class(self, rule_class: Any) -> bool:
-        """Try to instantiate and register a rule class."""
-        try:
-            rule_instance = rule_class()
-            self.register(rule_instance)
+            self.register(rule)
             return True
-        except (TypeError, AttributeError, ValueError):
+        except ValueError:
+            # Rule already registered, skip
             return False
-
-    def _is_rule_class(self, obj: Any) -> bool:
-        """Check if an object is a valid rule class.
-
-        Args:
-            obj: Object to check.
-
-        Returns:
-            True if obj is a concrete BaseLintRule subclass.
-        """
-        return (
-            inspect.isclass(obj)
-            and issubclass(obj, BaseLintRule)
-            and obj is not BaseLintRule  # Don't instantiate the base class
-            and not inspect.isabstract(obj)  # Don't instantiate abstract classes
-        )

src/core/rule_discovery.py

@@ -0,0 +1,132 @@
+"""
+Purpose: Automatic rule discovery for plugin-based linter architecture
+
+Scope: Discovers and validates linting rules from Python packages
+
+Overview: Provides automatic rule discovery functionality for the linter framework. Scans Python
+    packages for classes inheriting from BaseLintRule, filters out abstract base classes, validates
+    rule classes, and attempts instantiation. Handles import errors gracefully to support partial
+    package installations. Enables plugin architecture by discovering rules without explicit registration.
+
+Dependencies: importlib, inspect, pkgutil, BaseLintRule
+
+Exports: RuleDiscovery
+
+Interfaces: discover_from_package(package_path) -> list[BaseLintRule]
+
+Implementation: Package traversal with pkgutil, class introspection with inspect, error handling
+"""
+
+import importlib
+import inspect
+import pkgutil
+from typing import Any
+
+from .base import BaseLintRule
+
+
+class RuleDiscovery:
+    """Discovers linting rules from Python packages."""
+
+    def discover_from_package(self, package_path: str) -> list[BaseLintRule]:
+        """Discover rules from a package and its modules.
+
+        Args:
+            package_path: Python package path (e.g., 'src.linters')
+
+        Returns:
+            List of discovered rule instances
+        """
+        try:
+            package = importlib.import_module(package_path)
+        except ImportError:
+            return []
+
+        if not hasattr(package, "__path__"):
+            return self._discover_from_module(package_path)
+
+        return self._discover_from_package_modules(package_path, package)
+
+    def _discover_from_package_modules(self, package_path: str, package: Any) -> list[BaseLintRule]:
+        """Discover rules from all modules in a package.
+
+        Args:
+            package_path: Package path
+            package: Imported package object
+
+        Returns:
+            List of discovered rules
+        """
+        rules = []
+        for _, module_name, _ in pkgutil.iter_modules(package.__path__):
+            full_module_name = f"{package_path}.{module_name}"
+            module_rules = self._try_discover_from_module(full_module_name)
+            rules.extend(module_rules)
+        return rules
+
+    def _try_discover_from_module(self, module_name: str) -> list[BaseLintRule]:
+        """Try to discover rules from a module, return empty list on error.
+
+        Args:
+            module_name: Full module name
+
+        Returns:
+            List of discovered rules (empty on error)
+        """
+        try:
+            return self._discover_from_module(module_name)
+        except (ImportError, AttributeError):
+            return []
+
+    def _discover_from_module(self, module_path: str) -> list[BaseLintRule]:
+        """Discover rules from a specific module.
+
+        Args:
+            module_path: Full module path to search
+
+        Returns:
+            List of discovered rule instances
+        """
+        try:
+            module = importlib.import_module(module_path)
+        except (ImportError, AttributeError):
+            return []
+
+        rules = []
+        for _name, obj in inspect.getmembers(module):
+            if not self._is_rule_class(obj):
+                continue
+            rule_instance = self._try_instantiate_rule(obj)
+            if rule_instance:
+                rules.append(rule_instance)
+        return rules
+
+    def _try_instantiate_rule(self, rule_class: type[BaseLintRule]) -> BaseLintRule | None:
+        """Try to instantiate a rule class.
+
+        Args:
+            rule_class: Rule class to instantiate
+
+        Returns:
+            Rule instance or None on error
+        """
+        try:
+            return rule_class()
+        except (TypeError, AttributeError):
+            return None
+
+    def _is_rule_class(self, obj: Any) -> bool:
+        """Check if an object is a valid rule class.
+
+        Args:
+            obj: Object to check
+
+        Returns:
+            True if obj is a concrete BaseLintRule subclass
+        """
+        return (
+            inspect.isclass(obj)
+            and issubclass(obj, BaseLintRule)
+            and obj is not BaseLintRule
+            and not inspect.isabstract(obj)
+        )

src/core/violation_builder.py

@@ -0,0 +1,122 @@
+"""
+Purpose: Base violation builder class for consistent violation creation across all linters
+
+Scope: Core violation building functionality used by all linter violation builders
+
+Overview: Provides base classes and data structures for violation creation across all linters.
+    Defines ViolationInfo dataclass containing all required and optional violation fields,
+    and BaseViolationBuilder class with common build() method. Eliminates duplicate violation
+    construction patterns across file_placement, nesting, and srp linters. Ensures consistent
+    violation creation with proper defaults for column and severity fields. Linter-specific
+    builders extend this base class to inherit common construction logic while maintaining
+    their domain-specific message generation and suggestion logic.
+
+Dependencies: dataclasses, src.core.types (Violation, Severity)
+
+Exports: ViolationInfo dataclass, BaseViolationBuilder class
+
+Interfaces: ViolationInfo(rule_id, file_path, line, message, column, severity),
+    BaseViolationBuilder.build(info: ViolationInfo) -> Violation
+
+Implementation: Uses dataclass for type-safe violation info, base class provides build()
+    method that constructs Violation objects with proper defaults
+"""
+
+from dataclasses import dataclass
+
+from src.core.types import Severity, Violation
+
+
+@dataclass
+class ViolationInfo:
+    """Information needed to build a violation.
+
+    Attributes:
+        rule_id: Identifier for the rule that was violated
+        file_path: Path to the file containing the violation
+        line: Line number where violation occurs (1-indexed)
+        message: Description of the violation
+        column: Column number where violation occurs (0-indexed, default=1)
+        severity: Severity level of the violation (default=ERROR)
+        suggestion: Optional suggestion for fixing the violation
+    """
+
+    rule_id: str
+    file_path: str
+    line: int
+    message: str
+    column: int = 1
+    severity: Severity = Severity.ERROR
+    suggestion: str | None = None
+
+
+class BaseViolationBuilder:
+    """Base class for building violations with consistent structure.
+
+    Provides common build() method for creating Violation objects from ViolationInfo.
+    Linter-specific builders extend this class to add their domain-specific violation
+    creation methods while inheriting the common construction logic.
+    """
+
+    def build(self, info: ViolationInfo) -> Violation:
+        """Build a Violation from ViolationInfo.
+
+        Args:
+            info: ViolationInfo containing all violation details
+
+        Returns:
+            Violation object with all fields populated
+        """
+        return Violation(
+            rule_id=info.rule_id,
+            file_path=info.file_path,
+            line=info.line,
+            column=info.column,
+            message=info.message,
+            severity=info.severity,
+            suggestion=info.suggestion,
+        )
+
+    def build_from_params(  # pylint: disable=too-many-arguments,too-many-positional-arguments
+        self,
+        rule_id: str,
+        file_path: str,
+        line: int,
+        message: str,
+        column: int = 1,
+        severity: Severity = Severity.ERROR,
+        suggestion: str | None = None,
+    ) -> Violation:
+        """Build a Violation directly from parameters.
+
+        Note: Pylint too-many-arguments disabled. This convenience method mirrors the
+        ViolationInfo dataclass fields (7 parameters, 3 with defaults). The alternative
+        would require every caller to create ViolationInfo objects manually, reducing
+        readability. This is a standard builder pattern where all parameters are
+        inherently related (Violation fields).
+
+        This is a convenience method that combines ViolationInfo creation and build()
+        to reduce duplication in violation builder methods.
+
+        Args:
+            rule_id: Identifier for the rule that was violated
+            file_path: Path to the file containing the violation
+            line: Line number where violation occurs (1-indexed)
+            message: Description of the violation
+            column: Column number where violation occurs (0-indexed, default=1)
+            severity: Severity level of the violation (default=ERROR)
+            suggestion: Optional suggestion for fixing the violation
+
+        Returns:
+            Violation object with all fields populated
+        """
+        info = ViolationInfo(
+            rule_id=rule_id,
+            file_path=file_path,
+            line=line,
+            message=message,
+            column=column,
+            severity=severity,
+            suggestion=suggestion,
+        )
+        return self.build(info)

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()