reveal-cli 0.2.0__py3-none-any.whl

reveal/_archive_old_v0.1/analyzers/bash_analyzer.py

@@ -0,0 +1,202 @@
+"""
+Bash/Shell script analyzer using tree-sitter.
+
+Extracts:
+- Functions
+- Variables
+- Exported variables
+- Source/include statements
+"""
+
+from typing import Dict, Any, List
+from .treesitter_base import TreeSitterAnalyzer, TREE_SITTER_AVAILABLE
+from ..registry import register
+
+
+@register(['.sh', '.bash', '.zsh'], name='Bash', icon='🐚')
+class BashAnalyzer(TreeSitterAnalyzer):
+    """
+    Analyzer for Bash/Shell script files.
+
+    Features:
+    - Function definitions
+    - Variable assignments
+    - Exported variables
+    - Source statements
+
+    All positions are exact (tree-sitter preserves source locations).
+    """
+
+    language_name = 'bash'
+
+    def __init__(self, lines: List[str], **kwargs):
+        """Initialize Bash analyzer."""
+        self.node_type_map = {
+            'function': 'function_definition',
+        }
+        super().__init__(lines, **kwargs)
+
+    def extract_custom(self) -> Dict[str, List[Dict[str, Any]]]:
+        """Extract Bash-specific items."""
+        return {
+            'variables': self._extract_variables(),
+            'exports': self._extract_exports(),
+            'sources': self._extract_sources(),
+        }
+
+    def _extract_variables(self) -> List[Dict[str, Any]]:
+        """Extract variable assignments."""
+        if not self.tree:
+            return []
+
+        variables = []
+        cursor = self.tree.walk()
+
+        def visit(cursor):
+            node = cursor.node
+
+            if node.type == 'variable_assignment':
+                # Get variable name
+                name_node = node.child_by_field_name('name')
+                if name_node:
+                    line = node.start_point[0] + 1
+                    if self.in_focus_range(line):
+                        variables.append({
+                            'name': name_node.text.decode('utf-8'),
+                            'line': line
+                        })
+
+            # Recurse
+            if cursor.goto_first_child():
+                visit(cursor)
+                while cursor.goto_next_sibling():
+                    visit(cursor)
+                cursor.goto_parent()
+
+        visit(cursor)
+        return variables
+
+    def _extract_exports(self) -> List[Dict[str, Any]]:
+        """Extract export statements."""
+        if not self.tree:
+            return []
+
+        exports = []
+        cursor = self.tree.walk()
+
+        def visit(cursor):
+            node = cursor.node
+
+            if node.type == 'declaration_command':
+                # Check if it's an export
+                for child in node.children:
+                    if child.type == 'variable_assignment':
+                        name_node = child.child_by_field_name('name')
+                        if name_node:
+                            line = node.start_point[0] + 1
+                            if self.in_focus_range(line):
+                                exports.append({
+                                    'name': name_node.text.decode('utf-8'),
+                                    'line': line
+                                })
+
+            # Recurse
+            if cursor.goto_first_child():
+                visit(cursor)
+                while cursor.goto_next_sibling():
+                    visit(cursor)
+                cursor.goto_parent()
+
+        visit(cursor)
+        return exports
+
+    def _extract_sources(self) -> List[Dict[str, Any]]:
+        """Extract source/. statements."""
+        if not self.tree:
+            return []
+
+        sources = []
+        cursor = self.tree.walk()
+
+        def visit(cursor):
+            node = cursor.node
+
+            # Look for source command or . command
+            if node.type == 'command':
+                command_name = node.child_by_field_name('name')
+                if command_name:
+                    cmd_text = command_name.text.decode('utf-8')
+                    if cmd_text in ('source', '.'):
+                        # Get the sourced file
+                        full_text = node.text.decode('utf-8').strip()
+                        line = node.start_point[0] + 1
+                        if self.in_focus_range(line):
+                            sources.append({
+                                'name': full_text,
+                                'line': line
+                            })
+
+            # Recurse
+            if cursor.goto_first_child():
+                visit(cursor)
+                while cursor.goto_next_sibling():
+                    visit(cursor)
+                cursor.goto_parent()
+
+        visit(cursor)
+        return sources
+
+    def format_structure(self, structure: Dict[str, Any]) -> List[str]:
+        """
+        Custom formatting for Bash structure output.
+
+        Groups items logically:
+        1. Source statements
+        2. Functions
+        3. Exported variables
+        4. Variables
+        """
+        if not TREE_SITTER_AVAILABLE or 'error' in structure:
+            return None
+
+        lines = []
+
+        # Sources
+        sources = structure.get('sources', [])
+        if sources:
+            lines.append(f"\nSource statements ({len(sources)}):")
+            for item in sources[:10]:
+                loc = self.format_location(item['line'])
+                lines.append(f"  {loc:30}  {item['name']}")
+            if len(sources) > 10:
+                lines.append(f"  ... and {len(sources) - 10} more")
+
+        # Functions
+        functions = structure.get('functions', [])
+        if functions:
+            lines.append(f"\nFunctions ({len(functions)}):")
+            for item in functions:
+                loc = self.format_location(item['line'])
+                lines.append(f"  {loc:30}  {item['name']}()")
+
+        # Exports
+        exports = structure.get('exports', [])
+        if exports:
+            lines.append(f"\nExported variables ({len(exports)}):")
+            for item in exports[:15]:
+                loc = self.format_location(item['line'])
+                lines.append(f"  {loc:30}  {item['name']}")
+            if len(exports) > 15:
+                lines.append(f"  ... and {len(exports) - 15} more")
+
+        # Variables
+        variables = structure.get('variables', [])
+        if variables:
+            lines.append(f"\nVariables ({len(variables)}):")
+            for item in variables[:20]:
+                loc = self.format_location(item['line'])
+                lines.append(f"  {loc:30}  {item['name']}")
+            if len(variables) > 20:
+                lines.append(f"  ... and {len(variables) - 20} more")
+
+        return lines if lines else None

