tree-sitter-analyzer 1.9.17.1__py3-none-any.whl

tree_sitter_analyzer/core/engine.py

@@ -0,0 +1,585 @@
+#!/usr/bin/env python3
+"""
+Updated Engine module for tree_sitter_analyzer.core.
+
+This module provides the AnalysisEngine class which is the core component
+of the new architecture responsible for file analysis workflow.
+"""
+
+import logging
+from pathlib import Path
+from typing import Any
+
+from tree_sitter import Tree
+
+from ..language_detector import LanguageDetector
+from ..models import AnalysisResult, CodeElement
+from ..plugins.manager import PluginManager
+from .parser import Parser, ParseResult
+from .query import QueryExecutor
+
+# Configure logging
+logger = logging.getLogger(__name__)
+
+
+class AnalysisEngine:
+    """
+    Core analysis engine for the new architecture.
+
+    This class orchestrates the analysis workflow by coordinating
+    parsing, query execution, and element extraction through plugins.
+    """
+
+    def __init__(self) -> None:
+        """Initialize the AnalysisEngine with core components."""
+        try:
+            self.parser = Parser()
+            self.query_executor = QueryExecutor()
+            self.language_detector = LanguageDetector()
+
+            # Initialize plugin system
+            self.plugin_manager = PluginManager()
+            self._initialize_plugins()
+
+            logger.info("AnalysisEngine initialized successfully")
+
+        except Exception as e:
+            logger.error(f"Failed to initialize AnalysisEngine: {e}")
+            raise
+
+    def analyze_file(
+        self,
+        file_path: str | Path,
+        language: str | None = None,
+        queries: list[str] | None = None,
+    ) -> AnalysisResult:
+        """
+        Analyze a source code file.
+
+        Args:
+            file_path: Path to the file to analyze
+            language: Optional language override
+            queries: List of query names to execute (all available if not specified)
+
+        Returns:
+            AnalysisResult containing analysis results
+        """
+        file_path_obj = Path(file_path)
+        file_path_str = str(file_path_obj)
+
+        try:
+            # Check if file exists
+            if not file_path_obj.exists():
+                raise FileNotFoundError(f"File not found: {file_path_str}")
+
+            # Determine language
+            detected_language = self._determine_language(file_path_obj, language)
+
+            # Parse the file
+            parse_result = self.parser.parse_file(file_path_str, detected_language)
+
+            if not parse_result.success:
+                logger.warning(
+                    f"Parsing failed for {file_path_str}: {parse_result.error_message}"
+                )
+                return self._create_empty_result(
+                    file_path_str, detected_language, error=parse_result.error_message
+                )
+
+            # Perform analysis
+            return self._perform_analysis(parse_result, queries=queries)
+
+        except FileNotFoundError:
+            raise
+        except PermissionError:
+            raise
+        except Exception as e:
+            logger.error(f"Error analyzing file {file_path_str}: {e}")
+            return self._create_empty_result(
+                file_path_str, language or "unknown", error=str(e)
+            )
+
+    def analyze_code(
+        self,
+        source_code: str,
+        language: str | None = None,
+        filename: str | None = None,
+    ) -> AnalysisResult:
+        """
+        Analyze source code string.
+
+        Args:
+            source_code: Source code to analyze
+            language: Programming language (required if no filename)
+            filename: Optional filename for language detection
+
+        Returns:
+            AnalysisResult containing analysis results
+        """
+        try:
+            # Determine language
+            if language is None and filename is not None:
+                language = self.language_detector.detect_from_extension(filename)
+            elif language is None:
+                language = "unknown"
+
+            # Parse the code
+            parse_result = self.parser.parse_code(source_code, language, filename)
+
+            if not parse_result.success:
+                logger.warning(
+                    f"Parsing failed for {language} code: {parse_result.error_message}"
+                )
+                return self._create_empty_result(
+                    filename, language, error=parse_result.error_message
+                )
+
+            # Perform analysis
+            return self._perform_analysis(parse_result)
+
+        except Exception as e:
+            logger.error(f"Error analyzing {language} code: {e}")
+            return self._create_empty_result(
+                filename, language or "unknown", error=str(e)
+            )
+
+    def _determine_language(
+        self, file_path: Path, language_override: str | None
+    ) -> str:
+        """
+        Determine the programming language for a file.
+
+        Args:
+            file_path: Path to the file
+            language_override: Optional language override
+
+        Returns:
+            Detected or overridden language
+        """
+        if language_override:
+            return language_override
+
+        try:
+            return self.language_detector.detect_from_extension(str(file_path))
+        except Exception as e:
+            logger.warning(f"Language detection failed for {file_path}: {e}")
+            return "unknown"
+
+    def _perform_analysis(
+        self, parse_result: ParseResult, queries: list[str] | None = None
+    ) -> AnalysisResult:
+        """
+        Perform comprehensive analysis on parsed code.
+
+        Args:
+            parse_result: Result from parsing operation
+            queries: Optional list of query names to execute (default: all queries)
+
+        Returns:
+            AnalysisResult containing analysis results
+        """
+        try:
+            # Get plugin for the language
+            plugin = self._get_language_plugin(parse_result.language)
+
+            # Execute queries
+            query_results = self._execute_queries(
+                parse_result.tree,
+                plugin,
+                queries=queries,
+                source_code=parse_result.source_code or "",
+                language_name=parse_result.language,
+            )
+
+            # Extract elements
+            elements = self._extract_elements(parse_result, plugin)
+
+            # Count nodes
+            node_count = self._count_nodes(parse_result.tree)
+
+            # Create analysis result using existing AnalysisResult structure
+            return AnalysisResult(
+                file_path=parse_result.file_path or "",
+                language=parse_result.language,
+                elements=elements,
+                node_count=node_count,
+                query_results=query_results,
+                source_code=parse_result.source_code,
+                line_count=(
+                    len(parse_result.source_code.splitlines())
+                    if parse_result.source_code
+                    else 0
+                ),
+                success=True,
+                error_message=None,
+                analysis_time=0.0,
+                package=None,
+            )
+
+        except Exception as e:
+            logger.error(f"Error performing analysis: {e}")
+            return self._create_empty_result(
+                parse_result.file_path, parse_result.language, error=str(e)
+            )
+
+    def _get_language_plugin(self, language: str) -> Any | None:
+        """
+        Get the appropriate language plugin.
+
+        Args:
+            language: Programming language name
+
+        Returns:
+            Language plugin instance or None
+        """
+        if self.plugin_manager is not None:
+            try:
+                return self.plugin_manager.get_plugin(language)
+            except Exception as e:
+                logger.error(f"Error getting plugin for {language}: {e}")
+
+        return None
+
+    def _execute_queries(
+        self,
+        tree: Tree | None,
+        plugin: Any | None,
+        queries: list[str] | None = None,
+        source_code: str = "",
+        language_name: str = "unknown",
+    ) -> dict[str, Any]:
+        """
+        Execute queries on the parsed tree.
+
+        Args:
+            tree: Parsed Tree-sitter tree
+            plugin: Language plugin
+            queries: Optional list of query names to execute (default: uses plugin queries or ["class", "method", "field"])
+            source_code: Source code for context
+            language_name: Name of the programming language
+
+        Returns:
+            Dictionary of query results
+        """
+        if tree is None:
+            return {}
+
+        try:
+            # Use provided queries or determine from plugin/fallback
+            if queries is not None:
+                query_names = queries
+            elif plugin and hasattr(plugin, "get_supported_queries"):
+                # If plugin is available, use its supported queries
+                query_names = plugin.get_supported_queries()
+            else:
+                # Fallback to common queries that exist in the system
+                query_names = ["class", "method", "field"]  # Use actual query names
+
+            # Get language object for query execution
+            language_obj = self._get_language_object(tree)
+            if language_obj is None:
+                return {}
+
+            # Execute queries
+            results = {}
+            for query_name in query_names:
+                try:
+                    result = self.query_executor.execute_query_with_language_name(
+                        tree,
+                        language_obj,
+                        query_name,
+                        source_code,
+                        language_name,
+                    )
+                    results[query_name] = result
+                except Exception as e:
+                    logger.error(f"Error executing query {query_name}: {e}")
+                    results[query_name] = {"error": str(e), "captures": []}
+
+            return results
+
+        except Exception as e:
+            logger.error(f"Error executing queries: {e}")
+            return {}
+
+    def _extract_elements(
+        self, parse_result: ParseResult, plugin: Any | None
+    ) -> list[CodeElement]:
+        """
+        Extract code elements using the language plugin.
+
+        Args:
+            parse_result: Result from parsing operation
+            plugin: Language plugin
+
+        Returns:
+            List of extracted code elements
+        """
+        try:
+            if plugin and hasattr(plugin, "create_extractor"):
+                extractor = plugin.create_extractor()
+                if extractor:
+                    # Set current file path for package detection
+                    if hasattr(extractor, "current_file"):
+                        extractor.current_file = parse_result.file_path or ""
+
+                    # Extract different types of elements
+                    elements = []
+
+                    # Extract packages first (needed for proper class package resolution)
+                    if hasattr(extractor, "extract_packages"):
+                        packages = extractor.extract_packages(
+                            parse_result.tree, parse_result.source_code
+                        )
+                        elements.extend(packages)
+
+                    # Extract functions/methods
+                    if hasattr(extractor, "extract_functions"):
+                        functions = extractor.extract_functions(
+                            parse_result.tree, parse_result.source_code
+                        )
+                        elements.extend(functions)
+
+                    # Extract classes
+                    if hasattr(extractor, "extract_classes"):
+                        classes = extractor.extract_classes(
+                            parse_result.tree, parse_result.source_code
+                        )
+                        elements.extend(classes)
+
+                    # Extract variables/fields
+                    if hasattr(extractor, "extract_variables"):
+                        variables = extractor.extract_variables(
+                            parse_result.tree, parse_result.source_code
+                        )
+                        elements.extend(variables)
+
+                    # Extract imports
+                    if hasattr(extractor, "extract_imports"):
+                        imports = extractor.extract_imports(
+                            parse_result.tree, parse_result.source_code
+                        )
+                        elements.extend(imports)
+
+                    return elements
+
+            # Fallback: create basic elements from query results
+            return self._create_basic_elements(parse_result)
+
+        except Exception as e:
+            logger.error(f"Error extracting elements: {e}")
+            return []
+
+    def _create_basic_elements(self, parse_result: ParseResult) -> list[CodeElement]:
+        """
+        Create basic code elements as fallback.
+
+        Args:
+            parse_result: Result from parsing operation
+
+        Returns:
+            List of basic code elements
+        """
+        # This is a basic fallback implementation
+        # Real implementation would extract meaningful elements
+        elements: list[Any] = []
+
+        try:
+            if parse_result.tree and parse_result.tree.root_node:
+                # Create a basic element representing the file
+
+                # Note: CodeElement is abstract, so we'd need a concrete implementation
+                # For now, return empty list until concrete element types are available
+                pass
+
+        except Exception as e:
+            logger.error(f"Error creating basic elements: {e}")
+
+        return elements
+
+    def _count_nodes(self, tree: Tree | None) -> int:
+        """
+        Count nodes in the AST tree.
+
+        Args:
+            tree: Tree-sitter tree
+
+        Returns:
+            Number of nodes in the tree
+        """
+        if tree is None or tree.root_node is None:
+            return 0
+
+        try:
+
+            def count_recursive(node: Any) -> int:
+                """Recursively count nodes."""
+                count = 1  # Count current node
+                if hasattr(node, "children"):
+                    for child in node.children:
+                        count += count_recursive(child)
+                return count
+
+            return count_recursive(tree.root_node)
+
+        except Exception as e:
+            logger.error(f"Error counting nodes: {e}")
+            return 0
+
+    def _get_language_object(self, tree: Tree) -> Any | None:
+        """
+        Get the language object associated with a tree.
+
+        Args:
+            tree: Tree-sitter tree
+
+        Returns:
+            Language object or None
+        """
+        try:
+            # Tree-sitter trees have a language property
+            if hasattr(tree, "language"):
+                return tree.language
+            return None
+        except Exception as e:
+            logger.error(f"Error getting language object: {e}")
+            return None
+
+    def _initialize_plugins(self) -> None:
+        """Initialize the plugin system."""
+        try:
+            if self.plugin_manager:
+                plugins = self.plugin_manager.load_plugins()
+                logger.info(f"Loaded {len(plugins)} plugins successfully")
+            else:
+                logger.warning("Plugin manager not available")
+        except Exception as e:
+            logger.error(f"Plugin initialization failed: {e}")
+            # Don't raise here to allow engine to work without plugins
+            logger.warning("Continuing without plugins")
+
+    def _create_empty_result(
+        self, file_path: str | None, language: str, error: str | None = None
+    ) -> AnalysisResult:
+        """
+        Create an empty analysis result.
+
+        Args:
+            file_path: File path
+            language: Programming language
+            error: Optional error message
+
+        Returns:
+            Empty AnalysisResult
+        """
+        return AnalysisResult(
+            file_path=file_path or "",
+            language=language,
+            line_count=0,
+            success=error is None,
+            elements=[],
+            node_count=0,
+            query_results={},
+            source_code="",
+            error_message=error,
+            analysis_time=0.0,
+            package=None,
+        )
+
+    def get_supported_languages(self) -> list[str]:
+        """
+        Get list of supported programming languages.
+
+        Returns:
+            List of supported language names
+        """
+        try:
+            if self.plugin_manager:
+                return list(self.plugin_manager.get_supported_languages())
+            return []
+        except Exception as e:
+            logger.error(f"Error getting supported languages: {e}")
+            return []
+
+    def get_available_queries(self, language: str) -> list[str]:
+        """
+        Get available queries for a specific language.
+
+        Args:
+            language: Programming language name
+
+        Returns:
+            List of available query names
+        """
+        try:
+            plugin = self._get_language_plugin(language)
+            if plugin and hasattr(plugin, "get_supported_queries"):
+                queries = plugin.get_supported_queries()
+                return list(queries) if queries else []
+            else:
+                # Return default queries
+                return ["class", "method", "field"]
+        except Exception as e:
+            logger.error(f"Error getting available queries for {language}: {e}")
+            return []
+
+    # Add compatibility methods for API layer
+    @property
+    def language_registry(self) -> "AnalysisEngine":
+        """Provide compatibility with API layer expecting language_registry"""
+        return self
+
+    def detect_language_from_file(self, file_path: Path) -> str | None:
+        """
+        Detect language from file path (compatibility method)
+
+        Args:
+            file_path: Path to the file
+
+        Returns:
+            Detected language name or None
+        """
+        try:
+            return self.language_detector.detect_from_extension(str(file_path))
+        except Exception as e:
+            logger.error(f"Error detecting language for {file_path}: {e}")
+            return None
+
+    def get_extensions_for_language(self, language: str) -> list[str]:
+        """
+        Get file extensions for a language (compatibility method)
+
+        Args:
+            language: Programming language name
+
+        Returns:
+            List of file extensions
+        """
+        try:
+            # Get extensions from language detector
+            extensions = []
+            for ext, lang in self.language_detector.EXTENSION_MAPPING.items():
+                if lang == language:
+                    extensions.append(ext)
+            return extensions
+        except Exception as e:
+            logger.error(f"Error getting extensions for {language}: {e}")
+            return []
+
+    def get_registry_info(self) -> dict[str, Any]:
+        """
+        Get registry information (compatibility method)
+
+        Returns:
+            Registry information dictionary
+        """
+        try:
+            return {
+                "supported_languages": self.get_supported_languages(),
+                "total_languages": len(self.get_supported_languages()),
+                "language_detector_available": self.language_detector is not None,
+                "plugin_manager_available": self.plugin_manager is not None,
+            }
+        except Exception as e:
+            logger.error(f"Error getting registry info: {e}")
+            return {}