tree-sitter-analyzer 0.2.0__py3-none-any.whl → 0.4.0__py3-none-any.whl

tree_sitter_analyzer/cli/commands/query_command.py

@@ -1,82 +1,81 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-"""
-Query Command
-
-Handles query execution functionality.
-"""
-
-from ...output_manager import output_data, output_error, output_info, output_json
-from ...query_loader import query_loader
-from .base_command import BaseCommand
-
-
-class QueryCommand(BaseCommand):
-    """Command for executing queries."""
-
-    async def execute_async(self, language: str) -> int:
-        # Get the query to execute
-        query_to_execute = None
-
-        if hasattr(self.args, "query_key") and self.args.query_key:
-            try:
-                query_to_execute = query_loader.get_query(language, self.args.query_key)
-                if query_to_execute is None:
-                    output_error(
-                        f"ERROR: クエリ '{self.args.query_key}' が言語 '{language}' で見つかりません"
-                    )
-                    return 1
-            except ValueError as e:
-                output_error(f"ERROR: {e}")
-                return 1
-        elif hasattr(self.args, "query_string") and self.args.query_string:
-            query_to_execute = self.args.query_string
-
-        if not query_to_execute:
-            output_error("ERROR: クエリが指定されていません。")
-            return 1
-
-        # Perform analysis
-        analysis_result = await self.analyze_file(language)
-        if not analysis_result:
-            return 1
-
-        # Process query results
-        results = []
-        if hasattr(analysis_result, "query_results") and analysis_result.query_results:
-            results = analysis_result.query_results.get("captures", [])
-        else:
-            # Create basic results from elements
-            if hasattr(analysis_result, "elements") and analysis_result.elements:
-                for element in analysis_result.elements:
-                    results.append(
-                        {
-                            "capture_name": getattr(
-                                element, "__class__", type(element)
-                            ).__name__.lower(),
-                            "node_type": getattr(
-                                element, "__class__", type(element)
-                            ).__name__,
-                            "start_line": getattr(element, "start_line", 0),
-                            "end_line": getattr(element, "end_line", 0),
-                            "content": getattr(element, "name", str(element)),
-                        }
-                    )
-
-        # Output results
-        if results:
-            if self.args.output_format == "json":
-                output_json(results)
-            else:
-                for i, query_result in enumerate(results, 1):
-                    output_data(
-                        f"\n{i}. {query_result['capture_name']} ({query_result['node_type']})"
-                    )
-                    output_data(
-                        f"   位置: 行 {query_result['start_line']}-{query_result['end_line']}"
-                    )
-                    output_data(f"   内容:\n{query_result['content']}")
-        else:
-            output_info(f"\nINFO: クエリにマッチする結果は見つかりませんでした。")
-
-        return 0
+#!/usr/bin/env python3
+"""
+Query Command
+
+Handles query execution functionality.
+"""
+
+from ...output_manager import output_data, output_error, output_info, output_json
+from ...query_loader import query_loader
+from .base_command import BaseCommand
+
+
+class QueryCommand(BaseCommand):
+    """Command for executing queries."""
+
+    async def execute_async(self, language: str) -> int:
+        # Get the query to execute
+        query_to_execute = None
+
+        if hasattr(self.args, "query_key") and self.args.query_key:
+            try:
+                query_to_execute = query_loader.get_query(language, self.args.query_key)
+                if query_to_execute is None:
+                    output_error(
+                        f"ERROR: クエリ '{self.args.query_key}' が言語 '{language}' で見つかりません"
+                    )
+                    return 1
+            except ValueError as e:
+                output_error(f"ERROR: {e}")
+                return 1
+        elif hasattr(self.args, "query_string") and self.args.query_string:
+            query_to_execute = self.args.query_string
+
+        if not query_to_execute:
+            output_error("ERROR: クエリが指定されていません。")
+            return 1
+
+        # Perform analysis
+        analysis_result = await self.analyze_file(language)
+        if not analysis_result:
+            return 1
+
+        # Process query results
+        results = []
+        if hasattr(analysis_result, "query_results") and analysis_result.query_results:
+            results = analysis_result.query_results.get("captures", [])
+        else:
+            # Create basic results from elements
+            if hasattr(analysis_result, "elements") and analysis_result.elements:
+                for element in analysis_result.elements:
+                    results.append(
+                        {
+                            "capture_name": getattr(
+                                element, "__class__", type(element)
+                            ).__name__.lower(),
+                            "node_type": getattr(
+                                element, "__class__", type(element)
+                            ).__name__,
+                            "start_line": getattr(element, "start_line", 0),
+                            "end_line": getattr(element, "end_line", 0),
+                            "content": getattr(element, "name", str(element)),
+                        }
+                    )
+
+        # Output results
+        if results:
+            if self.args.output_format == "json":
+                output_json(results)
+            else:
+                for i, query_result in enumerate(results, 1):
+                    output_data(
+                        f"\n{i}. {query_result['capture_name']} ({query_result['node_type']})"
+                    )
+                    output_data(
+                        f"   位置: 行 {query_result['start_line']}-{query_result['end_line']}"
+                    )
+                    output_data(f"   内容:\n{query_result['content']}")
+        else:
+            output_info("\nINFO: クエリにマッチする結果は見つかりませんでした。")
+
+        return 0

