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

tree_sitter_analyzer/cli/commands/summary_command.py

@@ -0,0 +1,93 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Summary Command
+
+Handles summary functionality with specified element types.
+"""
+from typing import TYPE_CHECKING
+
+from ...output_manager import output_data, output_json, output_section
+from .base_command import BaseCommand
+
+if TYPE_CHECKING:
+    from ...models import AnalysisResult
+
+
+class SummaryCommand(BaseCommand):
+    """Command for summary analysis with specified element types."""
+
+    async def execute_async(self, language: str) -> int:
+        analysis_result = await self.analyze_file(language)
+        if not analysis_result:
+            return 1
+
+        self._output_summary_analysis(analysis_result)
+        return 0
+
+    def _output_summary_analysis(self, analysis_result: "AnalysisResult") -> None:
+        """Output summary analysis results."""
+        output_section("要約結果")
+        
+        # Get summary types from args (default: classes,methods)
+        summary_types = getattr(self.args, 'summary', 'classes,methods')
+        if summary_types:
+            requested_types = [t.strip() for t in summary_types.split(',')]
+        else:
+            requested_types = ['classes', 'methods']
+        
+        # Extract elements by type
+        classes = [e for e in analysis_result.elements if e.__class__.__name__ == 'Class']
+        methods = [e for e in analysis_result.elements if e.__class__.__name__ == 'Function']
+        fields = [e for e in analysis_result.elements if e.__class__.__name__ == 'Variable']
+        imports = [e for e in analysis_result.elements if e.__class__.__name__ == 'Import']
+        
+        summary_data = {
+            'file_path': analysis_result.file_path,
+            'language': analysis_result.language,
+            'summary': {}
+        }
+        
+        if 'classes' in requested_types:
+            summary_data['summary']['classes'] = [
+                {'name': getattr(c, 'name', 'unknown')} for c in classes
+            ]
+        
+        if 'methods' in requested_types:
+            summary_data['summary']['methods'] = [
+                {'name': getattr(m, 'name', 'unknown')} for m in methods
+            ]
+        
+        if 'fields' in requested_types:
+            summary_data['summary']['fields'] = [
+                {'name': getattr(f, 'name', 'unknown')} for f in fields
+            ]
+        
+        if 'imports' in requested_types:
+            summary_data['summary']['imports'] = [
+                {'name': getattr(i, 'name', 'unknown')} for i in imports
+            ]
+        
+        if self.args.output_format == "json":
+            output_json(summary_data)
+        else:
+            self._output_text_format(summary_data, requested_types)
+            
+    def _output_text_format(self, summary_data: dict, requested_types: list) -> None:
+        """Output summary in human-readable text format."""
+        output_data(f"ファイル: {summary_data['file_path']}")
+        output_data(f"言語: {summary_data['language']}")
+        
+        for element_type in requested_types:
+            if element_type in summary_data['summary']:
+                elements = summary_data['summary'][element_type]
+                type_name_map = {
+                    'classes': 'クラス',
+                    'methods': 'メソッド', 
+                    'fields': 'フィールド',
+                    'imports': 'インポート'
+                }
+                type_name = type_name_map.get(element_type, element_type)
+                output_data(f"\n{type_name} ({len(elements)}個):")
+                for element in elements:
+                    output_data(f"  - {element['name']}") 

tree_sitter_analyzer/cli/commands/table_command.py

@@ -0,0 +1,233 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Table Command
+
+Handles table format output generation.
+"""
+
+import sys
+
+from ...output_manager import output_error
+from ...table_formatter import create_table_formatter
+from .base_command import BaseCommand
+
+
+class TableCommand(BaseCommand):
+    """Command for generating table format output."""
+
+    async def execute_async(self, language: str) -> int:
+        """Execute table format generation."""
+        try:
+            # Perform analysis
+            analysis_result = await self.analyze_file(language)
+            if not analysis_result:
+                return 1
+
+            # Convert analysis result to structure format
+            structure_result = self._convert_to_structure_format(
+                analysis_result, language
+            )
+
+            # Create table formatter
+            include_javadoc = getattr(self.args, "include_javadoc", False)
+            formatter = create_table_formatter(
+                self.args.table, language, include_javadoc
+            )
+            table_output = formatter.format_structure(structure_result)
+
+            # Output table
+            self._output_table(table_output)
+
+            return 0
+
+        except Exception as e:
+            output_error(f"ERROR: テーブル形式での解析でエラーが発生しました: {e}")
+            return 1
+
+    def _convert_to_structure_format(self, analysis_result, language: str) -> dict:
+        """Convert AnalysisResult to the format expected by table formatter."""
+        classes = []
+        methods = []
+        fields = []
+        imports = []
+        package_name = "unknown"
+
+        # Process each element
+        for i, element in enumerate(analysis_result.elements):
+            try:
+                element_type = getattr(element, "__class__", type(element)).__name__
+                element_name = getattr(element, "name", None)
+
+                if element_type == "Package":
+                    package_name = element_name
+                elif element_type == "Class":
+                    classes.append(self._convert_class_element(element, i))
+                elif element_type == "Function":
+                    methods.append(self._convert_function_element(element, language))
+                elif element_type == "Variable":
+                    fields.append(self._convert_variable_element(element, language))
+                elif element_type == "Import":
+                    imports.append(self._convert_import_element(element))
+
+            except Exception as element_error:
+                output_error(f"ERROR: Element {i} processing failed: {element_error}")
+                continue
+
+        return {
+            "file_path": analysis_result.file_path,
+            "language": analysis_result.language,
+            "line_count": analysis_result.line_count,
+            "package": {"name": package_name},
+            "classes": classes,
+            "methods": methods,
+            "fields": fields,
+            "imports": imports,
+            "statistics": {
+                "method_count": len(methods),
+                "field_count": len(fields),
+                "class_count": len(classes),
+                "import_count": len(imports),
+            },
+        }
+
+    def _convert_class_element(self, element, index: int) -> dict:
+        """Convert class element to table format."""
+        element_name = getattr(element, "name", None)
+        final_name = element_name if element_name else f"UnknownClass_{index}"
+
+        return {
+            "name": final_name,
+            "type": "class",
+            "visibility": "public",
+            "line_range": {
+                "start": getattr(element, "start_line", 0),
+                "end": getattr(element, "end_line", 0),
+            },
+        }
+
+    def _convert_function_element(self, element, language: str) -> dict:
+        """Convert function element to table format."""
+        # Process parameters based on language
+        params = getattr(element, "parameters", [])
+        processed_params = self._process_parameters(params, language)
+
+        # Get visibility
+        visibility = self._get_element_visibility(element)
+
+        # Get JavaDoc if enabled
+        include_javadoc = getattr(self.args, "include_javadoc", False)
+        javadoc = getattr(element, "docstring", "") or "" if include_javadoc else ""
+
+        return {
+            "name": getattr(element, "name", str(element)),
+            "visibility": visibility,
+            "return_type": getattr(element, "return_type", "Any"),
+            "parameters": processed_params,
+            "is_constructor": getattr(element, "is_constructor", False),
+            "is_static": getattr(element, "is_static", False),
+            "complexity_score": getattr(element, "complexity_score", 1),
+            "line_range": {
+                "start": getattr(element, "start_line", 0),
+                "end": getattr(element, "end_line", 0),
+            },
+            "javadoc": javadoc,
+        }
+
+    def _convert_variable_element(self, element, language: str) -> dict:
+        """Convert variable element to table format."""
+        # Get field type based on language
+        if language == "python":
+            field_type = getattr(element, "variable_type", "") or ""
+        else:
+            field_type = getattr(element, "variable_type", "") or getattr(
+                element, "field_type", ""
+            )
+
+        # Get visibility
+        field_visibility = self._get_element_visibility(element)
+
+        # Get JavaDoc if enabled
+        include_javadoc = getattr(self.args, "include_javadoc", False)
+        javadoc = getattr(element, "docstring", "") or "" if include_javadoc else ""
+
+        return {
+            "name": getattr(element, "name", str(element)),
+            "type": field_type,
+            "visibility": field_visibility,
+            "modifiers": getattr(element, "modifiers", []),
+            "line_range": {
+                "start": getattr(element, "start_line", 0),
+                "end": getattr(element, "end_line", 0),
+            },
+            "javadoc": javadoc,
+        }
+
+    def _convert_import_element(self, element) -> dict:
+        """Convert import element to table format."""
+        return {
+            "statement": getattr(element, "name", str(element)),
+            "name": getattr(element, "name", str(element)),
+        }
+
+    def _process_parameters(self, params, language: str) -> list:
+        """Process parameters based on language syntax."""
+        if isinstance(params, str):
+            param_list = []
+            if params.strip():
+                param_names = [p.strip() for p in params.split(",") if p.strip()]
+                param_list = [{"name": name, "type": "Any"} for name in param_names]
+            return param_list
+        elif isinstance(params, list):
+            param_list = []
+            for param in params:
+                if isinstance(param, str):
+                    param = param.strip()
+                    if language == "python":
+                        # Python format: "name: type"
+                        if ":" in param:
+                            parts = param.split(":", 1)
+                            param_name = parts[0].strip()
+                            param_type = parts[1].strip() if len(parts) > 1 else "Any"
+                            param_list.append({"name": param_name, "type": param_type})
+                        else:
+                            param_list.append({"name": param, "type": "Any"})
+                    else:
+                        # Java format: "Type name"
+                        last_space_idx = param.rfind(" ")
+                        if last_space_idx != -1:
+                            param_type = param[:last_space_idx].strip()
+                            param_name = param[last_space_idx + 1 :].strip()
+                            if param_type and param_name:
+                                param_list.append(
+                                    {"name": param_name, "type": param_type}
+                                )
+                            else:
+                                param_list.append({"name": param, "type": "Any"})
+                        else:
+                            param_list.append({"name": param, "type": "Any"})
+                elif isinstance(param, dict):
+                    param_list.append(param)
+                else:
+                    param_list.append({"name": str(param), "type": "Any"})
+            return param_list
+        else:
+            return []
+
+    def _get_element_visibility(self, element) -> str:
+        """Get element visibility."""
+        visibility = getattr(element, "visibility", "public")
+        if hasattr(element, "is_private") and getattr(element, "is_private", False):
+            visibility = "private"
+        elif hasattr(element, "is_public") and getattr(element, "is_public", False):
+            visibility = "public"
+        return visibility
+
+    def _output_table(self, table_output: str) -> None:
+        """Output the table with proper encoding."""
+        try:
+            # Windows対応: UTF-8エンコーディングで出力
+            sys.stdout.buffer.write(table_output.encode("utf-8"))
+        except (AttributeError, UnicodeEncodeError):
+            # フォールバック: 通常のprint
+            print(table_output, end="")

