collie-lsp 0.1.0

data/lib/collie_lsp/handlers/code_action.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module CollieLsp
+  module Handlers
+    # Quick fixes for autocorrectable offenses
+    module CodeAction
+      module_function
+
+      # Handle textDocument/codeAction 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]
+        range = request[:params][:range]
+        doc = document_store.get(uri)
+
+        unless doc
+          writer.write(id: request[:id], result: [])
+          return
+        end
+
+        # Get diagnostics in range
+        diagnostics = doc[:diagnostics].select do |diag|
+          in_range?(diag, range)
+        end
+
+        code_actions = []
+
+        # Add "Fix all" action if there are any diagnostics
+        if diagnostics.any?
+          filename = uri.gsub(%r{^file://}, '')
+          corrected = collie.autocorrect(doc[:text], filename: filename)
+
+          code_actions << {
+            title: 'Fix all auto-correctable offenses',
+            kind: 'source.fixAll',
+            edit: {
+              changes: {
+                uri => [{
+                  range: full_document_range(doc[:text]),
+                  newText: corrected
+                }]
+              }
+            }
+          }
+        end
+
+        writer.write(
+          id: request[:id],
+          result: code_actions
+        )
+      end
+
+      # Check if a diagnostic is within the given range
+      # @param diagnostic [Hash] LSP diagnostic
+      # @param range [Hash] LSP range
+      # @return [Boolean]
+      def in_range?(diagnostic, range)
+        diagnostic[:range][:start][:line] >= range[:start][:line] &&
+          diagnostic[:range][:end][:line] <= range[:end][:line]
+      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/completion.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module CollieLsp
+  module Handlers
+    # Auto-completion for tokens and nonterminals
+    module Completion
+      module_function
+
+      # Handle textDocument/completion 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: [])
+          return
+        end
+
+        ast = doc[:ast]
+        unless ast
+          writer.write(id: request[:id], result: [])
+          return
+        end
+
+        completions = build_completions(ast)
+
+        writer.write(
+          id: request[:id],
+          result: completions
+        )
+      end
+
+      # Build completion items from AST
+      # @param ast [Hash] Parsed AST
+      # @return [Array<Hash>] LSP completion items
+      def build_completions(ast)
+        completions = []
+
+        # Add all declared tokens
+        ast[:declarations]&.each do |decl|
+          next unless decl[:kind] == :token
+
+          decl[:names]&.each do |name|
+            completions << {
+              label: name,
+              kind: 14, # Keyword
+              detail: "Token: #{name}",
+              documentation: 'Declared token'
+            }
+          end
+        end
+
+        # Add all nonterminals
+        ast[:rules]&.each do |rule|
+          completions << {
+            label: rule[:name],
+            kind: 7, # Class (nonterminal)
+            detail: "Nonterminal: #{rule[:name]}",
+            documentation: 'Grammar rule'
+          }
+        end
+
+        completions
+      end
+    end
+  end
+end

data/lib/collie_lsp/handlers/definition.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module CollieLsp
+  module Handlers
+    # Go to definition support
+    module Definition
+      module_function
+
+      # Handle textDocument/definition 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
+
+        location = find_definition_location(ast, symbol, uri)
+
+        if location
+          writer.write(id: request[:id], result: location)
+        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
+
+      # Find definition location for a symbol
+      # @param ast [Hash] Parsed AST
+      # @param symbol [String] Symbol name
+      # @param uri [String] Document URI
+      # @return [Hash, nil] LSP location or nil
+      def find_definition_location(ast, symbol, uri)
+        # Check if it's a token declaration
+        ast[:declarations]&.each do |decl|
+          next unless decl[:kind] == :token
+
+          if decl[:names]&.include?(symbol) && decl[:location]
+            return {
+              uri: uri,
+              range: {
+                start: {
+                  line: decl[:location][:line] - 1,
+                  character: decl[:location][:column] - 1
+                },
+                end: {
+                  line: decl[:location][:line] - 1,
+                  character: decl[:location][:column] + symbol.length - 1
+                }
+              }
+            }
+          end
+        end
+
+        # Check if it's a nonterminal rule
+        rule = ast[:rules]&.find { |r| r[:name] == symbol }
+        if rule && rule[:location]
+          return {
+            uri: uri,
+            range: {
+              start: {
+                line: rule[:location][:line] - 1,
+                character: rule[:location][:column] - 1
+              },
+              end: {
+                line: rule[:location][:line] - 1,
+                character: rule[:location][:column] + symbol.length - 1
+              }
+            }
+          }
+        end
+
+        nil
+      end
+    end
+  end
+end

data/lib/collie_lsp/handlers/diagnostics.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module CollieLsp
+  module Handlers
+    # Converts Collie offenses to LSP diagnostics
+    module Diagnostics
+      module_function
+
+      # Publish diagnostics for a document
+      # @param uri [String] Document URI
+      # @param offenses [Array<Hash>] Collie offenses
+      # @param document_store [DocumentStore] Document store
+      # @param writer [Object] Response writer
+      def publish(uri, offenses, document_store, writer)
+        diagnostics = offenses.map do |offense|
+          offense_to_diagnostic(offense)
+        end
+
+        document_store.update_diagnostics(uri, diagnostics)
+
+        writer.write(
+          method: 'textDocument/publishDiagnostics',
+          params: {
+            uri: uri,
+            diagnostics: diagnostics
+          }
+        )
+      end
+
+      # Convert a Collie offense to an LSP diagnostic
+      # @param offense [Hash] Collie offense
+      # @return [Hash] LSP diagnostic
+      def offense_to_diagnostic(offense)
+        location = offense[:location] || { line: 1, column: 1 }
+        line = location[:line] - 1 # LSP is 0-indexed
+        column = location[:column] - 1
+
+        {
+          range: {
+            start: { line: line, character: column },
+            end: { line: line, character: column + 10 } # Approximate
+          },
+          severity: severity_to_lsp(offense[:severity]),
+          code: offense[:rule_name] || 'unknown',
+          source: 'collie',
+          message: offense[:message] || 'Unknown error'
+        }
+      end
+
+      # Convert Collie severity to LSP severity
+      # @param severity [Symbol] Collie severity (:error, :warning, :convention, :info)
+      # @return [Integer] LSP severity (1-4)
+      def severity_to_lsp(severity)
+        case severity
+        when :error then 1    # Error
+        when :warning then 2  # Warning
+        when :convention then 3 # Information
+        when :info then 4 # Hint
+        else 3
+        end
+      end
+    end
+  end
+end

data/lib/collie_lsp/handlers/document_symbol.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+module CollieLsp
+  module Handlers
+    # Document symbol support for outline view
+    module DocumentSymbol
+      module_function
+
+      # Handle textDocument/documentSymbol 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
+
+        ast = doc[:ast]
+        unless ast
+          writer.write(id: request[:id], result: [])
+          return
+        end
+
+        symbols = build_document_symbols(ast)
+
+        writer.write(
+          id: request[:id],
+          result: symbols
+        )
+      end
+
+      # Build document symbols from AST
+      # @param ast [Hash] Parsed AST
+      # @return [Array<Hash>] LSP document symbols
+      def build_document_symbols(ast)
+        symbols = []
+
+        symbols.concat(build_token_symbols(ast))
+        symbols.concat(build_type_symbols(ast))
+        symbols.concat(build_precedence_symbols(ast))
+        symbols.concat(build_rule_symbols(ast))
+
+        symbols
+      end
+
+      # Build token symbols
+      # @param ast [Hash] Parsed AST
+      # @return [Array<Hash>] Token symbols
+      def build_token_symbols(ast)
+        symbols = []
+        ast[:declarations]&.each do |decl|
+          next unless decl[:kind] == :token && decl[:location]
+
+          decl[:names]&.each do |name|
+            symbols << create_symbol(
+              name: name,
+              kind: 14,
+              location: decl[:location],
+              detail: 'Token'
+            )
+          end
+        end
+        symbols
+      end
+
+      # Build type symbols
+      # @param ast [Hash] Parsed AST
+      # @return [Array<Hash>] Type symbols
+      def build_type_symbols(ast)
+        symbols = []
+        ast[:declarations]&.each do |decl|
+          next unless decl[:kind] == :type && decl[:location]
+
+          decl[:names]&.each do |name|
+            symbols << create_symbol(
+              name: name,
+              kind: 7,
+              location: decl[:location],
+              detail: 'Type'
+            )
+          end
+        end
+        symbols
+      end
+
+      # Build precedence symbols
+      # @param ast [Hash] Parsed AST
+      # @return [Array<Hash>] Precedence symbols
+      def build_precedence_symbols(ast)
+        symbols = []
+        ast[:declarations]&.each do |decl|
+          next unless %i[left right nonassoc].include?(decl[:kind]) && decl[:location]
+
+          assoc_name = decl[:kind].to_s.capitalize
+          decl[:tokens]&.each do |token|
+            symbols << create_symbol(
+              name: token,
+              kind: 22,
+              location: decl[:location],
+              detail: "#{assoc_name} precedence"
+            )
+          end
+        end
+        symbols
+      end
+
+      # Build rule symbols
+      # @param ast [Hash] Parsed AST
+      # @return [Array<Hash>] Rule symbols
+      def build_rule_symbols(ast)
+        symbols = []
+        ast[:rules]&.each do |rule|
+          next unless rule[:location]
+
+          children = build_rule_children(rule)
+          symbols << create_symbol(
+            name: rule[:name],
+            kind: 12,
+            location: rule[:location],
+            detail: "Grammar rule (#{rule[:alternatives]&.size || 0} alternatives)",
+            children: children
+          )
+        end
+        symbols
+      end
+
+      # Build children symbols for a rule (alternatives)
+      # @param rule [Hash] Grammar rule
+      # @return [Array<Hash>] Child symbols
+      def build_rule_children(rule)
+        children = []
+
+        rule[:alternatives]&.each_with_index do |alt, index|
+          next unless alt[:location]
+
+          # Create a symbol for each alternative
+          symbols_str = alt[:symbols]&.map { |s| s[:name] }&.join(' ') || 'ε'
+          children << create_symbol(
+            name: "Alternative #{index + 1}",
+            kind: 6, # Property
+            location: alt[:location],
+            detail: symbols_str
+          )
+        end
+
+        children
+      end
+
+      # Create a document symbol
+      # @param name [String] Symbol name
+      # @param kind [Integer] LSP symbol kind
+      # @param location [Hash] Location hash with :line and :column
+      # @param detail [String] Symbol detail
+      # @param children [Array<Hash>] Child symbols
+      # @return [Hash] LSP document symbol
+      def create_symbol(name:, kind:, location:, detail: nil, children: nil)
+        line = location[:line] - 1
+        column = location[:column] - 1
+
+        symbol = {
+          name: name,
+          kind: kind,
+          range: {
+            start: { line: line, character: column },
+            end: { line: line, character: column + name.length }
+          },
+          selectionRange: {
+            start: { line: line, character: column },
+            end: { line: line, character: column + name.length }
+          }
+        }
+
+        symbol[:detail] = detail if detail
+        symbol[:children] = children if children && !children.empty?
+
+        symbol
+      end
+    end
+  end
+end