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

tree_sitter_analyzer/plugins/base.py

@@ -0,0 +1,446 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Plugin Base Classes
+
+Defines the base interfaces for language plugins and element extractors.
+All language plugins must inherit from these base classes.
+"""
+
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING, Any, Dict, List, Optional
+import logging
+
+if TYPE_CHECKING:
+    import tree_sitter
+
+from ..models import Class as ModelClass
+from ..models import (
+    CodeElement,
+    Function as ModelFunction,
+    Import as ModelImport,
+    Variable as ModelVariable,
+)
+from ..utils import log_debug, log_error, log_warning
+
+logger = logging.getLogger(__name__)
+
+
+class ElementExtractor(ABC):
+    """
+    Abstract base class for language-specific element extractors.
+    
+    Element extractors are responsible for parsing ASTs and extracting
+    meaningful code elements like functions, classes, variables, etc.
+    """
+    
+    @abstractmethod
+    def extract_functions(
+        self, tree: "tree_sitter.Tree", source_code: str
+    ) -> List[ModelFunction]:
+        """
+        Extract function definitions from the syntax tree.
+        
+        Args:
+            tree: Tree-sitter AST
+            source_code: Original source code
+            
+        Returns:
+            List of extracted function objects
+        """
+        pass
+    
+    @abstractmethod
+    def extract_classes(
+        self, tree: "tree_sitter.Tree", source_code: str
+    ) -> List[ModelClass]:
+        """
+        Extract class definitions from the syntax tree.
+        
+        Args:
+            tree: Tree-sitter AST
+            source_code: Original source code
+            
+        Returns:
+            List of extracted class objects
+        """
+        pass
+    
+    @abstractmethod
+    def extract_variables(
+        self, tree: "tree_sitter.Tree", source_code: str
+    ) -> List[ModelVariable]:
+        """
+        Extract variable declarations from the syntax tree.
+        
+        Args:
+            tree: Tree-sitter AST
+            source_code: Original source code
+            
+        Returns:
+            List of extracted variable objects
+        """
+        pass
+    
+    @abstractmethod
+    def extract_imports(
+        self, tree: "tree_sitter.Tree", source_code: str
+    ) -> List[ModelImport]:
+        """
+        Extract import statements from the syntax tree.
+        
+        Args:
+            tree: Tree-sitter AST
+            source_code: Original source code
+            
+        Returns:
+            List of extracted import objects
+        """
+        pass
+    
+    def extract_all_elements(
+        self, tree: "tree_sitter.Tree", source_code: str
+    ) -> List[CodeElement]:
+        """
+        Extract all code elements from the syntax tree.
+        
+        Args:
+            tree: Tree-sitter AST
+            source_code: Original source code
+            
+        Returns:
+            List of all extracted code elements
+        """
+        elements = []
+        
+        try:
+            elements.extend(self.extract_functions(tree, source_code))
+            elements.extend(self.extract_classes(tree, source_code))
+            elements.extend(self.extract_variables(tree, source_code))
+            elements.extend(self.extract_imports(tree, source_code))
+        except Exception as e:
+            log_error(f"Failed to extract all elements: {e}")
+        
+        return elements
+
+
+class LanguagePlugin(ABC):
+    """
+    Abstract base class for language-specific plugins.
+    
+    Language plugins provide language-specific functionality including
+    element extraction, file extension mapping, and language identification.
+    """
+    
+    @abstractmethod
+    def get_language_name(self) -> str:
+        """
+        Return the name of the programming language this plugin supports.
+        
+        Returns:
+            Language name (e.g., "java", "python", "javascript")
+        """
+        pass
+    
+    @abstractmethod
+    def get_file_extensions(self) -> List[str]:
+        """
+        Return list of file extensions this plugin supports.
+        
+        Returns:
+            List of file extensions (e.g., [".java", ".class"])
+        """
+        pass
+    
+    @abstractmethod
+    def create_extractor(self) -> ElementExtractor:
+        """
+        Create and return an element extractor for this language.
+        
+        Returns:
+            ElementExtractor instance for this language
+        """
+        pass
+    
+    def is_applicable(self, file_path: str) -> bool:
+        """
+        Check if this plugin is applicable for the given file.
+        
+        Args:
+            file_path: Path to the file to check
+            
+        Returns:
+            True if this plugin can handle the file
+        """
+        extensions = self.get_file_extensions()
+        return any(file_path.lower().endswith(ext.lower()) for ext in extensions)
+    
+    def get_plugin_info(self) -> Dict[str, Any]:
+        """
+        Get information about this plugin.
+        
+        Returns:
+            Dictionary containing plugin information
+        """
+        return {
+            "language": self.get_language_name(),
+            "extensions": self.get_file_extensions(),
+            "class_name": self.__class__.__name__,
+            "module": self.__class__.__module__,
+        }
+
+
+class DefaultExtractor(ElementExtractor):
+    """
+    Default implementation of ElementExtractor with basic functionality.
+    
+    This extractor provides generic extraction logic that works across
+    multiple languages by looking for common node types.
+    """
+    
+    def extract_functions(
+        self, tree: "tree_sitter.Tree", source_code: str
+    ) -> List[ModelFunction]:
+        """Basic function extraction implementation."""
+        functions: List[ModelFunction] = []
+        
+        try:
+            if hasattr(tree, "root_node"):
+                lines = source_code.splitlines()
+                self._traverse_for_functions(tree.root_node, functions, lines, source_code)
+        except Exception as e:
+            log_error(f"Error in function extraction: {e}")
+        
+        return functions
+    
+    def extract_classes(
+        self, tree: "tree_sitter.Tree", source_code: str
+    ) -> List[ModelClass]:
+        """Basic class extraction implementation."""
+        classes: List[ModelClass] = []
+        
+        try:
+            if hasattr(tree, "root_node"):
+                lines = source_code.splitlines()
+                self._traverse_for_classes(tree.root_node, classes, lines, source_code)
+        except Exception as e:
+            log_error(f"Error in class extraction: {e}")
+        
+        return classes
+    
+    def extract_variables(
+        self, tree: "tree_sitter.Tree", source_code: str
+    ) -> List[ModelVariable]:
+        """Basic variable extraction implementation."""
+        variables: List[ModelVariable] = []
+        
+        try:
+            if hasattr(tree, "root_node"):
+                lines = source_code.splitlines()
+                self._traverse_for_variables(tree.root_node, variables, lines, source_code)
+        except Exception as e:
+            log_error(f"Error in variable extraction: {e}")
+        
+        return variables
+    
+    def extract_imports(
+        self, tree: "tree_sitter.Tree", source_code: str
+    ) -> List[ModelImport]:
+        """Basic import extraction implementation."""
+        imports: List[ModelImport] = []
+        
+        try:
+            if hasattr(tree, "root_node"):
+                lines = source_code.splitlines()
+                self._traverse_for_imports(tree.root_node, imports, lines, source_code)
+        except Exception as e:
+            log_error(f"Error in import extraction: {e}")
+        
+        return imports
+    
+    def _traverse_for_functions(
+        self, 
+        node: "tree_sitter.Node", 
+        functions: List[ModelFunction], 
+        lines: List[str],
+        source_code: str
+    ) -> None:
+        """Traverse tree to find function-like nodes."""
+        if hasattr(node, "type") and self._is_function_node(node.type):
+            try:
+                name = self._extract_node_name(node, source_code) or "unknown"
+                raw_text = self._extract_node_text(node, source_code)
+                
+                func = ModelFunction(
+                    name=name,
+                    start_line=node.start_point[0] + 1 if hasattr(node, "start_point") else 0,
+                    end_line=node.end_point[0] + 1 if hasattr(node, "end_point") else 0,
+                    raw_text=raw_text,
+                    language=self._get_language_hint(),
+                )
+                functions.append(func)
+            except Exception as e:
+                log_debug(f"Failed to extract function: {e}")
+        
+        if hasattr(node, "children"):
+            for child in node.children:
+                self._traverse_for_functions(child, functions, lines, source_code)
+    
+    def _traverse_for_classes(
+        self, 
+        node: "tree_sitter.Node", 
+        classes: List[ModelClass], 
+        lines: List[str],
+        source_code: str
+    ) -> None:
+        """Traverse tree to find class-like nodes."""
+        if hasattr(node, "type") and self._is_class_node(node.type):
+            try:
+                name = self._extract_node_name(node, source_code) or "unknown"
+                raw_text = self._extract_node_text(node, source_code)
+                
+                cls = ModelClass(
+                    name=name,
+                    start_line=node.start_point[0] + 1 if hasattr(node, "start_point") else 0,
+                    end_line=node.end_point[0] + 1 if hasattr(node, "end_point") else 0,
+                    raw_text=raw_text,
+                    language=self._get_language_hint(),
+                )
+                classes.append(cls)
+            except Exception as e:
+                log_debug(f"Failed to extract class: {e}")
+        
+        if hasattr(node, "children"):
+            for child in node.children:
+                self._traverse_for_classes(child, classes, lines, source_code)
+    
+    def _traverse_for_variables(
+        self, 
+        node: "tree_sitter.Node", 
+        variables: List[ModelVariable], 
+        lines: List[str],
+        source_code: str
+    ) -> None:
+        """Traverse tree to find variable declarations."""
+        if hasattr(node, "type") and self._is_variable_node(node.type):
+            try:
+                name = self._extract_node_name(node, source_code) or "unknown"
+                raw_text = self._extract_node_text(node, source_code)
+                
+                var = ModelVariable(
+                    name=name,
+                    start_line=node.start_point[0] + 1 if hasattr(node, "start_point") else 0,
+                    end_line=node.end_point[0] + 1 if hasattr(node, "end_point") else 0,
+                    raw_text=raw_text,
+                    language=self._get_language_hint(),
+                )
+                variables.append(var)
+            except Exception as e:
+                log_debug(f"Failed to extract variable: {e}")
+        
+        if hasattr(node, "children"):
+            for child in node.children:
+                self._traverse_for_variables(child, variables, lines, source_code)
+    
+    def _traverse_for_imports(
+        self, 
+        node: "tree_sitter.Node", 
+        imports: List[ModelImport], 
+        lines: List[str],
+        source_code: str
+    ) -> None:
+        """Traverse tree to find import statements."""
+        if hasattr(node, "type") and self._is_import_node(node.type):
+            try:
+                name = self._extract_node_name(node, source_code) or "unknown"
+                raw_text = self._extract_node_text(node, source_code)
+                
+                imp = ModelImport(
+                    name=name,
+                    start_line=node.start_point[0] + 1 if hasattr(node, "start_point") else 0,
+                    end_line=node.end_point[0] + 1 if hasattr(node, "end_point") else 0,
+                    raw_text=raw_text,
+                    language=self._get_language_hint(),
+                )
+                imports.append(imp)
+            except Exception as e:
+                log_debug(f"Failed to extract import: {e}")
+        
+        if hasattr(node, "children"):
+            for child in node.children:
+                self._traverse_for_imports(child, imports, lines, source_code)
+    
+    def _is_function_node(self, node_type: str) -> bool:
+        """Check if a node type represents a function."""
+        function_types = [
+            "function_definition", "function_declaration", "method_definition",
+            "function", "method", "procedure", "subroutine"
+        ]
+        return any(ftype in node_type.lower() for ftype in function_types)
+    
+    def _is_class_node(self, node_type: str) -> bool:
+        """Check if a node type represents a class."""
+        class_types = [
+            "class_definition", "class_declaration", "interface_definition",
+            "class", "interface", "struct", "enum"
+        ]
+        return any(ctype in node_type.lower() for ctype in class_types)
+    
+    def _is_variable_node(self, node_type: str) -> bool:
+        """Check if a node type represents a variable."""
+        variable_types = [
+            "variable_declaration", "variable_definition", "field_declaration",
+            "assignment", "declaration", "variable", "field"
+        ]
+        return any(vtype in node_type.lower() for vtype in variable_types)
+    
+    def _is_import_node(self, node_type: str) -> bool:
+        """Check if a node type represents an import."""
+        import_types = [
+            "import_statement", "import_declaration", "include_statement",
+            "import", "include", "require", "use"
+        ]
+        return any(itype in node_type.lower() for itype in import_types)
+    
+    def _extract_node_name(self, node: "tree_sitter.Node", source_code: str) -> Optional[str]:
+        """Extract name from a tree-sitter node."""
+        try:
+            # Look for identifier children
+            if hasattr(node, "children"):
+                for child in node.children:
+                    if hasattr(child, "type") and child.type == "identifier":
+                        return self._extract_node_text(child, source_code)
+            
+            # Fallback: use position-based name
+            return f"element_{node.start_point[0]}_{node.start_point[1]}"
+        except Exception:
+            return None
+    
+    def _extract_node_text(self, node: "tree_sitter.Node", source_code: str) -> str:
+        """Extract text content from a tree-sitter node."""
+        try:
+            if hasattr(node, "start_byte") and hasattr(node, "end_byte"):
+                source_bytes = source_code.encode('utf-8')
+                node_bytes = source_bytes[node.start_byte:node.end_byte]
+                return node_bytes.decode('utf-8', errors='replace')
+            return ""
+        except Exception as e:
+            log_debug(f"Failed to extract node text: {e}")
+            return ""
+    
+    def _get_language_hint(self) -> str:
+        """Get a hint about the language being processed."""
+        return "unknown"
+
+
+class DefaultLanguagePlugin(LanguagePlugin):
+    """Default plugin that provides basic functionality for any language."""
+    
+    def get_language_name(self) -> str:
+        return "generic"
+    
+    def get_file_extensions(self) -> List[str]:
+        return [".txt", ".md"]  # Fallback extensions
+    
+    def create_extractor(self) -> ElementExtractor:
+        return DefaultExtractor()