linti 0.4.2__py3-none-any.whl

linti/__init__.py

@@ -0,0 +1,9 @@
+from linti.lexer.lexer import Lexer
+from linti.linter.linter import Linter
+from linti.rules.Rule import BaseRule
+
+__all__ = [
+    "BaseRule",
+    "Lexer",
+    "Linter",
+]

linti/cli/__init__.py

@@ -0,0 +1 @@
+"""CLI module for linti."""

linti/cli/auto_fixer.py

@@ -0,0 +1,218 @@
+"""Auto-fixing functionality for TM1 linter."""
+
+from pathlib import Path
+from typing import Optional
+
+from linti.lexer.lexer import Lexer
+from linti.linter.lint_context import LintContext
+from linti.linter.lint_issue import LintIssue
+from linti.linter.linter import Linter
+
+MAX_AUTO_FIX_PASSES = 10
+
+
+def apply_fixes(code: str, issues: list[LintIssue]) -> tuple[str, int]:
+    """
+    Apply all fixable issues to code.
+
+    Replaces text at positions specified by each issue's Fix object.
+    Works with any rule that provides a Fix — no rule-specific logic needed.
+
+    Args:
+        code: The original source code
+        issues: List of LintIssue objects (only those with a fix are applied)
+
+    Returns:
+        Tuple of (fixed_code, num_fixes_applied)
+    """
+    fixable = [issue for issue in issues if issue.fix is not None]
+
+    if not fixable:
+        return code, 0
+
+    # Sort fixes from back to front.
+    # At the same position, apply replacements before insertions.
+    fixable.sort(key=lambda i: (-i.fix.position, len(i.fix.old_value) == 0))
+
+    fixed_code = code
+    for issue in fixable:
+        fix = issue.fix
+        start = fix.position
+        end = start + len(fix.old_value)
+
+        # Verify the old value is at the expected position
+        if fixed_code[start:end] == fix.old_value:
+            fixed_code = fixed_code[:start] + fix.new_value + fixed_code[end:]
+
+    return fixed_code, len(fixable)
+
+
+def collect_fixable_issues(
+    code: str, linter: Linter, lint_context: Optional[LintContext] = None
+) -> list[LintIssue]:
+    """
+    Lint code and return only the fixable issues.
+
+    Args:
+        code: The TI code to analyze
+        linter: Configured linter instance
+        lint_context: Optional LintContext
+
+    Returns:
+        List of LintIssue objects that have a Fix
+    """
+    tokens = Lexer(code).tokenize()
+    issues = linter.lint(tokens, lint_context)
+    return [issue for issue in issues if issue.fix is not None]
+
+
+def apply_fixes_iteratively(
+    code: str,
+    linter: Linter,
+    lint_context: Optional[LintContext] = None,
+    max_passes: int = MAX_AUTO_FIX_PASSES,
+) -> tuple[str, int]:
+    """Apply fixable issues repeatedly until no more fixes remain.
+
+    This is needed when one fix creates the structure required for later fixes,
+    for example splitting statements onto new lines before indentation can be
+    computed correctly.
+
+    Args:
+        code: The original source code
+        linter: Configured linter instance
+        lint_context: Optional lint context
+        max_passes: Safety limit to avoid infinite fix loops
+
+    Returns:
+        Tuple of (fixed_code, total_num_fixes_applied)
+    """
+    fixed_code = code
+    total_fixes = 0
+
+    for _ in range(max_passes):
+        issues = collect_fixable_issues(fixed_code, linter, lint_context)
+        if not issues:
+            break
+
+        next_code, num_fixes = apply_fixes(fixed_code, issues)
+        if num_fixes == 0 or next_code == fixed_code:
+            break
+
+        fixed_code = next_code
+        total_fixes += num_fixes
+
+    return fixed_code, total_fixes
+
+
+def auto_fix_ti_file(
+    file_path: Path, linter: Linter, lint_context: Optional[LintContext] = None
+) -> int:
+    """
+    Auto-fix a TI file in place.
+
+    Args:
+        file_path: Path to the TI file
+        linter: Configured linter instance
+        lint_context: Optional LintContext
+
+    Returns:
+        Number of fixes applied
+    """
+    with open(file_path, "r") as f:
+        original_code = f.read()
+
+    fixed_code, num_fixes = apply_fixes_iteratively(original_code, linter, lint_context)
+
+    if num_fixes > 0:
+        with open(file_path, "w") as f:
+            f.write(fixed_code)
+
+    return num_fixes
+
+
+def auto_fix_yaml_procedures(
+    file_path: Path, process, linter: Linter
+) -> dict[str, int]:
+    """
+    Auto-fix procedures in a YAML ProcessObject file.
+
+    Args:
+        file_path: Path to the YAML file
+        process: TM1Process with procedures
+        linter: Configured linter instance
+
+    Returns:
+        Dict mapping procedure names to number of fixes applied
+    """
+    from linti.loader.base import extract_procedures
+
+    procedures = extract_procedures(process)
+    fixes_by_proc = {}
+
+    # Read original YAML content
+    with open(file_path, "r") as f:
+        yaml_lines = f.readlines()
+
+    indent_prefix = " " * process.content_indent
+
+    # Process each procedure
+    for proc_name, proc_info in procedures.items():
+        code = proc_info.code
+        yaml_start_line = proc_info.source_line
+
+        # Create context for this procedure
+        lint_ctx = LintContext(
+            block=proc_name,
+            parameters=process.parameters,
+            parameter_lines=process.parameter_lines,
+            variables=process.variables,
+            variable_lines=process.variable_lines,
+            block_start_line=proc_info.source_line,
+            block_end_line=proc_info.source_end_line,
+        )
+
+        # Apply fixes
+        fixed_code, num_fixes = apply_fixes_iteratively(code, linter, lint_ctx)
+
+        if num_fixes > 0:
+            fixes_by_proc[proc_name] = num_fixes
+
+            # Replace the procedure content in YAML
+            # yaml_start_line points to where the procedure content starts (after "ProcedureName: |-")
+            # We need to find where the content ends (next line at lower indent or end of file)
+
+            content_start = yaml_start_line  # This is 1-based line number
+            content_start_idx = content_start - 1  # Convert to 0-based index
+
+            # Find end of content (next line not indented at the content level or end of file)
+            content_end_idx = content_start_idx
+            for j in range(content_start_idx, len(yaml_lines)):
+                line = yaml_lines[j]
+                # If line has content and is not indented at (or beyond) the content level, we've hit the end
+                if line.strip() and not line.startswith(indent_prefix):
+                    content_end_idx = j
+                    break
+            else:
+                content_end_idx = len(yaml_lines)
+
+            # Replace the content with fixed code
+            fixed_lines = []
+            for line in fixed_code.split("\n"):
+                if not line and not fixed_lines:
+                    # Skip leading empty lines
+                    continue
+                if line:
+                    fixed_lines.append(f"{indent_prefix}{line}\n")
+                else:
+                    # Preserve blank lines without adding trailing spaces
+                    fixed_lines.append("\n")
+
+            yaml_lines[content_start_idx:content_end_idx] = fixed_lines
+
+    # Write back the modified YAML
+    if fixes_by_proc:
+        with open(file_path, "w") as f:
+            f.writelines(yaml_lines)
+
+    return fixes_by_proc

