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

src/core/rule_discovery.py

@@ -10,7 +10,7 @@ Overview: Provides automatic rule discovery functionality for the linter framewo
 
 Dependencies: importlib, inspect, pkgutil, BaseLintRule
 
-Exports: RuleDiscovery
+Exports: discover_from_package function, RuleDiscovery class (compat)
 
 Interfaces: discover_from_package(package_path) -> list[BaseLintRule]
 
@@ -19,114 +19,177 @@ Implementation: Package traversal with pkgutil, class introspection with inspect
 
 import importlib
 import inspect
+import logging
 import pkgutil
+from types import ModuleType
 from typing import Any
 
 from .base import BaseLintRule
 
+logger = logging.getLogger(__name__)
 
-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.
+def discover_from_package(package_path: str) -> list[BaseLintRule]:
+    """Discover rules from a package and its modules.
 
-        Args:
-            package_path: Python package path (e.g., 'src.linters')
+    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 []
+    Returns:
+        List of discovered rule instances
+    """
+    try:
+        package = importlib.import_module(package_path)
+    except ImportError as e:
+        logger.debug("Failed to import package %s: %s", package_path, e)
+        return []
 
-        if not hasattr(package, "__path__"):
-            return self._discover_from_module(package_path)
+    if not hasattr(package, "__path__"):
+        return _discover_from_module(package_path)
 
-        return self._discover_from_package_modules(package_path, package)
+    return _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
+def _discover_from_package_modules(package_path: str, package: Any) -> list[BaseLintRule]:
+    """Discover rules from all modules in a package.
 
-        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
+    Args:
+        package_path: Package path
+        package: Imported package object
 
-    def _try_discover_from_module(self, module_name: str) -> list[BaseLintRule]:
-        """Try to discover rules from a module, return empty list on error.
+    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 = _try_discover_from_module(full_module_name)
+        rules.extend(module_rules)
+    return rules
 
-        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 _try_discover_from_module(module_name: str) -> list[BaseLintRule]:
+    """Try to discover rules from a module, return empty list on error.
 
-    def _discover_from_module(self, module_path: str) -> list[BaseLintRule]:
-        """Discover rules from a specific module.
+    Args:
+        module_name: Full module name
 
-        Args:
-            module_path: Full module path to search
+    Returns:
+        List of discovered rules (empty on error)
+    """
+    try:
+        return _discover_from_module(module_name)
+    except (ImportError, AttributeError):
+        return []
 
-        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
+def _discover_from_module(module_path: str) -> list[BaseLintRule]:
+    """Discover rules from a specific module.
 
-        Returns:
-            Rule instance or None on error
-        """
-        try:
-            return rule_class()
-        except (TypeError, AttributeError):
-            return None
+    Args:
+        module_path: Full module path to search
+
+    Returns:
+        List of discovered rule instances
+    """
+    module = _try_import_module(module_path)
+    if module is None:
+        return []
+    return _extract_rules_from_module(module)
+
+
+def _try_import_module(module_path: str) -> ModuleType | None:
+    """Try to import a module, returning None on failure.
+
+    Args:
+        module_path: Full module path to import
+
+    Returns:
+        Module object or None if import fails
+    """
+    try:
+        return importlib.import_module(module_path)
+    except (ImportError, AttributeError):
+        return None
 
-    def _is_rule_class(self, obj: Any) -> bool:
-        """Check if an object is a valid rule class.
+
+def _extract_rules_from_module(module: ModuleType) -> list[BaseLintRule]:
+    """Extract rule instances from a module.
+
+    Args:
+        module: Imported module to scan
+
+    Returns:
+        List of discovered rule instances
+    """
+    rule_classes = [obj for _name, obj in inspect.getmembers(module) if _is_rule_class(obj)]
+    return _instantiate_rules(rule_classes)
+
+
+def _instantiate_rules(rule_classes: list[type[BaseLintRule]]) -> list[BaseLintRule]:
+    """Instantiate a list of rule classes.
+
+    Args:
+        rule_classes: List of rule classes to instantiate
+
+    Returns:
+        List of successfully instantiated rules
+    """
+    instances = (_try_instantiate_rule(cls) for cls in rule_classes)
+    return [inst for inst in instances if inst is not None]
+
+
+def _try_instantiate_rule(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(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)
+    )
+
+
+# Legacy class wrapper for backward compatibility
+class RuleDiscovery:
+    """Discovers linting rules from Python packages.
+
+    Note: This class is a thin wrapper around module-level functions
+    for backward compatibility.
+    """
+
+    def __init__(self) -> None:
+        """Initialize the discovery service."""
+        pass  # No state needed
+
+    def discover_from_package(self, package_path: str) -> list[BaseLintRule]:
+        """Discover rules from a package and its modules.
 
         Args:
-            obj: Object to check
+            package_path: Python package path (e.g., 'src.linters')
 
         Returns:
