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

tree_sitter_analyzer/formatters/kotlin_formatter.py

@@ -0,0 +1,268 @@
+#!/usr/bin/env python3
+"""
+Kotlin-specific table formatter.
+"""
+
+from typing import Any
+
+from .base_formatter import BaseTableFormatter
+
+
+class KotlinTableFormatter(BaseTableFormatter):
+    """Table formatter specialized for Kotlin"""
+
+    def _format_full_table(self, data: dict[str, Any]) -> str:
+        """Full table format for Kotlin"""
+        lines = []
+
+        # Header - Kotlin
+        package_name = (data.get("package") or {}).get("name", "default")
+        file_name = data.get("file_path", "Unknown").split("/")[-1].split("\\")[-1]
+        if package_name != "default":
+            lines.append(f"# {package_name}.{file_name}")
+        else:
+            lines.append(f"# {file_name}")
+        lines.append("")
+
+        # Imports
+        imports = data.get("imports", [])
+        if imports:
+            lines.append("## Imports")
+            lines.append("```kotlin")
+            for imp in imports:
+                lines.append(str(imp.get("statement", "")))
+            lines.append("```")
+            lines.append("")
+
+        # Classes/Objects/Interfaces
+        classes = data.get("classes", [])
+        if classes:
+            lines.append("## Classes & Objects")
+            lines.append("| Name | Type | Visibility | Lines | Props | Methods |")
+            lines.append("|------|------|------------|-------|-------|---------|")
+
+            for cls in classes:
+                name = str(cls.get("name", "Unknown"))
+                cls_type = str(cls.get("type", "class"))
+                visibility = str(cls.get("visibility", "public"))
+                line_range = cls.get("line_range", {})
+                lines_str = f"{line_range.get('start', 0)}-{line_range.get('end', 0)}"
+
+                # Count props/methods within
+                class_props = len(
+                    [
+                        p
+                        for p in data.get("fields", [])
+                        if line_range.get("start", 0)
+                        <= p.get("line_range", {}).get("start", 0)
+                        <= line_range.get("end", 0)
+                    ]
+                )
+                class_methods = len(
+                    [
+                        m
+                        for m in data.get("methods", [])
+                        if line_range.get("start", 0)
+                        <= m.get("line_range", {}).get("start", 0)
+                        <= line_range.get("end", 0)
+                    ]
+                )
+
+                lines.append(
+                    f"| {name} | {cls_type} | {visibility} | {lines_str} | {class_props} | {class_methods} |"
+                )
+            lines.append("")
+
+        # Top-level Functions
+        # We want to list all functions, but maybe group them or just list them.
+        # BaseTableFormatter lists all methods in data.get("methods") usually.
+        fns = data.get("methods", [])
+        if fns:
+            lines.append("## Functions")
+            lines.append("| Function | Signature | Vis | Lines | Suspend | Doc |")
+            lines.append("|----------|-----------|-----|-------|---------|-----|")
+
+            for fn in fns:
+                lines.append(self._format_fn_row(fn))
+            lines.append("")
+
+        # Top-level Properties
+        props = data.get("fields", [])  # Mapped to fields
+        if props:
+            lines.append("## Properties")
+            lines.append("| Name | Type | Vis | Kind | Line | Doc |")
+            lines.append("|------|------|-----|------|------|-----|")
+
+            for prop in props:
+                lines.append(self._format_prop_row(prop))
+            lines.append("")
+
+        return "\n".join(lines)
+
+    def _format_compact_table(self, data: dict[str, Any]) -> str:
+        """Compact table format for Kotlin"""
+        lines = []
+
+        # Header
+        package_name = (data.get("package") or {}).get("name", "default")
+        file_name = data.get("file_path", "Unknown").split("/")[-1].split("\\")[-1]
+        if package_name != "default":
+            lines.append(f"# {package_name}.{file_name}")
+        else:
+            lines.append(f"# {file_name}")
+        lines.append("")
+
+        # Info
+        stats = data.get("statistics") or {}
+        lines.append("## Info")
+        lines.append("| Property | Value |")
+        lines.append("|----------|-------|")
+        lines.append(f"| Package | {package_name} |")
+        lines.append(f"| Classes | {len(data.get('classes', []))} |")
+        lines.append(f"| Functions | {stats.get('method_count', 0)} |")
+        lines.append(f"| Properties | {stats.get('field_count', 0)} |")
+        lines.append("")
+
+        # Functions (compact)
+        fns = data.get("methods", [])
+        if fns:
+            lines.append("## Functions")
+            lines.append("| Fn | Sig | V | S | L | Doc |")
+            lines.append("|----|-----|---|---|---|-----|")
+
+            for fn in fns:
+                name = str(fn.get("name", ""))
+                signature = self._create_compact_signature(fn)
+                visibility = self._convert_visibility(str(fn.get("visibility", "")))
+                is_suspend = "Y" if fn.get("is_suspend", False) else "-"
+                line_range = fn.get("line_range", {})
+                lines_str = f"{line_range.get('start', 0)}-{line_range.get('end', 0)}"
+                doc = self._clean_csv_text(
+                    self._extract_doc_summary(str(fn.get("docstring", "") or ""))
+                )
+
+                lines.append(
+                    f"| {name} | {signature} | {visibility} | {is_suspend} | {lines_str} | {doc} |"
+                )
+            lines.append("")
+
+        return "\n".join(lines)
+
+    def _format_fn_row(self, fn: dict[str, Any]) -> str:
+        """Format a function table row for Kotlin"""
+        name = str(fn.get("name", ""))
+        signature = self._create_full_signature(fn)
+        visibility = self._convert_visibility(str(fn.get("visibility", "")))
+        is_suspend = "Yes" if fn.get("is_suspend", False) else "-"
+        line_range = fn.get("line_range", {})
+        lines_str = f"{line_range.get('start', 0)}-{line_range.get('end', 0)}"
+        doc = self._clean_csv_text(
+            self._extract_doc_summary(str(fn.get("docstring", "") or ""))
+        )
+
+        return f"| {name} | {signature} | {visibility} | {lines_str} | {is_suspend} | {doc} |"
+
+    def _format_prop_row(self, prop: dict[str, Any]) -> str:
+        """Format a property table row for Kotlin"""
+        name = str(prop.get("name", ""))
+        prop_type = str(prop.get("type", ""))
+        visibility = self._convert_visibility(str(prop.get("visibility", "")))
+        # Check val/var if extracted
+        kind = (
+            "val"
+            if prop.get("is_val", False)
+            else ("var" if prop.get("is_var", False) else "-")
+        )
+        line = prop.get("line_range", {}).get("start", 0)
+        doc = self._clean_csv_text(
+            self._extract_doc_summary(str(prop.get("docstring", "") or ""))
+        )
+
+        return f"| {name} | {prop_type} | {visibility} | {kind} | {line} | {doc} |"
+
+    def _create_full_signature(self, fn: dict[str, Any]) -> str:
+        """Create full function signature for Kotlin"""
+        # Kotlin: fun name(p1: T1, p2: T2): R
+        params = fn.get("parameters", [])
+        params_str_list = []
+        for p in params:
+            if isinstance(p, dict):
+                # "name: type" is expected
+                params_str_list.append(f"{p.get('name')}: {p.get('type')}")
+            else:
+                params_str_list.append(str(p))
+
+        params_str = ", ".join(params_str_list)
+        return_type = fn.get("return_type", "")
+        ret_str = f": {return_type}" if return_type and return_type != "Unit" else ""
+
+        return f"fun({params_str}){ret_str}"
+
+    def _create_compact_signature(self, fn: dict[str, Any]) -> str:
+        """Create compact function signature for Kotlin"""
+        params = fn.get("parameters", [])
+        params_summary = f"({len(params)})"
+        return_type = fn.get("return_type", "")
+        ret_str = f":{return_type}" if return_type and return_type != "Unit" else ""
+
+        return f"{params_summary}{ret_str}"
+
+    def _convert_visibility(self, visibility: str) -> str:
+        """Convert visibility to short symbol"""
+        if visibility == "public":
+            return "pub"
+        elif visibility == "private":
+            return "priv"
+        elif visibility == "protected":
+            return "prot"
+        elif visibility == "internal":
+            return "int"
+        return visibility
+
+    def format_table(
+        self, analysis_result: dict[str, Any], table_type: str = "full"
+    ) -> str:
+        """Format table output for Kotlin"""
+        # Set the format type based on table_type parameter
+        original_format_type = self.format_type
+        self.format_type = table_type
+
+        try:
+            # Handle json format separately
+            if table_type == "json":
+                return self._format_json(analysis_result)
+            # Use the existing format_structure method
+            return self.format_structure(analysis_result)
+        finally:
+            # Restore original format type
+            self.format_type = original_format_type
+
+    def format_summary(self, analysis_result: dict[str, Any]) -> str:
+        """Format summary output for Kotlin"""
+        return self._format_compact_table(analysis_result)
+
+    def format_structure(self, analysis_result: dict[str, Any]) -> str:
+        """Format structure analysis output for Kotlin"""
+        if self.format_type == "compact":
+            return self._format_compact_table(analysis_result)
+        return self._format_full_table(analysis_result)
+
+    def format_advanced(
+        self, analysis_result: dict[str, Any], output_format: str = "json"
+    ) -> str:
+        """Format advanced analysis output for Kotlin"""
+        if output_format == "json":
+            return self._format_json(analysis_result)
+        elif output_format == "csv":
+            return self._format_csv(analysis_result)
+        else:
+            return self._format_full_table(analysis_result)
+
+    def _format_json(self, data: dict[str, Any]) -> str:
+        """Format data as JSON"""
+        import json
+
+        try:
+            return json.dumps(data, indent=2, ensure_ascii=False)
+        except (TypeError, ValueError) as e:
+            return f"# JSON serialization error: {e}\n"

