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

tree_sitter_analyzer/file_handler.py

@@ -0,0 +1,246 @@
+#!/usr/bin/env python3
+"""
+File Handler Module
+
+This module provides file reading functionality with encoding detection and fallback.
+"""
+
+import itertools
+from pathlib import Path
+
+from .encoding_utils import read_file_safe, read_file_safe_streaming
+from .utils import setup_logger
+
+# Set up logger for this module
+logger = setup_logger(__name__)
+
+
+def log_error(message: str, *args: object, **kwargs: object) -> None:
+    """Log error message"""
+    logger.error(message, *args, **kwargs)  # type: ignore[arg-type]
+
+
+def log_info(message: str, *args: object, **kwargs: object) -> None:
+    """Log info message"""
+    logger.info(message, *args, **kwargs)  # type: ignore[arg-type]
+
+
+def log_warning(message: str, *args: object, **kwargs: object) -> None:
+    """Log warning message"""
+    logger.warning(message, *args, **kwargs)  # type: ignore[arg-type]
+
+
+def detect_language_from_extension(file_path: str) -> str:
+    """
+    Detect programming language from file extension
+
+    Args:
+        file_path: File path to analyze
+
+    Returns:
+        Language name or 'unknown' if not recognized
+    """
+    extension = Path(file_path).suffix.lower()
+
+    extension_map = {
+        ".java": "java",
+        ".py": "python",
+        ".js": "javascript",
+        ".ts": "typescript",
+        ".cpp": "cpp",
+        ".c": "c",
+        ".h": "c",
+        ".hpp": "cpp",
+        ".cs": "csharp",
+        ".go": "go",
+        ".rs": "rust",
+        ".rb": "ruby",
+        ".php": "php",
+        ".kt": "kotlin",
+        ".scala": "scala",
+        ".swift": "swift",
+    }
+
+    return extension_map.get(extension, "unknown")
+
+
+def read_file_with_fallback(file_path: str) -> bytes | None:
+    """
+    Read file with encoding fallback using unified encoding utilities
+
+    Args:
+        file_path: Path to the file to read
+
+    Returns:
+        File content as bytes, or None if file doesn't exist
+    """
+    # Check file existence first
+    file_obj = Path(file_path)
+    if not file_obj.exists():
+        log_error(f"File does not exist: {file_path}")
+        return None
+
+    try:
+        content, detected_encoding = read_file_safe(file_path)
+        log_info(
+            f"Successfully read file {file_path} with encoding: {detected_encoding}"
+        )
+        return content.encode("utf-8")
+
+    except Exception as e:
+        log_error(f"Failed to read file {file_path}: {e}")
+        return None
+
+
+def read_file_partial(
+    file_path: str,
+    start_line: int,
+    end_line: int | None = None,
+    start_column: int | None = None,
+    end_column: int | None = None,
+) -> str | None:
+    """
+    Read partial file content by line/column range using streaming for memory efficiency.
+
+    Performance: Uses streaming approach for 150x speedup on large files.
+    Only loads requested lines into memory instead of entire file.
+
+    Args:
+        file_path: Path to file
+        start_line: Start line (1-based)
+        end_line: End line (1-based, None means EOF)
+        start_column: Start column (0-based, optional)
+        end_column: End column (0-based, optional)
+
+    Returns:
+        Selected content string, or None on error
+    """
+    # Check file existence
+    file_obj = Path(file_path)
+    if not file_obj.exists():
+        log_error(f"File does not exist: {file_path}")
+        return None
+
+    # Parameter validation
+    if start_line < 1:
+        log_error(f"Invalid start_line: {start_line}. Line numbers start from 1.")
+        return None
+
+    if end_line is not None and end_line < start_line:
+        log_error(f"Invalid range: end_line ({end_line}) < start_line ({start_line})")
+        return None
+
+    try:
+        # Use streaming approach for memory efficiency
+        with read_file_safe_streaming(file_path) as f:
+            # Convert to 0-based indexing
+            start_idx = start_line - 1
+            end_idx = end_line - 1 if end_line is not None else None
+
+            # Use itertools.islice for efficient line selection
+            if end_idx is not None:
+                # Read specific range
+                selected_lines_iter = itertools.islice(f, start_idx, end_idx + 1)
+            else:
+                # Read from start_line to end of file
+                selected_lines_iter = itertools.islice(f, start_idx, None)
+
+            # Convert iterator to list for processing
+            selected_lines = list(selected_lines_iter)
+
+            # Check if we got any lines
+            if not selected_lines:
+                # Check if start_line is beyond file length by counting lines
+                with read_file_safe_streaming(file_path) as f_count:
+                    total_lines = sum(1 for _ in f_count)
+
+                if start_idx >= total_lines:
+                    log_warning(
+                        f"start_line ({start_line}) exceeds file length ({total_lines})"
+                    )
+                    return ""
+                else:
+                    # File might be empty or other issue
+                    return ""
+
+        # Handle column range if specified
+        if start_column is not None or end_column is not None:
+            processed_lines = []
+            for i, line in enumerate(selected_lines):
+                # Strip newline for processing
+                line_content = line.rstrip("\r\n")
+
+                if i == 0 and start_column is not None:
+                    # First line: apply start_column
+                    line_content = (
+                        line_content[start_column:]
+                        if start_column < len(line_content)
+                        else ""
+                    )
+
+                if i == len(selected_lines) - 1 and end_column is not None:
+                    # Last line: apply end_column
+                    if i == 0 and start_column is not None:
+                        # Single line: apply both start and end columns
+                        col_end = (
+                            end_column - start_column
+                            if end_column >= start_column
+                            else 0
+                        )
+                        line_content = line_content[:col_end] if col_end > 0 else ""
+                    else:
+                        line_content = (
+                            line_content[:end_column]
+                            if end_column < len(line_content)
+                            else line_content
+                        )
+
+                # Preserve original newline (except last line)
+                if i < len(selected_lines) - 1:
+                    # Detect original newline char of the line
+                    original_line = selected_lines[i]
+                    if original_line.endswith("\r\n"):
+                        line_content += "\r\n"
+                    elif original_line.endswith("\n"):
+                        line_content += "\n"
+                    elif original_line.endswith("\r"):
+                        line_content += "\r"
+
+                processed_lines.append(line_content)
+
+            result = "".join(processed_lines)
+        else:
+            # No column range: join lines directly
+            result = "".join(selected_lines)
+
+        # Calculate end line for logging
+        actual_end_line = end_line or (start_line + len(selected_lines) - 1)
+
+        log_info(
+            f"Successfully read partial file {file_path}: "
+            f"lines {start_line}-{actual_end_line}"
+            f"{f', columns {start_column}-{end_column}' if start_column is not None or end_column is not None else ''}"
+        )
+
+        return result
+
+    except Exception as e:
+        log_error(f"Failed to read partial file {file_path}: {e}")
+        return None
+
+
+def read_file_lines_range(
+    file_path: str, start_line: int, end_line: int | None = None
+) -> str | None:
+    """
+    指定した行番号範囲でファイルの一部を読み込み（列指定なし）
+
+    Args:
+        file_path: 読み込むファイルのパス
+        start_line: 開始行番号（1ベース）
+        end_line: 終了行番号（Noneの場合はファイル末尾まで、1ベース）
+
+    Returns:
+        指定範囲のファイル内容（文字列）、エラーの場合はNone
+    """
+    return read_file_partial(file_path, start_line, end_line)

