tree-sitter-analyzer 1.8.3__py3-none-any.whl → 1.9.0__py3-none-any.whl

tree_sitter_analyzer/formatters/formatter_registry.py

@@ -8,7 +8,6 @@ Provides extensible formatter architecture following the Registry pattern.
 
 import logging
 from abc import ABC, abstractmethod
-from typing import Any
 
 from ..models import CodeElement
 
@@ -18,7 +17,7 @@ logger = logging.getLogger(__name__)
 class IFormatter(ABC):
     """
     Interface for code element formatters.
-    
+
     All formatters must implement this interface to be compatible
     with the FormatterRegistry system.
     """
@@ -28,7 +27,7 @@ class IFormatter(ABC):
     def get_format_name() -> str:
         """
         Return the format name this formatter supports.
-        
+
         Returns:
             Format name (e.g., "json", "csv", "markdown")
         """
@@ -38,10 +37,10 @@ class IFormatter(ABC):
     def format(self, elements: list[CodeElement]) -> str:
         """
         Format a list of CodeElements into a string representation.
-        
+
         Args:
             elements: List of CodeElement objects to format
-            
+
         Returns:
             Formatted string representation
         """
@@ -51,7 +50,7 @@ class IFormatter(ABC):
 class FormatterRegistry:
     """
     Registry for managing and providing formatter instances.
-    
+
     Implements the Registry pattern to allow dynamic registration
     and retrieval of formatters by format name.
     """
@@ -62,23 +61,23 @@ class FormatterRegistry:
     def register_formatter(cls, formatter_class: type[IFormatter]) -> None:
         """
         Register a formatter class in the registry.
-        
+
         Args:
             formatter_class: Formatter class implementing IFormatter
-            
+
         Raises:
             ValueError: If formatter_class doesn't implement IFormatter
         """
         if not issubclass(formatter_class, IFormatter):
-            raise ValueError(f"Formatter class must implement IFormatter interface")
-        
+            raise ValueError("Formatter class must implement IFormatter interface")
+
         format_name = formatter_class.get_format_name()
         if not format_name:
             raise ValueError("Formatter must provide a non-empty format name")
-        
+
         if format_name in cls._formatters:
             logger.warning(f"Overriding existing formatter for format: {format_name}")
-        
+
         cls._formatters[format_name] = formatter_class
         logger.debug(f"Registered formatter for format: {format_name}")
 
@@ -86,13 +85,13 @@ class FormatterRegistry:
     def get_formatter(cls, format_name: str) -> IFormatter:
         """
         Get a formatter instance for the specified format.
-        
+
         Args:
             format_name: Name of the format to get formatter for
-            
+
         Returns:
             Formatter instance
-            
+
         Raises:
             ValueError: If format is not supported
         """
@@ -102,7 +101,7 @@ class FormatterRegistry:
                 f"Unsupported format: {format_name}. "
                 f"Available formats: {available_formats}"
             )
-        
+
         formatter_class = cls._formatters[format_name]
         return formatter_class()
 
@@ -110,7 +109,7 @@ class FormatterRegistry:
     def get_available_formats(cls) -> list[str]:
         """
         Get list of all available format names.
-        
+
         Returns:
             List of available format names
         """
@@ -120,10 +119,10 @@ class FormatterRegistry:
     def is_format_supported(cls, format_name: str) -> bool:
         """
         Check if a format is supported.
-        
+
         Args:
             format_name: Format name to check
-            
+
         Returns:
             True if format is supported
         """
@@ -133,10 +132,10 @@ class FormatterRegistry:
     def unregister_formatter(cls, format_name: str) -> bool:
         """
         Unregister a formatter for the specified format.
-        
+
         Args:
             format_name: Format name to unregister
-            
+
         Returns:
             True if formatter was unregistered, False if not found
         """
@@ -150,7 +149,7 @@ class FormatterRegistry:
     def clear_registry(cls) -> None:
         """
         Clear all registered formatters.
-        
+
         This method is primarily for testing purposes.
         """
         cls._formatters.clear()
@@ -159,6 +158,7 @@ class FormatterRegistry:
 
 # Built-in formatter implementations
 
+
 class JsonFormatter(IFormatter):
     """JSON formatter for CodeElement lists"""
 
@@ -169,7 +169,7 @@ class JsonFormatter(IFormatter):
     def format(self, elements: list[CodeElement]) -> str:
         """Format elements as JSON"""
         import json
-        
+
         result = []
         for element in elements:
             element_dict = {
@@ -179,7 +179,7 @@ class JsonFormatter(IFormatter):
                 "end_line": element.end_line,
                 "language": element.language,
             }
-            
+
             # Add type-specific attributes
             if hasattr(element, "parameters"):
                 element_dict["parameters"] = getattr(element, "parameters", [])
@@ -195,9 +195,9 @@ class JsonFormatter(IFormatter):
                 element_dict["selector"] = getattr(element, "selector", "")
             if hasattr(element, "element_class"):
                 element_dict["element_class"] = getattr(element, "element_class", "")
-            
+
             result.append(element_dict)
-        
+
         return json.dumps(result, indent=2, ensure_ascii=False)
 
 
@@ -212,30 +212,41 @@ class CsvFormatter(IFormatter):
         """Format elements as CSV"""
         import csv
         import io