linti/cli/config_loader.py

@@ -0,0 +1,56 @@
+"""Configuration loading with CLI output."""
+
+from pathlib import Path
+from typing import Optional
+
+import typer
+
+from linti.config import Config
+
+
+def load_config(file_path: Path, config_override: Optional[Path] = None) -> Config:
+    """
+    Load configuration from file or discover default.
+
+    Args:
+        file_path: Path to a TI file, YAML file, or directory being linted
+        config_override: Optional explicit config file path
+
+    Returns:
+        Loaded Config object
+    """
+    if config_override:
+        cfg = Config.load_from_file(config_override)
+        typer.echo(f"Loaded config from: {config_override}")
+        return cfg
+
+    if file_path.is_dir():
+        # For directories, walk upward from the directory itself
+        target_sentinel = file_path / "_dummy"
+        cfg = Config.find_and_load(target_sentinel)
+        # Check if a config was actually found (walk upward)
+        directory = file_path.resolve()
+        while True:
+            config_file = directory / "linti.yaml"
+            if config_file.exists():
+                typer.echo(f"Loaded config from: {config_file}")
+                break
+            parent = directory.parent
+            if parent == directory:
+                break
+            directory = parent
+        return cfg
+
+    # For files, walk upward from the file's directory
+    cfg = Config.find_and_load(file_path)
+    directory = file_path.parent.resolve()
+    while True:
+        config_file = directory / "linti.yaml"
+        if config_file.exists():
+            typer.echo(f"Loaded config from: {config_file}")
+            break
+        parent = directory.parent
+        if parent == directory:
+            break
+        directory = parent
+    return cfg

linti/cli/file_linter.py