reveal/_archive_old_v0.1/analyzers/csharp_analyzer.py

@@ -0,0 +1,167 @@
+"""
+C# file analyzer using tree-sitter.
+
+Extracts C# structure including:
+- Namespaces
+- Classes
+- Interfaces
+- Structs
+- Enums
+- Methods
+- Properties
+- Using statements (imports)
+
+Demonstrates the power of tree-sitter for enterprise languages.
+"""
+
+from typing import Dict, Any, List
+from .treesitter_base import TreeSitterAnalyzer, TREE_SITTER_AVAILABLE
+from ..registry import register
+
+
+@register(['.cs'], name='C#', icon='🔷')
+class CSharpAnalyzer(TreeSitterAnalyzer):
+    """
+    Analyzer for C# source files.
+
+    Features:
+    - Full OOP structure (classes, interfaces, methods)
+    - Namespace detection
+    - Using statements
+    - Properties and fields
+    - Delegates and events
+
+    All positions are exact (tree-sitter preserves source locations).
+    """
+
+    # Set language for tree-sitter
+    language_name = 'c_sharp'
+
+    def __init__(self, lines: List[str], **kwargs):
+        """Initialize C# analyzer."""
+        # Map reveal's generic names to C#'s tree-sitter node types
+        self.node_type_map = {
+            'function': 'method_declaration',
+            'class': 'class_declaration',
+            'import': 'using_directive',
+        }
+        super().__init__(lines, **kwargs)
+
+    def extract_custom(self) -> Dict[str, List[Dict[str, Any]]]:
+        """Extract C#-specific items."""
+        return {
+            'namespaces': self._extract_nodes('namespace_declaration', name_field='name'),
+            'interfaces': self._extract_nodes('interface_declaration', name_field='name'),
+            'structs': self._extract_nodes('struct_declaration', name_field='name'),
+            'enums': self._extract_nodes('enum_declaration', name_field='name'),
+            'properties': self._extract_nodes('property_declaration', name_field='name'),
+            'delegates': self._extract_nodes('delegate_declaration', name_field='name'),
+            'events': self._extract_nodes('event_declaration', name_field='name'),
+        }
+
+    def format_structure(self, structure: Dict[str, Any]) -> List[str]:
+        """
+        Custom formatting for C# structure output.
+
+        Groups items logically:
+        1. Namespaces
+        2. Using statements
+        3. Types (classes, interfaces, structs, enums)
+        4. Members (methods, properties, events)
+        """
+        if not TREE_SITTER_AVAILABLE or 'error' in structure:
+            return None  # Use default formatting
+
+        lines = []
+
+        # Namespaces
+        namespaces = structure.get('namespaces', [])
+        if namespaces:
+            lines.append(f"\nNamespaces ({len(namespaces)}):")
+            for item in namespaces:
+                loc = self.format_location(item['line'])
+                lines.append(f"  {loc:30}  {item['name']}")
+
+        # Using statements
+        imports = structure.get('imports', [])
+        if imports:
+            lines.append(f"\nUsing statements ({len(imports)}):")
+            for item in imports[:10]:  # Limit display
+                loc = self.format_location(item['line'])
+                # Clean up "using System;" -> "System"
+                name = item['name'].replace('using ', '').replace(';', '').strip()
+                lines.append(f"  {loc:30}  {name}")
+            if len(imports) > 10:
+                lines.append(f"  ... and {len(imports) - 10} more")
+
+        # Types section
+        classes = structure.get('classes', [])
+        interfaces = structure.get('interfaces', [])
+        structs = structure.get('structs', [])
+        enums = structure.get('enums', [])
+
+        type_count = len(classes) + len(interfaces) + len(structs) + len(enums)
+        if type_count > 0:
+            lines.append(f"\nTypes ({type_count}):")
+
+            if classes:
+                lines.append(f"  Classes ({len(classes)}):")
+                for item in classes:
+                    loc = self.format_location(item['line'])
+                    lines.append(f"    {loc:28}  {item['name']}")
+
+            if interfaces:
+                lines.append(f"  Interfaces ({len(interfaces)}):")
+                for item in interfaces:
+                    loc = self.format_location(item['line'])
+                    lines.append(f"    {loc:28}  {item['name']}")
+
+            if structs:
+                lines.append(f"  Structs ({len(structs)}):")
+                for item in structs:
+                    loc = self.format_location(item['line'])
+                    lines.append(f"    {loc:28}  {item['name']}")
+
+            if enums:
+                lines.append(f"  Enums ({len(enums)}):")
+                for item in enums:
+                    loc = self.format_location(item['line'])
+                    lines.append(f"    {loc:28}  {item['name']}")
+
+        # Methods
+        methods = structure.get('functions', [])
+        if methods:
+            lines.append(f"\nMethods ({len(methods)}):")
+            for item in methods[:20]:  # Limit display
+                loc = self.format_location(item['line'])
+                lines.append(f"  {loc:30}  {item['name']}()")
+            if len(methods) > 20:
+                lines.append(f"  ... and {len(methods) - 20} more")
+
+        # Properties
+        properties = structure.get('properties', [])
+        if properties:
+            lines.append(f"\nProperties ({len(properties)}):")
+            for item in properties[:15]:  # Limit display
+                loc = self.format_location(item['line'])
+                lines.append(f"  {loc:30}  {item['name']}")
+            if len(properties) > 15:
+                lines.append(f"  ... and {len(properties) - 15} more")
+
+        # Events
+        events = structure.get('events', [])
+        if events:
+            lines.append(f"\nEvents ({len(events)}):")
+            for item in events:
+                loc = self.format_location(item['line'])
+                lines.append(f"  {loc:30}  {item['name']}")
+
+        # Delegates
+        delegates = structure.get('delegates', [])
+        if delegates:
+            lines.append(f"\nDelegates ({len(delegates)}):")
+            for item in delegates:
+                loc = self.format_location(item['line'])
+                lines.append(f"  {loc:30}  {item['name']}")
+
+        return lines if lines else None

