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

tree_sitter_analyzer/formatters/ruby_formatter.py

@@ -0,0 +1,278 @@
+#!/usr/bin/env python3
+"""
+Ruby-specific table formatter.
+"""
+
+from typing import Any
+
+from .base_formatter import BaseTableFormatter
+
+
+class RubyTableFormatter(BaseTableFormatter):
+    """Table formatter specialized for Ruby"""
+
+    def _format_full_table(self, data: dict[str, Any]) -> str:
+        """Full table format for Ruby"""
+        lines = []
+
+        # Header - Ruby (multi-class supported)
+        classes = data.get("classes", [])
+
+        if len(classes) > 1:
+            # If multiple classes exist, use filename
+            file_name = data.get("file_path", "Unknown").split("/")[-1].split("\\")[-1]
+            lines.append(f"# {file_name}")
+        else:
+            # Single class: use class name
+            class_name = classes[0].get("name", "Unknown") if classes else "Unknown"
+            lines.append(f"# {class_name}")
+        lines.append("")
+
+        # Require statements (imports)
+        imports = data.get("imports", [])
+        if imports:
+            lines.append("## Imports")
+            lines.append("```ruby")
+            for imp in imports:
+                import_text = imp.get("raw_text", "").strip()
+                if import_text:
+                    lines.append(import_text)
+            lines.append("```")
+            lines.append("")
+
+        # Class Info - Ruby (multi-class aware)
+        if len(classes) > 1:
+            lines.append("## Classes Overview")
+            lines.append("| Class | Type | Lines | Methods | Constants |")
+            lines.append("|-------|------|-------|---------|-----------|")
+
+            for class_info in classes:
+                name = str(class_info.get("name", "Unknown"))
+                class_type = str(class_info.get("class_type", "class"))
+                line_range = class_info.get("line_range", {})
+                lines_str = f"{line_range.get('start', 0)}-{line_range.get('end', 0)}"
+
+                # Count methods/constants within the class range
+                class_methods = [
+                    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)
+                ]
+                class_constants = [
+                    f
+                    for f in data.get("fields", [])
+                    if f.get("is_constant", False)
+                    and line_range.get("start", 0)
+                    <= f.get("line_range", {}).get("start", 0)
+                    <= line_range.get("end", 0)
+                ]
+
+                lines.append(
+                    f"| {name} | {class_type} | {lines_str} | {len(class_methods)} | {len(class_constants)} |"
+                )
+        else:
+            # Single class details
+            lines.append("## Info")
+            lines.append("| Property | Value |")
+            lines.append("|----------|-------|")
+
+            class_info = data.get("classes", [{}])[0] if data.get("classes") else {}
+            stats = data.get("statistics") or {}
+
+            lines.append(f"| Type | {str(class_info.get('class_type', 'class'))} |")
+            lines.append(f"| Methods | {stats.get('method_count', 0)} |")
+            lines.append(
+                f"| Constants | {sum(1 for f in data.get('fields', []) if f.get('is_constant', False))} |"
+            )
+
+        lines.append("")
+
+        # Methods
+        methods = data.get("methods", [])
+        if methods:
+            lines.append("## Methods")
+            lines.append("| Name | Type | Lines | Parameters |")
+            lines.append("|------|------|-------|------------|")
+
+            for method in methods:
+                name = str(method.get("name", "Unknown"))
+                metadata = method.get("metadata", {})
+                method_type = metadata.get("method_type", "instance")
+                attr_type = metadata.get("attr_type", "")
+
+                # Determine display type
+                if attr_type:
+                    display_type = attr_type
+                elif method_type == "class":
+                    display_type = "class method"
+                else:
+                    display_type = "instance method"
+
+                line_range = method.get("line_range", {})
+                lines_str = f"{line_range.get('start', 0)}-{line_range.get('end', 0)}"
+                params = ", ".join(method.get("parameters", []))
+
+                lines.append(f"| {name} | {display_type} | {lines_str} | {params} |")
+
+        lines.append("")
+
+        # Variables (Constants, Instance Variables, Class Variables)
+        fields = data.get("fields", [])
+        if fields:
+            lines.append("## Variables")
+            lines.append("| Name | Type | Visibility | Lines |")
+            lines.append("|------|------|------------|-------|")
+
+            for field in fields:
+                name = str(field.get("name", "Unknown"))
+                metadata = field.get("metadata", {})
+
+                # Determine variable type
+                if field.get("is_constant", False):
+                    var_type = "constant"
+                elif metadata.get("is_class_variable", False):
+                    var_type = "class variable"
+                elif metadata.get("is_instance_variable", False):
+                    var_type = "instance variable"
+                elif metadata.get("is_global", False):
+                    var_type = "global variable"
+                else:
+                    var_type = "variable"
+
+                visibility = str(field.get("visibility", "public"))
+                line_range = field.get("line_range", {})
+                lines_str = f"{line_range.get('start', 0)}-{line_range.get('end', 0)}"
+
+                lines.append(f"| {name} | {var_type} | {visibility} | {lines_str} |")
+
+        lines.append("")
+
+        return "\n".join(lines)
+
+    def _format_compact_table(self, data: dict[str, Any]) -> str:
+        """Compact table format for Ruby"""
+        lines = []
+
+        # Header
+        classes = data.get("classes", [])
+
+        if len(classes) > 1:
+            file_name = data.get("file_path", "Unknown").split("/")[-1].split("\\")[-1]
+            lines.append(f"# {file_name}")
+        else:
+            class_name = classes[0].get("name", "Unknown") if classes else "Unknown"
+            lines.append(f"# {class_name}")
+        lines.append("")
+
+        # Statistics
+        stats = data.get("statistics") or {}
+        lines.append("## Statistics")
+        lines.append(f"- Classes: {stats.get('class_count', 0)}")
+        lines.append(f"- Methods: {stats.get('method_count', 0)}")
+        lines.append(
+            f"- Constants: {sum(1 for f in data.get('fields', []) if f.get('is_constant', False))}"
+        )
+        lines.append(f"- Imports: {len(data.get('imports', []))}")
+        lines.append("")
+
+        # Classes
+        if classes:
+            lines.append("## Classes")
+            for class_info in classes:
+                name = str(class_info.get("name", "Unknown"))
+                class_type = str(class_info.get("class_type", "class"))
+                line_range = class_info.get("line_range", {})
+                lines_str = f"{line_range.get('start', 0)}-{line_range.get('end', 0)}"
+                lines.append(f"- **{name}** ({class_type}) - Lines {lines_str}")
+            lines.append("")
+
+        # Methods
+        methods = data.get("methods", [])
+        if methods:
+            lines.append("## Methods")
+            for method in methods:
+                name = str(method.get("name", "Unknown"))
+                metadata = method.get("metadata", {})
+                method_type = metadata.get("method_type", "instance")
+                line_range = method.get("line_range", {})
+                lines_str = f"{line_range.get('start', 0)}-{line_range.get('end', 0)}"
+
+                type_prefix = "." if method_type == "class" else "#"
+                lines.append(f"- {type_prefix}{name} - Lines {lines_str}")
+            lines.append("")
+
+        return "\n".join(lines)
+
+    def _format_csv(self, data: dict[str, Any]) -> str:
+        """CSV format for Ruby"""
+        lines = []
+
+        # Header
+        lines.append("Type,Name,Additional,Lines")
+
+        # Classes
+        for class_info in data.get("classes", []):
+            name = str(class_info.get("name", "Unknown"))
+            class_type = str(class_info.get("class_type", "class"))
+            line_range = class_info.get("line_range", {})
+            lines_str = f"{line_range.get('start', 0)}-{line_range.get('end', 0)}"
+            lines.append(f"{class_type},{name},,{lines_str}")
+
+        # Methods
+        for method in data.get("methods", []):
+            name = str(method.get("name", "Unknown"))
+            metadata = method.get("metadata", {})
+            method_type = metadata.get("method_type", "instance")
+            attr_type = metadata.get("attr_type", "")
+            line_range = method.get("line_range", {})
+            lines_str = f"{line_range.get('start', 0)}-{line_range.get('end', 0)}"
+
+            additional = attr_type if attr_type else method_type
+            lines.append(f"method,{name},{additional},{lines_str}")
+
+        # Variables
+        for field in data.get("fields", []):
+            name = str(field.get("name", "Unknown"))
+            metadata = field.get("metadata", {})
+
+            # Determine variable type
+            if field.get("is_constant", False):
+                var_type = "constant"
+            elif metadata.get("is_class_variable", False):
+                var_type = "class_variable"
+            elif metadata.get("is_instance_variable", False):
+                var_type = "instance_variable"
+            else:
+                var_type = "variable"
+
+            line_range = field.get("line_range", {})
+            lines_str = f"{line_range.get('start', 0)}-{line_range.get('end', 0)}"
+            lines.append(f"{var_type},{name},,{lines_str}")
+
+        return "\n".join(lines)
+
+
+class RubyFullFormatter(RubyTableFormatter):
+    """Full table formatter for Ruby"""
+
+    def format(self, data: dict[str, Any]) -> str:
+        """Format data as full table"""
+        return self._format_full_table(data)
+
+
+class RubyCompactFormatter(RubyTableFormatter):
+    """Compact table formatter for Ruby"""
+
+    def format(self, data: dict[str, Any]) -> str:
+        """Format data as compact table"""
+        return self._format_compact_table(data)
+
+
+class RubyCSVFormatter(RubyTableFormatter):
+    """CSV formatter for Ruby"""
+
+    def format(self, data: dict[str, Any]) -> str:
+        """Format data as CSV"""
+        return self._format_csv(data)