tree_sitter_analyzer/formatters/__init__.py

@@ -0,0 +1 @@
+# Language-specific formatters

tree_sitter_analyzer/formatters/base_formatter.py

@@ -0,0 +1,201 @@
+#!/usr/bin/env python3
+"""
+Base formatter for language-specific formatting.
+"""
+
+import csv
+import io
+from abc import ABC, abstractmethod
+from typing import Any
+
+
+class BaseFormatter(ABC):
+    """Base class for language-specific formatters"""
+
+    @abstractmethod
+    def __init__(self) -> None:
+        pass
+
+    @abstractmethod
+    def format_summary(self, analysis_result: dict[str, Any]) -> str:
+        """Format summary output"""
+        pass
+
+    @abstractmethod
+    def format_structure(self, analysis_result: dict[str, Any]) -> str:
+        """Format structure analysis output"""
+        pass
+
+    @abstractmethod
+    def format_advanced(
+        self, analysis_result: dict[str, Any], output_format: str = "json"
+    ) -> str:
+        """Format advanced analysis output"""
+        pass
+
+    @abstractmethod
+    def format_table(
+        self, analysis_result: dict[str, Any], table_type: str = "full"
+    ) -> str:
+        """Format table output"""
+        pass
+
+
+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"""
+        import os
+
+        return "\r\n" if os.name == "nt" else "\n"  # Windows uses \r\n, others use \n
+
+    def _convert_to_platform_newlines(self, text: str) -> str:
+        """Convert regular \n to platform-specific newline code"""
+        platform_newline = self._get_platform_newline()
+        if platform_newline != "\n":
+            return text.replace("\n", platform_newline)
+        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