tree_sitter_analyzer/cli/info_commands.py

@@ -0,0 +1,121 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Information Commands for CLI
+
+Commands that display information without requiring file analysis.
+"""
+
+from abc import ABC, abstractmethod
+from argparse import Namespace
+
+from ..language_detector import detect_language_from_file, detector
+from ..output_manager import output_data, output_error, output_info, output_list
+from ..query_loader import query_loader
+
+
+class InfoCommand(ABC):
+    """Base class for information commands that don't require file analysis."""
+
+    def __init__(self, args: Namespace):
+        self.args = args
+
+    @abstractmethod
+    def execute(self) -> int:
+        """Execute the information command."""
+        pass
+
+
+class ListQueriesCommand(InfoCommand):
+    """Command to list available queries."""
+
+    def execute(self) -> int:
+        if self.args.language:
+            language = self.args.language
+        elif hasattr(self.args, "file_path") and self.args.file_path:
+            language = detect_language_from_file(self.args.file_path)
+        else:
+            output_list("サポートされている言語:")
+            for lang in query_loader.list_supported_languages():
+                output_list(f"  {lang}")
+                queries = query_loader.list_queries_for_language(lang)
+                for query_key in queries:
+                    description = (
+                        query_loader.get_query_description(lang, query_key)
+                        or "説明なし"
+                    )
+                    output_list(f"    {query_key:<20} - {description}")
+            return 0
+
+        output_list(f"利用可能なクエリキー ({language}):")
+        for query_key in query_loader.list_queries_for_language(language):
+            description = (
+                query_loader.get_query_description(language, query_key) or "説明なし"
+            )
+            output_list(f"  {query_key:<20} - {description}")
+        return 0
+
+
+class DescribeQueryCommand(InfoCommand):
+    """Command to describe a specific query."""
+
+    def execute(self) -> int:
+        if self.args.language:
+            language = self.args.language
+        elif hasattr(self.args, "file_path") and self.args.file_path:
+            language = detect_language_from_file(self.args.file_path)
+        else:
+            output_error(
+                "ERROR: クエリ説明表示には--languageまたは対象ファイルの指定が必要です"
+            )
+            return 1
+
+        try:
+            query_description = query_loader.get_query_description(
+                language, self.args.describe_query
+            )
+            query_content = query_loader.get_query(language, self.args.describe_query)
+
+            if query_description is None or query_content is None:
+                output_error(
+                    f"ERROR: クエリ '{self.args.describe_query}' が言語 '{language}' で見つかりません"
+                )
+                return 1
+
+            output_info(
+                f"クエリキー '{self.args.describe_query}' ({language}): {query_description}"
+            )
+            output_data(f"クエリ内容:\n{query_content}")
+        except ValueError as e:
+            output_error(f"ERROR: {e}")
+            return 1
+        return 0
+
+
+class ShowLanguagesCommand(InfoCommand):
+    """Command to show supported languages."""
+
+    def execute(self) -> int:
+        output_list("サポートされている言語:")
+        for language in detector.get_supported_languages():
+            info = detector.get_language_info(language)
+            extensions = ", ".join(info["extensions"][:5])
+            if len(info["extensions"]) > 5:
+                extensions += f", ... (他{len(info['extensions'])-5}個)"
+            output_list(f"  {language:<12} - 拡張子: {extensions}")
+        return 0
+
+
+class ShowExtensionsCommand(InfoCommand):
+    """Command to show supported extensions."""
+
+    def execute(self) -> int:
+        output_list("サポートされている拡張子:")
+        supported_extensions = detector.get_supported_extensions()
+        for i in range(0, len(supported_extensions), 8):
+            line = "  " + "  ".join(
+                f"{ext:<6}" for ext in supported_extensions[i : i + 8]
+            )
+            output_list(line)
+        output_info(f"\n合計 {len(supported_extensions)} 個の拡張子をサポート")
+        return 0