tree-sitter-analyzer 0.9.1__py3-none-any.whl → 0.9.2__py3-none-any.whl

tree_sitter_analyzer/formatters/base_formatter.py

@@ -1,167 +1,167 @@
-#!/usr/bin/env python3
-"""
-Base formatter for language-specific table formatting.
-"""
-
-import csv
-import io
-import os
-from abc import ABC, abstractmethod
-from typing import Any
-
-
-class BaseTableFormatter(ABC):
-    """Base class for language-specific table formatters"""
-
-    def __init__(self, format_type: str = "full"):
-        self.format_type = format_type
-
-    def _get_platform_newline(self) -> str:
-        """Get platform-specific newline code"""
-        return os.linesep
-
-    def _convert_to_platform_newlines(self, text: str) -> str:
-        """Convert regular \n to platform-specific newline code"""
-        if os.linesep != "\n":
-            return text.replace("\n", os.linesep)
-        return text
-
-    def format_structure(self, structure_data: dict[str, Any]) -> str:
-        """Format structure data in table format"""
-        if self.format_type == "full":
-            result = self._format_full_table(structure_data)
-        elif self.format_type == "compact":
-            result = self._format_compact_table(structure_data)
-        elif self.format_type == "csv":
-            result = self._format_csv(structure_data)
-        else:
-            raise ValueError(f"Unsupported format type: {self.format_type}")
-
-        # Finally convert to platform-specific newline code
-        if self.format_type == "csv":
-            return result
-
-        return self._convert_to_platform_newlines(result)
-
-    @abstractmethod
-    def _format_full_table(self, data: dict[str, Any]) -> str:
-        """Full table format (language-specific implementation)"""
-        pass
-
-    @abstractmethod
-    def _format_compact_table(self, data: dict[str, Any]) -> str:
-        """Compact table format (language-specific implementation)"""
-        pass
-
-    def _format_csv(self, data: dict[str, Any]) -> str:
-        """CSV format (common implementation)"""
-        output = io.StringIO()
-        writer = csv.writer(output, lineterminator="\n")
-
-        # Header
-        writer.writerow(
-            ["Type", "Name", "Signature", "Visibility", "Lines", "Complexity", "Doc"]
-        )
-
-        # Fields
-        for field in data.get("fields", []):
-            writer.writerow(
-                [
-                    "Field",
-                    str(field.get("name", "")),
-                    f"{str(field.get('name', ''))}:{str(field.get('type', ''))}",
-                    str(field.get("visibility", "")),
-                    f"{field.get('line_range', {}).get('start', 0)}-{field.get('line_range', {}).get('end', 0)}",
-                    "",
-                    self._clean_csv_text(
-                        self._extract_doc_summary(str(field.get("javadoc", "")))
-                    ),
-                ]
-            )
-
-        # Methods
-        for method in data.get("methods", []):
-            writer.writerow(
-                [
-                    "Constructor" if method.get("is_constructor", False) else "Method",
-                    str(method.get("name", "")),
-                    self._clean_csv_text(self._create_full_signature(method)),
-                    str(method.get("visibility", "")),
-                    f"{method.get('line_range', {}).get('start', 0)}-{method.get('line_range', {}).get('end', 0)}",
-                    method.get("complexity_score", 0),
-                    self._clean_csv_text(
-                        self._extract_doc_summary(str(method.get("javadoc", "")))
-                    ),
-                ]
-            )
-
-        csv_content = output.getvalue()
-        csv_content = csv_content.replace("\r\n", "\n").replace("\r", "\n")
-        csv_content = csv_content.rstrip("\n")
-        output.close()
-
-        return csv_content
-
-    # Common helper methods
-    def _create_full_signature(self, method: dict[str, Any]) -> str:
-        """Create complete method signature"""
-        params = method.get("parameters", [])
-        param_strs = []
-        for param in params:
-            if isinstance(param, dict):
-                param_type = str(param.get("type", "Object"))
-                param_name = str(param.get("name", "param"))
-                param_strs.append(f"{param_name}:{param_type}")
-            else:
-                param_strs.append(str(param))
-
-        params_str = ", ".join(param_strs)
-        return_type = str(method.get("return_type", "void"))
-
-        modifiers = []
-        if method.get("is_static", False):
-            modifiers.append("[static]")
-
-        modifier_str = " ".join(modifiers)
-        signature = f"({params_str}):{return_type}"
-
-        if modifier_str:
-            signature += f" {modifier_str}"
-
-        return signature
-
-    def _convert_visibility(self, visibility: str) -> str:
-        """Convert visibility to symbol"""
-        mapping = {"public": "+", "private": "-", "protected": "#", "package": "~"}
-        return mapping.get(visibility, visibility)
-
-    def _extract_doc_summary(self, javadoc: str) -> str:
-        """Extract summary from documentation"""
-        if not javadoc:
-            return "-"
-
-        # Remove comment symbols
-        clean_doc = (
-            javadoc.replace("/**", "").replace("*/", "").replace("*", "").strip()
-        )
-
-        # Get first line
-        lines = clean_doc.split("\n")
-        first_line = lines[0].strip()
-
-        # Truncate if too long
-        if len(first_line) > 50:
-            first_line = first_line[:47] + "..."
-
-        return first_line.replace("|", "\\|").replace("\n", " ")
-
-    def _clean_csv_text(self, text: str) -> str:
-        """Text cleaning for CSV format"""
-        if not text:
-            return ""
-
-        cleaned = text.replace("\r\n", " ").replace("\r", " ").replace("\n", " ")
-        cleaned = " ".join(cleaned.split())
-        cleaned = cleaned.replace('"', '""')
-
-        return cleaned
+#!/usr/bin/env python3
+"""
+Base formatter for language-specific table formatting.
+"""
+
+import csv
+import io
+import os
+from abc import ABC, abstractmethod
+from typing import Any
+
+
+class BaseTableFormatter(ABC):
+    """Base class for language-specific table formatters"""
+
+    def __init__(self, format_type: str = "full"):
+        self.format_type = format_type
+
+    def _get_platform_newline(self) -> str:
+        """Get platform-specific newline code"""
+        return os.linesep
+
+    def _convert_to_platform_newlines(self, text: str) -> str:
+        """Convert regular \n to platform-specific newline code"""
+        if os.linesep != "\n":
+            return text.replace("\n", os.linesep)
+        return text
+
+    def format_structure(self, structure_data: dict[str, Any]) -> str:
+        """Format structure data in table format"""
+        if self.format_type == "full":
+            result = self._format_full_table(structure_data)
+        elif self.format_type == "compact":
+            result = self._format_compact_table(structure_data)
+        elif self.format_type == "csv":
+            result = self._format_csv(structure_data)
+        else:
+            raise ValueError(f"Unsupported format type: {self.format_type}")
+
+        # Finally convert to platform-specific newline code
+        if self.format_type == "csv":
+            return result
+
+        return self._convert_to_platform_newlines(result)
+
+    @abstractmethod
+    def _format_full_table(self, data: dict[str, Any]) -> str:
+        """Full table format (language-specific implementation)"""
+        pass
+
+    @abstractmethod
+    def _format_compact_table(self, data: dict[str, Any]) -> str:
+        """Compact table format (language-specific implementation)"""
+        pass
+
+    def _format_csv(self, data: dict[str, Any]) -> str:
+        """CSV format (common implementation)"""
+        output = io.StringIO()
+        writer = csv.writer(output, lineterminator="\n")
+
+        # Header
+        writer.writerow(
+            ["Type", "Name", "Signature", "Visibility", "Lines", "Complexity", "Doc"]
+        )
+
+        # Fields
+        for field in data.get("fields", []):
+            writer.writerow(
+                [
+                    "Field",
+                    str(field.get("name", "")),
+                    f"{str(field.get('name', ''))}:{str(field.get('type', ''))}",
+                    str(field.get("visibility", "")),
+                    f"{field.get('line_range', {}).get('start', 0)}-{field.get('line_range', {}).get('end', 0)}",
+                    "",
+                    self._clean_csv_text(
+                        self._extract_doc_summary(str(field.get("javadoc", "")))
+                    ),
+                ]
+            )
+
+        # Methods
+        for method in data.get("methods", []):
+            writer.writerow(
+                [
+                    "Constructor" if method.get("is_constructor", False) else "Method",
+                    str(method.get("name", "")),
+                    self._clean_csv_text(self._create_full_signature(method)),
+                    str(method.get("visibility", "")),
+                    f"{method.get('line_range', {}).get('start', 0)}-{method.get('line_range', {}).get('end', 0)}",
+                    method.get("complexity_score", 0),
+                    self._clean_csv_text(
+                        self._extract_doc_summary(str(method.get("javadoc", "")))
+                    ),
+                ]
+            )
+
+        csv_content = output.getvalue()
+        csv_content = csv_content.replace("\r\n", "\n").replace("\r", "\n")
+        csv_content = csv_content.rstrip("\n")
+        output.close()
+
+        return csv_content
+
+    # Common helper methods
+    def _create_full_signature(self, method: dict[str, Any]) -> str:
+        """Create complete method signature"""
+        params = method.get("parameters", [])
+        param_strs = []
+        for param in params:
+            if isinstance(param, dict):
+                param_type = str(param.get("type", "Object"))
+                param_name = str(param.get("name", "param"))
+                param_strs.append(f"{param_name}:{param_type}")
+            else:
+                param_strs.append(str(param))
+
+        params_str = ", ".join(param_strs)
+        return_type = str(method.get("return_type", "void"))
+
+        modifiers = []
+        if method.get("is_static", False):
+            modifiers.append("[static]")
+
+        modifier_str = " ".join(modifiers)
+        signature = f"({params_str}):{return_type}"
+
+        if modifier_str:
+            signature += f" {modifier_str}"
+
+        return signature
+
+    def _convert_visibility(self, visibility: str) -> str:
+        """Convert visibility to symbol"""
+        mapping = {"public": "+", "private": "-", "protected": "#", "package": "~"}
+        return mapping.get(visibility, visibility)
+
+    def _extract_doc_summary(self, javadoc: str) -> str:
+        """Extract summary from documentation"""
+        if not javadoc:
+            return "-"
+
+        # Remove comment symbols
+        clean_doc = (
+            javadoc.replace("/**", "").replace("*/", "").replace("*", "").strip()
+        )
+
+        # Get first line
+        lines = clean_doc.split("\n")
+        first_line = lines[0].strip()
+
+        # Truncate if too long
+        if len(first_line) > 50:
+            first_line = first_line[:47] + "..."
+
+        return first_line.replace("|", "\\|").replace("\n", " ")
+
+    def _clean_csv_text(self, text: str) -> str:
+        """Text cleaning for CSV format"""
+        if not text:
+            return ""
+
+        cleaned = text.replace("\r\n", " ").replace("\r", " ").replace("\n", " ")
+        cleaned = " ".join(cleaned.split())
+        cleaned = cleaned.replace('"', '""')
+
+        return cleaned

