machine-dialect 0.1.0a1__py3-none-any.whl

machine_dialect/linter/__main__.py

@@ -0,0 +1,144 @@
+"""Command-line interface for the Machine Dialect™ linter.
+
+This module provides the CLI for running the linter on Machine Dialect™ files.
+"""
+
+import argparse
+import json
+import sys
+from pathlib import Path
+from typing import Any
+
+from machine_dialect.linter import Linter, Violation
+
+
+def load_config(config_path: Path | None) -> dict[str, Any]:
+    """Load linter configuration from a file.
+
+    Args:
+        config_path: Path to the configuration file.
+
+    Returns:
+        Configuration dictionary.
+    """
+    if not config_path or not config_path.exists():
+        return {}
+
+    with open(config_path) as f:
+        if config_path.suffix == ".json":
+            return json.load(f)  # type: ignore[no-any-return]
+        else:
+            # For now, only support JSON
+            print(f"Warning: Unsupported config format {config_path.suffix}, using defaults")
+            return {}
+
+
+def format_violation(violation: Violation, filename: str) -> str:
+    """Format a violation for display.
+
+    Args:
+        violation: The violation to format.
+        filename: The filename where the violation occurred.
+
+    Returns:
+        A formatted string for display.
+    """
+    return f"{filename}:{violation}"
+
+
+def main() -> None:
+    """Main entry point for the linter CLI."""
+    parser = argparse.ArgumentParser(description="Lint Machine Dialect™ code for style and errors")
+
+    parser.add_argument(
+        "files",
+        nargs="*",  # Changed from "+" to "*" to make it optional
+        type=Path,
+        help="Machine Dialect™ files to lint",
+    )
+
+    parser.add_argument(
+        "-c",
+        "--config",
+        type=Path,
+        help="Path to configuration file",
+    )
+
+    parser.add_argument(
+        "-q",
+        "--quiet",
+        action="store_true",
+        help="Only show errors, not warnings",
+    )
+
+    parser.add_argument(
+        "--list-rules",
+        action="store_true",
+        help="List all available rules and exit",
+    )
+
+    args = parser.parse_args()
+
+    # Handle --list-rules
+    if args.list_rules:
+        linter = Linter()
+        print("Available linting rules:")
+        for rule in linter.rules:
+            print(f"  {rule.rule_id}: {rule.description}")
+        sys.exit(0)
+
+    # Check if files were provided
+    if not args.files:
+        parser.error("No files specified to lint")
+
+    # Load configuration
+    config = load_config(args.config)
+    linter = Linter(config)
+
+    # Lint files
+    total_violations = 0
+    has_errors = False
+
+    for filepath in args.files:
+        if not filepath.exists():
+            print(f"Error: File not found: {filepath}", file=sys.stderr)
+            has_errors = True
+            continue
+
+        try:
+            violations = linter.lint_file(str(filepath))
+
+            # Filter violations if --quiet
+            if args.quiet:
+                from machine_dialect.linter.violations import ViolationSeverity
+
+                violations = [v for v in violations if v.severity == ViolationSeverity.ERROR]
+
+            # Display violations
+            for violation in violations:
+                print(format_violation(violation, str(filepath)))
+                if violation.fix_suggestion:
+                    print(f"  Suggestion: {violation.fix_suggestion}")
+
+            total_violations += len(violations)
+
+            # Check for errors
+            from machine_dialect.linter.violations import ViolationSeverity
+
+            if any(v.severity == ViolationSeverity.ERROR for v in violations):
+                has_errors = True
+
+        except Exception as e:
+            print(f"Error linting {filepath}: {e}", file=sys.stderr)
+            has_errors = True
+
+    # Summary
+    if not args.quiet and total_violations > 0:
+        print(f"\nFound {total_violations} issue(s)")
+
+    # Exit with error code if there were errors
+    sys.exit(1 if has_errors or total_violations > 0 else 0)
+
+
+if __name__ == "__main__":
+    main()

machine_dialect/linter/linter.py