-        
+
         output = io.StringIO()
         writer = csv.writer(output, lineterminator="\n")
-        
+
         # Write header
-        writer.writerow([
-            "Type", "Name", "Start Line", "End Line", "Language", 
-            "Visibility", "Parameters", "Return Type", "Modifiers"
-        ])
-        
+        writer.writerow(
+            [
+                "Type",
+                "Name",
+                "Start Line",
+                "End Line",
+                "Language",
+                "Visibility",
+                "Parameters",
+                "Return Type",
+                "Modifiers",
+            ]
+        )
+
         # Write data rows
         for element in elements:
-            writer.writerow([
-                getattr(element, "element_type", "unknown"),
-                element.name,
-                element.start_line,
-                element.end_line,
-                element.language,
-                getattr(element, "visibility", ""),
-                str(getattr(element, "parameters", [])),
-                getattr(element, "return_type", ""),
-                str(getattr(element, "modifiers", []))
-            ])
-        
+            writer.writerow(
+                [
+                    getattr(element, "element_type", "unknown"),
+                    element.name,
+                    element.start_line,
+                    element.end_line,
+                    element.language,
+                    getattr(element, "visibility", ""),
+                    str(getattr(element, "parameters", [])),
+                    getattr(element, "return_type", ""),
+                    str(getattr(element, "modifiers", [])),
+                ]
+            )
+
         csv_content = output.getvalue()
         output.close()
         return csv_content.rstrip("\n")
@@ -252,13 +263,13 @@ class FullFormatter(IFormatter):
         """Format elements as full table"""
         if not elements:
             return "No elements found."
-        
+
         lines = []
         lines.append("=" * 80)
         lines.append("CODE STRUCTURE ANALYSIS")
         lines.append("=" * 80)
         lines.append("")
-        
+
         # Group elements by type
         element_groups: dict[str, list[CodeElement]] = {}
         for element in elements:
@@ -266,32 +277,36 @@ class FullFormatter(IFormatter):
             if element_type not in element_groups:
                 element_groups[element_type] = []
             element_groups[element_type].append(element)
-        
+
         # Format each group
         for element_type, group_elements in element_groups.items():
             lines.append(f"{element_type.upper()}S ({len(group_elements)})")
             lines.append("-" * 40)
-            
+
             for element in group_elements:
                 lines.append(f"  {element.name}")
                 lines.append(f"    Lines: {element.start_line}-{element.end_line}")
                 lines.append(f"    Language: {element.language}")
-                
+
                 if hasattr(element, "visibility"):
-                    lines.append(f"    Visibility: {getattr(element, 'visibility', 'unknown')}")
+                    lines.append(
+                        f"    Visibility: {getattr(element, 'visibility', 'unknown')}"
+                    )
                 if hasattr(element, "parameters"):
                     params = getattr(element, "parameters", [])
                     if params:
-                        lines.append(f"    Parameters: {', '.join(str(p) for p in params)}")
+                        lines.append(
+                            f"    Parameters: {', '.join(str(p) for p in params)}"
+                        )
                 if hasattr(element, "return_type"):
                     ret_type = getattr(element, "return_type", None)
                     if ret_type:
                         lines.append(f"    Return Type: {ret_type}")
-                
+
                 lines.append("")
-            
+
             lines.append("")
-        
+
         return "\n".join(lines)
 
 
@@ -306,29 +321,24 @@ class CompactFormatter(IFormatter):
         """Format elements in compact format"""
         if not elements:
             return "No elements found."
-        
+
         lines = []
         lines.append("CODE ELEMENTS")
         lines.append("-" * 20)
-        
+
         for element in elements:
             element_type = getattr(element, "element_type", "unknown")
             visibility = getattr(element, "visibility", "")
             vis_symbol = self._get_visibility_symbol(visibility)
-            
+
             line = f"{vis_symbol} {element.name} ({element_type}) [{element.start_line}-{element.end_line}]"
             lines.append(line)
-        
+
         return "\n".join(lines)
 
     def _get_visibility_symbol(self, visibility: str) -> str:
         """Get symbol for visibility"""
-        mapping = {
-            "public": "+",
-            "private": "-", 
-            "protected": "#",
-            "package": "~"
-        }
+        mapping = {"public": "+", "private": "-", "protected": "#", "package": "~"}
         return mapping.get(visibility, "?")
 
 
@@ -339,10 +349,15 @@ def register_builtin_formatters() -> None:
     FormatterRegistry.register_formatter(CsvFormatter)
     FormatterRegistry.register_formatter(FullFormatter)
     FormatterRegistry.register_formatter(CompactFormatter)
-    
+
     # Register HTML formatters if available
     try:
-        from .html_formatter import HtmlFormatter, HtmlJsonFormatter, HtmlCompactFormatter
+        from .html_formatter import (
+            HtmlCompactFormatter,
+            HtmlFormatter,
+            HtmlJsonFormatter,
+        )
+
         FormatterRegistry.register_formatter(HtmlFormatter)
         FormatterRegistry.register_formatter(HtmlJsonFormatter)
         FormatterRegistry.register_formatter(HtmlCompactFormatter)
@@ -352,4 +367,4 @@ def register_builtin_formatters() -> None:
 
 
 # Auto-register built-in formatters when module is imported
-register_builtin_formatters()
+register_builtin_formatters()