tree_sitter_analyzer/formatters/language_formatter_factory.py

@@ -0,0 +1,123 @@
+#!/usr/bin/env python3
+"""
+Factory for creating language-specific formatters for different output types.
+"""
+
+from .base_formatter import BaseFormatter
+from .csharp_formatter import CSharpTableFormatter
+from .go_formatter import GoTableFormatter
+from .html_formatter import HtmlFormatter
+from .java_formatter import JavaTableFormatter
+from .javascript_formatter import JavaScriptTableFormatter
+from .kotlin_formatter import KotlinTableFormatter
+from .markdown_formatter import MarkdownFormatter
+from .php_formatter import PHPTableFormatter
+from .python_formatter import PythonTableFormatter
+from .ruby_formatter import RubyTableFormatter
+from .rust_formatter import RustTableFormatter
+from .sql_formatter_wrapper import SQLFormatterWrapper
+from .typescript_formatter import TypeScriptTableFormatter
+from .yaml_formatter import YAMLFormatter
+
+
+class LanguageFormatterFactory:
+    """Factory for creating language-specific formatters"""
+
+    _formatters: dict[str, type[BaseFormatter]] = {
+        "markdown": MarkdownFormatter,
+        "md": MarkdownFormatter,  # Alias
+        "html": HtmlFormatter,
+        "css": HtmlFormatter,  # CSS files also use HTML formatter
+        "sql": SQLFormatterWrapper,  # SQL-specific formatter
+        "python": PythonTableFormatter,  # Python files use Python formatter
+        "py": PythonTableFormatter,  # Python alias
+        "java": JavaTableFormatter,  # Java files use Java formatter
+        "kotlin": KotlinTableFormatter,  # Kotlin files use Kotlin formatter
+        "kt": KotlinTableFormatter,  # Kotlin alias
+        "kts": KotlinTableFormatter,  # Kotlin script alias
+        "javascript": JavaScriptTableFormatter,  # JavaScript files use JavaScript formatter
+        "js": JavaScriptTableFormatter,  # JavaScript alias
+        "typescript": TypeScriptTableFormatter,  # TypeScript files use TypeScript formatter
+        "ts": TypeScriptTableFormatter,  # TypeScript alias
+        "csharp": CSharpTableFormatter,  # C# files use C# formatter
+        "cs": CSharpTableFormatter,  # C# alias
+        "php": PHPTableFormatter,  # PHP files use PHP formatter
+        "ruby": RubyTableFormatter,  # Ruby files use Ruby formatter
+        "rb": RubyTableFormatter,  # Ruby alias
+        "rust": RustTableFormatter,  # Rust files use Rust formatter
+        "rs": RustTableFormatter,  # Rust alias
+        "go": GoTableFormatter,  # Go files use Go formatter
+        "yaml": YAMLFormatter,  # YAML files use YAML formatter
+        "yml": YAMLFormatter,  # YAML alias
+    }
+
+    @classmethod
+    def create_formatter(cls, language: str) -> BaseFormatter:
+        """
+        Create formatter for specified language
+
+        Args:
+            language: Programming language name
+
+        Returns:
+            Language-specific formatter
+        """
+        formatter_class = cls._formatters.get(language.lower())
+
+        if formatter_class is None:
+            raise ValueError(f"Unsupported language: {language}")
+
+        return formatter_class()
+
+    @classmethod
+    def register_formatter(
+        cls, language: str, formatter_class: type[BaseFormatter]
+    ) -> None:
+        """
+        Register new language formatter
+
+        Args:
+            language: Programming language name
+            formatter_class: Formatter class
+        """
+        cls._formatters[language.lower()] = formatter_class
+
+    @classmethod
+    def get_supported_languages(cls) -> list[str]:
+        """
+        Get list of supported languages
+
+        Returns:
+            List of supported languages
+        """
+        return list(cls._formatters.keys())
+
+    @classmethod
+    def supports_language(cls, language: str) -> bool:
+        """
+        Check if language is supported
+
+        Args:
+            language: Programming language name
+
+        Returns:
+            True if language is supported
+        """
+        return language.lower() in cls._formatters
+
+
+def create_language_formatter(language: str) -> BaseFormatter | None:
+    """
+    Create language formatter (function for compatibility)
+
+    Args:
+        language: Programming language name
+
+    Returns:
+        Language formatter or None if not supported
+    """
+    try:
+        return LanguageFormatterFactory.create_formatter(language)
+    except ValueError:
+        # Return None for unsupported languages instead of raising exception
+        return None