@@ -0,0 +1,154 @@
+"""Main linter class for Machine Dialect™.
+
+This module provides the main Linter class that orchestrates the
+linting process by running rules against an AST.
+"""
+
+from typing import Any
+
+from machine_dialect.ast import (
+    ASTNode,
+    ExpressionStatement,
+    PrefixExpression,
+    Program,
+    ReturnStatement,
+    SetStatement,
+)
+from machine_dialect.linter.rules import Rule
+from machine_dialect.linter.rules.base import Context
+from machine_dialect.linter.violations import Violation, ViolationSeverity
+from machine_dialect.parser import Parser
+
+
+class Linter:
+    """Main linter class that runs rules against Machine Dialect™ code.
+
+    The linter uses a visitor pattern to traverse the AST and apply
+    registered rules to each node.
+    """
+
+    def __init__(self, config: dict[str, Any] | None = None) -> None:
+        """Initialize the linter with optional configuration.
+
+        Args:
+            config: Configuration dictionary for the linter.
+        """
+        self.config = config or {}
+        self.rules: list[Rule] = []
+        self._register_default_rules()
+
+    def _register_default_rules(self) -> None:
+        """Register the default set of linting rules."""
+        # Import rules here to avoid circular imports
+        from machine_dialect.linter.rules.statement_termination import StatementTerminationRule
+
+        # Add default rules
+        self.add_rule(StatementTerminationRule())
+
+    def add_rule(self, rule: Rule) -> None:
+        """Add a linting rule to the linter.
+
+        Args:
+            rule: The rule instance to add.
+        """
+        if rule.is_enabled(self.config):
+            self.rules.append(rule)
+
+    def lint(self, source_code: str, filename: str = "<stdin>") -> list[Violation]:
+        """Lint the given source code.
+
+        Args:
+            source_code: The Machine Dialect™ source code to lint.
+            filename: The filename for error reporting.
+
+        Returns:
+            A list of violations found in the code.
+        """
+        # Parse the source code
+        parser = Parser()
+        program = parser.parse(source_code)
+
+        # Include parse errors as violations
+        violations: list[Violation] = []
+        for error in parser.errors:
+            violations.append(
+                Violation(
+                    rule_id="parse-error",
+                    message=str(error),
+                    severity=ViolationSeverity.ERROR,
+                    line=error._line,
+                    column=error._column,
+                )
+            )
+
+        # If there are parse errors, don't run other rules
+        if violations:
+            return violations
+
+        # Create context
+        context = Context(filename, source_code)
+
+        # Visit the AST and collect violations
+        violations.extend(self._visit_node(program, context))
+
+        return violations
+
+    def _visit_node(self, node: ASTNode | None, context: Context) -> list[Violation]:
+        """Visit an AST node and its children, applying rules.
+
+        Args:
+            node: The AST node to visit.
+            context: The linting context.
+
+        Returns:
+            A list of violations found.
+        """
+        if node is None:
+            return []
+
+        violations: list[Violation] = []
+
+        # Apply all rules to this node
+        for rule in self.rules:
+            violations.extend(rule.check(node, context))
+
+        # Visit children based on node type
+        context.push_parent(node)
+
+        if isinstance(node, Program):
+            for statement in node.statements:
+                violations.extend(self._visit_node(statement, context))
+
+        elif isinstance(node, SetStatement):
+            violations.extend(self._visit_node(node.name, context))
+            violations.extend(self._visit_node(node.value, context))
+
+        elif isinstance(node, ReturnStatement):
+            # ReturnStatement doesn't have a value attribute yet (TODO)
+            # violations.extend(self._visit_node(node.value, context))
+            pass
+
+        elif isinstance(node, ExpressionStatement):
+            violations.extend(self._visit_node(node.expression, context))
+
+        elif isinstance(node, PrefixExpression):
+            violations.extend(self._visit_node(node.right, context))
+
+        # Literals and identifiers have no children to visit
+
+        context.pop_parent()
+        return violations
+
+    def lint_file(self, filepath: str) -> list[Violation]:
+        """Lint a file by reading its contents and running the linter.
+
+        Args:
+            filepath: Path to the file to lint.
+
+        Returns:
+            A list of violations found in the file.
+        """
+        with open(filepath, encoding="utf-8") as f:
+            source_code = f.read()
+
+        return self.lint(source_code, filepath)

machine_dialect/linter/rules/__init__.py

@@ -0,0 +1,8 @@
+"""Linting rules for Machine Dialect™.
+
+This module manages the registration and execution of linting rules.
+"""
+
+from .base import Rule
+
+__all__ = ["Rule"]

machine_dialect/linter/rules/base.py