tree_sitter_analyzer/formatters/formatter_factory.py

@@ -1,78 +1,78 @@
-#!/usr/bin/env python3
-"""
-Factory for creating language-specific table formatters.
-"""
-
-from .base_formatter import BaseTableFormatter
-from .java_formatter import JavaTableFormatter
-from .python_formatter import PythonTableFormatter
-
-
-class TableFormatterFactory:
-    """Factory for creating language-specific table formatters"""
-
-    _formatters: dict[str, type[BaseTableFormatter]] = {
-        "java": JavaTableFormatter,
-        "python": PythonTableFormatter,
-    }
-
-    @classmethod
-    def create_formatter(
-        cls, language: str, format_type: str = "full"
-    ) -> BaseTableFormatter:
-        """
-        Create table formatter for specified language
-
-        Args:
-            language: Programming language name
-            format_type: Format type (full, compact, csv)
-
-        Returns:
-            Language-specific table formatter
-        """
-        formatter_class = cls._formatters.get(language.lower())
-
-        if formatter_class is None:
-            # Use Java formatter as default
-            formatter_class = JavaTableFormatter
-
-        return formatter_class(format_type)
-
-    @classmethod
-    def register_formatter(
-        cls, language: str, formatter_class: type[BaseTableFormatter]
-    ) -> 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())
-
-
-def create_table_formatter(
-    format_type: str, language: str = "java"
-) -> BaseTableFormatter:
-    """
-    Create table formatter (function for compatibility)
-
-    Args:
-        format_type: Format type
-        language: Programming language name
-
-    Returns:
-        Table formatter
-    """
-    return TableFormatterFactory.create_formatter(language, format_type)
+#!/usr/bin/env python3
+"""
+Factory for creating language-specific table formatters.
+"""
+
+from .base_formatter import BaseTableFormatter
+from .java_formatter import JavaTableFormatter
+from .python_formatter import PythonTableFormatter
+
+
+class TableFormatterFactory:
+    """Factory for creating language-specific table formatters"""
+
+    _formatters: dict[str, type[BaseTableFormatter]] = {
+        "java": JavaTableFormatter,
+        "python": PythonTableFormatter,
+    }
+
+    @classmethod
+    def create_formatter(
+        cls, language: str, format_type: str = "full"
+    ) -> BaseTableFormatter:
+        """
+        Create table formatter for specified language
+
+        Args:
+            language: Programming language name
+            format_type: Format type (full, compact, csv)
+
+        Returns:
+            Language-specific table formatter
+        """
+        formatter_class = cls._formatters.get(language.lower())
+
+        if formatter_class is None:
+            # Use Java formatter as default
+            formatter_class = JavaTableFormatter
+
+        return formatter_class(format_type)
+
+    @classmethod
+    def register_formatter(
+        cls, language: str, formatter_class: type[BaseTableFormatter]
+    ) -> 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())
+
+
+def create_table_formatter(
+    format_type: str, language: str = "java"
+) -> BaseTableFormatter:
+    """
+    Create table formatter (function for compatibility)
+
+    Args:
+        format_type: Format type
+        language: Programming language name
+
+    Returns:
+        Table formatter
+    """
+    return TableFormatterFactory.create_formatter(language, format_type)

