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

src/cli/linters/performance.py

@@ -0,0 +1,287 @@
+"""
+Purpose: CLI commands for performance linters (string-concat-loop, regex-in-loop, perf)
+
+Scope: Commands that detect performance anti-patterns in loops
+
+Overview: Provides CLI commands for performance anti-pattern detection: string-concat-loop
+    finds O(n^2) string concatenation using += in loops, regex-in-loop detects repeated
+    regex compilation inside loops. The `perf` command runs all performance rules together
+    with optional --rule flag to select specific rules. Each command supports standard options
+    (config, format, recursive) and integrates with the orchestrator for execution.
+
+Dependencies: click for CLI framework, src.cli.main for CLI group, src.cli.utils for shared utilities,
+    src.cli.linters.shared for linter-specific helpers
+
+Exports: string_concat_loop command, regex_in_loop command, perf command
+
+Interfaces: Click CLI commands registered to main CLI group
+
+Implementation: Click decorators for command definition, orchestrator-based linting execution
+
+Suppressions:
+    - too-many-arguments,too-many-positional-arguments: Click commands with custom options require
+      additional parameters beyond the standard 5 (ctx + 4 standard options). The perf command adds
+      --rule option for 6 total parameters - framework design requirement for CLI extensibility.
+"""
+
+import logging
+import sys
+from pathlib import Path
+from typing import TYPE_CHECKING, NoReturn
+
+import click
+
+from src.cli.linters.shared import (
+    ExecuteParams,
+    create_linter_command,
+    prepare_standard_command,
+    run_linter_command,
+    standard_linter_options,
+)
+from src.cli.main import cli
+from src.cli.utils import execute_linting_on_paths, setup_base_orchestrator, validate_paths_exist
+from src.core.cli_utils import format_violations
+from src.core.types import Violation
+
+if TYPE_CHECKING:
+    from src.orchestrator.core import Orchestrator
+
+# Configure module logger
+logger = logging.getLogger(__name__)
+
+
+# =============================================================================
+# String Concat Loop Command
+# =============================================================================
+
+
+def _setup_performance_orchestrator(
+    path_objs: list[Path], config_file: str | None, verbose: bool, project_root: Path | None = None
+) -> "Orchestrator":
+    """Set up orchestrator for performance linting."""
+    return setup_base_orchestrator(path_objs, config_file, verbose, project_root)
+
+
+def _setup_and_validate(params: ExecuteParams) -> "Orchestrator":
+    """Validate paths and set up orchestrator for linting.
+
+    Common setup code extracted to avoid DRY violations across execute functions.
+    """
+    validate_paths_exist(params.path_objs)
+    return _setup_performance_orchestrator(
+        params.path_objs, params.config_file, params.verbose, params.project_root
+    )
+
+
+def _run_string_concat_lint(
+    orchestrator: "Orchestrator", path_objs: list[Path], recursive: bool, parallel: bool = False
+) -> list[Violation]:
+    """Execute string-concat-loop lint on files or directories."""
+    all_violations = execute_linting_on_paths(orchestrator, path_objs, recursive, parallel)
+    return [v for v in all_violations if v.rule_id == "performance.string-concat-loop"]
+
+
+def _execute_string_concat_lint(params: ExecuteParams) -> NoReturn:
+    """Execute string-concat-loop lint."""
+    orchestrator = _setup_and_validate(params)
+    violations = _run_string_concat_lint(
+        orchestrator, params.path_objs, params.recursive, params.parallel
+    )
+
+    if params.verbose:
+        logger.info(f"Found {len(violations)} string-concat-loop violation(s)")
+
+    format_violations(violations, params.format)
+    sys.exit(1 if violations else 0)
+
+
+string_concat_loop = create_linter_command(
+    "string-concat-loop",
+    _execute_string_concat_lint,
+    "Check for string concatenation in loops.",
+    "Detects O(n^2) string building patterns using += in for/while loops.\n"
+    "    This is a common performance anti-pattern in Python and TypeScript.",
+)
+
+
+# =============================================================================
+# Regex In Loop Command
+# =============================================================================
+
+
+def _run_regex_in_loop_lint(
+    orchestrator: "Orchestrator", path_objs: list[Path], recursive: bool, parallel: bool = False
+) -> list[Violation]:
+    """Execute regex-in-loop lint on files or directories."""
+    all_violations = execute_linting_on_paths(orchestrator, path_objs, recursive, parallel)
+    return [v for v in all_violations if v.rule_id == "performance.regex-in-loop"]
+
+
+def _execute_regex_in_loop_lint(params: ExecuteParams) -> NoReturn:
+    """Execute regex-in-loop lint."""
+    orchestrator = _setup_and_validate(params)
+    violations = _run_regex_in_loop_lint(
+        orchestrator, params.path_objs, params.recursive, params.parallel
+    )
+
+    if params.verbose:
+        logger.info(f"Found {len(violations)} regex-in-loop violation(s)")
+
+    format_violations(violations, params.format)
+    sys.exit(1 if violations else 0)
+
+
+regex_in_loop = create_linter_command(
+    "regex-in-loop",
+    _execute_regex_in_loop_lint,
+    "Check for regex compilation in loops.",
+    "Detects re.match(), re.search(), re.sub(), re.findall(), re.split(), and\n"
+    "    re.fullmatch() calls inside loops. These recompile the regex pattern on\n"
+    "    each iteration instead of compiling once with re.compile().",
+)
+
+
+# =============================================================================
+# Combined Perf Command
+# =============================================================================
+
+# Valid rule names for the --rule option
+PERF_RULES = {
+    "string-concat": "performance.string-concat-loop",
+    "regex-loop": "performance.regex-in-loop",
+    # Also accept full rule names
+    "string-concat-loop": "performance.string-concat-loop",
+    "regex-in-loop": "performance.regex-in-loop",
+}
+
+
+def _filter_by_rule(violations: list[Violation], rule: str | None) -> list[Violation]:
+    """Filter violations by rule name if specified.
+
+    Args:
+        violations: List of violations to filter
+        rule: Optional rule name (string-concat, regex-loop, or full rule names)
+
+    Returns:
+        Filtered list of violations
+    """
+    if not rule:
+        return violations
+
+    rule_id = PERF_RULES.get(rule)
+    if not rule_id:
+        logger.warning(f"Unknown rule '{rule}'. Valid rules: {', '.join(PERF_RULES.keys())}")
+        return violations
+
+    return [v for v in violations if v.rule_id == rule_id]
+
+
+def _run_all_perf_lint(
+    orchestrator: "Orchestrator",
+    path_objs: list[Path],
+    recursive: bool,
+    rule: str | None,
+    parallel: bool = False,
+) -> list[Violation]:
+    """Execute all performance lints on files or directories.
+
+    Args:
+        orchestrator: Configured orchestrator instance
+        path_objs: List of paths to analyze
+        recursive: Whether to scan directories recursively
+        rule: Optional rule filter (string-concat, regex-loop, or full rule names)
+        parallel: Whether to use parallel processing
+
+    Returns:
+        List of performance-related violations
+    """
+    all_violations = execute_linting_on_paths(orchestrator, path_objs, recursive, parallel)
+    perf_violations = [v for v in all_violations if v.rule_id.startswith("performance.")]
+    return _filter_by_rule(perf_violations, rule)
+
+
+def _execute_perf_lint(params: ExecuteParams, rule: str | None) -> NoReturn:
+    """Execute combined performance lint."""
+    orchestrator = _setup_and_validate(params)
+    violations = _run_all_perf_lint(
+        orchestrator, params.path_objs, params.recursive, rule, params.parallel
+    )
+
+    if params.verbose:
+        logger.info(f"Found {len(violations)} performance violation(s)")
+
+    format_violations(violations, params.format)
+    sys.exit(1 if violations else 0)
+
+
+@cli.command(
+    "perf",
+    help="""Check for performance anti-patterns in code.
+
+    Detects common performance issues in loops:
+    - string-concat-loop: O(n^2) string building using += in loops
+    - regex-in-loop: Regex recompilation on each loop iteration
+
+    PATHS: Files or directories to lint (defaults to current directory if none provided)
+
+    Examples:
+
+        \\b
+        # Check current directory for all performance issues
+        thai-lint perf
+
+        \\b
+        # Check specific directory
+        thai-lint perf src/
+
+        \\b
+        # Check only string concatenation issues
+        thai-lint perf --rule string-concat src/
+
+        \\b
+        # Check only regex-in-loop issues
+        thai-lint perf --rule regex-loop src/
+
+        \\b
+        # Get JSON output
+        thai-lint perf --format json .
+
+        \\b
+        # Use custom config file
+        thai-lint perf --config .thailint.yaml src/
+    """,
+)
+@click.option(
+    "--rule",
+    "-r",
+    "rule",
+    type=click.Choice(["string-concat", "regex-loop"]),
+    help="Run only a specific performance rule",
+)
+@standard_linter_options
+def perf(  # pylint: disable=too-many-arguments,too-many-positional-arguments
+    ctx: click.Context,
+    paths: tuple[str, ...],
+    config_file: str | None,
+    format: str,
+    recursive: bool,
+    parallel: bool,
+    rule: str | None,
+) -> None:
+    """Run all performance linters.
+
+    Args:
+        ctx: Click context with global options
+        paths: Files or directories to lint
+        config_file: Optional path to config file
+        format: Output format (text, json, sarif)
+        recursive: Whether to scan directories recursively
+        parallel: Whether to use parallel processing
+        rule: Optional rule filter (string-concat or regex-loop)
+    """
+    params = prepare_standard_command(ctx, paths, config_file, format, recursive, parallel)
+
+    def execute_with_rule(p: ExecuteParams) -> None:
+        _execute_perf_lint(p, rule)
+
+    run_linter_command(execute_with_rule, params)

