autosar-calltree 0.3.0__py3-none-any.whl

autosar_calltree/cli/main.py

@@ -0,0 +1,330 @@
+"""
+Command-line interface for autosar-calltree.
+
+This module provides the main CLI entry point using Click.
+"""
+
+import sys
+from pathlib import Path
+from typing import Optional
+
+import click
+from rich.console import Console
+from rich.progress import Progress, SpinnerColumn, TextColumn
+from rich.table import Table
+
+from ..analyzers.call_tree_builder import CallTreeBuilder
+from ..config.module_config import ModuleConfig
+from ..database.function_database import FunctionDatabase
+from ..generators.mermaid_generator import MermaidGenerator
+from ..version import __version__
+
+console = Console(record=True)
+
+
+@click.command()
+@click.option(
+    "--start-function",
+    "-s",
+    required=False,  # Not required if --list-functions or --search is used
+    help="Name of the function to start call tree from",
+)
+@click.option(
+    "--max-depth",
+    "-d",
+    default=3,
+    type=int,
+    help="Maximum depth to traverse (default: 3)",
+)
+@click.option(
+    "--source-dir",
+    "-i",
+    default="./demo",
+    type=click.Path(exists=True, file_okay=False, dir_okay=True),
+    help="Source directory containing C files (default: ./demo)",
+)
+@click.option(
+    "--output",
+    "-o",
+    default="call_tree.md",
+    type=click.Path(),
+    help="Output file path (default: call_tree.md)",
+)
+@click.option(
+    "--format",
+    "-f",
+    type=click.Choice(["mermaid", "xmi", "both"], case_sensitive=False),
+    default="mermaid",
+    help="Output format (default: mermaid)",
+)
+@click.option(
+    "--cache-dir",
+    type=click.Path(file_okay=False, dir_okay=True),
+    help="Cache directory (default: <source-dir>/.cache)",
+)
+@click.option("--no-cache", is_flag=True, help="Disable cache usage")
+@click.option("--rebuild-cache", is_flag=True, help="Force rebuild of cache")
+@click.option("--verbose", "-v", is_flag=True, help="Enable verbose output")
+@click.option(
+    "--list-functions", "-l", is_flag=True, help="List all available functions and exit"
+)
+@click.option(
+    "--search", type=str, help="Search for functions matching pattern and exit"
+)
+@click.option(
+    "--no-abbreviate-rte",
+    is_flag=True,
+    help="Do not abbreviate RTE function names in diagrams",
+)
+@click.option(
+    "--module-config",
+    type=click.Path(exists=True),
+    help="Path to YAML file mapping C files to SW modules",
+)
+@click.option(
+    "--use-module-names",
+    is_flag=True,
+    help="Use SW module names as Mermaid participants (requires --module-config)",
+)
+@click.version_option(version=__version__, prog_name="autosar-calltree")
+def cli(
+    start_function: str,
+    max_depth: int,
+    source_dir: str,
+    output: str,
+    format: str,
+    cache_dir: Optional[str],
+    no_cache: bool,
+    rebuild_cache: bool,
+    verbose: bool,
+    list_functions: bool,
+    search: Optional[str],
+    no_abbreviate_rte: bool,
+    module_config: Optional[str],
+    use_module_names: bool,
+):
+    """
+    AUTOSAR Call Tree Analyzer
+
+    Analyzes C/AUTOSAR codebases and generates function call trees
+    with Mermaid sequence diagrams or XMI output.
+    """
+    try:
+        # Print banner
+        if not verbose:
+            console.print(
+                f"[bold cyan]AUTOSAR Call Tree Analyzer v{__version__}[/bold cyan]"
+            )
+            console.print()
+
+        # Validate use_module_names requires module_config
+        if use_module_names and not module_config:
+            console.print(
+                "[yellow]Warning:[/yellow] --use-module-names requires --module-config. "
+                "Module names will not be used."
+            )
+            use_module_names = False
+
+        # Load module configuration if provided
+        config = None
+        if module_config:
+            try:
+                config = ModuleConfig(Path(module_config))
+                if verbose:
+                    console.print(
+                        f"[cyan]Loaded module configuration from {module_config}[/cyan]"
+                    )
+                    config_stats = config.get_statistics()
+                    console.print(
+                        f"  - Specific file mappings: {config_stats['specific_file_mappings']}"
+                    )
+                    console.print(
+                        f"  - Pattern mappings: {config_stats['pattern_mappings']}"
+                    )
+            except Exception as e:
+                console.print(f"[bold red]Error loading module config:[/bold red] {e}")
+                sys.exit(1)
+
+        # Initialize database
+        use_cache = not no_cache
+
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            console=console,
+            transient=True,
+        ) as progress:
+            # Build database
+            task = progress.add_task(
+                f"Building function database from {source_dir}...", total=None
+            )
+
+            db = FunctionDatabase(source_dir, cache_dir=cache_dir, module_config=config)
+            db.build_database(
+                use_cache=use_cache, rebuild_cache=rebuild_cache, verbose=verbose
+            )
+
+            progress.update(task, completed=True)
+
+        # Print statistics
+        stats = db.get_statistics()
+
+        if verbose:
+            console.print("\n[bold]Database Statistics:[/bold]")
+            table = Table(show_header=False)
+            table.add_column("Property", style="cyan")
+            table.add_column("Value", style="green")
+            table.add_row("Files Scanned", str(stats["total_files_scanned"]))
+            table.add_row("Functions Found", str(stats["total_functions_found"]))
+            table.add_row("Unique Names", str(stats["unique_function_names"]))
+            table.add_row("Static Functions", str(stats["static_functions"]))
+            table.add_row("Parse Errors", str(stats["parse_errors"]))
+            console.print(table)
+
+            # Print module statistics if available
+            if stats.get("module_stats"):
+                console.print("\n[bold]Module Distribution:[/bold]")
+                for module, count in sorted(stats["module_stats"].items()):
+                    console.print(f"  {module}: {count} functions")
+            console.print()
+
+        # Handle list functions
+        if list_functions:
+            console.print("[bold]Available Functions:[/bold]\n")
+            functions = db.get_all_function_names()
+            for idx, func_name in enumerate(functions, 1):
+                console.print(f"{idx:4d}. {func_name}")
+            console.print(f"\n[cyan]Total: {len(functions)} functions[/cyan]")
+            return
+
+        # Handle search
+        if search:
+            console.print(f"[bold]Search Results for '{search}':[/bold]\n")
+            results = db.search_functions(search)
+            if results:
+                for func_info in results:
+                    file_name = Path(func_info.file_path).name
+                    console.print(
+                        f"  [cyan]{func_info.name}[/cyan] "
+                        f"({file_name}:{func_info.line_number})"
+                    )
+                console.print(f"\n[cyan]Found {len(results)} matches[/cyan]")
+            else:
+                console.print(
+                    f"[yellow]No functions found matching '{search}'[/yellow]"
+                )
+            return
+
+        # Validate start_function is provided if not using list/search
+        if not start_function:
+            console.print("[bold red]Error:[/bold red] --start-function is required")
+            console.print("Use --list-functions to see available functions")
+            sys.exit(1)
+
+        # Build call tree
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            console=console,
+            transient=True,
+        ) as progress:
+            task = progress.add_task(
+                f"Building call tree for {start_function}...", total=None
+            )
+
+            builder = CallTreeBuilder(db)
+            result = builder.build_tree(
+                start_function=start_function, max_depth=max_depth, verbose=verbose
+            )
+
+            progress.update(task, completed=True)
+
+        # Check for errors
+        if result.errors:
+            console.print("[bold red]Errors:[/bold red]")
+            for error in result.errors:
+                console.print(f"  - {error}")
+            sys.exit(1)
+
+        # Print analysis statistics
+        if not verbose:
+            console.print("[bold]Analysis Results:[/bold]")
+            console.print(
+                f"  - Total functions: [cyan]{result.statistics.total_functions}[/cyan]"
+            )
+            console.print(
+                f"  - Unique functions: [cyan]{result.statistics.unique_functions}[/cyan]"
+            )
+            console.print(
+                f"  - Max depth: [cyan]{result.statistics.max_depth_reached}[/cyan]"
+            )
+            if result.statistics.circular_dependencies_found > 0:
+                console.print(
+                    f"  - Circular dependencies: "
+                    f"[yellow]{result.statistics.circular_dependencies_found}[/yellow]"
+                )
+            console.print()
+
+        # Generate output
+        output_path = Path(output)
+
+        if format in ["mermaid", "both"]:
+            with Progress(
+                SpinnerColumn(),
+                TextColumn("[progress.description]{task.description}"),
+                console=console,
+                transient=True,
+            ) as progress:
+                task = progress.add_task("Generating Mermaid diagram...", total=None)
+
+                mermaid_output = (
+                    output_path
+                    if format == "mermaid"
+                    else output_path.with_suffix(".mermaid.md")
+                )
+
+                generator = MermaidGenerator(
+                    abbreviate_rte=not no_abbreviate_rte,
+                    use_module_names=use_module_names,
+                )
+                generator.generate(result, str(mermaid_output))
+
+                progress.update(task, completed=True)
+
+            console.print(
+                f"[green]Generated[/green] Mermaid diagram: [cyan]{mermaid_output}[/cyan]"
+            )
+
+        if format == "xmi":
+            console.print("[yellow]Warning:[/yellow] XMI format not yet implemented")
+
+        if format == "both":
+            console.print(
+                "[yellow]Warning:[/yellow] XMI format not yet implemented (only Mermaid generated)"
+            )
+
+        # Print warnings for circular dependencies
+        if result.circular_dependencies:
+            console.print(
+                "\n[bold yellow]Warning:[/bold yellow] Circular dependencies detected!"
+            )
+            for idx, circ_dep in enumerate(result.circular_dependencies, 1):
+                cycle_str = " → ".join(circ_dep.cycle)
+                console.print(
+                    f"  {idx}. [yellow]{cycle_str}[/yellow] (depth {circ_dep.depth})"
+                )
+
+        console.print("\n[bold green]Analysis complete![/bold green]")
+
+    except KeyboardInterrupt:
+        console.print("\n[yellow]Interrupted by user[/yellow]")
+        sys.exit(130)
+    except Exception as e:
+        console.print(f"\n[bold red]Error:[/bold red] {e}")
+        if verbose:
+            console.print_exception()
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    cli()

