collie-lsp 0.1.0

data/lib/collie_lsp/handlers/folding_range.rb

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+module CollieLsp
+  module Handlers
+    # Code folding support
+    module FoldingRange
+      module_function
+
+      # Handle textDocument/foldingRange request
+      # @param request [Hash] LSP request
+      # @param document_store [DocumentStore] Document store
+      # @param _collie [CollieWrapper] Collie wrapper (unused)
+      # @param writer [Object] Response writer
+      def handle(request, document_store, _collie, writer)
+        uri = request[:params][:textDocument][:uri]
+        doc = document_store.get(uri)
+
+        unless doc
+          writer.write(id: request[:id], result: [])
+          return
+        end
+
+        ranges = build_folding_ranges(doc[:text], doc[:ast])
+
+        writer.write(
+          id: request[:id],
+          result: ranges
+        )
+      end
+
+      # Build folding ranges from document
+      # @param text [String] Document text
+      # @param ast [Hash, nil] Parsed AST (may be nil)
+      # @return [Array<Hash>] LSP folding ranges
+      def build_folding_ranges(text, ast)
+        ranges = []
+
+        # Add ranges from AST if available
+        ranges.concat(build_ast_folding_ranges(ast)) if ast
+
+        # Add ranges from text structure
+        ranges.concat(build_text_folding_ranges(text))
+
+        # Sort and remove overlaps
+        ranges.sort_by { |r| [r[:startLine], r[:endLine]] }
+      end
+
+      # Build folding ranges from AST
+      # @param ast [Hash] Parsed AST
+      # @return [Array<Hash>] Folding ranges
+      def build_ast_folding_ranges(ast)
+        ranges = []
+
+        # Fold grammar rules with multiple alternatives
+        ast[:rules]&.each do |rule|
+          next unless rule[:location] && rule[:alternatives]
+          next if rule[:alternatives].size < 2
+
+          # Find the end of the rule (look for semicolon)
+          start_line = rule[:location][:line] - 1
+          end_line = find_rule_end_line(rule, ast)
+
+          # Only create a range if the rule spans multiple lines
+          ranges << create_folding_range(start_line, end_line, 'region') if end_line && end_line > start_line
+        end
+
+        ranges
+      end
+
+      # Build folding ranges from text structure
+      # @param text [String] Document text
+      # @return [Array<Hash>] Folding ranges
+      def build_text_folding_ranges(text)
+        ranges = []
+        lines = text.lines
+
+        # Fold block comments
+        ranges.concat(find_comment_blocks(lines))
+
+        # Fold C code blocks (%{ ... %})
+        ranges.concat(find_c_code_blocks(lines))
+
+        # Fold action blocks ({ ... })
+        ranges.concat(find_action_blocks(lines))
+
+        ranges
+      end
+
+      # Find the end line of a rule
+      # @param rule [Hash] Rule
+      # @param ast [Hash] AST (for context)
+      # @return [Integer, nil] End line number or nil
+      def find_rule_end_line(rule, ast)
+        # Find the next rule's start line
+        rule_index = ast[:rules].index(rule)
+        return nil unless rule_index
+
+        if rule_index < ast[:rules].size - 1
+          next_rule = ast[:rules][rule_index + 1]
+          return next_rule[:location][:line] - 2 if next_rule[:location]
+        end
+
+        # Last rule - use a default offset
+        rule[:location][:line] + 10
+      end
+
+      # Find block comment ranges
+      # @param lines [Array<String>] Document lines
+      # @return [Array<Hash>] Folding ranges
+      def find_comment_blocks(lines)
+        ranges = []
+        in_comment = false
+        comment_start = nil
+
+        lines.each_with_index do |line, idx|
+          if !in_comment && line.include?('/*')
+            in_comment = true
+            comment_start = idx
+          elsif in_comment && line.include?('*/')
+            in_comment = false
+            ranges << create_folding_range(comment_start, idx, 'comment') if comment_start && idx > comment_start
+            comment_start = nil
+          end
+        end
+
+        ranges
+      end
+
+      # Find C code block ranges
+      # @param lines [Array<String>] Document lines
+      # @return [Array<Hash>] Folding ranges
+      def find_c_code_blocks(lines)
+        ranges = []
+        in_block = false
+        block_start = nil
+
+        lines.each_with_index do |line, idx|
+          if !in_block && line.strip == '%{'
+            in_block = true
+            block_start = idx
+          elsif in_block && line.strip == '%}'
+            in_block = false
+            ranges << create_folding_range(block_start, idx, 'region') if block_start && idx > block_start
+            block_start = nil
+          end
+        end
+
+        ranges
+      end
+
+      # Find action block ranges (multi-line only)
+      # @param lines [Array<String>] Document lines
+      # @return [Array<Hash>] Folding ranges
+      def find_action_blocks(lines)
+        ranges = []
+
+        lines.each_with_index do |line, idx|
+          # Look for opening brace
+          brace_pos = line.index('{')
+          next unless brace_pos
+
+          # Find matching closing brace
+          end_line = find_matching_brace(lines, idx, brace_pos)
+          next unless end_line && end_line > idx
+
+          ranges << create_folding_range(idx, end_line, 'region')
+        end
+
+        ranges
+      end
+
+      # Find matching closing brace
+      # @param lines [Array<String>] Document lines
+      # @param start_line [Integer] Line with opening brace
+      # @param start_pos [Integer] Position of opening brace
+      # @return [Integer, nil] Line with closing brace or nil
+      def find_matching_brace(lines, start_line, start_pos)
+        depth = 1
+        pos = start_pos + 1
+
+        (start_line...lines.length).each do |line_idx|
+          line = lines[line_idx]
+          start = line_idx == start_line ? pos : 0
+
+          (start...line.length).each do |char_idx|
+            char = line[char_idx]
+            depth += 1 if char == '{'
+            depth -= 1 if char == '}'
+
+            return line_idx if depth.zero?
+          end
+        end
+
+        nil
+      end
+
+      # Create a folding range
+      # @param start_line [Integer] Start line (0-indexed)
+      # @param end_line [Integer] End line (0-indexed)
+      # @param kind [String] Folding range kind
+      # @return [Hash] LSP folding range
+      def create_folding_range(start_line, end_line, kind)
+        {
+          startLine: start_line,
+          endLine: end_line,
+          kind: kind
+        }
+      end
+    end
+  end
+end

