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

src/cli/config_merge.py

@@ -0,0 +1,241 @@
+"""
+Purpose: Configuration merge utilities for init-config command
+
+Scope: Functions for merging missing linter sections into existing config files
+
+Overview: Provides utilities for the init-config command to add missing linter sections
+    to existing configuration files without overwriting user customizations. Handles
+    template parsing, section extraction, missing section identification, and content
+    merging while preserving comments and formatting.
+
+Dependencies: re for pattern matching, yaml for config parsing, click for output,
+    pathlib for file operations
+
+Exports: perform_merge, LINTER_SECTIONS
+
+Interfaces: perform_merge(output_path, preset, output, generate_config_fn) -> None
+
+Implementation: Text-based parsing and merging to preserve YAML comments
+"""
+
+import re
+import sys
+from collections.abc import Callable
+from pathlib import Path
+
+import click
+import yaml
+
+# Known linter section names that should be in the template
+LINTER_SECTIONS = [
+    "magic-numbers",
+    "nesting",
+    "srp",
+    "dry",
+    "file-placement",
+    "print-statements",
+    "stringly-typed",
+    "file-header",
+    "method-property",
+    "stateless-class",
+    "pipeline",
+    "lazy-ignores",
+]
+
+
+def _is_section_header_line(line: str) -> bool:
+    """Check if line is a section header (# ==== style comment)."""
+    return line.startswith("# ===")
+
+
+def _get_linter_section_name(line: str) -> str | None:
+    """Extract linter section name from line if it's a known linter section."""
+    section_match = re.match(r"^([a-z][a-z0-9-]*):$", line)
+    if section_match and section_match.group(1) in LINTER_SECTIONS:
+        return section_match.group(1)
+    return None
+
+
+def _is_buffer_line(line: str) -> bool:
+    """Check if line should be buffered (comment or empty)."""
+    stripped = line.strip()
+    return stripped.startswith("#") or stripped == ""
+
+
+def _save_current_section(
+    sections: dict[str, str], current_section: str | None, current_content: list[str]
+) -> None:
+    """Save current section to sections dict if valid."""
+    if current_section and current_content:
+        sections[current_section] = "\n".join(current_content)
+
+
+def _handle_section_header(
+    line: str, sections: dict[str, str], current_section: str | None, current_content: list[str]
+) -> tuple[str | None, list[str], list[str]]:
+    """Handle a section header line (# === style)."""
+    _save_current_section(sections, current_section, current_content)
+    return None, [], [line]
+
+
+def _start_linter_section(
+    section_name: str, line: str, header_buffer: list[str]
+) -> tuple[str | None, list[str], list[str]]:
+    """Start a new linter section with the header buffer and section line."""
+    return section_name, header_buffer + [line], []
+
+
+def _handle_content_line(
+    line: str, current_section: str | None, current_content: list[str], header_buffer: list[str]
+) -> tuple[str | None, list[str], list[str]]:
+    """Handle a regular content line."""
+    if current_section:
+        current_content.append(line)
+        return current_section, current_content, header_buffer
+    if _is_buffer_line(line):
+        header_buffer.append(line)
+        return current_section, current_content, header_buffer
+    return current_section, current_content, []
+
+
+def _process_template_line(
+    line: str,
+    sections: dict[str, str],
+    current_section: str | None,
+    current_content: list[str],
+    header_buffer: list[str],
+) -> tuple[str | None, list[str], list[str]]:
+    """Process a single template line and update state."""
+    if _is_section_header_line(line):
+        return _handle_section_header(line, sections, current_section, current_content)
+
+    section_name = _get_linter_section_name(line)
+    if section_name:
+        _save_current_section(sections, current_section, current_content)
+        return _start_linter_section(section_name, line, header_buffer)
+
+    return _handle_content_line(line, current_section, current_content, header_buffer)
+
+
+def extract_linter_sections(template: str) -> dict[str, str]:
+    """Extract each linter section from template as text blocks.
+
+    Args:
+        template: Full template content
+
+    Returns:
+        Dict mapping section name to section content (with header comments)
+    """
+    sections: dict[str, str] = {}
+    lines = template.split("\n")
+    current_section: str | None = None
+    current_content: list[str] = []
+    header_buffer: list[str] = []
+
+    for line in lines:
+        current_section, current_content, header_buffer = _process_template_line(
+            line, sections, current_section, current_content, header_buffer
+        )
+
+    # Save last section
+    if current_section and current_content:
+        sections[current_section] = "\n".join(current_content)
+
+    return sections
+
+
+def identify_missing_sections(existing_config: dict, all_sections: list[str]) -> list[str]:
+    """Identify which linter sections are missing from existing config.
+
+    Args:
+        existing_config: Parsed existing config dict
+        all_sections: List of all linter section names
+
+    Returns:
+        List of section names missing from existing config
+    """
+    return [s for s in all_sections if s not in existing_config]
+
+
+def _find_global_settings_position(content: str) -> int:
+    """Find position of GLOBAL SETTINGS section in content."""
+    marker = "# ============================================================================\n# GLOBAL SETTINGS"
+    return content.find(marker)
+
+
+def _insert_before_global_settings(content: str, sections_text: str, insert_pos: int) -> str:
+    """Insert sections before GLOBAL SETTINGS marker."""
+    return content[:insert_pos] + sections_text + "\n\n" + content[insert_pos:]
+
+
+def merge_config_sections(existing_content: str, missing_sections: dict[str, str]) -> str:
+    """Merge missing sections into existing config content.
+
+    Args:
+        existing_content: Original config file content
+        missing_sections: Dict of section name -> section content to add
+
+    Returns:
+        Merged config content with missing sections appended
+    """
+    if not missing_sections:
+        return existing_content
+
+    sections_text = "\n".join(missing_sections.values())
+    insert_pos = _find_global_settings_position(existing_content)
+
+    if insert_pos > 0:
+        return _insert_before_global_settings(existing_content, sections_text, insert_pos)
+    return existing_content.rstrip() + "\n\n" + sections_text + "\n"
+
+
+def _parse_existing_config(content: str, output: str) -> dict:
+    """Parse existing config file content as YAML."""
+    try:
+        return yaml.safe_load(content) or {}
+    except yaml.YAMLError:
+        click.echo(f"Error: Could not parse {output} as YAML", err=True)
+        click.echo("Use --force to overwrite with a fresh config", err=True)
+        sys.exit(1)
+
+
+def _build_missing_sections_dict(
+    missing_names: list[str], template_sections: dict[str, str]
+) -> dict[str, str]:
+    """Build dict of missing section name -> content."""
+    return {name: template_sections[name] for name in missing_names if name in template_sections}
+
+
+def _report_merge_results(missing_names: list[str], output: str) -> None:
+    """Report which sections were added."""
+    click.echo(f"Added {len(missing_names)} missing linter section(s) to {output}:")
+    for name in missing_names:
+        click.echo(f"  - {name}")
+
+
+def perform_merge(
+    output_path: Path, preset: str, output: str, generate_config_fn: Callable[[str], str]
+) -> None:
+    """Merge missing linter sections into existing config.
+
+    Args:
+        output_path: Path to existing config file
+        preset: Preset to use for missing sections
+        output: Output filename for display
+        generate_config_fn: Function to generate config content from preset
+    """
+    existing_content = output_path.read_text(encoding="utf-8")
+    existing_config = _parse_existing_config(existing_content, output)
+
+    template_sections = extract_linter_sections(generate_config_fn(preset))
+    missing_names = identify_missing_sections(existing_config, list(template_sections.keys()))
+
+    if not missing_names:
+        click.echo(f"{output} already contains all linter sections")
+        return
+
+    missing_sections = _build_missing_sections_dict(missing_names, template_sections)
+    merged_content = merge_config_sections(existing_content, missing_sections)
+    output_path.write_text(merged_content, encoding="utf-8")
+
+    _report_merge_results(missing_names, output)