@@ -0,0 +1,280 @@
+"""File linting operations for TI files, YAML files, and directories."""
+
+from pathlib import Path
+from typing import Optional
+
+import typer
+
+from linti.cli.auto_fixer import (
+    auto_fix_ti_file,
+    auto_fix_yaml_procedures,
+)
+from linti.cli.config_loader import load_config
+from linti.cli.issue_reporter import (
+    report_directory_issues,
+    report_issues,
+    report_yaml_issues,
+)
+from linti.lexer.lexer import Lexer
+from linti.linter.lint_context import LintContext
+from linti.linter.linter import Linter
+from linti.loader.base import extract_procedures
+from linti.loader.yaml_loader import load_yaml_process
+from linti.parser.ast import UnknownStatement
+from linti.parser.parser import Parser
+from linti.rules.rule_factory import create_rules
+
+
+def analyze_and_lint_code(
+    code: str,
+    linter: Linter,
+    show_tokens: bool,
+    show_ast: bool,
+    context_label: Optional[str] = None,
+    lint_context: Optional[LintContext] = None,
+) -> list:
+    """
+    Tokenize, parse, and lint code.
+
+    Args:
+        code: The TI code to analyze
+        linter: Configured linter instance
+        show_tokens: Whether to display tokens
+        show_ast: Whether to display AST
+        context_label: Optional context label for output (e.g., procedure name)
+        lint_context: Optional LintContext with block, parameters, variables
+
+    Returns:
+        List of linting issues
+    """
+    lexer = Lexer(code)
+    tokens = lexer.tokenize()
+
+    if show_tokens:
+        label = f" ({context_label})" if context_label else ""
+        typer.echo(f"\nTokens{label}:")
+        for token in tokens:
+            if token.type.name not in ["WHITESPACE", "NEWLINE"]:
+                typer.echo(f"{token.type.name:15} {token.value!r}")
+
+    # Build AST
+    parser = Parser(tokens)
+    ast = parser.parse()
+
+    if show_ast:
+        label = f" ({context_label})" if context_label else ""
+        typer.echo(f"\nAST{label}:")
+        typer.echo(f"Program with {len(ast.statements)} statements:")
+        for i, stmt in enumerate(ast.statements, 1):
+            stmt_name = stmt.__class__.__name__
+            if isinstance(stmt, UnknownStatement):
+                typer.echo(
+                    f"  {i}. {stmt_name} (error: {stmt.error_message})",
+                    err=True,
+                )
+            else:
+                typer.echo(f"  {i}. {stmt_name}")
+
+    # Run linter and return issues
+    return linter.lint(tokens, lint_context, ast=ast)
+
+
+def lint_ti_file(
+    file_path: Path,
+    show_tokens: bool,
+    show_ast: bool,
+    config: Optional[Path],
+    auto_fix: bool = False,
+    select: Optional[str] = None,
+) -> None:
+    """
+    Lint a TI (.ti) file.
+
+    Args:
+        file_path: Path to the TI file
+        show_tokens: Whether to display tokens
+        show_ast: Whether to display AST
+        config: Optional config file path
+        auto_fix: Whether to automatically fix supported auto-fixable issues
+        select: Optional rule IDs/patterns to select (e.g., "F110" or "F,N1")
+
+    Raises:
+        typer.Exit: With appropriate exit code
+    """
+    cfg = load_config(file_path, config)
+    token_rules, statement_rules = create_rules(cfg, select=select)
+    linter = Linter(rules=token_rules, statement_rules=statement_rules)
+
+    if auto_fix:
+        # Apply auto-fixes
+        num_fixes = auto_fix_ti_file(file_path, linter, lint_context=None)
+        if num_fixes > 0:
+            typer.echo(f"Fixed {num_fixes} auto-fixable issue(s) in {file_path}")
+        else:
+            typer.echo(f"No auto-fixable issues to fix in {file_path}")
+
+    # Read the file (potentially after fixes have been applied)
+    with open(file_path, "r") as f:
+        ti_code = f.read()
+
+    issues = analyze_and_lint_code(
+        ti_code,
+        linter,
+        show_tokens,
+        show_ast,
+        context_label=None,
+        lint_context=LintContext(block="prolog", process_name=file_path.stem),
+    )
+
+    raise typer.Exit(code=report_issues(file_path, issues))
+
+
+def lint_yaml_file(
+    file_path: Path,
+    show_tokens: bool,
+    show_ast: bool,
+    config: Optional[Path],
+    linter: Optional[Linter] = None,
+    return_issues: bool = False,
+    silent_errors: bool = False,
+    auto_fix: bool = False,
+    select: Optional[str] = None,
+) -> Optional[list]:
+    """
+    Lint a YAML ProcessObject file (TM1py format).
+
+    Args:
+        file_path: Path to the YAML file
+        show_tokens: Whether to display tokens
+        show_ast: Whether to display AST
+        config: Optional config file path
+        linter: Optional pre-created Linter instance (if None, will be created)
+        return_issues: If True, return issues instead of reporting and exiting
+        silent_errors: If True, return None on error instead of raising Exit
+        auto_fix: Whether to automatically fix supported auto-fixable issues
+        select: Optional rule IDs/patterns to select (e.g., "F110" or "F,N1")
+
+    Returns:
+        List of (proc_name, issue, yaml_line) tuples if return_issues=True, else None
+
+    Raises:
+        typer.Exit: With appropriate exit code (unless return_issues=True)
+    """
+    try:
+        process = load_yaml_process(file_path)
+    except Exception as e:
+        if silent_errors:
+            return None
+        typer.echo(f"Error loading YAML file: {e}", err=True)
+        raise typer.Exit(code=1)
+
+    typer.echo(f"Process: {process.name}")
+
+    # Use provided linter or create a new one
+    if linter is None:
+        cfg = load_config(file_path, config)
+        token_rules, statement_rules = create_rules(cfg, select=select)
+        linter = Linter(rules=token_rules, statement_rules=statement_rules)
+
+    # Apply auto-fixes if requested
+    if auto_fix:
+        fixes_by_proc = auto_fix_yaml_procedures(file_path, process, linter)
+        if fixes_by_proc:
+            total_fixes = sum(fixes_by_proc.values())
+            typer.echo(f"Fixed {total_fixes} auto-fixable issue(s) in {file_path}:")
+            for proc_name, count in fixes_by_proc.items():
+                typer.echo(f"  - {proc_name}: {count} fix(es)")
+            # Reload process after fixes
+            process = load_yaml_process(file_path)
+        else:
+            typer.echo(f"No auto-fixable issues to fix in {file_path}")
+
+    # Extract and lint each procedure
+    procedures = extract_procedures(process)
+    all_issues = []
+
+    for proc_name, proc_info in procedures.items():
+        lint_ctx = LintContext(
+            block=proc_name,
+            process_name=process.name,
+            parameters=process.parameters,
+            parameter_lines=process.parameter_lines,
+            variables=process.variables,
+            variable_lines=process.variable_lines,
+            block_start_line=proc_info.source_line,
+            block_end_line=proc_info.source_end_line,
+        )
+        issues = analyze_and_lint_code(
+            proc_info.code,
+            linter,
+            show_tokens,
+            show_ast,
+            context_label=proc_name,
+            lint_context=lint_ctx,
+        )
+        for issue in issues:
+            # Adjust line number to source file location
+            adjusted_issue = (proc_name, issue, proc_info.source_line)
+            all_issues.append(adjusted_issue)
+
+    if return_issues:
+        return all_issues
+    else:
+        raise typer.Exit(code=report_yaml_issues(file_path, all_issues))
+
+
+def lint_directory(
+    directory: Path,
+    show_tokens: bool,
+    show_ast: bool,
+    config: Optional[Path],
+    auto_fix: bool = False,
+    select: Optional[str] = None,
+) -> None:
+    """
+    Lint all YAML process files in a directory and all subdirectories.
+
+    Args:
+        directory: Path to the directory
+        show_tokens: Whether to display tokens
+        show_ast: Whether to display AST
+        config: Optional config file path
+        auto_fix: Whether to automatically fix supported auto-fixable issues
+        select: Optional rule IDs/patterns to select (e.g., "F110" or "F,N1")
+
+    Raises:
+        typer.Exit: With appropriate exit code
+    """
+    yaml_files = sorted({*directory.rglob("*.yaml"), *directory.rglob("*.yml")})
+
+    if not yaml_files:
+        typer.echo(f"No YAML files found in {directory}", err=False)
+        raise typer.Exit(code=0)
+
+    # Load configuration once for the directory
+    cfg = load_config(directory, config)
+
+    # Lint each YAML file and collect all issues
+    all_file_issues = []  # List of (file_path, proc_name, issue, yaml_line) tuples
+
+    for yaml_file in yaml_files:
+        # Create fresh rule instances per file to avoid cross-file state contamination
+        token_rules, statement_rules = create_rules(cfg, select=select)
+        linter = Linter(rules=token_rules, statement_rules=statement_rules)
+
+        file_issues = lint_yaml_file(
+            yaml_file,
+            show_tokens,
+            show_ast,
+            config,
+            linter,
+            return_issues=True,
+            silent_errors=True,
+            auto_fix=auto_fix,
+            select=select,
+        )
+        if file_issues:
+            for proc_name, issue, yaml_line in file_issues:
+                all_file_issues.append((yaml_file, proc_name, issue, yaml_line))
+
+    raise typer.Exit(code=report_directory_issues(directory, all_file_issues))