ai-codeindex 0.7.0__py3-none-any.whl

codeindex/route_extractor.py

@@ -0,0 +1,98 @@
+"""Route extraction framework for multi-framework support.
+
+This module provides the abstract base class for route extractors and
+the extraction context data structure.
+
+Epic 6: Framework-agnostic route extraction
+"""
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from pathlib import Path
+
+from .framework_detect import RouteInfo
+from .parser import ParseResult
+
+
+@dataclass
+class ExtractionContext:
+    """
+    Context for route extraction.
+
+    Provides all necessary information for a route extractor to analyze
+    and extract routes from code.
+    """
+
+    root_path: Path
+    """Project root directory"""
+
+    current_dir: Path
+    """Current directory being analyzed"""
+
+    parse_results: list[ParseResult]
+    """Parsed code symbols from the current directory"""
+
+    framework_version: str = ""
+    """Framework version (optional, for version-specific extraction)"""
+
+
+class RouteExtractor(ABC):
+    """
+    Abstract base class for framework-specific route extractors.
+
+    Each framework (ThinkPHP, Laravel, Django, FastAPI, etc.) should
+    implement this interface to provide route extraction capabilities.
+
+    Example:
+        class ThinkPHPRouteExtractor(RouteExtractor):
+            @property
+            def framework_name(self) -> str:
+                return "thinkphp"
+
+            def can_extract(self, context: ExtractionContext) -> bool:
+                return context.current_dir.name == "Controller"
+
+            def extract_routes(self, context: ExtractionContext) -> list[RouteInfo]:
+                # Implementation here
+                return routes
+    """
+
+    @property
+    @abstractmethod
+    def framework_name(self) -> str:
+        """
+        Return the framework name (e.g., "thinkphp", "laravel", "django").
+
+        Returns:
+            Framework identifier in lowercase
+        """
+        pass
+
+    @abstractmethod
+    def can_extract(self, context: ExtractionContext) -> bool:
+        """
+        Check if this extractor can extract routes from the given context.
+
+        This method is called to determine if the current directory is
+        relevant for this framework's route extraction.
+
+        Args:
+            context: Extraction context with directory and parse results
+
+        Returns:
+            True if this extractor should process this context
+        """
+        pass
+
+    @abstractmethod
+    def extract_routes(self, context: ExtractionContext) -> list[RouteInfo]:
+        """
+        Extract route information from the given context.
+
+        Args:
+            context: Extraction context with directory and parse results
+
+        Returns:
+            List of RouteInfo objects representing discovered routes
+        """
+        pass

codeindex/route_registry.py

@@ -0,0 +1,77 @@
+"""Route extractor registry for framework-agnostic route extraction.
+
+This module provides a registry to store and retrieve route extractors
+for different frameworks.
+
+Epic 6: Framework-agnostic route extraction
+"""
+
+from .route_extractor import RouteExtractor
+
+
+class RouteExtractorRegistry:
+    """
+    Registry for route extractors.
+
+    Stores and manages route extractors for different frameworks.
+    Each extractor is registered by its framework name.
+
+    Example:
+        registry = RouteExtractorRegistry()
+        registry.register(ThinkPHPRouteExtractor())
+        registry.register(LaravelRouteExtractor())
+
+        extractor = registry.get("thinkphp")
+        if extractor:
+            routes = extractor.extract_routes(context)
+    """
+
+    def __init__(self):
+        """Initialize an empty registry."""
+        self._extractors: dict[str, RouteExtractor] = {}
+
+    def register(self, extractor: RouteExtractor) -> None:
+        """
+        Register a route extractor.
+
+        Args:
+            extractor: RouteExtractor instance to register
+
+        Note:
+            If an extractor with the same framework_name already exists,
+            it will be overwritten.
+        """
+        self._extractors[extractor.framework_name] = extractor
+
+    def get(self, framework: str) -> RouteExtractor | None:
+        """
+        Get a route extractor by framework name.
+
+        Args:
+            framework: Framework name (e.g., "thinkphp", "laravel")
+
+        Returns:
+            RouteExtractor instance if found, None otherwise
+        """
+        return self._extractors.get(framework)
+
+    def has_extractor(self, framework: str) -> bool:
+        """
+        Check if an extractor is registered for a framework.
+
+        Args:
+            framework: Framework name to check
+
+        Returns:
+            True if extractor is registered, False otherwise
+        """
+        return framework in self._extractors
+
+    def list_frameworks(self) -> list[str]:
+        """
+        List all registered framework names.
+
+        Returns:
+            List of framework names (sorted alphabetically)
+        """
+        return sorted(self._extractors.keys())

codeindex/scanner.py

