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

src/linters/file_placement/linter.py

@@ -6,22 +6,20 @@ Scope: Validate file organization against allow/deny patterns
 Overview: Implements file placement validation using regex patterns from JSON/YAML config.
     Orchestrates configuration loading, pattern validation, path resolution, rule checking,
     and violation creation through focused helper classes. Supports directory-specific rules,
-    global patterns, and generates helpful suggestions. Main linter class acts as coordinator.
+    global patterns, and generates helpful suggestions. Main linter class acts as coordinator
+    using composition pattern with specialized helper classes for configuration loading,
+    path resolution, pattern matching, and violation creation.
 
-Dependencies: src.core (base classes, types), pathlib, typing
+Dependencies: src.core (base classes, types), pathlib, typing, json, yaml modules
 
 Exports: FilePlacementLinter, FilePlacementRule
 
-Implementation: Composition pattern with helper classes for each responsibility
+Interfaces: lint_path(file_path) -> list[Violation], check_file_allowed(file_path) -> bool,
+    lint_directory(dir_path) -> list[Violation]
 
-SRP Exception: FilePlacementRule has 13 methods (exceeds max 8)
-    Justification: Framework adapter class that bridges BaseLintRule interface with
-    FilePlacementLinter implementation. Must handle multiple config sources (metadata vs file),
-    multiple config formats (wrapped vs unwrapped), project root detection with fallbacks,
-    and linter caching. This complexity is inherent to adapter pattern - splitting would
-    create unnecessary indirection between framework and implementation without improving
-    maintainability. All methods are focused on the single responsibility of integrating
-    file placement validation with the linting framework.
+Implementation: Composition pattern with helper classes for each responsibility
+    (ConfigLoader, PathResolver, PatternMatcher, PatternValidator, RuleChecker,
+    ViolationFactory)
 """
 
 import json

src/linters/method_property/__init__.py

@@ -0,0 +1,49 @@
+"""
+Purpose: Package exports for method-should-be-property linter
+
+Scope: Method property linter public API
+
+Overview: Exports the MethodPropertyRule class and MethodPropertyConfig dataclass for use by
+    the orchestrator and external consumers. Provides a convenience lint() function for
+    standalone usage of the linter.
+
+Dependencies: MethodPropertyRule from linter module, MethodPropertyConfig from config module
+
+Exports: MethodPropertyRule, MethodPropertyConfig, lint function
+
+Interfaces: lint(file_path, content, config) -> list[Violation] convenience function
+
+Implementation: Simple re-exports from submodules with optional convenience wrapper
+"""
+
+from .config import MethodPropertyConfig
+from .linter import MethodPropertyRule
+
+__all__ = ["MethodPropertyRule", "MethodPropertyConfig", "lint"]
+
+
+def lint(
+    file_path: str,
+    content: str,
+    config: dict | None = None,
+) -> list:
+    """Lint a file for method-should-be-property violations.
+
+    Args:
+        file_path: Path to the file being linted
+        content: Content of the file
+        config: Optional configuration dictionary
+
+    Returns:
+        List of Violation objects
+    """
+    from unittest.mock import Mock
+
+    rule = MethodPropertyRule()
+    context = Mock()
+    context.file_path = file_path
+    context.file_content = content
+    context.language = "python"
+    context.config = config
+
+    return rule.check(context)

src/linters/method_property/config.py

@@ -0,0 +1,135 @@
+"""
+Purpose: Configuration schema for method-should-be-property linter
+
+Scope: Method property linter configuration for Python files
+
+Overview: Defines configuration schema for method-should-be-property linter. Provides
+    MethodPropertyConfig dataclass with enabled flag, max_body_statements threshold (default 3)
+    for determining when a method body is too complex to be a property candidate, and ignore
+    patterns list for excluding specific files or directories. Includes configurable action verb
+    exclusions (prefixes and names) with sensible defaults that can be extended or overridden.
+    Supports per-file and per-directory config overrides through from_dict class method.
+    Integrates with orchestrator's configuration system via .thailint.yaml.
+
+Dependencies: dataclasses module for configuration structure, typing module for type hints
+
+Exports: MethodPropertyConfig dataclass, DEFAULT_EXCLUDE_PREFIXES, DEFAULT_EXCLUDE_NAMES
+
+Interfaces: from_dict(config, language) -> MethodPropertyConfig for configuration loading
+
+Implementation: Dataclass with defaults matching Pythonic conventions and common use cases
+"""
+
+from dataclasses import dataclass, field
+from typing import Any
+
+# Default action verb prefixes - methods starting with these are excluded
+# These represent actions/transformations, not property access
+DEFAULT_EXCLUDE_PREFIXES: tuple[str, ...] = (
+    "to_",  # Transformation: to_dict, to_json, to_string
+    "dump_",  # Serialization: dump_to_json, dump_to_apigw
+    "generate_",  # Factory: generate_report, generate_html
+    "create_",  # Factory: create_instance, create_config
+    "build_",  # Construction: build_query, build_html
+    "make_",  # Factory: make_request, make_connection
+    "render_",  # Output: render_template, render_html
+    "compute_",  # Calculation: compute_hash, compute_total
+    "calculate_",  # Calculation: calculate_sum, calculate_average
+)
+
+# Default action verb names - exact method names that are excluded
+# These are lifecycle hooks, display actions, and resource operations
+DEFAULT_EXCLUDE_NAMES: frozenset[str] = frozenset(
+    {
+        "finalize",  # Lifecycle hook
+        "serialize",  # Transformation
+        "dump",  # Serialization
+        "validate",  # Validation action
+        "show",  # Display action
+        "display",  # Display action
+        "print",  # Output action
+        "refresh",  # Update action
+        "reset",  # State action
+        "clear",  # State action
+        "close",  # Resource action
+        "open",  # Resource action
+        "save",  # Persistence action
+        "load",  # Persistence action
+        "execute",  # Action
+        "run",  # Action
+    }
+)
+
+
+def _load_list_config(
+    config: dict[str, Any], key: str, override_key: str, default: tuple[str, ...]
+) -> tuple[str, ...]:
+    """Load a list config with extend/override semantics."""
+    if override_key in config and isinstance(config[override_key], list):
+        return tuple(config[override_key])
+    if key in config and isinstance(config[key], list):
+        return default + tuple(config[key])
+    return default
+
+
+def _load_set_config(
+    config: dict[str, Any], key: str, override_key: str, default: frozenset[str]
+) -> frozenset[str]:
+    """Load a set config with extend/override semantics."""
+    if override_key in config and isinstance(config[override_key], list):
+        return frozenset(config[override_key])
+    if key in config and isinstance(config[key], list):
+        return default | frozenset(config[key])
+    return default
+
+
+@dataclass
+class MethodPropertyConfig:  # thailint: ignore[dry]
+    """Configuration for method-should-be-property linter."""
+
+    enabled: bool = True
+    max_body_statements: int = 3
+    ignore: list[str] = field(default_factory=list)
+    ignore_methods: list[str] = field(default_factory=list)
+
+    # Action verb exclusions (extend defaults or override)
+    exclude_prefixes: tuple[str, ...] = DEFAULT_EXCLUDE_PREFIXES
+    exclude_names: frozenset[str] = DEFAULT_EXCLUDE_NAMES
+
+    # dry: ignore-block
+    @classmethod
+    def from_dict(
+        cls, config: dict[str, Any] | None, language: str | None = None
+    ) -> "MethodPropertyConfig":
+        """Load configuration from dictionary.
+
+        Args:
+            config: Dictionary containing configuration values, or None
+            language: Programming language (unused, for interface compatibility)
+
+        Returns:
+            MethodPropertyConfig instance with values from dictionary
+        """
+        if config is None:
+            return cls()
+
+        ignore_patterns = config.get("ignore", [])
+        if not isinstance(ignore_patterns, list):
+            ignore_patterns = []
+
+        ignore_methods = config.get("ignore_methods", [])
+        if not isinstance(ignore_methods, list):
+            ignore_methods = []
+
+        return cls(
+            enabled=config.get("enabled", True),
+            max_body_statements=config.get("max_body_statements", 3),
+            ignore=ignore_patterns,
+            ignore_methods=ignore_methods,
+            exclude_prefixes=_load_list_config(
+                config, "exclude_prefixes", "exclude_prefixes_override", DEFAULT_EXCLUDE_PREFIXES
+            ),
+            exclude_names=_load_set_config(
+                config, "exclude_names", "exclude_names_override", DEFAULT_EXCLUDE_NAMES
+            ),
+        )

src/linters/method_property/linter.py

@@ -0,0 +1,419 @@
+"""
+Purpose: Main method-should-be-property linter rule implementation
+
+Scope: Method-should-be-property detection for Python files
+
+Overview: Implements method-should-be-property linter rule following MultiLanguageLintRule
+    interface. Orchestrates configuration loading, Python AST analysis for property candidates,
+    and violation building through focused helper classes. Detects methods that should be
+    converted to @property decorators following Pythonic conventions. Supports configurable
+    max_body_statements threshold, ignore patterns for excluding files, and inline ignore
+    directives (thailint: ignore, noqa) for suppressing specific violations. Handles test file
+    detection and non-Python languages gracefully.
+
+Dependencies: BaseLintContext and MultiLanguageLintRule from core, ast module, pathlib,
+    analyzer classes, config classes
+
+Exports: MethodPropertyRule class implementing MultiLanguageLintRule interface
+
+Interfaces: check(context) -> list[Violation] for rule validation, standard rule properties
+    (rule_id, rule_name, description)
+
+Implementation: Composition pattern with helper classes (analyzer, violation builder),
+    AST-based analysis for Python with comprehensive exclusion rules
+"""
+
+import ast
+from pathlib import Path
+
+from src.core.base import BaseLintContext, MultiLanguageLintRule
+from src.core.types import Violation
+
+from .config import MethodPropertyConfig
+from .python_analyzer import PropertyCandidate, PythonMethodAnalyzer
+from .violation_builder import ViolationBuilder
+
+
+class MethodPropertyRule(MultiLanguageLintRule):  # thailint: ignore[srp,dry]
+    """Detects methods that should be @property decorators."""
+
+    def __init__(self) -> None:
+        """Initialize the method property rule."""
+        self._violation_builder = ViolationBuilder(self.rule_id)
+
+    @property
+    def rule_id(self) -> str:
+        """Unique identifier for this rule."""
+        return "method-property.should-be-property"
+
+    @property
+    def rule_name(self) -> str:
+        """Human-readable name for this rule."""
+        return "method should be property"
+
+    @property
+    def description(self) -> str:
+        """Description of what this rule checks."""
+        return "Methods should be converted to @property decorators for Pythonic attribute access"
+
+    def _load_config(self, context: BaseLintContext) -> MethodPropertyConfig:
+        """Load configuration from context.
+
+        Args:
+            context: Lint context
+
+        Returns:
+            MethodPropertyConfig instance
+        """
+        test_config = self._try_load_test_config(context)
+        if test_config is not None:
+            return test_config
+
+        return MethodPropertyConfig()
+
+    # dry: ignore-block
+    def _try_load_test_config(self, context: BaseLintContext) -> MethodPropertyConfig | None:
+        """Try to load test-style configuration.
+
+        Args:
+            context: Lint context
+
+        Returns:
+            Config if found, None otherwise
+        """
+        if not hasattr(context, "config"):
+            return None
+        config_attr = context.config
+        if config_attr is None or not isinstance(config_attr, dict):
+            return None
+
+        # Check for method-property specific config
+        linter_config = config_attr.get("method-property", config_attr)
+        return MethodPropertyConfig.from_dict(linter_config)
+
+    # dry: ignore-block
+    def _is_file_ignored(self, context: BaseLintContext, config: MethodPropertyConfig) -> bool:
+        """Check if file matches ignore patterns.
+
+        Args:
+            context: Lint context
+            config: Configuration
+
+        Returns:
+            True if file should be ignored
+        """
+        if not config.ignore:
+            return False
+
+        if not context.file_path:
+            return False
+
+        file_path = Path(context.file_path)
+        for pattern in config.ignore:
+            if self._matches_pattern(file_path, pattern):
+                return True
+        return False
+
+    # dry: ignore-block
+    def _matches_pattern(self, file_path: Path, pattern: str) -> bool:
+        """Check if file path matches a glob pattern.
+
+        Args:
+            file_path: Path to check
+            pattern: Glob pattern
+
+        Returns:
+            True if path matches pattern
+        """
+        if file_path.match(pattern):
+            return True
+        if pattern in str(file_path):
+            return True
+        return False
+
+    # dry: ignore-block
+    def _is_test_file(self, file_path: object) -> bool:
+        """Check if file is a test file.
+
+        Args:
+            file_path: Path to check
+
+        Returns:
+            True if test file
+        """
+        path_str = str(file_path)
+        file_name = Path(path_str).name
+
+        # Check test_*.py pattern
+        if file_name.startswith("test_") and file_name.endswith(".py"):
+            return True
+
+        # Check *_test.py pattern
+        if file_name.endswith("_test.py"):
+            return True
+
+        return False
+
+    def _check_python(
+        self, context: BaseLintContext, config: MethodPropertyConfig
+    ) -> list[Violation]:
+        """Check Python code for method property violations.
+
+        Args:
+            context: Lint context with Python file information
+            config: Method property configuration
+
+        Returns:
+            List of violations found in Python code
+        """
+        if self._is_file_ignored(context, config):
+            return []
+
+        if self._is_test_file(context.file_path):
+            return []
+
+        tree = self._parse_python_code(context.file_content)
+        if tree is None:
+            return []
+
+        analyzer = PythonMethodAnalyzer(
+            max_body_statements=config.max_body_statements,
+            exclude_prefixes=config.exclude_prefixes,
+            exclude_names=config.exclude_names,
+        )
+        candidates = analyzer.find_property_candidates(tree)
+        candidates = self._filter_ignored_methods(candidates, config)
+        return self._collect_violations(candidates, context)
+
+    def _filter_ignored_methods(
+        self,
+        candidates: list[PropertyCandidate],
+        config: MethodPropertyConfig,
+    ) -> list[PropertyCandidate]:
+        """Filter out candidates with ignored method names.
+
+        Args:
+            candidates: List of property candidates
+            config: Configuration with ignore_methods list
+
+        Returns:
+            Filtered list of candidates
+        """
+        if not config.ignore_methods:
+            return candidates
+        return [c for c in candidates if c.method_name not in config.ignore_methods]
+
+    # dry: ignore-block
+    def _parse_python_code(self, code: str | None) -> ast.AST | None:
+        """Parse Python code into AST.
+
+        Args:
+            code: Python source code
+
+        Returns:
+            AST or None if parse fails
+        """
+        try:
+            return ast.parse(code or "")
+        except SyntaxError:
+            return None
+
+    def _collect_violations(
+        self,
+        candidates: list[PropertyCandidate],
+        context: BaseLintContext,
+    ) -> list[Violation]:
+        """Collect violations from property candidates.
+
+        Args:
+            candidates: List of property candidates
+            context: Lint context
+
+        Returns:
+            List of violations
+        """
+        violations = []
+        for candidate in candidates:
+            violation = self._create_violation(candidate, context)
+            if not self._should_ignore(violation, candidate, context):
+                violations.append(violation)
+        return violations
+
+    def _create_violation(
+        self,
+        candidate: PropertyCandidate,
+        context: BaseLintContext,
+    ) -> Violation:
+        """Create a violation for a property candidate.
+
+        Args:
+            candidate: The property candidate
+            context: Lint context
+
+        Returns:
+            Violation object
+        """
+        return self._violation_builder.create_violation(
+            method_name=candidate.method_name,
+            line=candidate.line,
+            column=candidate.column,
+            file_path=context.file_path,
+            is_get_prefix=candidate.is_get_prefix,
+            class_name=candidate.class_name,
+        )
+
+    def _should_ignore(
+        self,
+        violation: Violation,
+        candidate: PropertyCandidate,
+        context: BaseLintContext,
+    ) -> bool:
+        """Check if violation should be ignored based on directives.
+
+        Args:
+            violation: Violation to check
+            candidate: The property candidate
+            context: Lint context
+
+        Returns:
+            True if violation should be ignored
+        """
+        if self._has_inline_ignore(violation, context):
+            return True
+        if self._has_docstring_ignore(candidate, context):
+            return True
+        return False
+
+    # dry: ignore-block
+    def _has_inline_ignore(self, violation: Violation, context: BaseLintContext) -> bool:
+        """Check for inline ignore directive on method line.
+
+        Args:
+            violation: Violation to check
+            context: Lint context
+
+        Returns:
+            True if line has ignore directive
+        """
+        line_text = self._get_line_text(violation.line, context)
+        if line_text is None:
+            return False
+
+        line_lower = line_text.lower()
+
+        # Check for thailint: ignore[method-property]
+        if "thailint:" in line_lower and "ignore" in line_lower:
+            return True
+
+        # Check for noqa
+        if "# noqa" in line_lower:
+            return True
+
+        return False
+
+    def _has_docstring_ignore(
+        self,
+        candidate: PropertyCandidate,
+        context: BaseLintContext,
+    ) -> bool:
+        """Check for ignore directive in method docstring.
+
+        Args:
+            candidate: Property candidate
+            context: Lint context
+
+        Returns:
+            True if docstring has ignore directive
+        """
+        tree = self._parse_python_code(context.file_content)
+        if tree is None:
+            return False
+
+        docstring = self._find_method_docstring(tree, candidate)
+        if docstring is None:
+            return False
+
+        docstring_lower = docstring.lower()
+        return "thailint: ignore" in docstring_lower
+
+    def _find_method_docstring(
+        self,
+        tree: ast.AST,
+        candidate: PropertyCandidate,
+    ) -> str | None:
+        """Find the docstring for a method.
+
+        Args:
+            tree: AST tree
+            candidate: Property candidate
+
+        Returns:
+            Docstring text or None
+        """
+        target_class = self._find_class_node(tree, candidate.class_name)
+        if target_class is None:
+            return None
+        return self._find_method_in_class(target_class, candidate.method_name)
+
+    def _find_class_node(self, tree: ast.AST, class_name: str) -> ast.ClassDef | None:
+        """Find a class node by name in the AST.
+
+        Args:
+            tree: AST tree
+            class_name: Name of the class to find
+
+        Returns:
+            ClassDef node or None
+        """
+        for node in ast.walk(tree):
+            if isinstance(node, ast.ClassDef) and node.name == class_name:
+                return node
+        return None
+
+    def _find_method_in_class(self, class_node: ast.ClassDef, method_name: str) -> str | None:
+        """Find method docstring within a class.
+
+        Args:
+            class_node: Class node to search
+            method_name: Method name to find
+
+        Returns:
+            Docstring or None
+        """
+        for item in class_node.body:
+            if isinstance(item, ast.FunctionDef) and item.name == method_name:
+                return ast.get_docstring(item)
+        return None
+
+    def _get_line_text(self, line: int, context: BaseLintContext) -> str | None:
+        """Get the text of a specific line.
+
+        Args:
+            line: Line number (1-indexed)
+            context: Lint context
+
+        Returns:
+            Line text or None
+        """
+        if not context.file_content:
+            return None
+
+        lines = context.file_content.splitlines()
+        if line <= 0 or line > len(lines):
+            return None
+
+        return lines[line - 1]
+
+    def _check_typescript(
+        self, context: BaseLintContext, config: MethodPropertyConfig
+    ) -> list[Violation]:
+        """Check TypeScript code for violations.
+
+        Args:
+            context: Lint context
+            config: Configuration
+
+        Returns:
+            Empty list (not implemented for TypeScript)
+        """
+        return []