thailint 0.12.0__py3-none-any.whl → 0.14.0__py3-none-any.whl

src/linters/method_property/config.py

@@ -18,6 +18,10 @@ Exports: MethodPropertyConfig dataclass, DEFAULT_EXCLUDE_PREFIXES, DEFAULT_EXCLU
 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
@@ -96,7 +100,6 @@ class MethodPropertyConfig:  # thailint: ignore[dry]
     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

src/linters/method_property/linter.py

@@ -21,6 +21,10 @@ Interfaces: check(context) -> list[Violation] for rule validation, standard rule
 
 Implementation: Composition pattern with helper classes (analyzer, violation builder),
     AST-based analysis for Python with comprehensive exclusion rules
+
+Suppressions:
+    - srp,dry: Rule class coordinates analyzer, config, and violation building. Method count
+        exceeds limit due to comprehensive ignore directive support.
 """
 
 import ast
@@ -71,7 +75,6 @@ class MethodPropertyRule(MultiLanguageLintRule):  # thailint: ignore[srp,dry]
 
         return MethodPropertyConfig()
 
-    # dry: ignore-block
     def _try_load_test_config(self, context: BaseLintContext) -> MethodPropertyConfig | None:
         """Try to load test-style configuration.
 
@@ -91,7 +94,6 @@ class MethodPropertyRule(MultiLanguageLintRule):  # thailint: ignore[srp,dry]
         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.
 
@@ -109,12 +111,8 @@ class MethodPropertyRule(MultiLanguageLintRule):  # thailint: ignore[srp,dry]
             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)
 
-    # dry: ignore-block
     def _matches_pattern(self, file_path: Path, pattern: str) -> bool:
         """Check if file path matches a glob pattern.
 
@@ -131,7 +129,6 @@ class MethodPropertyRule(MultiLanguageLintRule):  # thailint: ignore[srp,dry]
             return True
         return False
 
-    # dry: ignore-block
     def _is_test_file(self, file_path: object) -> bool:
         """Check if file is a test file.
 
@@ -203,7 +200,6 @@ class MethodPropertyRule(MultiLanguageLintRule):  # thailint: ignore[srp,dry]
             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.
 
@@ -284,7 +280,6 @@ class MethodPropertyRule(MultiLanguageLintRule):  # thailint: ignore[srp,dry]
             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.
 

src/linters/method_property/python_analyzer.py

@@ -18,6 +18,10 @@ Exports: PythonMethodAnalyzer class, PropertyCandidate dataclass
 Interfaces: find_property_candidates(tree) -> list[PropertyCandidate]
 
 Implementation: AST walk pattern with comprehensive method body analysis and exclusion checks
+
+Suppressions:
+    - srp: Analyzer class implements comprehensive exclusion rules requiring many helper methods.
+        All methods support single responsibility of property candidate detection.
 """
 
 import ast
@@ -391,10 +395,7 @@ class PythonMethodAnalyzer:  # thailint: ignore[srp]
         Returns:
             True if assigning to self.*
         """
-        for target in targets:
-            if self._is_self_target(target):
-                return True
-        return False
+        return any(self._is_self_target(target) for target in targets)
 
     def _is_self_target(self, target: ast.expr) -> bool:
         """Check if target is a self attribute (self.* or self._*).

src/linters/method_property/violation_builder.py

@@ -16,6 +16,9 @@ Exports: ViolationBuilder class
 Interfaces: create_violation(method_name, line, column, file_path, is_get_prefix, class_name)
 
 Implementation: Builder pattern with message templates suggesting @property decorator conversion
+
+Suppressions:
+    - too-many-arguments,too-many-positional-arguments: Violation creation with related params
 """
 
 from pathlib import Path

src/linters/nesting/linter.py

@@ -16,13 +16,13 @@ Exports: NestingDepthRule class
 Interfaces: NestingDepthRule.check(context) -> list[Violation], properties for rule metadata
 
 Implementation: Composition pattern with helper classes, AST-based analysis with configurable limits
+
 """
 
-import ast
 from typing import Any
 
 from src.core.base import BaseLintContext, MultiLanguageLintRule
-from src.core.linter_utils import load_linter_config
+from src.core.linter_utils import load_linter_config, with_parsed_python
 from src.core.types import Violation
 from src.linter_config.ignore import get_ignore_parser
 
@@ -106,11 +106,16 @@ class NestingDepthRule(MultiLanguageLintRule):
         Returns:
             List of violations found in Python code
         """