tree_sitter_analyzer/formatters/rust_formatter.py

@@ -0,0 +1,233 @@
+#!/usr/bin/env python3
+"""
+Rust-specific table formatter.
+"""
+
+from typing import Any
+
+from .base_formatter import BaseTableFormatter
+
+
+class RustTableFormatter(BaseTableFormatter):
+    """Table formatter specialized for Rust"""
+
+    def _format_full_table(self, data: dict[str, Any]) -> str:
+        """Full table format for Rust"""
+        lines = []
+
+        # Header - Rust (module-centric)
+        file_name = data.get("file_path", "Unknown").split("/")[-1].split("\\")[-1]
+        lines.append(f"# {file_name}")
+        lines.append("")
+
+        # Module Info
+        modules = data.get("modules", [])
+        if modules:
+            lines.append("## Modules")
+            lines.append("| Name | Visibility | Lines |")
+            lines.append("|------|------------|-------|")
+            for mod in modules:
+                lines.append(
+                    f"| {mod.get('name')} | {mod.get('visibility')} | {mod.get('line_range', {}).get('start')}-{mod.get('line_range', {}).get('end')} |"
+                )
+            lines.append("")
+
+        # Structs (mapped from classes)
+        structs = data.get("classes", [])
+        if structs:
+            lines.append("## Structs")
+            lines.append("| Name | Type | Visibility | Lines | Fields | Traits |")
+            lines.append("|------|------|------------|-------|--------|--------|")
+
+            for struct in structs:
+                name = str(struct.get("name", "Unknown"))
+                struct_type = str(struct.get("type", "struct"))  # struct, enum, trait
+                visibility = str(struct.get("visibility", "private"))
+                line_range = struct.get("line_range", {})
+                lines_str = f"{line_range.get('start', 0)}-{line_range.get('end', 0)}"
+
+                # Count fields
+                fields_count = len(
+                    [
+                        f
+                        for f in data.get("fields", [])
+                        if line_range.get("start", 0)
+                        <= f.get("line_range", {}).get("start", 0)
+                        <= line_range.get("end", 0)
+                    ]
+                )
+
+                # Traits (from interfaces field)
+                traits = struct.get("implements_interfaces", [])
+                traits_str = ", ".join(traits) if traits else "-"
+
+                lines.append(
+                    f"| {name} | {struct_type} | {visibility} | {lines_str} | {fields_count} | {traits_str} |"
+                )
+            lines.append("")
+
+        # Functions (mapped from methods)
+        fns = data.get("methods", [])
+        if fns:
+            lines.append("## Functions")
+            lines.append("| Function | Signature | Vis | Async | Lines | Doc |")
+            lines.append("|----------|-----------|-----|-------|-------|-----|")
+
+            for fn in fns:
+                lines.append(self._format_fn_row(fn))
+            lines.append("")
+
+        # Traits (if mapped separately or included in classes)
+        # Note: The extractor maps traits to classes with type="trait"
+
+        # Impl blocks
+        impls = data.get("impls", [])
+        if impls:
+            lines.append("## Implementations")
+            lines.append("| Type | Trait | Lines |")
+            lines.append("|------|-------|-------|")
+            for impl in impls:
+                trait_name = impl.get("trait", "-")
+                type_name = impl.get("type", "Unknown")
+                line_range = impl.get("line_range", {})
+                lines_str = f"{line_range.get('start', 0)}-{line_range.get('end', 0)}"
+                lines.append(f"| {type_name} | {trait_name} | {lines_str} |")
+            lines.append("")
+
+        return "\n".join(lines)
+
+    def _format_compact_table(self, data: dict[str, Any]) -> str:
+        """Compact table format for Rust"""
+        lines = []
+
+        # Header
+        file_name = data.get("file_path", "Unknown").split("/")[-1].split("\\")[-1]
+        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"| Structs | {len(data.get('classes', []))} |")
+        lines.append(f"| Functions | {stats.get('method_count', 0)} |")
+        lines.append(f"| Lines | {stats.get('lines', 0)} |")
+        lines.append("")
+
+        # Functions (compact)
+        fns = data.get("methods", [])
+        if fns:
+            lines.append("## Functions")
+            lines.append("| Fn | Sig | V | A | 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_async = "Y" if fn.get("is_async", 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_async} | {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 Rust"""
+        name = str(fn.get("name", ""))
+        signature = self._create_full_signature(fn)
+        visibility = self._convert_visibility(str(fn.get("visibility", "")))
+        is_async = "Yes" if fn.get("is_async", 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} | {is_async} | {lines_str} | {doc} |"
+
+    def _create_full_signature(self, fn: dict[str, Any]) -> str:
+        """Create full function signature for Rust"""
+        params = fn.get("parameters", [])
+        # Rust parameters are usually strings like "x: i32", keep them as is or simplify
+        params_str = ", ".join([str(p) for p in params])
+        return_type = fn.get("return_type", "")
+        ret_str = f" -> {return_type}" if return_type and return_type != "()" else ""
+
+        return f"fn({params_str}){ret_str}"
+
+    def _create_compact_signature(self, fn: dict[str, Any]) -> str:
+        """Create compact function signature for Rust"""
+        params = fn.get("parameters", [])
+        # Simply count parameters or use short types if available
+        params_summary = f"({len(params)})"
+        return_type = fn.get("return_type", "")
+        ret_str = f"->{return_type}" if return_type and return_type != "()" else ""
+
+        return f"{params_summary}{ret_str}"
+
+    def _convert_visibility(self, visibility: str) -> str:
+        """Convert visibility to short symbol"""
+        if visibility == "pub":
+            return "pub"
+        elif visibility == "pub(crate)":
+            return "crate"
+        elif visibility == "private":  # Default
+            return "priv"
+        return visibility
+
+    def format_table(
+        self, analysis_result: dict[str, Any], table_type: str = "full"
+    ) -> str:
+        """Format table output for Rust"""
+        # 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 Rust"""
+        return self._format_compact_table(analysis_result)
+
+    def format_structure(self, analysis_result: dict[str, Any]) -> str:
+        """Format structure analysis output for Rust"""
+        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 Rust"""
+        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"