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

src/linters/magic_numbers/linter.py

@@ -12,7 +12,7 @@ Overview: Implements magic numbers linter rule following BaseLintRule interface.
     because refactoring for A-grade complexity requires extracting helper methods. Class maintains
     single responsibility of magic number detection - all methods support this core purpose.
 
-Dependencies: BaseLintRule, BaseLintContext, PythonMagicNumberAnalyzer, ContextAnalyzer,
+Dependencies: BaseLintRule, BaseLintContext, PythonMagicNumberAnalyzer, is_acceptable_context,
     ViolationBuilder, MagicNumberConfig, IgnoreDirectiveParser
 
 Exports: MagicNumberRule class
@@ -21,20 +21,28 @@ Interfaces: MagicNumberRule.check(context) -> list[Violation], properties for ru
 
 Implementation: Composition pattern with helper classes, AST-based analysis with configurable
     allowed numbers and context detection
+
+Suppressions:
+    - too-many-arguments,too-many-positional-arguments: TypeScript violation creation with related params
+    - srp: Rule class coordinates analyzers and violation builders. Method count exceeds limit
+        due to complexity refactoring. All methods support magic number detection.
 """
 
 import ast
 from pathlib import Path
+from typing import Any
 
 from src.core.base import BaseLintContext, MultiLanguageLintRule
 from src.core.linter_utils import load_linter_config
 from src.core.types import Violation
-from src.linter_config.ignore import IgnoreDirectiveParser
+from src.core.violation_utils import get_violation_line, has_python_noqa
+from src.linter_config.ignore import get_ignore_parser
 
 from .config import MagicNumberConfig
-from .context_analyzer import ContextAnalyzer
+from .context_analyzer import is_acceptable_context
 from .python_analyzer import PythonMagicNumberAnalyzer
 from .typescript_analyzer import TypeScriptMagicNumberAnalyzer
+from .typescript_ignore_checker import TypeScriptIgnoreChecker
 from .violation_builder import ViolationBuilder
 
 
@@ -43,9 +51,9 @@ class MagicNumberRule(MultiLanguageLintRule):  # thailint: ignore[srp]
 
     def __init__(self) -> None:
         """Initialize the magic numbers rule."""
-        self._ignore_parser = IgnoreDirectiveParser()
+        self._ignore_parser = get_ignore_parser()
         self._violation_builder = ViolationBuilder(self.rule_id)
-        self._context_analyzer = ContextAnalyzer()
+        self._typescript_ignore_checker = TypeScriptIgnoreChecker()
 
     @property
     def rule_id(self) -> str:
@@ -131,10 +139,7 @@ class MagicNumberRule(MultiLanguageLintRule):  # thailint: ignore[srp]
             return False
 
         file_path = Path(context.file_path)
-        for pattern in config.ignore:
-            if self._matches_pattern(file_path, pattern):
-                return True
-        return False
+        return any(self._matches_pattern(file_path, pattern) for pattern in config.ignore)
 
     def _matches_pattern(self, file_path: Path, pattern: str) -> bool:
         """Check if file path matches a glob pattern.
@@ -248,9 +253,7 @@ class MagicNumberRule(MultiLanguageLintRule):  # thailint: ignore[srp]
             "allowed_numbers": config.allowed_numbers,
         }
 
-        if self._context_analyzer.is_acceptable_context(
-            node, parent, context.file_path, config_dict
-        ):
+        if is_acceptable_context(node, parent, context.file_path, config_dict):
             return False
 
         return True