src/cli/linters/__init__.py

@@ -0,0 +1,67 @@
+"""
+Purpose: CLI linters package that registers all linter commands to the main CLI group
+
+Scope: Export and registration of all linter CLI commands (nesting, srp, dry, magic-numbers, etc.)
+
+Overview: Package initialization that imports all linter command modules to trigger their registration
+    with the main CLI group via Click decorators. Each submodule defines commands using @cli.command()
+    decorators that automatically register with the CLI when imported. Organized by logical grouping:
+    structure_quality (nesting, srp), code_smells (dry, magic-numbers), code_patterns (print-statements,
+    method-property, stateless-class), structure (file-placement, pipeline), documentation (file-header).
+
+Dependencies: Click for CLI framework, src.cli.main for CLI group, individual linter modules
+
+Exports: All linter command functions for reference and testing
+
+Interfaces: Click command decorators, integration with main CLI group
+
+Implementation: Module imports trigger command registration via Click decorator side effects
+
+Suppressions:
+    - F401: Module imports trigger Click command registration via decorator side effects
+"""
+
+# Import all linter command modules to register them with the CLI
+# Each module uses @cli.command() decorators that register on import
+from src.cli.linters import (  # noqa: F401
+    code_patterns,
+    code_smells,
+    documentation,
+    performance,
+    structure,
+    structure_quality,
+)
+
+# Re-export command functions for testing and reference
+from src.cli.linters.code_patterns import (
+    method_property,
+    print_statements,
+    stateless_class,
+)
+from src.cli.linters.code_smells import dry, magic_numbers
+from src.cli.linters.documentation import file_header
+from src.cli.linters.performance import perf, regex_in_loop, string_concat_loop
+from src.cli.linters.structure import file_placement, pipeline
+from src.cli.linters.structure_quality import nesting, srp
+
+__all__ = [
+    # Structure quality commands
+    "nesting",
+    "srp",
+    # Code smell commands
+    "dry",
+    "magic_numbers",
+    # Code pattern commands
+    "print_statements",
+    "method_property",
+    "stateless_class",
+    # Structure commands
+    "file_placement",
+    "pipeline",
+    # Documentation commands
+    "file_header",
+    # Performance commands
+    "perf",
+    "string_concat_loop",
+    "regex_in_loop",
+]