tree_sitter_analyzer/formatters/java_formatter.py

@@ -9,22 +9,22 @@ from .base_formatter import BaseTableFormatter
 
 
 class JavaTableFormatter(BaseTableFormatter):
-    """Java言語専用のテーブルフォーマッター"""
+    """Table formatter specialized for Java"""
 
     def _format_full_table(self, data: dict[str, Any]) -> str:
-        """Java用完全版テーブル形式"""
+        """Full table format for Java"""
         lines = []
 
-        # ヘッダー - Java用（複数クラス対応）
+        # Header - Java (multi-class supported)
         classes = data.get("classes", [])
         package_name = (data.get("package") or {}).get("name", "unknown")
 
         if len(classes) > 1:
-            # 複数クラスがある場合はファイル名を使用
+            # If multiple classes exist, use filename
             file_name = data.get("file_path", "Unknown").split("/")[-1].split("\\")[-1]
             lines.append(f"# {package_name}.{file_name}")
         else:
-            # 単一クラスの場合は従来通り
+            # Single class: use class name
             class_name = classes[0].get("name", "Unknown") if classes else "Unknown"
             lines.append(f"# {package_name}.{class_name}")
         lines.append("")
@@ -39,7 +39,7 @@ class JavaTableFormatter(BaseTableFormatter):
             lines.append("```")
             lines.append("")
 