reveal/_archive_old_v0.1/analyzers/gdscript_analyzer.py

@@ -0,0 +1,201 @@
+"""GDScript file analyzer for Godot Engine."""
+
+import re
+from typing import Dict, Any, List
+from .base import BaseAnalyzer
+from ..registry import register
+
+
+@register(['.gd'], name='GDScript', icon='🎮')
+class GDScriptAnalyzer(BaseAnalyzer):
+    """Analyzer for GDScript files (Godot Engine)"""
+
+    def __init__(self, lines: List[str], **kwargs):
+        super().__init__(lines, **kwargs)
+
+    def analyze_structure(self) -> Dict[str, Any]:
+        """Analyze GDScript structure."""
+        extends_class = None
+        class_name = None
+        signals = []
+        exports = []
+        functions = []
+        constants = []
+        variables = []
+
+        for i, line in enumerate(self.lines, 1):
+            stripped = line.strip()
+
+            # extends declaration
+            if stripped.startswith('extends '):
+                extends_class = stripped[8:].strip()
+
+            # class_name declaration
+            elif stripped.startswith('class_name '):
+                class_name = stripped[11:].strip()
+
+            # signal definitions
+            elif stripped.startswith('signal '):
+                signal_match = re.match(r'signal\s+(\w+)', stripped)
+                if signal_match:
+                    signals.append({'name': signal_match.group(1), 'line': i})
+
+            # @export variables
+            elif stripped.startswith('@export'):
+                # Look for variable on same line or next line
+                var_match = re.search(r'var\s+(\w+)', stripped)
+                if var_match:
+                    exports.append({'name': var_match.group(1), 'line': i})
+                elif i < len(self.lines):
+                    next_line = self.lines[i].strip()
+                    var_match = re.search(r'var\s+(\w+)', next_line)
+                    if var_match:
+                        exports.append({'name': var_match.group(1), 'line': i + 1})
+
+            # const declarations
+            elif stripped.startswith('const '):
+                const_match = re.match(r'const\s+(\w+)', stripped)
+                if const_match:
+                    constants.append({'name': const_match.group(1), 'line': i})
+
+            # var declarations (not exported)
+            elif stripped.startswith('var ') and not any(e['line'] == i for e in exports):
+                var_match = re.match(r'var\s+(\w+)', stripped)
+                if var_match:
+                    variables.append({'name': var_match.group(1), 'line': i})
+
+            # function definitions
+            elif stripped.startswith('func '):
+                func_match = re.match(r'func\s+(\w+)', stripped)
+                if func_match:
+                    func_name = func_match.group(1)
+                    # Mark special Godot lifecycle functions
+                    is_lifecycle = func_name in ['_ready', '_process', '_physics_process',
+                                                  '_input', '_unhandled_input', '_enter_tree',
+                                                  '_exit_tree', '_draw', '_notification']
+                    functions.append({
+                        'name': func_name,
+                        'line': i,
+                        'lifecycle': is_lifecycle
+                    })
+
+        return {
+            'extends': extends_class,
+            'class_name': class_name,
+            'signals': signals,
+            'exports': exports,
+            'constants': constants,
+            'variables': variables,
+            'functions': functions
+        }
+
+    def generate_preview(self) -> List[tuple[int, str]]:
+        """Generate GDScript preview showing key elements."""
+        preview = []
+
+        for i, line in enumerate(self.lines, 1):
+            stripped = line.strip()
+
+            # Include extends/class_name
+            if stripped.startswith('extends ') or stripped.startswith('class_name '):
+                preview.append((i, line))
+
+            # Include comments at the top (documentation)
+            elif stripped.startswith('#') and i <= 10:
+                preview.append((i, line))
+
+            # Include signal definitions
+            elif stripped.startswith('signal '):
+                preview.append((i, line))
+
+            # Include @export declarations
+            elif stripped.startswith('@export'):
+                preview.append((i, line))
+                # Include the variable line too
+                if i < len(self.lines) and self.lines[i].strip().startswith('var '):
+                    preview.append((i + 1, self.lines[i]))
+
+            # Include const declarations
+            elif stripped.startswith('const '):
+                preview.append((i, line))
+
+            # Include function signatures
+            elif stripped.startswith('func '):
+                preview.append((i, line))
+                # Include function docstring if present
+                if i < len(self.lines):
+                    next_line = self.lines[i].strip()
+                    if next_line.startswith('#'):
+                        preview.append((i + 1, self.lines[i]))
+
+        # Sort by line number and limit to first 40 lines
+        preview = sorted(list(set(preview)), key=lambda x: x[0])
+        return preview[:40]
+
+    def format_structure(self, structure: Dict[str, Any]) -> List[str]:
+        """Format GDScript structure output."""
+        output = []
+
+        # Class inheritance
+        if structure['extends']:
+            output.append(f"Extends: {structure['extends']}")
+        if structure['class_name']:
+            output.append(f"Class Name: {structure['class_name']}")
+
+        if structure['extends'] or structure['class_name']:
+            output.append("")
+
+        # Signals
+        if structure['signals']:
+            output.append("Signals:")
+            for sig in structure['signals']:
+                loc = self.format_location(sig['line'])
+                output.append(f"  {loc:<30}  signal {sig['name']}")
+            output.append("")
+
+        # Exported variables
+        if structure['exports']:
+            output.append("Exported Variables:")
+            for exp in structure['exports']:
+                loc = self.format_location(exp['line'])
+                output.append(f"  {loc:<30}  @export var {exp['name']}")
+            output.append("")
+
+        # Constants
+        if structure['constants']:
+            output.append("Constants:")
+            for const in structure['constants']:
+                loc = self.format_location(const['line'])
+                output.append(f"  {loc:<30}  const {const['name']}")
+            output.append("")
+
+        # Variables
+        if structure['variables']:
+            output.append("Variables:")
+            for var in structure['variables'][:10]:  # Limit to first 10
+                loc = self.format_location(var['line'])
+                output.append(f"  {loc:<30}  var {var['name']}")
+            if len(structure['variables']) > 10:
+                output.append(f"  ... and {len(structure['variables']) - 10} more")
+            output.append("")
+
+        # Functions
+        if structure['functions']:
+            output.append("Functions:")
+            lifecycle = [f for f in structure['functions'] if f.get('lifecycle')]
+            regular = [f for f in structure['functions'] if not f.get('lifecycle')]
+
+            if lifecycle:
+                output.append("  Lifecycle:")
+                for func in lifecycle:
+                    loc = self.format_location(func['line'])
+                    output.append(f"    {loc:<30}  func {func['name']}()")
+
+            if regular:
+                if lifecycle:
+                    output.append("  Custom:")
+                for func in regular:
+                    loc = self.format_location(func['line'])
+                    output.append(f"    {loc:<30}  func {func['name']}()")
+
+        return output