-        try:
-            tree = ast.parse(context.file_content or "")
-        except SyntaxError as e:
-            return [self._violation_builder.create_syntax_error_violation(e, context)]
+        return with_parsed_python(
+            context,
+            self._violation_builder,
+            lambda tree: self._analyze_python_tree(tree, config, context),
+        )
 
+    def _analyze_python_tree(
+        self, tree: Any, config: NestingConfig, context: BaseLintContext
+    ) -> list[Violation]:
+        """Analyze parsed Python AST for nesting violations."""
         functions = self._python_analyzer.find_all_functions(tree)
         return self._process_python_functions(functions, self._python_analyzer, config, context)
 

src/linters/nesting/typescript_analyzer.py

@@ -16,20 +16,14 @@ Exports: TypeScriptNestingAnalyzer class with calculate_max_depth methods
 Interfaces: calculate_max_depth(func_node) -> tuple[int, int], find_all_functions(root_node)
 
 Implementation: Inherits tree-sitter parsing from base, visitor pattern with depth tracking
-"""
-
-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
+"""
 
-    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,
+)
 
 from .typescript_function_extractor import TypeScriptFunctionExtractor
 

src/linters/nesting/typescript_function_extractor.py

@@ -27,10 +27,6 @@ from src.analyzers.typescript_base import TypeScriptBaseAnalyzer
 class TypeScriptFunctionExtractor(TypeScriptBaseAnalyzer):
     """Extracts function information from TypeScript AST nodes."""
 
-    def __init__(self) -> None:  # pylint: disable=useless-parent-delegation
-        """Initialize the TypeScript function extractor."""
-        super().__init__()  # Sets self.tree_sitter_available from base class
-
     def collect_all_functions(self, root_node: Any) -> list[tuple[Any, str]]:
         """Collect all function nodes from TypeScript AST.
 

src/linters/nesting/violation_builder.py

@@ -17,6 +17,7 @@ Interfaces: create_nesting_violation, create_typescript_nesting_violation, creat
 
 Implementation: Formats messages with depth information, provides targeted refactoring suggestions,
     extends BaseViolationBuilder for consistent violation construction
+
 """
 
 import ast

src/linters/performance/__init__.py

@@ -0,0 +1,91 @@
+"""
+Purpose: Performance linter package initialization
+
+Scope: Exports for performance linter module
+
+Overview: Initializes the performance linter package and exposes the main rule classes for
+    external use. Exports StringConcatLoopRule as the primary interface for the performance
+    linter, allowing the orchestrator to discover and instantiate the rule. Also exports
+    configuration and analyzer classes for advanced use cases. Provides a convenience lint()
+    function for direct usage without orchestrator setup. This module serves as the entry
+    point for the performance linter functionality within the thai-lint framework.
+
+Dependencies: StringConcatLoopRule, PerformanceConfig, analyzers
+
+Exports: StringConcatLoopRule (primary), PerformanceConfig, analyzers, lint
+
+Interfaces: Standard Python package initialization with __all__ for explicit exports
+
+Implementation: Simple re-export pattern for package interface, convenience function
+"""
+
+from pathlib import Path
+from typing import Any
+
+from .config import PerformanceConfig
+from .linter import StringConcatLoopRule
+from .python_analyzer import PythonStringConcatAnalyzer
+from .regex_analyzer import PythonRegexInLoopAnalyzer
+from .regex_linter import RegexInLoopRule
+from .typescript_analyzer import TypeScriptStringConcatAnalyzer
+
+__all__ = [
+    "StringConcatLoopRule",
+    "RegexInLoopRule",
+    "PerformanceConfig",
+    "PythonStringConcatAnalyzer",
+    "PythonRegexInLoopAnalyzer",
+    "TypeScriptStringConcatAnalyzer",
+    "lint",
+]
+
+
+def lint(
+    path: Path | str,
+    config: dict[str, Any] | None = None,
+) -> list:
+    """Lint a file or directory for performance issues.
+
+    Args:
+        path: Path to file or directory to lint
+        config: Configuration dict (optional, uses defaults if not provided)
+
+    Returns:
+        List of violations found
+
+    Example:
+        >>> from src.linters.performance import lint
+        >>> violations = lint('src/my_module.py')
+        >>> for v in violations:
+        ...     print(f"{v.file_path}:{v.line} - {v.message}")
+    """
+    path_obj = Path(path) if isinstance(path, str) else path
+    project_root = path_obj if path_obj.is_dir() else path_obj.parent
+
+    orchestrator = _setup_performance_orchestrator(project_root, config)
+    violations = _execute_performance_lint(orchestrator, path_obj)
+
+    return [v for v in violations if "performance" in v.rule_id]
+
+
+def _setup_performance_orchestrator(project_root: Path, config: dict[str, Any] | None) -> Any:
+    """Set up orchestrator with performance config."""
+    from src.orchestrator.core import Orchestrator
+
+    orchestrator = Orchestrator(project_root=project_root)
+
+    if config:
+        orchestrator.config["performance"] = config
+    else:
+        orchestrator.config["performance"] = {"enabled": True}
+
+    return orchestrator
+
+
+def _execute_performance_lint(orchestrator: Any, path_obj: Path) -> list:
+    """Execute linting on file or directory."""
+    if path_obj.is_file():
+        return orchestrator.lint_file(path_obj)
+    if path_obj.is_dir():
+        return orchestrator.lint_directory(path_obj)
+    return []