autosar_calltree/config/__init__.py

@@ -0,0 +1,10 @@
+"""
+Configuration management for AUTOSAR Call Tree Analyzer.
+
+This module provides functionality for managing YAML-based configurations,
+including mapping C source files to SW modules.
+"""
+
+from .module_config import ModuleConfig
+
+__all__ = ["ModuleConfig"]

autosar_calltree/config/module_config.py

@@ -0,0 +1,179 @@
+"""
+Module configuration management for SW module mappings.
+
+This module provides functionality for loading and managing YAML-based
+configurations that map C source files to SW (Software) modules.
+
+Requirements:
+- SWR_CONFIG_00001: YAML Configuration File Support
+- SWR_CONFIG_00002: Module Configuration Validation
+"""
+
+import fnmatch
+import re
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple
+
+
+class ModuleConfig:
+    """
+    Manages SW module configuration from YAML file.
+
+    This class handles loading, validating, and looking up SW module mappings
+    for C source files. It supports both specific file mappings and glob pattern
+    mappings.
+
+    Attributes:
+        specific_mappings: Dictionary mapping exact filenames to module names
+        pattern_mappings: List of compiled regex patterns and module names
+        default_module: Default module name for unmapped files (optional)
+        _lookup_cache: Cache for filename to module lookups
+    """
+
+    def __init__(self, config_path: Optional[Path] = None) -> None:
+        """
+        Initialize the module configuration.
+
+        Args:
+            config_path: Path to YAML configuration file (optional)
+        """
+        self.specific_mappings: Dict[str, str] = {}
+        self.pattern_mappings: List[Tuple[re.Pattern, str]] = []
+        self.default_module: Optional[str] = None
+        self._lookup_cache: Dict[str, Optional[str]] = {}
+
+        if config_path:
+            self.load_config(config_path)
+
+    def load_config(self, config_path: Path) -> None:
+        """
+        Load module configuration from YAML file.
+
+        Implements: SWR_CONFIG_00001 (YAML Configuration File Support)
+        Implements: SWR_CONFIG_00002 (Module Configuration Validation)
+
+        Args:
+            config_path: Path to YAML configuration file
+
+        Raises:
+            FileNotFoundError: If config file doesn't exist
+            ValueError: If config file format is invalid
+        """
+        import yaml  # type: ignore
+
+        if not config_path.exists():
+            raise FileNotFoundError(f"Configuration file not found: {config_path}")
+
+        with open(config_path, "r", encoding="utf-8") as f:
+            data = yaml.safe_load(f)
+
+        if not isinstance(data, dict):
+            raise ValueError(
+                "Invalid configuration format: expected dictionary at root level"
+            )
+
+        # Load specific file mappings (exact filename match)
+        file_mappings = data.get("file_mappings", {})
+        if not isinstance(file_mappings, dict):
+            raise ValueError("'file_mappings' must be a dictionary")
+
+        for filename, module in file_mappings.items():
+            if not isinstance(filename, str) or not isinstance(module, str):
+                raise ValueError("File mappings must be strings")
+            if not module.strip():
+                raise ValueError(f"Module name cannot be empty for file: {filename}")
+            self.specific_mappings[filename] = module
+
+        # Load pattern mappings (glob patterns)
+        pattern_mappings = data.get("pattern_mappings", {})
+        if not isinstance(pattern_mappings, dict):
+            raise ValueError("'pattern_mappings' must be a dictionary")
+
+        for pattern, module in pattern_mappings.items():
+            if not isinstance(pattern, str) or not isinstance(module, str):
+                raise ValueError("Pattern mappings must be strings")
+            if not module.strip():
+                raise ValueError(f"Module name cannot be empty for pattern: {pattern}")
+
+            # Compile glob pattern to regex for faster matching
+            regex = fnmatch.translate(pattern)
+            compiled = re.compile(regex)
+            self.pattern_mappings.append((compiled, module))
+
+        # Load default module (optional)
+        default_module = data.get("default_module")
+        if default_module is not None:
+            if not isinstance(default_module, str) or not default_module.strip():
+                raise ValueError("'default_module' must be a non-empty string")
+            self.default_module = default_module
+
+    def get_module_for_file(self, file_path: Path) -> Optional[str]:
+        """
+        Get SW module name for a given file.
+
+        This method first checks specific file mappings, then pattern mappings,
+        and finally returns the default module if configured.
+
+        Lookup results are cached for performance.
+
+        Args:
+            file_path: Path to the source file
+
+        Returns:
+            Module name if found, None otherwise
+        """
+        filename = file_path.name
+
+        # Check cache first
+        if filename in self._lookup_cache:
+            return self._lookup_cache[filename]
+
+        # Check specific file mappings (exact match)
+        if filename in self.specific_mappings:
+            module = self.specific_mappings[filename]
+            self._lookup_cache[filename] = module
+            return module
+
+        # Check pattern mappings (glob patterns)
+        for pattern, module in self.pattern_mappings:
+            if pattern.match(filename):
+                self._lookup_cache[filename] = module
+                return module
+
+        # Use default module if configured
+        if self.default_module is not None:
+            self._lookup_cache[filename] = self.default_module
+            return self.default_module
+
+        # No match found
+        self._lookup_cache[filename] = None
+        return None
+
+    def validate_config(self) -> List[str]:
+        """
+        Validate the current configuration.
+
+        Returns:
+            List of validation error messages (empty if valid)
+        """
+        errors = []
+
+        if not self.specific_mappings and not self.pattern_mappings:
+            errors.append(
+                "Configuration must contain either 'file_mappings' or 'pattern_mappings'"
+            )
+
+        return errors
+
+    def get_statistics(self) -> Dict[str, int]:
+        """
+        Get statistics about the configuration.
+
+        Returns:
+            Dictionary with configuration statistics
+        """
+        return {
+            "specific_file_mappings": len(self.specific_mappings),
+            "pattern_mappings": len(self.pattern_mappings),
+            "has_default_module": 1 if self.default_module else 0,
+        }

autosar_calltree/database/__init__.py

@@ -0,0 +1,23 @@
+"""Database package initialization."""
+
+from .models import (
+    AnalysisResult,
+    AnalysisStatistics,
+    CallTreeNode,
+    CircularDependency,
+    FunctionDict,
+    FunctionInfo,
+    FunctionType,
+    Parameter,
+)
+
+__all__ = [
+    "FunctionType",
+    "Parameter",
+    "FunctionInfo",
+    "CallTreeNode",
+    "CircularDependency",
+    "AnalysisStatistics",
+    "AnalysisResult",
+    "FunctionDict",
+]