@@ -0,0 +1,167 @@
+"""Directory scanner for codeindex."""
+
+import fnmatch
+from dataclasses import dataclass
+from pathlib import Path
+
+from .config import Config
+
+
+@dataclass
+class ScanResult:
+    """Result of scanning a directory."""
+
+    path: Path
+    files: list[Path]
+    subdirs: list[Path]
+
+    @property
+    def indexable_files(self) -> list[Path]:
+        """Get all indexable files (Python, PHP, etc.)."""
+        return self.files
+
+    @property
+    def python_files(self) -> list[Path]:
+        """Get Python files only."""
+        return [f for f in self.files if f.suffix == ".py"]
+
+    @property
+    def php_files(self) -> list[Path]:
+        """Get PHP files only."""
+        return [f for f in self.files if f.suffix in (".php", ".phtml")]
+
+
+LANGUAGE_EXTENSIONS = {
+    "python": [".py"],
+    "php": [".php", ".phtml"],
+}
+
+
+def get_language_extensions(languages: list[str]) -> set[str]:
+    """Get file extensions for specified languages."""
+    extensions = set()
+    for lang in languages:
+        extensions.update(LANGUAGE_EXTENSIONS.get(lang, []))
+    return extensions
+
+
+def should_exclude(path: Path, exclude_patterns: list[str], base_path: Path) -> bool:
+    """Check if path matches any exclude pattern."""
+    # Resolve both paths to handle symlinks (e.g., /var -> /private/var on macOS)
+    rel_path = str(path.resolve().relative_to(base_path.resolve()))
+
+    for pattern in exclude_patterns:
+        if fnmatch.fnmatch(rel_path, pattern):
+            return True
+        if fnmatch.fnmatch(str(path), pattern):
+            return True
+        # Check if any parent matches
+        if "**" in pattern:
+            simple_pattern = pattern.replace("**", "*")
+            if fnmatch.fnmatch(rel_path, simple_pattern):
+                return True
+
+    return False
+
+
+def scan_directory(
+    path: Path,
+    config: Config,
+    base_path: Path | None = None,
+    recursive: bool = True
+) -> ScanResult:
+    """
+    Scan a directory and return its contents.
+
+    Args:
+        path: Directory to scan
+        config: Configuration object
+        base_path: Base path for relative pattern matching
+        recursive: Whether to scan subdirectories recursively
+
+    Returns:
+        ScanResult with files and subdirectories
+    """
+    if base_path is None:
+        base_path = path
+
+    files: list[Path] = []
+    subdirs: list[Path] = []
+
+    if not path.exists() or not path.is_dir():
+        return ScanResult(path=path, files=[], subdirs=[])
+
+    for item in sorted(path.iterdir()):
+        # Skip excluded paths
+        if should_exclude(item, config.exclude, base_path):
+            continue
+
+        if item.is_file():
+            # Filter by language/extension
+            if item.suffix == ".py" and "python" in config.languages:
+                files.append(item)
+            elif item.suffix in (".php", ".phtml") and "php" in config.languages:
+                files.append(item)
+            # Add more language support here in V2
+        elif item.is_dir() and recursive:
+            # Recursively scan subdirectories
+            sub_result = scan_directory(item, config, base_path, recursive)
+            files.extend(sub_result.files)
+            subdirs.extend(sub_result.subdirs)
+            subdirs.append(item)  # Track the subdirectory itself
+
+    return ScanResult(path=path, files=files, subdirs=subdirs)
+
+
+def find_all_directories(root: Path, config: Config) -> list[Path]:
+    """
+    Find all directories that should be indexed.
+
+    If config.include is specified, recursively finds all subdirectories
+    with indexable files under those paths.
+    Otherwise, walks the entire directory tree.
+
+    Args:
+        root: Root directory to start from
+        config: Configuration object
+
+    Returns:
+        List of directory paths to index
+    """
+    dirs_to_index: list[Path] = []
+
+    def walk_directory(current: Path):
+        """Recursively walk a directory and collect all dirs with files."""
+        if should_exclude(current, config.exclude, root):
+            return
+
+        # Check if this directory has indexable files (non-recursive scan)
+        has_files = False
+        for item in current.iterdir():
+            if item.is_file():
+                if item.suffix == ".py" and "python" in config.languages:
+                    has_files = True
+                    break
+                elif item.suffix in (".php", ".phtml") and "php" in config.languages:
+                    has_files = True
+                    break
+
+        if has_files:
+            dirs_to_index.append(current)
+
+        # Recurse into subdirectories
+        for item in sorted(current.iterdir()):
+            if item.is_dir() and not should_exclude(item, config.exclude, root):
+                walk_directory(item)
+
+    # If include paths are specified, walk each one recursively
+    if config.include:
+        for include_path in config.include:
+            full_path = root / include_path
+            if full_path.exists() and full_path.is_dir():
+                walk_directory(full_path)
+        return dirs_to_index
+
+    # Otherwise, walk the entire directory tree from root
+    walk_directory(root)
+    return dirs_to_index