tree_sitter_analyzer/cli/commands/structure_command.py

@@ -1,121 +1,138 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-"""
-Structure Command
-
-Handles structure analysis functionality with appropriate Japanese output.
-"""
-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 StructureCommand(BaseCommand):
-    """Command for structure analysis with Japanese output."""
-
-    async def execute_async(self, language: str) -> int:
-        analysis_result = await self.analyze_file(language)
-        if not analysis_result:
-            return 1
-
-        self._output_structure_analysis(analysis_result)
-        return 0
-
-    def _output_structure_analysis(self, analysis_result: "AnalysisResult") -> None:
-        """Output structure analysis results with appropriate Japanese header."""
-        output_section("Structure Analysis Results")
-        
-        # Convert to legacy structure format expected by tests
-        structure_dict = self._convert_to_legacy_format(analysis_result)
-        
-        if self.args.output_format == "json":
-            output_json(structure_dict)
-        else:
-            self._output_text_format(structure_dict)
-    
-    def _convert_to_legacy_format(self, analysis_result: "AnalysisResult") -> dict:
-        """Convert AnalysisResult to legacy structure format expected by tests."""
-        import time
-        
-        # 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']
-        packages = [e for e in analysis_result.elements if e.__class__.__name__ == 'Package']
-        
-        return {
-            'file_path': analysis_result.file_path,
-            'language': analysis_result.language,
-            'package': {
-                'name': packages[0].name,
-                'line_range': {
-                    'start': packages[0].start_line,
-                    'end': packages[0].end_line
-                }
-            } if packages else None,
-            'classes': [{'name': getattr(c, 'name', 'unknown')} for c in classes],
-            'methods': [{'name': getattr(m, 'name', 'unknown')} for m in methods],
-            'fields': [{'name': getattr(f, 'name', 'unknown')} for f in fields],
-            'imports': [{
-                'name': getattr(i, 'name', 'unknown'),
-                'is_static': getattr(i, 'is_static', False),
-                'is_wildcard': getattr(i, 'is_wildcard', False),
-                'statement': getattr(i, 'import_statement', ''),
-                'line_range': {
-                    'start': getattr(i, 'start_line', 0),
-                    'end': getattr(i, 'end_line', 0)
-                }
-            } for i in imports],
-            'annotations': [],
-            'statistics': {
-                'class_count': len(classes),
-                'method_count': len(methods),
-                'field_count': len(fields),
-                'import_count': len(imports),
-                'total_lines': analysis_result.line_count,
-                'annotation_count': 0
-            },
-            'analysis_metadata': {
-                'analysis_time': getattr(analysis_result, 'analysis_time', 0.0),
-                'language': analysis_result.language,
-                'file_path': analysis_result.file_path,
-                'analyzer_version': '2.0.0',
-                'timestamp': time.time()
-                         }
-         }
-    
-    def _output_text_format(self, structure_dict: dict) -> None:
-        """Output structure analysis in human-readable text format."""
-        output_data(f"File: {structure_dict['file_path']}")
-        output_data(f"Language: {structure_dict['language']}")
-        
-        if structure_dict['package']:
-            output_data(f"Package: {structure_dict['package']['name']}")
-        
-        stats = structure_dict['statistics']
-        output_data(f"Statistics:")
-        output_data(f"  Classes: {stats['class_count']}")
-        output_data(f"  Methods: {stats['method_count']}")
-        output_data(f"  Fields: {stats['field_count']}")
-        output_data(f"  Imports: {stats['import_count']}")
-        output_data(f"  Total lines: {stats['total_lines']}")
-        
-        if structure_dict['classes']:
-            output_data("Classes:")
-            for cls in structure_dict['classes']:
-                output_data(f"  - {cls['name']}")
-        
-        if structure_dict['methods']:
-            output_data("Methods:")
-            for method in structure_dict['methods']:
-                output_data(f"  - {method['name']}")
-        
-        if structure_dict['fields']:
-            output_data("Fields:")
-            for field in structure_dict['fields']:
-                output_data(f"  - {field['name']}") 
+#!/usr/bin/env python3
+"""
+Structure Command
+
+Handles structure analysis functionality with appropriate Japanese output.
+"""
+
+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 StructureCommand(BaseCommand):
+    """Command for structure analysis with Japanese output."""
+
+    async def execute_async(self, language: str) -> int:
+        analysis_result = await self.analyze_file(language)
+        if not analysis_result:
+            return 1
+
+        self._output_structure_analysis(analysis_result)
+        return 0
+
+    def _output_structure_analysis(self, analysis_result: "AnalysisResult") -> None:
+        """Output structure analysis results with appropriate Japanese header."""
+        output_section("Structure Analysis Results")
+
+        # Convert to legacy structure format expected by tests
+        structure_dict = self._convert_to_legacy_format(analysis_result)
+
+        if self.args.output_format == "json":
+            output_json(structure_dict)
+        else:
+            self._output_text_format(structure_dict)
+
+    def _convert_to_legacy_format(self, analysis_result: "AnalysisResult") -> dict:
+        """Convert AnalysisResult to legacy structure format expected by tests."""
+        import time
+
+        # 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"
+        ]
+        packages = [
+            e for e in analysis_result.elements if e.__class__.__name__ == "Package"
+        ]
+
+        return {
+            "file_path": analysis_result.file_path,
+            "language": analysis_result.language,
+            "package": (
+                {
+                    "name": packages[0].name,
+                    "line_range": {
+                        "start": packages[0].start_line,
+                        "end": packages[0].end_line,
+                    },
+                }
+                if packages
+                else None
+            ),
+            "classes": [{"name": getattr(c, "name", "unknown")} for c in classes],
+            "methods": [{"name": getattr(m, "name", "unknown")} for m in methods],
+            "fields": [{"name": getattr(f, "name", "unknown")} for f in fields],
+            "imports": [
+                {
+                    "name": getattr(i, "name", "unknown"),
+                    "is_static": getattr(i, "is_static", False),
+                    "is_wildcard": getattr(i, "is_wildcard", False),
+                    "statement": getattr(i, "import_statement", ""),
+                    "line_range": {
+                        "start": getattr(i, "start_line", 0),
+                        "end": getattr(i, "end_line", 0),
+                    },
+                }
+                for i in imports
+            ],
+            "annotations": [],
+            "statistics": {
+                "class_count": len(classes),
+                "method_count": len(methods),
+                "field_count": len(fields),
+                "import_count": len(imports),
+                "total_lines": analysis_result.line_count,
+                "annotation_count": 0,
+            },
+            "analysis_metadata": {
+                "analysis_time": getattr(analysis_result, "analysis_time", 0.0),
+                "language": analysis_result.language,
+                "file_path": analysis_result.file_path,
+                "analyzer_version": "2.0.0",
+                "timestamp": time.time(),
+            },
+        }
+
+    def _output_text_format(self, structure_dict: dict) -> None:
+        """Output structure analysis in human-readable text format."""
+        output_data(f"File: {structure_dict['file_path']}")
+        output_data(f"Language: {structure_dict['language']}")
+
+        if structure_dict["package"]:
+            output_data(f"Package: {structure_dict['package']['name']}")
+
+        stats = structure_dict["statistics"]
+        output_data("Statistics:")
+        output_data(f"  Classes: {stats['class_count']}")
+        output_data(f"  Methods: {stats['method_count']}")
+        output_data(f"  Fields: {stats['field_count']}")
+        output_data(f"  Imports: {stats['import_count']}")
+        output_data(f"  Total lines: {stats['total_lines']}")
+
+        if structure_dict["classes"]:
+            output_data("Classes:")
+            for cls in structure_dict["classes"]:
+                output_data(f"  - {cls['name']}")
+
+        if structure_dict["methods"]:
+            output_data("Methods:")
+            for method in structure_dict["methods"]:
+                output_data(f"  - {method['name']}")
+
+        if structure_dict["fields"]:
+            output_data("Fields:")
+            for field in structure_dict["fields"]:
+                output_data(f"  - {field['name']}")

tree_sitter_analyzer/cli/commands/summary_command.py

@@ -1,93 +1,101 @@
-#!/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("Summary Results")
-        
-        # 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"File: {summary_data['file_path']}")
-        output_data(f"Language: {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': 'Classes',
-                    'methods': 'Methods',
-                    'fields': 'Fields',
-                    'imports': 'Imports'
-                }
-                type_name = type_name_map.get(element_type, element_type)
-                output_data(f"\n{type_name} ({len(elements)} items):")
-                for element in elements:
-                    output_data(f"  - {element['name']}") 
+#!/usr/bin/env python3
+"""
+Summary Command
+
+Handles summary functionality with specified element types.
+"""
+
+from typing import TYPE_CHECKING, Any
+
+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("Summary Results")
+
+        # 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: dict[str, Any] = {
+            "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"File: {summary_data['file_path']}")
+        output_data(f"Language: {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": "Classes",
+                    "methods": "Methods",
+                    "fields": "Fields",
+                    "imports": "Imports",
+                }
+                type_name = type_name_map.get(element_type, element_type)
+                output_data(f"\n{type_name} ({len(elements)} items):")
+                for element in elements:
+                    output_data(f"  - {element['name']}")