src/linters/performance/config.py

@@ -0,0 +1,43 @@
+"""
+Purpose: Configuration schema for performance linter rules
+
+Scope: PerformanceConfig dataclass with settings for string-concat-loop and regex-in-loop
+
+Overview: Defines configuration schema for performance linter rules. Provides PerformanceConfig
+    dataclass with enabled flag and optional rule-specific settings. Supports loading from
+    YAML/JSON configuration files. Integrates with the orchestrator's configuration system
+    to allow users to customize performance rule settings via .thailint.yaml files.
+
+Dependencies: dataclasses, typing
+
+Exports: PerformanceConfig dataclass
+
+Interfaces: PerformanceConfig(enabled: bool = True), from_dict class method for loading config
+
+Implementation: Dataclass with validation and defaults, simple enabled flag (extensible)
+"""
+
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass
+class PerformanceConfig:
+    """Configuration for performance linter rules."""
+
+    enabled: bool = True
+
+    @classmethod
+    def from_dict(cls, config: dict[str, Any], language: str | None = None) -> "PerformanceConfig":
+        """Load configuration from dictionary.
+
+        Args:
+            config: Dictionary containing configuration values
+            language: Programming language (reserved for language-specific config)
+
+        Returns:
+            PerformanceConfig instance with values from dictionary
+        """
+        return cls(
+            enabled=config.get("enabled", True),
+        )

src/linters/performance/constants.py

@@ -0,0 +1,49 @@
+"""
+Purpose: Shared constants for performance linter rules
+
+Scope: Common patterns and constants used across Python and TypeScript analyzers
+
+Overview: Provides shared constants for the performance linter, including variable
+    name patterns that suggest string building. Used by both PythonStringConcatAnalyzer
+    and TypeScriptStringConcatAnalyzer to detect likely string concatenation.
+
+Dependencies: None
+
+Exports: STRING_VARIABLE_PATTERNS, LOOP_NODE_TYPES_TS
+
+Interfaces: Frozen sets of patterns
+
+Implementation: Constants shared between analyzers
+"""
+
+# Variable names that suggest string building
+STRING_VARIABLE_PATTERNS = frozenset(
+    {
+        "result",
+        "output",
+        "message",
+        "msg",
+        "text",
+        "html",
+        "content",
+        "body",
+        "buffer",
+        "response",
+        "data",
+        "line",
+        "lines",
+        "string",
+        "str",
+        "s",
+    }
+)
+
+# Tree-sitter node types for loops (TypeScript)
+LOOP_NODE_TYPES_TS = frozenset(
+    {
+        "for_statement",
+        "for_in_statement",
+        "while_statement",
+        "do_statement",
+    }
+)

src/linters/performance/linter.py