-        # Class Info - Java用（複数クラス対応）
+        # Class Info - Java (multi-class aware)
         if len(classes) > 1:
             lines.append("## Classes")
             lines.append("| Class | Type | Visibility | Lines | Methods | Fields |")
@@ -52,7 +52,7 @@ class JavaTableFormatter(BaseTableFormatter):
                 line_range = class_info.get("line_range", {})
                 lines_str = f"{line_range.get('start', 0)}-{line_range.get('end', 0)}"
 
-                # このクラスのメソッド数とフィールド数を計算
+                # Count methods/fields within the class range
                 class_methods = [
                     m
                     for m in data.get("methods", [])
@@ -72,7 +72,7 @@ class JavaTableFormatter(BaseTableFormatter):
                     f"| {name} | {class_type} | {visibility} | {lines_str} | {len(class_methods)} | {len(class_fields)} |"
                 )
         else:
-            # 単一クラスの場合は従来通り
+            # Single class details
             lines.append("## Class Info")
             lines.append("| Property | Value |")
             lines.append("|----------|-------|")
@@ -159,24 +159,24 @@ class JavaTableFormatter(BaseTableFormatter):
                 lines.append(self._format_method_row(method))
             lines.append("")
 
-        # 末尾の空行を削除
+        # Trim trailing blank lines
         while lines and lines[-1] == "":
             lines.pop()
 
         return "\n".join(lines)
 
     def _format_compact_table(self, data: dict[str, Any]) -> str:
-        """Java用コンパクト版テーブル形式"""
+        """Compact table format for Java"""
         lines = []
 
-        # ヘッダー
+        # Header
         package_name = (data.get("package") or {}).get("name", "unknown")
         classes = data.get("classes", [])
         class_name = classes[0].get("name", "Unknown") if classes else "Unknown"
         lines.append(f"# {package_name}.{class_name}")
         lines.append("")
 
-        # 基本情報
+        # Info
         stats = data.get("statistics") or {}
         lines.append("## Info")
         lines.append("| Property | Value |")
@@ -186,7 +186,7 @@ class JavaTableFormatter(BaseTableFormatter):
         lines.append(f"| Fields | {stats.get('field_count', 0)} |")
         lines.append("")
 
-        # メソッド（簡略版）
+        # Methods (compact)
         methods = data.get("methods", [])
         if methods:
             lines.append("## Methods")
@@ -209,20 +209,20 @@ class JavaTableFormatter(BaseTableFormatter):
                 )
             lines.append("")
 
-        # 末尾の空行を削除
+        # Trim trailing blank lines
         while lines and lines[-1] == "":
             lines.pop()
 
         return "\n".join(lines)
 
     def _format_method_row(self, method: dict[str, Any]) -> str:
-        """Java用メソッド行のフォーマット"""
+        """Format a method table row for Java"""
         name = str(method.get("name", ""))
         signature = self._create_full_signature(method)
         visibility = self._convert_visibility(str(method.get("visibility", "")))
         line_range = method.get("line_range", {})
         lines_str = f"{line_range.get('start', 0)}-{line_range.get('end', 0)}"
-        cols_str = "5-6"  # デフォルト値
+        cols_str = "5-6"  # default placeholder
         complexity = method.get("complexity_score", 0)
         doc = self._clean_csv_text(
             self._extract_doc_summary(str(method.get("javadoc", "")))
@@ -231,7 +231,7 @@ class JavaTableFormatter(BaseTableFormatter):
         return f"| {name} | {signature} | {visibility} | {lines_str} | {cols_str} | {complexity} | {doc} |"
 
     def _create_compact_signature(self, method: dict[str, Any]) -> str:
-        """Java用コンパクトなメソッドシグネチャを作成"""
+        """Create compact method signature for Java"""
         params = method.get("parameters", [])
         param_types = [
             self._shorten_type(p.get("type", "O") if isinstance(p, dict) else str(p))
@@ -243,7 +243,7 @@ class JavaTableFormatter(BaseTableFormatter):
         return f"({params_str}):{return_type}"
 
     def _shorten_type(self, type_name: Any) -> str:
-        """Java用型名を短縮"""
+        """Shorten type name for Java tables"""
         if type_name is None:
             return "O"