@@ -282,28 +285,17 @@ class MagicNumberRule(MultiLanguageLintRule):  # thailint: ignore[srp]
         Returns:
             True if line has generic ignore directive
         """
-        line_text = self._get_violation_line(violation, context)
+        line_text = get_violation_line(violation, context)
         if line_text is None:
             return False
 
         return self._has_generic_ignore_directive(line_text)
 
-    def _get_violation_line(self, violation: Violation, context: BaseLintContext) -> str | None:
-        """Get the line text for a violation."""
-        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_generic_ignore_directive(self, line_text: str) -> bool:
         """Check if line has generic ignore directive."""
         if self._has_generic_thailint_ignore(line_text):
             return True
-        return self._has_noqa_directive(line_text)
+        return has_python_noqa(line_text)
 
     def _has_generic_thailint_ignore(self, line_text: str) -> bool:
         """Check for generic thailint: ignore (no brackets)."""
@@ -312,10 +304,6 @@ class MagicNumberRule(MultiLanguageLintRule):  # thailint: ignore[srp]
         after_ignore = line_text.split("# thailint: ignore")[1].split("#")[0]
         return "[" not in after_ignore
 
-    def _has_noqa_directive(self, line_text: str) -> bool:
-        """Check for noqa-style comments."""
-        return "# noqa" in line_text
-
     def _check_typescript(
         self, context: BaseLintContext, config: MagicNumberConfig
     ) -> list[Violation]:
@@ -433,12 +421,17 @@ class MagicNumberRule(MultiLanguageLintRule):  # thailint: ignore[srp]
         return value in config.allowed_numbers or self._is_test_file(context.file_path)
 
     def _is_typescript_special_context(
-        self, node: object, analyzer: TypeScriptMagicNumberAnalyzer, context: BaseLintContext
+        self, node: Any, analyzer: TypeScriptMagicNumberAnalyzer, context: BaseLintContext
     ) -> bool:
-        """Check if in TypeScript-specific special context."""
-        # Calls require type: ignore because node is typed as object but analyzer expects Node
-        in_enum = analyzer.is_enum_context(node)  # type: ignore[arg-type]
-        in_const_def = analyzer.is_constant_definition(node, context.file_content or "")  # type: ignore[arg-type]
+        """Check if in TypeScript-specific special context.
+
+        Args:
+            node: Tree-sitter Node (typed as Any due to optional dependency)
+            analyzer: TypeScript analyzer
+            context: Lint context
+        """
+        in_enum = analyzer.is_enum_context(node)
+        in_const_def = analyzer.is_constant_definition(node, context.file_content or "")
         return in_enum or in_const_def
 
     def _is_test_file(self, file_path: object) -> bool:
@@ -466,51 +459,4 @@ class MagicNumberRule(MultiLanguageLintRule):  # thailint: ignore[srp]
         Returns:
             True if should ignore
         """
-        # Check standard ignore directives
-        if self._ignore_parser.should_ignore_violation(violation, context.file_content or ""):
-            return True
-
-        # Check TypeScript-style comments
-        return self._check_typescript_ignore(violation, context)
-
-    def _check_typescript_ignore(self, violation: Violation, context: BaseLintContext) -> bool:
-        """Check for TypeScript-style ignore directives.
-
-        Args:
-            violation: Violation to check
-            context: Lint context
-
-        Returns:
-            True if line has ignore directive
-        """
-        line_text = self._get_violation_line(violation, context)
-        if line_text is None:
-            return False
-
-        # Check for // thailint: ignore or // noqa
-        return self._has_typescript_ignore_directive(line_text)
-
-    def _has_typescript_ignore_directive(self, line_text: str) -> bool:
-        """Check if line has TypeScript-style ignore directive.
-
-        Args:
-            line_text: Line text to check
-
-        Returns:
-            True if has ignore directive
-        """
-        # Check for // thailint: ignore[magic-numbers]
-        if "// thailint: ignore[magic-numbers]" in line_text:
-            return True
-
-        # Check for // thailint: ignore (generic)
-        if "// thailint: ignore" in line_text:
-            after_ignore = line_text.split("// thailint: ignore")[1].split("//")[0]
-            if "[" not in after_ignore:
-                return True
-
-        # Check for // noqa
-        if "// noqa" in line_text:
-            return True
-
-        return False
+        return self._typescript_ignore_checker.should_ignore(violation, context)

src/linters/magic_numbers/python_analyzer.py

@@ -10,7 +10,7 @@ Overview: Provides PythonMagicNumberAnalyzer class that traverses Python AST to
     value, and source location. This analyzer handles Python-specific AST structure and provides
     the foundation for magic number detection by identifying all candidates before context filtering.
 
-Dependencies: ast module for AST parsing and node types
+Dependencies: ast module for AST parsing and node types, analyzers.ast_utils
 
 Exports: PythonMagicNumberAnalyzer class
 
@@ -23,6 +23,8 @@ Implementation: AST NodeVisitor pattern with parent tracking, filters for numeri
 import ast
 from typing import Any
 
+from src.analyzers.ast_utils import build_parent_map
+
 
 class PythonMagicNumberAnalyzer(ast.NodeVisitor):
     """Analyzes Python AST to find numeric literals."""
@@ -44,24 +46,10 @@ class PythonMagicNumberAnalyzer(ast.NodeVisitor):
             List of tuples (node, parent, value, line_number)
         """
         self.numeric_literals = []
-        self.parent_map = {}
-        self._build_parent_map(tree)
+        self.parent_map = build_parent_map(tree)
         self.visit(tree)
         return self.numeric_literals
 
-    def _build_parent_map(self, node: ast.AST, parent: ast.AST | None = None) -> None:
-        """Build a map of nodes to their parents.
-
-        Args:
-            node: Current AST node
-            parent: Parent of current node
-        """
-        if parent is not None:
-            self.parent_map[node] = parent
-
-        for child in ast.iter_child_nodes(node):
-            self._build_parent_map(child, node)
-
     def visit_Constant(self, node: ast.Constant) -> None:
         """Visit a Constant node and check if it's a numeric literal.
 