@@ -0,0 +1,149 @@
+"""
+Purpose: Main string concatenation in loop linter rule implementation
+
+Scope: StringConcatLoopRule class implementing MultiLanguageLintRule interface
+
+Overview: Implements string-concat-loop linter rule following MultiLanguageLintRule interface.
+    Orchestrates configuration loading, Python/TypeScript analysis, and violation building
+    through focused helper classes. Detects O(n²) string building patterns using += in loops.
+    Supports configurable enabled flag and ignore directives. Main rule class acts as
+    coordinator for string concatenation detection workflow.
+
+Dependencies: MultiLanguageLintRule, BaseLintContext, PythonStringConcatAnalyzer,
+    TypeScriptStringConcatAnalyzer, PerformanceViolationBuilder
+
+Exports: StringConcatLoopRule class
+
+Interfaces: StringConcatLoopRule.check(context) -> list[Violation], properties for rule metadata
+
+Implementation: Composition pattern with analyzer classes, AST-based analysis
+
+"""
+
+from typing import Any
+
+from src.core.base import BaseLintContext, MultiLanguageLintRule
+from src.core.linter_utils import load_linter_config, with_parsed_python
+from src.core.types import Violation
+from src.linter_config.ignore import get_ignore_parser
+
+from .config import PerformanceConfig
+from .python_analyzer import PythonStringConcatAnalyzer
+from .typescript_analyzer import TypeScriptStringConcatAnalyzer
+from .violation_builder import PerformanceViolationBuilder
+
+
+class StringConcatLoopRule(MultiLanguageLintRule):
+    """Detects O(n²) string concatenation in loops."""
+
+    def __init__(self) -> None:
+        """Initialize the string concat loop rule."""
+        self._ignore_parser = get_ignore_parser()
+        self._violation_builder = PerformanceViolationBuilder(self.rule_id)
+        # Singleton analyzers for performance
+        self._python_analyzer = PythonStringConcatAnalyzer()
+        self._typescript_analyzer = TypeScriptStringConcatAnalyzer()
+
+    @property
+    def rule_id(self) -> str:
+        """Unique identifier for this rule."""
+        return "performance.string-concat-loop"
+
+    @property
+    def rule_name(self) -> str:
+        """Human-readable name for this rule."""
+        return "String Concatenation in Loop"
+
+    @property
+    def description(self) -> str:
+        """Description of what this rule checks."""
+        return "String += in loops creates O(n²) complexity; use join() instead"
+
+    def _load_config(self, context: BaseLintContext) -> PerformanceConfig:
+        """Load configuration from context.
+
+        Args:
+            context: Lint context
+
+        Returns:
+            PerformanceConfig instance
+        """
+        return load_linter_config(context, "performance", PerformanceConfig)
+
+    def _check_python(self, context: BaseLintContext, config: PerformanceConfig) -> list[Violation]:
+        """Check Python code for string concatenation in loops.
+
+        Args:
+            context: Lint context with Python file information
+            config: Performance configuration
+
+        Returns:
+            List of violations found in Python code
+        """
+        return with_parsed_python(
+            context,
+            self._violation_builder,
+            lambda tree: self._analyze_python_string_concat(tree, context),
+        )
+
+    def _analyze_python_string_concat(self, tree: Any, context: BaseLintContext) -> list[Violation]:
+        """Analyze parsed Python AST for string concatenation in loops."""
+        violations_raw = self._python_analyzer.find_violations(tree)
+        violations_deduped = self._python_analyzer.deduplicate_violations(violations_raw)
+        return self._build_violations(violations_deduped, context)
+
+    def _check_typescript(
+        self, context: BaseLintContext, config: PerformanceConfig
+    ) -> list[Violation]:
+        """Check TypeScript code for string concatenation in loops.
+
+        Args:
+            context: Lint context with TypeScript file information
+            config: Performance configuration
+
+        Returns:
+            List of violations found in TypeScript code
+        """
+        root_node = self._typescript_analyzer.parse_typescript(context.file_content or "")
+        if root_node is None:
+            return []
+
+        violations_raw = self._typescript_analyzer.find_violations(root_node)
+        violations_deduped = self._typescript_analyzer.deduplicate_violations(violations_raw)
+
+        return self._build_violations(violations_deduped, context)
+
+    def _build_violations(self, raw_violations: list, context: BaseLintContext) -> list[Violation]:
+        """Build Violation objects from analyzer results.
+
+        Args:
+            raw_violations: List of StringConcatViolation dataclass instances
+            context: Lint context
+
+        Returns:
+            List of Violation objects
+        """
+        violations = []
+        for v in raw_violations:
+            violation = self._violation_builder.create_string_concat_violation(
+                variable_name=v.variable_name,
+                line_number=v.line_number,
+                column=v.column,
+                loop_type=v.loop_type,
+                context=context,
+            )
+            if not self._should_ignore(violation, context):
+                violations.append(violation)
+        return violations
+
+    def _should_ignore(self, violation: Violation, context: BaseLintContext) -> bool:
+        """Check if violation should be ignored based on inline directives.
+
+        Args:
+            violation: Violation to check
+            context: Lint context with file content
+
+        Returns:
+            True if violation should be ignored
+        """
+        return self._ignore_parser.should_ignore_violation(violation, context.file_content or "")