src/cli/linters/code_patterns.py

@@ -0,0 +1,270 @@
+"""
+Purpose: CLI commands for code pattern linters (print-statements, method-property, stateless-class, lazy-ignores, lbyl)
+
+Scope: Commands that detect code patterns and anti-patterns in Python code
+
+Overview: Provides CLI commands for code pattern linting: print-statements detects print() and
+    console.log calls that should use proper logging, method-property finds methods that should be
+    @property decorators, stateless-class detects classes without state that should be module
+    functions, lazy-ignores detects unjustified linting suppressions, and lbyl detects Look Before
+    You Leap anti-patterns. 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
+
+Exports: print_statements, method_property, stateless_class, lazy_ignores, lbyl commands
+
+Interfaces: Click CLI commands registered to main CLI group
+
+Implementation: Click decorators for command definition, orchestrator-based linting execution
+"""
+
+import logging
+import sys
+from pathlib import Path
+from typing import TYPE_CHECKING, NoReturn
+
+from src.cli.linters.shared import ExecuteParams, create_linter_command
+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__)
+
+
+# =============================================================================
+# Print Statements Command
+# =============================================================================
+
+
+def _setup_print_statements_orchestrator(
+    path_objs: list[Path], config_file: str | None, verbose: bool, project_root: Path | None = None
+) -> "Orchestrator":
+    """Set up orchestrator for print-statements command."""
+    return setup_base_orchestrator(path_objs, config_file, verbose, project_root)
+
+
+def _run_print_statements_lint(
+    orchestrator: "Orchestrator", path_objs: list[Path], recursive: bool, parallel: bool = False
+) -> list[Violation]:
+    """Execute print-statements lint on files or directories."""
+    all_violations = execute_linting_on_paths(orchestrator, path_objs, recursive, parallel)
+    return [v for v in all_violations if "print-statement" in v.rule_id]
+
+
+def _execute_print_statements_lint(params: ExecuteParams) -> NoReturn:
+    """Execute print-statements lint."""
+    validate_paths_exist(params.path_objs)
+    orchestrator = _setup_print_statements_orchestrator(
+        params.path_objs, params.config_file, params.verbose, params.project_root
+    )
+    print_statements_violations = _run_print_statements_lint(
+        orchestrator, params.path_objs, params.recursive, params.parallel
+    )
+
+    if params.verbose:
+        logger.info(f"Found {len(print_statements_violations)} print statement violation(s)")
+
+    format_violations(print_statements_violations, params.format)
+    sys.exit(1 if print_statements_violations else 0)
+
+
+print_statements = create_linter_command(
+    "print-statements",
+    _execute_print_statements_lint,
+    "Check for print/console statements in code.",
+    "Detects print() calls in Python and console.log/warn/error/debug/info calls\n"
+    "    in TypeScript/JavaScript that should be replaced with proper logging.",
+)
+
+
+# =============================================================================
+# Method Property Command
+# =============================================================================
+
+
+def _setup_method_property_orchestrator(
+    path_objs: list[Path], config_file: str | None, verbose: bool, project_root: Path | None = None
+) -> "Orchestrator":
+    """Set up orchestrator for method-property command."""
+    return setup_base_orchestrator(path_objs, config_file, verbose, project_root)
+
+
+def _run_method_property_lint(
+    orchestrator: "Orchestrator", path_objs: list[Path], recursive: bool, parallel: bool = False
+) -> list[Violation]:
+    """Execute method-property lint on files or directories."""
+    all_violations = execute_linting_on_paths(orchestrator, path_objs, recursive, parallel)
+    return [v for v in all_violations if "method-property" in v.rule_id]
+
+
+def _execute_method_property_lint(params: ExecuteParams) -> NoReturn:
+    """Execute method-property lint."""
+    validate_paths_exist(params.path_objs)
+    orchestrator = _setup_method_property_orchestrator(
+        params.path_objs, params.config_file, params.verbose, params.project_root
+    )
+    method_property_violations = _run_method_property_lint(
+        orchestrator, params.path_objs, params.recursive, params.parallel
+    )
+
+    if params.verbose:
+        logger.info(f"Found {len(method_property_violations)} method-property violation(s)")
+
+    format_violations(method_property_violations, params.format)
+    sys.exit(1 if method_property_violations else 0)
+
+
+method_property = create_linter_command(
+    "method-property",
+    _execute_method_property_lint,
+    "Check for methods that should be @property decorators.",
+    "Detects Python methods that could be converted to properties following\n"
+    "    Pythonic conventions: methods returning self._attribute, get_* prefixed\n"
+    "    methods (Java-style getters), or simple computed values with no side effects.",
+)
+
+
+# =============================================================================
+# Stateless Class Command
+# =============================================================================
+
+
+def _setup_stateless_class_orchestrator(
+    path_objs: list[Path], config_file: str | None, verbose: bool, project_root: Path | None = None
+) -> "Orchestrator":
+    """Set up orchestrator for stateless-class command."""
+    return setup_base_orchestrator(path_objs, config_file, verbose, project_root)
+
+
+def _run_stateless_class_lint(
+    orchestrator: "Orchestrator", path_objs: list[Path], recursive: bool, parallel: bool = False
+) -> list[Violation]:
+    """Execute stateless-class lint on files or directories."""
+    all_violations = execute_linting_on_paths(orchestrator, path_objs, recursive, parallel)
+    return [v for v in all_violations if "stateless-class" in v.rule_id]
+
+
+def _execute_stateless_class_lint(params: ExecuteParams) -> NoReturn:
+    """Execute stateless-class lint."""
+    validate_paths_exist(params.path_objs)
+    orchestrator = _setup_stateless_class_orchestrator(
+        params.path_objs, params.config_file, params.verbose, params.project_root
+    )
+    stateless_class_violations = _run_stateless_class_lint(
+        orchestrator, params.path_objs, params.recursive, params.parallel
+    )
+
+    if params.verbose:
+        logger.info(f"Found {len(stateless_class_violations)} stateless-class violation(s)")
+
+    format_violations(stateless_class_violations, params.format)
+    sys.exit(1 if stateless_class_violations else 0)
+
+
+stateless_class = create_linter_command(
+    "stateless-class",
+    _execute_stateless_class_lint,
+    "Check for stateless classes that should be module functions.",
+    "Detects Python classes that have no constructor (__init__), no instance\n"
+    "    state, and 2+ methods - indicating they should be refactored to module-level\n"
+    "    functions instead of using a class as a namespace.",
+)
+
+
+# =============================================================================
+# Lazy Ignores Command
+# =============================================================================
+
+
+def _setup_lazy_ignores_orchestrator(
+    path_objs: list[Path], config_file: str | None, verbose: bool, project_root: Path | None = None
+) -> "Orchestrator":
+    """Set up orchestrator for lazy-ignores command."""
+    return setup_base_orchestrator(path_objs, config_file, verbose, project_root)
+
+
+def _run_lazy_ignores_lint(
+    orchestrator: "Orchestrator", path_objs: list[Path], recursive: bool, parallel: bool = False
+) -> list[Violation]:
+    """Execute lazy-ignores 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.startswith("lazy-ignores")]
+
+
+def _execute_lazy_ignores_lint(params: ExecuteParams) -> NoReturn:
+    """Execute lazy-ignores lint."""
+    validate_paths_exist(params.path_objs)
+    orchestrator = _setup_lazy_ignores_orchestrator(
+        params.path_objs, params.config_file, params.verbose, params.project_root
+    )
+    lazy_ignores_violations = _run_lazy_ignores_lint(
+        orchestrator, params.path_objs, params.recursive, params.parallel
+    )
+
+    if params.verbose:
+        logger.info(f"Found {len(lazy_ignores_violations)} lazy-ignores violation(s)")
+
+    format_violations(lazy_ignores_violations, params.format)
+    sys.exit(1 if lazy_ignores_violations else 0)
+
+
+lazy_ignores = create_linter_command(
+    "lazy-ignores",
+    _execute_lazy_ignores_lint,
+    "Check for unjustified linting suppressions.",
+    "Detects ignore directives (noqa, type:ignore, pylint:disable, nosec) that lack\n"
+    "    corresponding entries in the file header's Suppressions section. Enforces a\n"
+    "    header-based suppression model requiring human approval for all linting bypasses.",
+)
+
+
+# =============================================================================
+# LBYL Command
+# =============================================================================
+
+
+def _setup_lbyl_orchestrator(
+    path_objs: list[Path], config_file: str | None, verbose: bool, project_root: Path | None = None
+) -> "Orchestrator":
+    """Set up orchestrator for lbyl command."""
+    return setup_base_orchestrator(path_objs, config_file, verbose, project_root)
+
+
+def _run_lbyl_lint(
+    orchestrator: "Orchestrator", path_objs: list[Path], recursive: bool, parallel: bool = False
+) -> list[Violation]:
+    """Execute lbyl 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.startswith("lbyl")]
+
+
+def _execute_lbyl_lint(params: ExecuteParams) -> NoReturn:
+    """Execute lbyl lint."""
+    validate_paths_exist(params.path_objs)
+    orchestrator = _setup_lbyl_orchestrator(
+        params.path_objs, params.config_file, params.verbose, params.project_root
+    )
+    lbyl_violations = _run_lbyl_lint(
+        orchestrator, params.path_objs, params.recursive, params.parallel
+    )
+
+    if params.verbose:
+        logger.info(f"Found {len(lbyl_violations)} LBYL violation(s)")
+
+    format_violations(lbyl_violations, params.format)
+    sys.exit(1 if lbyl_violations else 0)
+
+
+lbyl = create_linter_command(
+    "lbyl",
+    _execute_lbyl_lint,
+    "Check for Look Before You Leap anti-patterns.",
+    "Detects LBYL (Look Before You Leap) anti-patterns in Python code that should\n"
+    "    be refactored to EAFP (Easier to Ask Forgiveness than Permission) style.\n"
+    "    Examples: 'if key in dict: dict[key]' should use try/except KeyError.",
+)