@@ -0,0 +1,112 @@
+"""Base rule class for Machine Dialect™ linting rules.
+
+This module defines the abstract base class that all linting rules
+must inherit from.
+"""
+
+from abc import ABC, abstractmethod
+from typing import Any
+
+from machine_dialect.ast import ASTNode
+from machine_dialect.linter.violations import Violation
+
+
+class Context:
+    """Context information passed to rules during linting.
+
+    Attributes:
+        filename: The name of the file being linted.
+        source_lines: The source code split into lines.
+        parent_stack: Stack of parent nodes for context.
+    """
+
+    def __init__(self, filename: str, source_code: str) -> None:
+        """Initialize the linting context.
+
+        Args:
+            filename: The name of the file being linted.
+            source_code: The complete source code.
+        """
+        self.filename = filename
+        self.source_code = source_code
+        self.source_lines = source_code.splitlines()
+        self.parent_stack: list[ASTNode] = []
+
+    def push_parent(self, node: ASTNode) -> None:
+        """Push a parent node onto the stack.
+
+        Args:
+            node: The parent node to push.
+        """
+        self.parent_stack.append(node)
+
+    def pop_parent(self) -> ASTNode | None:
+        """Pop a parent node from the stack.
+
+        Returns:
+            The popped parent node, or None if stack is empty.
+        """
+        return self.parent_stack.pop() if self.parent_stack else None
+
+    @property
+    def current_parent(self) -> ASTNode | None:
+        """Get the current parent node without removing it.
+
+        Returns:
+            The current parent node, or None if stack is empty.
+        """
+        return self.parent_stack[-1] if self.parent_stack else None
+
+
+class Rule(ABC):
+    """Abstract base class for linting rules.
+
+    All linting rules must inherit from this class and implement
+    the required methods.
+    """
+
+    @property
+    @abstractmethod
+    def rule_id(self) -> str:
+        """Return the unique identifier for this rule.
+
+        Returns:
+            A string identifier like "MD001" or "style-naming".
+        """
+        pass
+
+    @property
+    @abstractmethod
+    def description(self) -> str:
+        """Return a human-readable description of what this rule checks.
+
+        Returns:
+            A description of the rule's purpose.
+        """
+        pass
+
+    @abstractmethod
+    def check(self, node: ASTNode, context: Context) -> list[Violation]:
+        """Check the given AST node for violations of this rule.
+
+        Args:
+            node: The AST node to check.
+            context: The linting context with additional information.
+
+        Returns:
+            A list of violations found, or empty list if none.
+        """
+        pass
+
+    def is_enabled(self, config: dict[str, Any]) -> bool:
+        """Check if this rule is enabled in the configuration.
+
+        Args:
+            config: The linter configuration dictionary.
+
+        Returns:
+            True if the rule is enabled, False otherwise.
+        """
+        # By default, rules are enabled unless explicitly disabled
+        rules_config = config.get("rules", {})
+        return rules_config.get(self.rule_id, True) is not False

machine_dialect/linter/rules/statement_termination.py

@@ -0,0 +1,99 @@
+"""Statement termination rule for Machine Dialect™.
+
+This rule checks that all statements are properly terminated with periods.
+"""
+
+from machine_dialect.ast import (
+    ASTNode,
+    ExpressionStatement,
+    ReturnStatement,
+    SetStatement,
+)
+from machine_dialect.linter.rules.base import Context, Rule
+from machine_dialect.linter.violations import Violation, ViolationSeverity
+
+
+class StatementTerminationRule(Rule):
+    """Check that all statements end with periods.
+
+    Machine Dialect™ requires statements to be terminated with periods.
+    This rule checks that the source code follows this convention.
+    """
+
+    @property
+    def rule_id(self) -> str:
+        """Return the rule identifier."""
+        return "MD101"
+
+    @property
+    def description(self) -> str:
+        """Return the rule description."""
+        return "Statements must end with periods"
+
+    def check(self, node: ASTNode, context: Context) -> list[Violation]:
+        """Check if statements are properly terminated.
+
+        Args:
+            node: The AST node to check.
+            context: The linting context.
+
+        Returns:
+            A list of violations found.
+        """
+        violations: list[Violation] = []
+
+        # Only check statement nodes
+        if not isinstance(node, SetStatement | ReturnStatement | ExpressionStatement):
+            return violations
+
+        # Get the token that represents this statement
+        token = node.token
+        if not token:
+            return violations
+
+        # Find the line in the source code
+        if token.line <= len(context.source_lines):
+            line = context.source_lines[token.line - 1]
+
+            # Find where this statement likely ends
+            # This is a simplified check - in reality we'd need more sophisticated logic
+            # For now, check if there's a period after the statement
+
+            # Skip if this is not the last statement on the line
+            # (simplified check - just look for period somewhere after the token position)
+            remaining_line = line[token.position :]
+
+            # Check if there's any non-whitespace after the statement before a period
+            found_period = False
+            found_content = False
+
+            for char in remaining_line:
+                if char == ".":
+                    found_period = True
+                    break
+                elif not char.isspace():
+                    found_content = True
+
+            # If we found content but no period, it's likely missing termination
+            # This is a heuristic and may have false positives
+            # Exception: statements at EOF don't require periods
+            is_last_line = token.line == len(context.source_lines)
+            is_last_statement_on_line = not any(
+                line[i:].strip() for i in range(token.position + len(remaining_line.rstrip()), len(line))
+            )
+            is_at_eof = is_last_line and is_last_statement_on_line
+
+            if found_content and not found_period and not is_at_eof:
+                violations.append(
+                    Violation(
+                        rule_id=self.rule_id,
+                        message="Statement should end with a period",
+                        severity=ViolationSeverity.STYLE,
+                        line=token.line,
+                        column=token.position + len(remaining_line.rstrip()),
+                        node=node,
+                        fix_suggestion="Add a period at the end of the statement",
+                    )
+                )
+
+        return violations

machine_dialect/linter/tests/__init__.py

@@ -0,0 +1 @@
+"""Tests for the Machine Dialect™ linter."""