tree_sitter_analyzer/formatters/legacy_formatter_adapters.py

@@ -0,0 +1,228 @@
+#!/usr/bin/env python3
+"""
+Legacy Formatter Adapters
+
+Adapters to integrate the legacy v1.6.1.4 TableFormatter with the v1.9.4 FormatterRegistry system.
+This ensures backward compatibility while maintaining the new architecture.
+"""
+
+import logging
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    pass
+
+from ..constants import (
+    ELEMENT_TYPE_CLASS,
+    ELEMENT_TYPE_FUNCTION,
+    ELEMENT_TYPE_IMPORT,
+    ELEMENT_TYPE_PACKAGE,
+    ELEMENT_TYPE_VARIABLE,
+    get_element_type,
+    is_element_of_type,
+)
+from ..legacy_table_formatter import LegacyTableFormatter
+from ..models import CodeElement
+from .formatter_registry import IFormatter
+
+logger = logging.getLogger(__name__)
+
+
+class LegacyFormatterAdapter(IFormatter):
+    """
+    Base adapter class for legacy table formatters.
+
+    Converts CodeElement lists to the legacy data structure format
+    and delegates formatting to LegacyTableFormatter.
+    """
+
+    @staticmethod
+    def get_format_name() -> str:
+        """Return the format name this formatter supports"""
+        # This will be overridden in subclasses
+        return "legacy"
+
+    def __init__(
+        self, format_type: str, language: str = "java", include_javadoc: bool = False
+    ):
+        """
+        Initialize the legacy formatter adapter.
+
+        Args:
+            format_type: Format type (full, compact, csv)
+            language: Programming language for syntax highlighting
+            include_javadoc: Whether to include JavaDoc/documentation
+        """
+        self.format_type = format_type
+        self.language = language
+        self.include_javadoc = include_javadoc
+        self.formatter = LegacyTableFormatter(
+            format_type=format_type, language=language, include_javadoc=include_javadoc
+        )
+
+    def format(self, elements: list[CodeElement]) -> str:
+        """
+        Format CodeElement list using legacy formatter.
+
+        Args:
+            elements: List of CodeElement objects to format
+
+        Returns:
+            Formatted string in legacy v1.6.1.4 format
+        """
+        # Convert CodeElement list to legacy data structure
+        legacy_data = self._convert_to_legacy_format(elements)
+
+        # Use legacy formatter
+        result = self.formatter.format_structure(legacy_data)
+
+        # Ensure Unix-style line endings for consistency
+        result = result.replace("\r\n", "\n").replace("\r", "\n")
+
+        return result
+
+    def _convert_to_legacy_format(self, elements: list[CodeElement]) -> dict[str, Any]:
+        """
+        Convert CodeElement list to legacy data structure format.
+
+        Args:
+            elements: List of CodeElement objects
+
+        Returns:
+            Dictionary in legacy format expected by LegacyTableFormatter
+        """
+        # Extract file_path from first element if available
+        file_path = "Unknown"
+        if elements and hasattr(elements[0], "file_path"):
+            file_path = elements[0].file_path or "Unknown"
+
+        # Initialize legacy data structure
+        legacy_data: dict[str, Any] = {
+            "file_path": file_path,
+            "package": {"name": "unknown"},
+            "imports": [],
+            "classes": [],
+            "methods": [],
+            "fields": [],
+            "statistics": {"method_count": 0, "field_count": 0, "class_count": 0},
+        }
+
+        # Process elements by type
+        package_name = "unknown"
+        for element in elements:
+            # Use is_element_of_type helper for accurate type checking
+            # Also handle legacy "method" and "field" type names
+            element_type = get_element_type(element)
+
+            if is_element_of_type(element, ELEMENT_TYPE_PACKAGE):
+                package_name = element.name
+                legacy_data["package"]["name"] = package_name
+            elif is_element_of_type(element, ELEMENT_TYPE_CLASS):
+                legacy_data["classes"].append(self._convert_class_element(element))
+            elif (
+                is_element_of_type(element, ELEMENT_TYPE_FUNCTION)
+                or element_type == "method"
+            ):
+                legacy_data["methods"].append(self._convert_method_element(element))
+            elif (
+                is_element_of_type(element, ELEMENT_TYPE_VARIABLE)
+                or element_type == "field"
+            ):
+                legacy_data["fields"].append(self._convert_field_element(element))
+            elif is_element_of_type(element, ELEMENT_TYPE_IMPORT):
+                legacy_data["imports"].append(self._convert_import_element(element))
+
+        # Update statistics
+        legacy_data["statistics"]["method_count"] = len(legacy_data["methods"])
+        legacy_data["statistics"]["field_count"] = len(legacy_data["fields"])
+        legacy_data["statistics"]["class_count"] = len(legacy_data["classes"])
+
+        # If no classes found, create a default one for proper formatting
+        if not legacy_data["classes"] and (
+            legacy_data["methods"] or legacy_data["fields"]
+        ):
+            legacy_data["classes"] = [
+                {
+                    "name": "Unknown",
+                    "type": "class",
+                    "visibility": "public",
+                    "line_range": {"start": 1, "end": 100},
+                }
+            ]
+
+        return legacy_data
+
+    def _convert_class_element(self, element: CodeElement) -> dict[str, Any]:
+        """Convert class CodeElement to legacy format"""
+        return {
+            "name": element.name,
+            "type": getattr(element, "class_type", "class"),
+            "visibility": getattr(element, "visibility", "public"),
+            "line_range": {"start": element.start_line, "end": element.end_line},
+            "modifiers": getattr(element, "modifiers", []),
+        }
+
+    def _convert_method_element(self, element: CodeElement) -> dict[str, Any]:
+        """Convert method CodeElement to legacy format"""
+        return {
+            "name": element.name,
+            "visibility": getattr(element, "visibility", "public"),
+            "return_type": getattr(element, "return_type", "void"),
+            "parameters": getattr(element, "parameters", []),
+            "line_range": {"start": element.start_line, "end": element.end_line},
+            "is_constructor": getattr(element, "is_constructor", False),
+            "is_static": getattr(element, "is_static", False),
+            "modifiers": getattr(element, "modifiers", []),
+            "complexity_score": getattr(element, "complexity_score", 0),
+            "javadoc": getattr(element, "documentation", ""),
+        }
+
+    def _convert_field_element(self, element: CodeElement) -> dict[str, Any]:
+        """Convert field CodeElement to legacy format"""
+        return {
+            "name": element.name,
+            "type": getattr(element, "field_type", "Object"),
+            "visibility": getattr(element, "visibility", "private"),
+            "line_range": {"start": element.start_line, "end": element.end_line},
+            "modifiers": getattr(element, "modifiers", []),
+            "javadoc": getattr(element, "documentation", ""),
+        }
+
+    def _convert_import_element(self, element: CodeElement) -> dict[str, Any]:
+        """Convert import CodeElement to legacy format"""
+        return {
+            "statement": getattr(element, "import_statement", f"import {element.name}")
+        }
+
+
+class LegacyFullFormatter(LegacyFormatterAdapter):
+    """Legacy full formatter producing Markdown tables"""
+
+    def __init__(self, language: str = "java", include_javadoc: bool = False):
+        super().__init__("full", language, include_javadoc)
+
+    @staticmethod
+    def get_format_name() -> str:
+        return "full"
+
+
+class LegacyCompactFormatter(LegacyFormatterAdapter):
+    """Legacy compact formatter with complexity scores"""
+
+    def __init__(self, language: str = "java", include_javadoc: bool = False):
+        super().__init__("compact", language, include_javadoc)
+
+    @staticmethod
+    def get_format_name() -> str:
+        return "compact"
+
+
+class LegacyCsvFormatter(LegacyFormatterAdapter):
+    """Legacy CSV formatter with simple structure"""
+
+    def __init__(self, language: str = "java", include_javadoc: bool = False):
+        super().__init__("csv", language, include_javadoc)
+
+    @staticmethod
+    def get_format_name() -> str:
+        return "csv"