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

tree_sitter_analyzer/plugins/manager.py

@@ -0,0 +1,355 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Plugin Manager
+
+Dynamic plugin discovery and management system.
+Handles loading plugins from entry points and local directories.
+"""
+
+import importlib
+import importlib.metadata
+import pkgutil
+from pathlib import Path
+from typing import List, Dict, Optional, Type
+import logging
+
+from .base import LanguagePlugin
+from ..utils import log_error, log_info, log_warning, log_debug
+
+logger = logging.getLogger(__name__)
+
+
+class PluginManager:
+    """
+    Manages dynamic discovery and loading of language plugins.
+    
+    This class handles:
+    - Discovery of plugins via entry points
+    - Loading plugins from local directories
+    - Plugin lifecycle management
+    - Error handling and fallback mechanisms
+    """
+    
+    def __init__(self):
+        """Initialize the plugin manager."""
+        self._loaded_plugins: Dict[str, LanguagePlugin] = {}
+        self._plugin_classes: Dict[str, Type[LanguagePlugin]] = {}
+        self._entry_point_group = "tree_sitter_analyzer.plugins"
+    
+    def load_plugins(self) -> List[LanguagePlugin]:
+        """
+        Load all available plugins from various sources.
+        
+        Returns:
+            List of successfully loaded plugin instances
+        """
+        loaded_plugins = []
+        
+        # Load plugins from entry points (installed packages)
+        entry_point_plugins = self._load_from_entry_points()
+        loaded_plugins.extend(entry_point_plugins)
+        
+        # Load plugins from local languages directory
+        local_plugins = self._load_from_local_directory()
+        loaded_plugins.extend(local_plugins)
+        
+        # Store loaded plugins
+        for plugin in loaded_plugins:
+            language = plugin.get_language_name()
+            self._loaded_plugins[language] = plugin
+        
+        log_info(f"Successfully loaded {len(loaded_plugins)} plugins")
+        return loaded_plugins
+    
+    def _load_from_entry_points(self) -> List[LanguagePlugin]:
+        """
+        Load plugins from setuptools entry points.
+        
+        Returns:
+            List of plugin instances loaded from entry points
+        """
+        plugins = []
+        
+        try:
+            # Get entry points for our plugin group
+            entry_points = importlib.metadata.entry_points()
+            
+            # Handle both old and new entry_points API
+            if hasattr(entry_points, 'select'):
+                # New API (Python 3.10+)
+                plugin_entries = entry_points.select(group=self._entry_point_group)
+            else:
+                # Old API
+                plugin_entries = entry_points.get(self._entry_point_group, [])
+            
+            for entry_point in plugin_entries:
+                try:
+                    # Load the plugin class
+                    plugin_class = entry_point.load()
+                    
+                    # Validate it's a LanguagePlugin
+                    if not issubclass(plugin_class, LanguagePlugin):
+                        log_warning(f"Entry point {entry_point.name} is not a LanguagePlugin")
+                        continue
+                    
+                    # Create instance
+                    plugin_instance = plugin_class()
+                    plugins.append(plugin_instance)
+                    
+                    log_debug(f"Loaded plugin from entry point: {entry_point.name}")
+                    
+                except Exception as e:
+                    log_error(f"Failed to load plugin from entry point {entry_point.name}: {e}")
+        
+        except Exception as e:
+            log_warning(f"Failed to load plugins from entry points: {e}")
+        
+        return plugins
+    
+    def _load_from_local_directory(self) -> List[LanguagePlugin]:
+        """
+        Load plugins from the local languages directory.
+        
+        Returns:
+            List of plugin instances loaded from local directory
+        """
+        plugins = []
+        
+        try:
+            # Get the languages directory path
+            current_dir = Path(__file__).parent.parent
+            languages_dir = current_dir / "languages"
+            
+            if not languages_dir.exists():
+                log_debug("Languages directory does not exist, creating it")
+                languages_dir.mkdir(exist_ok=True)
+                # Create __init__.py
+                (languages_dir / "__init__.py").touch()
+                return plugins
+            
+            # Import the languages package
+            languages_package = "tree_sitter_analyzer.languages"
+            
+            try:
+                languages_module = importlib.import_module(languages_package)
+            except ImportError as e:
+                log_warning(f"Could not import languages package: {e}")
+                return plugins
+            
+            # Discover plugin modules in the languages directory
+            for finder, name, ispkg in pkgutil.iter_modules(
+                languages_module.__path__, 
+                languages_module.__name__ + "."
+            ):
+                if ispkg:
+                    continue
+                
+                try:
+                    # Import the module
+                    module = importlib.import_module(name)
+                    
+                    # Look for LanguagePlugin classes
+                    plugin_classes = self._find_plugin_classes(module)
+                    
+                    for plugin_class in plugin_classes:
+                        try:
+                            plugin_instance = plugin_class()
+                            plugins.append(plugin_instance)
+                            log_debug(f"Loaded local plugin: {plugin_class.__name__}")
+                        except Exception as e:
+                            log_error(f"Failed to instantiate plugin {plugin_class.__name__}: {e}")
+                
+                except Exception as e:
+                    log_error(f"Failed to load plugin module {name}: {e}")
+        
+        except Exception as e:
+            log_warning(f"Failed to load plugins from local directory: {e}")
+        
+        return plugins
+    
+    def _find_plugin_classes(self, module) -> List[Type[LanguagePlugin]]:
+        """
+        Find LanguagePlugin classes in a module.
+        
+        Args:
+            module: Python module to search
+            
+        Returns:
+            List of LanguagePlugin classes found in the module
+        """
+        plugin_classes = []
+        
+        for attr_name in dir(module):
+            attr = getattr(module, attr_name)
+            
+            # Check if it's a class and subclass of LanguagePlugin
+            if (isinstance(attr, type) and 
+                issubclass(attr, LanguagePlugin) and 
+                attr is not LanguagePlugin):
+                plugin_classes.append(attr)
+        
+        return plugin_classes
+    
+    def get_plugin(self, language: str) -> Optional[LanguagePlugin]:
+        """
+        Get a plugin for a specific language.
+        
+        Args:
+            language: Programming language name
+            
+        Returns:
+            Plugin instance or None if not found
+        """
+        return self._loaded_plugins.get(language)
+    
+    def get_all_plugins(self) -> Dict[str, LanguagePlugin]:
+        """
+        Get all loaded plugins.
+        
+        Returns:
+            Dictionary mapping language names to plugin instances
+        """
+        return self._loaded_plugins.copy()
+    
+    def get_supported_languages(self) -> List[str]:
+        """
+        Get list of all supported languages.
+        
+        Returns:
+            List of supported language names
+        """
+        return list(self._loaded_plugins.keys())
+    
+    def reload_plugins(self) -> List[LanguagePlugin]:
+        """
+        Reload all plugins (useful for development).
+        
+        Returns:
+            List of reloaded plugin instances
+        """
+        log_info("Reloading all plugins")
+        
+        # Clear existing plugins
+        self._loaded_plugins.clear()
+        self._plugin_classes.clear()
+        
+        # Reload
+        return self.load_plugins()
+    
+    def register_plugin(self, plugin: LanguagePlugin) -> bool:
+        """
+        Manually register a plugin instance.
+        
+        Args:
+            plugin: Plugin instance to register
+            
+        Returns:
+            True if registration was successful
+        """
+        try:
+            language = plugin.get_language_name()
+            
+            if language in self._loaded_plugins:
+                log_warning(f"Plugin for language '{language}' already exists, replacing")
+            
+            self._loaded_plugins[language] = plugin
+            log_debug(f"Manually registered plugin for language: {language}")
+            return True
+            
+        except Exception as e:
+            log_error(f"Failed to register plugin: {e}")
+            return False
+    
+    def unregister_plugin(self, language: str) -> bool:
+        """
+        Unregister a plugin for a specific language.
+        
+        Args:
+            language: Programming language name
+            
+        Returns:
+            True if unregistration was successful
+        """
+        if language in self._loaded_plugins:
+            del self._loaded_plugins[language]
+            log_debug(f"Unregistered plugin for language: {language}")
+            return True
+        
+        return False
+    
+    def get_plugin_info(self, language: str) -> Optional[Dict[str, any]]:
+        """
+        Get information about a specific plugin.
+        
+        Args:
+            language: Programming language name
+            
+        Returns:
+            Plugin information dictionary or None
+        """
+        plugin = self.get_plugin(language)
+        if not plugin:
+            return None
+        
+        try:
+            return {
+                "language": plugin.get_language_name(),
+                "extensions": plugin.get_file_extensions(),
+                "class_name": plugin.__class__.__name__,
+                "module": plugin.__class__.__module__,
+                "has_extractor": hasattr(plugin, 'create_extractor')
+            }
+        except Exception as e:
+            log_error(f"Failed to get plugin info for {language}: {e}")
+            return None
+    
+    def validate_plugin(self, plugin: LanguagePlugin) -> bool:
+        """
+        Validate that a plugin implements the required interface correctly.
+        
+        Args:
+            plugin: Plugin instance to validate
+            
+        Returns:
+            True if the plugin is valid
+        """
+        try:
+            # Check required methods
+            required_methods = [
+                'get_language_name',
+                'get_file_extensions', 
+                'create_extractor'
+            ]
+            
+            for method_name in required_methods:
+                if not hasattr(plugin, method_name):
+                    log_error(f"Plugin missing required method: {method_name}")
+                    return False
+                
+                method = getattr(plugin, method_name)
+                if not callable(method):
+                    log_error(f"Plugin method {method_name} is not callable")
+                    return False
+            
+            # Test basic functionality
+            language = plugin.get_language_name()
+            if not language or not isinstance(language, str):
+                log_error("Plugin get_language_name() must return a non-empty string")
+                return False
+            
+            extensions = plugin.get_file_extensions()
+            if not isinstance(extensions, list):
+                log_error("Plugin get_file_extensions() must return a list")
+                return False
+            
+            extractor = plugin.create_extractor()
+            if not extractor:
+                log_error("Plugin create_extractor() must return an extractor instance")
+                return False
+            
+            return True
+            
+        except Exception as e:
+            log_error(f"Plugin validation failed: {e}")
+            return False

tree_sitter_analyzer/plugins/plugin_loader.py

@@ -0,0 +1,83 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Plugin Loader for Tree-sitter Analyzer
+
+Automatically loads and registers all available language plugins.
+"""
+
+from typing import List
+
+from ..utils import log_debug, log_error, log_info
+from . import plugin_registry
+
+
+def load_all_plugins() -> List[str]:
+    """Load and register all available language plugins"""
+    loaded_plugins = []
+
+    try:
+        # Import and register Java plugin
+        from .java_plugin import JavaPlugin
+
+        java_plugin = JavaPlugin()
+        plugin_registry.register_plugin(java_plugin)
+        loaded_plugins.append("java")
+        log_debug("Loaded Java plugin")
+    except Exception as e:
+        log_error(f"Failed to load Java plugin: {e}")
+
+    try:
+        # Import and register JavaScript plugin
+        from .javascript_plugin import JavaScriptPlugin
+
+        js_plugin = JavaScriptPlugin()
+        plugin_registry.register_plugin(js_plugin)
+        loaded_plugins.append("javascript")
+        log_debug("Loaded JavaScript plugin")
+    except Exception as e:
+        log_error(f"Failed to load JavaScript plugin: {e}")
+
+    try:
+        # Import and register Python plugin
+        from .python_plugin import PythonPlugin
+
+        python_plugin = PythonPlugin()
+        plugin_registry.register_plugin(python_plugin)
+        loaded_plugins.append("python")
+        log_debug("Loaded Python plugin")
+    except Exception as e:
+        log_error(f"Failed to load Python plugin: {e}")
+
+    if loaded_plugins:
+        log_info(
+            f"Successfully loaded {len(loaded_plugins)} language plugins: {', '.join(loaded_plugins)}"
+        )
+    else:
+        log_error("No language plugins were loaded successfully")
+
+    return loaded_plugins
+
+
+def get_supported_languages() -> List[str]:
+    """Get list of all supported languages"""
+    return plugin_registry.list_supported_languages()
+
+
+def get_supported_extensions() -> List[str]:
+    """Get list of all supported file extensions"""
+    return plugin_registry.list_supported_extensions()
+
+
+def get_plugin_for_file(file_path: str):
+    """Get appropriate plugin for a file"""
+    return plugin_registry.get_plugin_for_file(file_path)
+
+
+def get_plugin_by_language(language: str):
+    """Get plugin by language name"""
+    return plugin_registry.get_plugin(language)
+
+
+# Auto-load plugins when module is imported
+_loaded_plugins = load_all_plugins()