src/cli/linters/shared.py

@@ -0,0 +1,331 @@
+"""
+Purpose: Shared utilities for linter CLI commands
+
+Scope: Common helper functions and patterns used across all linter command modules
+
+Overview: Provides reusable utilities for linter CLI commands including config section management,
+    config value setting with logging, rule ID filtering, CLI context extraction, and help text
+    generation. Centralizes shared patterns to reduce duplication across linter command modules
+    (code_quality, code_patterns, structure, documentation, performance). All utilities are designed
+    to work with the orchestrator configuration system and Click CLI framework.
+
+Dependencies: logging for debug output, pathlib for Path type hints, click for Context type,
+    dataclasses for CommandContext
+
+Exports: ensure_config_section, set_config_value, filter_violations_by_prefix, CommandContext,
+    extract_command_context, make_linter_help, ExecuteParams, prepare_standard_command,
+    run_linter_command, standard_linter_options, filter_violations_by_startswith,
+    create_linter_command
+
+Interfaces: Orchestrator config dict manipulation, violation list filtering, CLI context extraction,
+    help text generation
+
+Implementation: Pure helper functions with no side effects beyond config mutation and logging
+
+Suppressions:
+    - too-many-arguments,too-many-positional-arguments: CLI helper functions require many parameters
+        by Click framework design (ctx, paths, config_file, format, recursive, parallel = 6 params)
+"""
+
+import logging
+from dataclasses import dataclass
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+import click
+
+from src.cli.utils import (
+    format_option,
+    get_project_root_from_context,
+    handle_linting_error,
+    parallel_option,
+)
+from src.core.types import Violation
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from src.orchestrator.core import Orchestrator
+
+
+def standard_linter_options(f: Any) -> Any:
+    """Apply standard linter CLI options to a command.
+
+    Bundles the common options used by most linter commands:
+    - paths argument (variadic)
+    - config file option
+    - format option
+    - recursive option
+    - parallel option
+    - pass_context
+
+    Usage:
+        @cli.command("my-linter")
+        @standard_linter_options
+        def my_linter(ctx, paths, config_file, format, recursive, parallel):
+            ...
+    """
+    f = click.pass_context(f)
+    f = parallel_option(f)
+    f = click.option(
+        "--recursive/--no-recursive", default=True, help="Scan directories recursively"
+    )(f)
+    f = format_option(f)
+    f = click.option(
+        "--config", "-c", "config_file", type=click.Path(), help="Path to config file"
+    )(f)
+    f = click.argument("paths", nargs=-1, type=click.Path())(f)
+    return f
+
+
+@dataclass
+class CommandContext:
+    """Extracted context from CLI command invocation.
+
+    Consolidates common CLI command setup into a reusable structure.
+    """
+
+    verbose: bool
+    project_root: Path | None
+    path_objs: list[Path]
+
+
+@dataclass
+class ExecuteParams:
+    """Parameters for linter execution functions.
+
+    Bundles the common parameters passed to _execute_*_lint functions
+    to reduce function signature duplication across CLI modules.
+    """
+
+    path_objs: list[Path]
+    config_file: str | None
+    format: str
+    recursive: bool
+    verbose: bool
+    project_root: Path | None
+    parallel: bool = False
+
+
+def extract_command_context(ctx: click.Context, paths: tuple[str, ...]) -> CommandContext:
+    """Extract common context values from CLI command invocation.
+
+    Consolidates the repeated pattern of extracting verbose, project_root,
+    and converting paths to Path objects with default handling.
+
+    Args:
+        ctx: Click context from command invocation
+        paths: Tuple of path strings from command arguments
+
+    Returns:
+        CommandContext with extracted values
+    """
+    verbose: bool = ctx.obj.get("verbose", False)
+    project_root = get_project_root_from_context(ctx)
+
+    if not paths:
+        paths = (".",)
+
+    path_objs = [Path(p) for p in paths]
+
+    return CommandContext(verbose=verbose, project_root=project_root, path_objs=path_objs)
+
+
+def prepare_standard_command(  # pylint: disable=too-many-arguments,too-many-positional-arguments
+    ctx: click.Context,
+    paths: tuple[str, ...],
+    config_file: str | None,
+    format: str,
+    recursive: bool,
+    parallel: bool = False,
+) -> ExecuteParams:
+    """Prepare standard linter command execution parameters.
+
+    Combines context extraction and ExecuteParams creation into a single call.
+    Use with commands that have the standard options (config, format, recursive, parallel).
+
+    Args:
+        ctx: Click context from command invocation
+        paths: Tuple of path strings from command arguments
+        config_file: Optional config file path
+        format: Output format
+        recursive: Whether to scan recursively
+        parallel: Whether to use parallel processing
+
+    Returns:
+        ExecuteParams ready for _execute_*_lint function
+    """
+    cmd_ctx = extract_command_context(ctx, paths)
+    return ExecuteParams(
+        path_objs=cmd_ctx.path_objs,
+        config_file=config_file,
+        format=format,
+        recursive=recursive,
+        verbose=cmd_ctx.verbose,
+        project_root=cmd_ctx.project_root,
+        parallel=parallel,
+    )
+
+
+def run_linter_command(
+    execute_fn: "Callable[[ExecuteParams], None]",
+    params: ExecuteParams,
+) -> None:
+    """Run a linter command with standard error handling.
+
+    Wraps the try/except pattern used by all linter commands.
+
+    Args:
+        execute_fn: The _execute_*_lint function to call
+        params: ExecuteParams for the execution
+    """
+    try:
+        execute_fn(params)
+    except Exception as e:
+        handle_linting_error(e, params.verbose)
+
+
+# Configure module logger
+logger = logging.getLogger(__name__)
+
+
+def ensure_config_section(orchestrator: "Orchestrator", section: str) -> dict[str, Any]:
+    """Ensure a config section exists and return it.
+
+    Args:
+        orchestrator: Orchestrator instance with config dict
+        section: Name of the config section to ensure exists
+
+    Returns:
+        The config section dict (created if it didn't exist)
+    """
+    if section not in orchestrator.config:
+        orchestrator.config[section] = {}
+    config_section: dict[str, Any] = orchestrator.config[section]
+    return config_section
+
+
+def set_config_value(config: dict[str, Any], key: str, value: Any, verbose: bool) -> None:
+    """Set a config value with optional debug logging.
+
+    Only sets the value if it is not None.
+
+    Args:
+        config: Config dict to update
+        key: Config key to set
+        value: Value to set (skipped if None)
+        verbose: Whether to log the override
+    """
+    if value is None:
+        return
+    config[key] = value
+    if verbose:
+        logger.debug(f"Overriding {key} to {value}")
+
+
+def filter_violations_by_prefix(violations: list[Violation], prefix: str) -> list[Violation]:
+    """Filter violations to those matching a rule ID prefix.
+
+    Args:
+        violations: List of violation objects with rule_id attribute
+        prefix: Prefix to match against rule_id
+
+    Returns:
+        Filtered list of violations where rule_id contains the prefix
+    """
+    return [v for v in violations if prefix in v.rule_id]
+
+
+def filter_violations_by_startswith(violations: list[Violation], prefix: str) -> list[Violation]:
+    """Filter violations to those with rule_id starting with prefix.
+
+    Args:
+        violations: List of violation objects with rule_id attribute
+        prefix: Prefix that rule_id must start with
+
+    Returns:
+        Filtered list of violations where rule_id starts with the prefix
+    """
+    return [v for v in violations if v.rule_id.startswith(prefix)]
+
+
+def create_linter_command(
+    name: str,
+    execute_fn: "Callable[[ExecuteParams], None]",
+    brief: str,
+    description: str,
+) -> "Callable[..., None]":
+    """Create a standard linter CLI command.
+
+    Factory function that generates Click commands with consistent structure,
+    eliminating boilerplate duplication across linter command modules.
+
+    Args:
+        name: CLI command name (e.g., "magic-numbers")
+        execute_fn: The _execute_*_lint function to call
+        brief: Brief one-line description
+        description: Detailed multi-line description
+
+    Returns:
+        Decorated Click command function
+    """
+    from src.cli.main import cli
+
+    @cli.command(name, help=make_linter_help(name, brief, description))
+    @standard_linter_options
+    def command(  # pylint: disable=too-many-arguments,too-many-positional-arguments
+        ctx: click.Context,
+        paths: tuple[str, ...],
+        config_file: str | None,
+        format: str,
+        recursive: bool,
+        parallel: bool,
+    ) -> None:
+        params = prepare_standard_command(ctx, paths, config_file, format, recursive, parallel)
+        run_linter_command(execute_fn, params)
+
+    return command
+
+
+def make_linter_help(command: str, brief: str, description: str) -> str:
+    """Generate standardized CLI help text for linter commands.
+
+    Creates consistent help text following the established pattern with
+    examples showing common usage patterns.
+
+    Args:
+        command: CLI command name (e.g., "magic-numbers")
+        brief: Brief one-line description
+        description: Detailed multi-line description
+
+    Returns:
+        Formatted help text string for Click command
+    """
+    return f"""{brief}
+
+    {description}
+
+    PATHS: Files or directories to lint (defaults to current directory if none provided)
+
+    Examples:
+
+        \\b
+        # Check current directory (all files recursively)
+        thai-lint {command}
+
+        \\b
+        # Check specific directory
+        thai-lint {command} src/
+
+        \\b
+        # Check single file
+        thai-lint {command} src/app.py
+
+        \\b
+        # Get JSON output
+        thai-lint {command} --format json .
+
+        \\b
+        # Use custom config file
+        thai-lint {command} --config .thailint.yaml src/
+    """