-            True if obj is a concrete BaseLintRule subclass
+            List of discovered rule instances
         """
-        return (
-            inspect.isclass(obj)
-            and issubclass(obj, BaseLintRule)
-            and obj is not BaseLintRule
-            and not inspect.isabstract(obj)
-        )
+        return discover_from_package(package_path)

src/core/types.py

@@ -81,3 +81,16 @@ class Violation:
             "severity": self.severity.value,
             "suggestion": self.suggestion,
         }
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "Violation":
+        """Reconstruct Violation from dictionary (for parallel processing)."""
+        return cls(
+            rule_id=data["rule_id"],
+            file_path=data["file_path"],
+            line=data["line"],
+            column=data["column"],
+            message=data["message"],
+            severity=Severity(data["severity"]),
+            suggestion=data.get("suggestion"),
+        )

src/core/violation_builder.py

@@ -13,13 +13,17 @@ Overview: Provides base classes and data structures for violation creation acros
 
 Dependencies: dataclasses, src.core.types (Violation, Severity)
 
-Exports: ViolationInfo dataclass, BaseViolationBuilder class
+Exports: ViolationInfo dataclass, build_violation function, build_violation_from_params function,
+    BaseViolationBuilder class (compat)
 
 Interfaces: ViolationInfo(rule_id, file_path, line, message, column, severity),
-    BaseViolationBuilder.build(info: ViolationInfo) -> Violation
+    build_violation(info: ViolationInfo) -> Violation
 
-Implementation: Uses dataclass for type-safe violation info, base class provides build()
-    method that constructs Violation objects with proper defaults
+Implementation: Uses dataclass for type-safe violation info, functions provide build logic
+    that constructs Violation objects with proper defaults
+
+Suppressions:
+    - too-many-arguments,too-many-positional-arguments: Violation fields as parameters
 """
 
 from dataclasses import dataclass
@@ -50,14 +54,82 @@ class ViolationInfo:
     suggestion: str | None = None
 
 
+def build_violation(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_violation_from_params(  # pylint: disable=too-many-arguments,too-many-positional-arguments
+    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 function mirrors the
+    ViolationInfo dataclass fields (7 parameters, 3 with defaults). The alternative
+    would require every caller to create ViolationInfo objects manually, reducing
+    readability.
+
+    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 build_violation(info)
+
+
+# Legacy class wrapper for backward compatibility
 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.
+
+    Note: This class is a thin wrapper around module-level functions
+    for backward compatibility.
     """
 
+    def __init__(self) -> None:
+        """Initialize the builder."""
+        pass  # No state needed
+
     def build(self, info: ViolationInfo) -> Violation:
         """Build a Violation from ViolationInfo.
 
@@ -67,15 +139,7 @@ class BaseViolationBuilder:
         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,
-        )
+        return build_violation(info)
 
     def build_from_params(  # pylint: disable=too-many-arguments,too-many-positional-arguments
         self,
@@ -110,7 +174,7 @@ class BaseViolationBuilder:
         Returns:
             Violation object with all fields populated
         """
-        info = ViolationInfo(
+        return build_violation_from_params(
             rule_id=rule_id,
             file_path=file_path,
             line=line,
@@ -119,4 +183,3 @@ class BaseViolationBuilder:
             severity=severity,
             suggestion=suggestion,
         )
-        return self.build(info)

src/core/violation_utils.py

@@ -0,0 +1,69 @@
+"""
+Purpose: Shared utility functions for violation processing across linters
+
+Scope: Common violation-related operations used by multiple linters
+
+Overview: Provides shared utility functions for working with violations, including
+    extracting line text and checking for ignore directives. These patterns were
+    previously duplicated across multiple linter modules (magic_numbers, print_statements,
+    method_property). Centralizing them here improves maintainability and ensures
+    consistent behavior across all linters.
+
+Dependencies: BaseLintContext, Violation types
+
+Exports: get_violation_line, has_python_noqa, has_typescript_noqa
+
+Interfaces:
+    get_violation_line(violation, context) -> str | None
+    has_python_noqa(line_text) -> bool
+    has_typescript_noqa(line_text) -> bool
+
+Implementation: Simple text extraction and pattern matching
+"""
+
+from src.core.base import BaseLintContext
+from src.core.types import Violation
+
+
+def get_violation_line(violation: Violation, context: BaseLintContext) -> str | None:
+    """Get the line text for a violation, lowercased.
+
+    Args:
+        violation: Violation to get line for
+        context: Lint context with file content
+
+    Returns:
+        Lowercased line text, or None if not available
+    """
+    if not context.file_content:
+        return None
+
+    lines = context.file_content.splitlines()
+    if violation.line <= 0 or violation.line > len(lines):
+        return None
+
+    return lines[violation.line - 1].lower()
+
+
+def has_python_noqa(line_text: str) -> bool:
+    """Check if line has Python-style noqa directive.
+
+    Args:
+        line_text: Lowercased line text
+
+    Returns:
+        True if line has # noqa comment
+    """
+    return "# noqa" in line_text
+
+
+def has_typescript_noqa(line_text: str) -> bool:
+    """Check if line has TypeScript-style noqa directive.
+
+    Args:
+        line_text: Lowercased line text
+
+    Returns:
+        True if line has // noqa comment
+    """
+    return "// noqa" in line_text

src/formatters/__init__.py

@@ -0,0 +1,22 @@
+"""
+Purpose: SARIF formatter package for thai-lint output
+
+Scope: SARIF v2.1.0 formatter implementation and package exports
+
+Overview: Formatters package providing SARIF (Static Analysis Results Interchange Format) v2.1.0
+    output generation from thai-lint Violation objects. Enables integration with GitHub Code
+    Scanning, Azure DevOps, VS Code SARIF Viewer, and other industry-standard CI/CD platforms.
+    Provides the SarifFormatter class for converting violations to SARIF JSON documents.
+
+Dependencies: sarif module for SarifFormatter class
+
+Exports: SarifFormatter class from sarif.py module
+
+Interfaces: from src.formatters.sarif import SarifFormatter
+
+Implementation: Package initialization with SarifFormatter export
+"""
+
+from src.formatters.sarif import SarifFormatter
+
+__all__ = ["SarifFormatter"]