src/linters/magic_numbers/typescript_analyzer.py

@@ -20,20 +20,17 @@ Interfaces: find_numeric_literals(root_node) -> list[tuple], is_enum_context(nod
 
 Implementation: Tree-sitter node traversal with visitor pattern, context-aware filtering
     for acceptable numeric literal locations
-"""
-
-from typing import Any
 
-from src.analyzers.typescript_base import TypeScriptBaseAnalyzer
-
-# dry: ignore-block - tree-sitter import pattern (common across TypeScript analyzers)
-try:
-    from tree_sitter import Node
+Suppressions:
+    - srp: Analyzer implements tree-sitter traversal with context detection methods.
+        Methods support single responsibility of magic number detection in TypeScript.
+"""
 
-    TREE_SITTER_AVAILABLE = True
-except ImportError:
-    TREE_SITTER_AVAILABLE = False
-    Node = Any  # type: ignore
+from src.analyzers.typescript_base import (
+    TREE_SITTER_AVAILABLE,
+    Node,
+    TypeScriptBaseAnalyzer,
+)
 
 
 class TypeScriptMagicNumberAnalyzer(TypeScriptBaseAnalyzer):  # thailint: ignore[srp]

src/linters/magic_numbers/typescript_ignore_checker.py

@@ -0,0 +1,81 @@
+"""
+Purpose: TypeScript-specific ignore directive checking for magic numbers linter
+
+Scope: Ignore directive detection for TypeScript/JavaScript files
+
+Overview: Provides ignore directive checking functionality specifically for TypeScript and JavaScript
+    files in the magic numbers linter. Handles both thailint-style and noqa-style ignore comments
+    using TypeScript comment syntax (// instead of #). Extracted from linter.py to reduce file
+    size and improve modularity.
+
+Dependencies: IgnoreDirectiveParser from src.linter_config.ignore, Violation type, violation_utils
+
+Exports: TypeScriptIgnoreChecker class
+
+Interfaces: TypeScriptIgnoreChecker.should_ignore(violation, context) -> bool
+
+Implementation: Comment parsing with TypeScript-specific syntax handling, uses shared utilities
+"""
+
+from src.core.base import BaseLintContext
+from src.core.types import Violation
+from src.core.violation_utils import get_violation_line, has_typescript_noqa
+from src.linter_config.ignore import get_ignore_parser
+
+
+class TypeScriptIgnoreChecker:
+    """Checks for TypeScript-style ignore directives in magic numbers linter."""
+
+    def __init__(self) -> None:
+        """Initialize with standard ignore parser."""
+        self._ignore_parser = get_ignore_parser()
+
+    def should_ignore(self, violation: Violation, context: BaseLintContext) -> bool:
+        """Check if TypeScript violation should be ignored.
+
+        Args:
+            violation: Violation to check
+            context: Lint context
+
+        Returns:
+            True if should ignore
+        """
+        if self._ignore_parser.should_ignore_violation(violation, context.file_content or ""):
+            return True
+
+        return self._check_typescript_ignore(violation, context)
+
+    def _check_typescript_ignore(self, violation: Violation, context: BaseLintContext) -> bool:
+        """Check for TypeScript-style ignore directives.
+
+        Args:
+            violation: Violation to check
+            context: Lint context
+
+        Returns:
+            True if line has ignore directive
+        """
+        line_text = get_violation_line(violation, context)
+        if line_text is None:
+            return False
+
+        return self._has_typescript_ignore_directive(line_text)
+
+    def _has_typescript_ignore_directive(self, line_text: str) -> bool:
+        """Check if line has TypeScript-style ignore directive.
+
+        Args:
+            line_text: Line text to check
+
+        Returns:
+            True if has ignore directive
+        """
+        if "// thailint: ignore[magic-numbers]" in line_text:
+            return True
+
+        if "// thailint: ignore" in line_text:
+            after_ignore = line_text.split("// thailint: ignore")[1].split("//")[0]
+            if "[" not in after_ignore:
+                return True
+
+        return has_typescript_noqa(line_text)

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,138 @@
+"""
+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
+
+Suppressions:
+    - dry: MethodPropertyConfig includes extensive exclusion lists that share patterns with
+        other config classes. Lists are maintained separately for clear documentation.
+"""
+
+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
+
+    @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
+            ),
+        )