data/lib/collie_lsp/handlers/formatting.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module CollieLsp
+  module Handlers
+    # Document formatting support
+    module Formatting
+      module_function
+
+      # Handle textDocument/formatting request
+      # @param request [Hash] LSP request
+      # @param document_store [DocumentStore] Document store
+      # @param collie [CollieWrapper] Collie wrapper
+      # @param writer [Object] Response writer
+      def handle(request, document_store, collie, writer)
+        uri = request[:params][:textDocument][:uri]
+        doc = document_store.get(uri)
+
+        unless doc
+          writer.write(id: request[:id], result: nil)
+          return
+        end
+
+        filename = uri.gsub(%r{^file://}, '')
+        formatted = collie.format(doc[:text], filename: filename)
+
+        unless formatted
+          writer.write(id: request[:id], result: nil)
+          return
+        end
+
+        # Calculate text edits (replace entire document)
+        edits = [{
+          range: full_document_range(doc[:text]),
+          newText: formatted
+        }]
+
+        writer.write(
+          id: request[:id],
+          result: edits
+        )
+      end
+
+      # Get the range covering the entire document
+      # @param text [String] Document text
+      # @return [Hash] LSP range
+      def full_document_range(text)
+        lines = text.lines.count
+        {
+          start: { line: 0, character: 0 },
+          end: { line: lines, character: 0 }
+        }
+      end
+    end
+  end
+end

data/lib/collie_lsp/handlers/hover.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module CollieLsp
+  module Handlers
+    # Show information on hover
+    module Hover
+      module_function
+
+      # Handle textDocument/hover request
+      # @param request [Hash] LSP request
+      # @param document_store [DocumentStore] Document store
+      # @param _collie [CollieWrapper] Collie wrapper (unused)
+      # @param writer [Object] Response writer
+      def handle(request, document_store, _collie, writer)
+        uri = request[:params][:textDocument][:uri]
+        position = request[:params][:position]
+        doc = document_store.get(uri)
+
+        unless doc
+          writer.write(id: request[:id], result: nil)
+          return
+        end
+
+        ast = doc[:ast]
+        unless ast
+          writer.write(id: request[:id], result: nil)
+          return
+        end
+
+        # Find symbol at position
+        symbol = find_symbol_at_position(doc[:text], position)
+        unless symbol
+          writer.write(id: request[:id], result: nil)
+          return
+        end
+
+        hover_content = build_hover_content(ast, symbol)
+
+        if hover_content
+          writer.write(
+            id: request[:id],
+            result: {
+              contents: hover_content
+            }
+          )
+        else
+          writer.write(id: request[:id], result: nil)
+        end
+      end
+
+      # Find symbol at the given position
+      # @param text [String] Document text
+      # @param position [Hash] LSP position
+      # @return [String, nil] Symbol name or nil
+      def find_symbol_at_position(text, position)
+        lines = text.lines
+        line = lines[position[:line]]
+        return nil unless line
+
+        # Extract word at character position
+        char = position[:character]
+        start_pos = char
+        end_pos = char
+
+        # Move backwards to find word start
+        start_pos -= 1 while start_pos.positive? && line[start_pos - 1] =~ /[A-Za-z0-9_]/
+        # Move forwards to find word end
+        end_pos += 1 while end_pos < line.length && line[end_pos] =~ /[A-Za-z0-9_]/
+
+        line[start_pos...end_pos]
+      end
+
+      # Build hover content for a symbol
+      # @param ast [Hash] Parsed AST
+      # @param symbol [String] Symbol name
+      # @return [Hash, nil] LSP markup content or nil
+      def build_hover_content(ast, symbol)
+        # Check if it's a token
+        ast[:declarations]&.each do |decl|
+          next unless decl[:kind] == :token
+
+          if decl[:names]&.include?(symbol)
+            return {
+              kind: 'markdown',
+              value: "**Token**: `#{symbol}`\n\nType: `#{decl[:type_tag] || 'none'}`"
+            }
+          end
+        end
+
+        # Check if it's a nonterminal
+        rule = ast[:rules]&.find { |r| r[:name] == symbol }
+        if rule
+          alt_count = rule[:alternatives]&.size || 0
+          return {
+            kind: 'markdown',
+            value: "**Nonterminal**: `#{symbol}`\n\n#{alt_count} alternative(s)"
+          }
+        end
+
+        nil
+      end
+    end
+  end
+end

data/lib/collie_lsp/handlers/references.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+module CollieLsp
+  module Handlers
+    # Find all references to a symbol
+    module References
+      module_function
+
+      # Handle textDocument/references request
+      # @param request [Hash] LSP request
+      # @param document_store [DocumentStore] Document store
+      # @param _collie [CollieWrapper] Collie wrapper (unused)
+      # @param writer [Object] Response writer
+      def handle(request, document_store, _collie, writer)
+        uri = request[:params][:textDocument][:uri]
+        position = request[:params][:position]
+        include_declaration = request[:params][:context][:includeDeclaration]
+        doc = document_store.get(uri)
+
+        unless doc
+          writer.write(id: request[:id], result: [])
+          return
+        end
+
+        ast = doc[:ast]
+        unless ast
+          writer.write(id: request[:id], result: [])
+          return
+        end
+
+        # Find symbol at position
+        symbol = find_symbol_at_position(doc[:text], position)
+        unless symbol
+          writer.write(id: request[:id], result: [])
+          return
+        end
+
+        locations = find_references(ast, symbol, uri, doc[:text], include_declaration)
+
+        writer.write(
+          id: request[:id],
+          result: locations
+        )
+      end
+
+      # Find symbol at the given position
+      # @param text [String] Document text
+      # @param position [Hash] LSP position
+      # @return [String, nil] Symbol name or nil
+      def find_symbol_at_position(text, position)
+        lines = text.lines
+        line = lines[position[:line]]
+        return nil unless line
+
+        # Extract word at character position
+        char = position[:character]
+        start_pos = char
+        end_pos = char
+
+        # Move backwards to find word start
+        start_pos -= 1 while start_pos.positive? && line[start_pos - 1] =~ /[A-Za-z0-9_]/
+        # Move forwards to find word end
+        end_pos += 1 while end_pos < line.length && line[end_pos] =~ /[A-Za-z0-9_]/
+
+        line[start_pos...end_pos]
+      end
+
+      # Find all references to a symbol
+      # @param ast [Hash] Parsed AST
+      # @param symbol [String] Symbol name
+      # @param uri [String] Document URI
+      # @param text [String] Document text
+      # @param include_declaration [Boolean] Include declaration in results
+      # @return [Array<Hash>] LSP locations
+      def find_references(ast, symbol, uri, text, include_declaration)
+        locations = []
+
+        # Find declaration location
+        declaration_loc = find_declaration(ast, symbol)
+
+        # Add declaration if requested
+        locations << create_location(uri, declaration_loc, symbol) if include_declaration && declaration_loc
+
+        # Find all usages in rules
+        locations.concat(find_usage_in_rules(ast, symbol, uri, text))
+
+        locations
+      end
+
+      # Find symbol usage in grammar rules
+      # @param ast [Hash] Parsed AST
+      # @param symbol [String] Symbol name
+      # @param uri [String] Document URI
+      # @param text [String] Document text
+      # @return [Array<Hash>] LSP locations
+      def find_usage_in_rules(ast, symbol, uri, text)
+        locations = []
+
+        ast[:rules]&.each do |rule|
+          rule[:alternatives]&.each_with_index do |alt, alt_index|
+            alt[:symbols]&.each_with_index do |sym, sym_index|
+              next unless sym[:name] == symbol
+
+              loc = estimate_symbol_location(text, rule, alt_index, sym_index, symbol)
+              locations << create_location(uri, loc, symbol) if loc
+            end
+          end
+        end
+
+        locations
+      end
+
+      # Find declaration location for a symbol
+      # @param ast [Hash] Parsed AST
+      # @param symbol [String] Symbol name
+      # @return [Hash, nil] Location hash or nil
+      def find_declaration(ast, symbol)
+        # Check token declarations
+        ast[:declarations]&.each do |decl|
+          next unless decl[:kind] == :token
+
+          return decl[:location] if decl[:names]&.include?(symbol) && decl[:location]
+        end
+
+        # Check nonterminal rules
+        rule = ast[:rules]&.find { |r| r[:name] == symbol }
+        return rule[:location] if rule && rule[:location]
+
+        nil
+      end
+
+      # Estimate symbol location in text
+      # @param text [String] Document text
+      # @param rule [Hash] Rule containing the symbol
+      # @param _alt_index [Integer] Alternative index (unused)
+      # @param _sym_index [Integer] Symbol index (unused)
+      # @param symbol [String] Symbol name
+      # @return [Hash, nil] Location hash or nil
+      def estimate_symbol_location(text, rule, _alt_index, _sym_index, symbol)
+        # This is a simplified implementation that searches for the symbol
+        # In a real implementation, positions would be tracked during parsing
+        return nil unless rule[:location]
+
+        search_symbol_from_line(text.lines, rule[:location][:line] - 1, symbol)
+      end
+
+      # Search for symbol starting from a specific line
+      # @param lines [Array<String>] Document lines
+      # @param start_line [Integer] Starting line number
+      # @param symbol [String] Symbol to search for
+      # @return [Hash, nil] Location hash or nil
+      def search_symbol_from_line(lines, start_line, symbol)
+        lines[start_line..].each_with_index do |line, offset|
+          col = line.index(symbol)
+          next unless col
+
+          return {
+            line: start_line + offset + 1,
+            column: col + 1
+          }
+        end
+
+        nil
+      end
+
+      # Create LSP location from position
+      # @param uri [String] Document URI
+      # @param location [Hash] Location hash with :line and :column
+      # @param symbol [String] Symbol name
+      # @return [Hash] LSP location
+      def create_location(uri, location, symbol)
+        line = location[:line] - 1
+        column = location[:column] - 1
+
+        {
+          uri: uri,
+          range: {
+            start: { line: line, character: column },
+            end: { line: line, character: column + symbol.length }
+          }
+        }
+      end
+    end
+  end
+end