mui-lsp 0.1.0

data/lib/mui/lsp/handlers/base.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Mui
+  module Lsp
+    module Handlers
+      # Base class for LSP response handlers
+      class Base
+        attr_reader :editor, :client
+
+        def initialize(editor:, client:)
+          @editor = editor
+          @client = client
+        end
+
+        def handle(result, error)
+          if error
+            handle_error(error)
+          elsif result
+            handle_result(result)
+          else
+            handle_empty
+          end
+        end
+
+        protected
+
+        def handle_result(result)
+          raise NotImplementedError, "Subclass must implement #handle_result"
+        end
+
+        def handle_error(error)
+          msg = error["message"] || "Unknown LSP error"
+          code = error["code"]
+          @editor.message = "LSP Error (#{code}): #{msg}"
+        end
+
+        def handle_empty
+          @editor.message = "No information available"
+        end
+
+        def current_file_path
+          @editor.current_buffer&.file_path
+        end
+
+        def current_uri
+          path = current_file_path
+          path ? TextDocumentSync.path_to_uri(path) : nil
+        end
+
+        def cursor_position
+          window = @editor.current_window
+          return nil unless window
+
+          {
+            line: window.cursor_row,
+            character: window.cursor_col
+          }
+        end
+
+        def markup_to_text(content)
+          return nil unless content
+
+          case content
+          when String
+            content
+          when Hash
+            value = content["value"] || content[:value]
+            case content["kind"] || content[:kind]
+            when "markdown"
+              # Strip basic markdown formatting
+              strip_markdown(value)
+            else
+              value
+            end
+          end
+        end
+
+        def strip_markdown(text)
+          return nil unless text
+
+          text
+            .gsub(/```\w*\n?/, "") # Remove code fence markers
+            .gsub(/`([^`]+)`/, '\1') # Remove inline code markers
+            .gsub(/\*\*([^*]+)\*\*/, '\1') # Remove bold
+            .gsub(/\*([^*]+)\*/, '\1') # Remove italic
+            .gsub(/^\s*#+\s*/, "") # Remove headings
+            .strip
+        end
+      end
+    end
+  end
+end

data/lib/mui/lsp/handlers/completion.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+module Mui
+  module Lsp
+    module Handlers
+      # Handler for textDocument/completion responses
+      class Completion < Base
+        # CompletionItemKind constants
+        module Kind
+          TEXT = 1
+          METHOD = 2
+          FUNCTION = 3
+          CONSTRUCTOR = 4
+          FIELD = 5
+          VARIABLE = 6
+          CLASS = 7
+          INTERFACE = 8
+          MODULE = 9
+          PROPERTY = 10
+          UNIT = 11
+          VALUE = 12
+          ENUM = 13
+          KEYWORD = 14
+          SNIPPET = 15
+          COLOR = 16
+          FILE = 17
+          REFERENCE = 18
+          FOLDER = 19
+          ENUM_MEMBER = 20
+          CONSTANT = 21
+          STRUCT = 22
+          EVENT = 23
+          OPERATOR = 24
+          TYPE_PARAMETER = 25
+        end
+
+        protected
+
+        def handle_result(result)
+          items = extract_items(result)
+          return handle_empty if items.empty?
+
+          show_completion_menu(items)
+        end
+
+        def handle_empty
+          @editor.message = "No completions available"
+        end
+
+        private
+
+        def extract_items(result)
+          case result
+          when Array
+            result
+          when Hash
+            # CompletionList
+            result["items"] || []
+          else
+            []
+          end
+        end
+
+        def show_completion_menu(items)
+          # Format items for display
+          formatted = items.map do |item|
+            {
+              label: item["label"],
+              kind: item["kind"],
+              detail: item["detail"],
+              documentation: item["documentation"],
+              insert_text: item["insertText"] || item["label"],
+              text_edit: item["textEdit"]
+            }
+          end
+
+          # Sort by sortText or label
+          formatted.sort_by! do |item|
+            items.find { |i| i["label"] == item[:label] }&.dig("sortText") || item[:label]
+          end
+
+          # Display completion menu or use Mui's completion system
+          display_completions(formatted)
+        end
+
+        def display_completions(items)
+          # For now, show first few items in message
+          # TODO: Integrate with Mui's popup menu or completion system
+          count = items.length
+
+          # Build a summary message
+          first_items = items.first(3).map { |item| item[:label] }
+          summary = first_items.join(", ")
+          summary += ", ..." if count > 3
+
+          @editor.message = "#{count} completion#{"s" unless count == 1}: #{summary}"
+
+          # Store items for potential insertion
+          store_completions(items)
+        end
+
+        def store_completions(items)
+          @editor.instance_variable_set(:@lsp_completions, items)
+        end
+
+        def kind_to_string(kind)
+          case kind
+          when Kind::TEXT then "Text"
+          when Kind::METHOD then "Method"
+          when Kind::FUNCTION then "Function"
+          when Kind::CONSTRUCTOR then "Constructor"
+          when Kind::FIELD then "Field"
+          when Kind::VARIABLE then "Variable"
+          when Kind::CLASS then "Class"
+          when Kind::INTERFACE then "Interface"
+          when Kind::MODULE then "Module"
+          when Kind::PROPERTY then "Property"
+          when Kind::UNIT then "Unit"
+          when Kind::VALUE then "Value"
+          when Kind::ENUM then "Enum"
+          when Kind::KEYWORD then "Keyword"
+          when Kind::SNIPPET then "Snippet"
+          when Kind::COLOR then "Color"
+          when Kind::FILE then "File"
+          when Kind::REFERENCE then "Reference"
+          when Kind::FOLDER then "Folder"
+          when Kind::ENUM_MEMBER then "EnumMember"
+          when Kind::CONSTANT then "Constant"
+          when Kind::STRUCT then "Struct"
+          when Kind::EVENT then "Event"
+          when Kind::OPERATOR then "Operator"
+          when Kind::TYPE_PARAMETER then "TypeParam"
+          else "Unknown"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mui/lsp/handlers/definition.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Mui
+  module Lsp
+    module Handlers
+      # Handler for textDocument/definition responses
+      class Definition < Base
+        protected
+
+        def handle_result(result)
+          locations = normalize_locations(result)
+          return handle_empty if locations.empty?
+
+          if locations.length == 1
+            jump_to_location(locations.first)
+          else
+            show_location_list(locations)
+          end
+        end
+
+        def handle_empty
+          @editor.message = "No definition found"
+        end
+
+        private
+
+        def normalize_locations(result)
+          case result
+          when Array
+            result.map { |loc| parse_location(loc) }.compact
+          when Hash
+            location = parse_location(result)
+            location ? [location] : []
+          else
+            []
+          end
+        end
+
+        def parse_location(data)
+          return nil unless data
+
+          # Handle both Location and LocationLink
+          if data["targetUri"]
+            # LocationLink
+            Protocol::Location.new(
+              uri: data["targetUri"],
+              range: data["targetSelectionRange"] || data["targetRange"]
+            )
+          elsif data["uri"]
+            # Location
+            Protocol::Location.from_hash(data)
+          end
+        end
+
+        def jump_to_location(location)
+          file_path = location.file_path
+          unless file_path
+            @editor.message = "Cannot open: #{location.uri}"
+            return
+          end
+
+          line = location.range.start.line
+          character = location.range.start.character
+
+          # Open the file in current window
+          current_buffer = @editor.buffer
+          if current_buffer.file_path != file_path
+            # Need to open a different file
+            new_buffer = Mui::Buffer.new
+            new_buffer.load(file_path)
+            @editor.window.buffer = new_buffer
+          end
+
+          # Jump to position
+          window = @editor.window
+          return unless window
+
+          window.cursor_row = line
+          window.cursor_col = character
+          window.ensure_cursor_visible
+
+          @editor.message = "#{File.basename(file_path)}:#{line + 1}"
+        end
+
+        def show_location_list(locations)
+          # Show a list of locations for the user to choose from
+          items = locations.map do |loc|
+            file_path = loc.file_path || loc.uri
+            line = loc.range.start.line + 1
+            "#{file_path}:#{line}"
+          end
+
+          @editor.message = "Found #{locations.length} definitions: #{items.first}..."
+          # TODO: Integrate with quickfix list or popup menu when available
+        end
+      end
+    end
+  end
+end

data/lib/mui/lsp/handlers/diagnostics.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+module Mui
+  module Lsp
+    module Handlers
+      # Handler for textDocument/publishDiagnostics notifications
+      class Diagnostics
+        attr_reader :editor, :diagnostics_by_uri
+
+        def initialize(editor:)
+          @editor = editor
+          @diagnostics_by_uri = {}
+          @mutex = Mutex.new
+        end
+
+        def handle(params)
+          uri = params["uri"]
+          raw_diagnostics = params["diagnostics"] || []
+
+          diagnostics = raw_diagnostics.map do |d|
+            Protocol::Diagnostic.from_hash(d)
+          end
+
+          @mutex.synchronize do
+            if diagnostics.empty?
+              @diagnostics_by_uri.delete(uri)
+            else
+              @diagnostics_by_uri[uri] = diagnostics
+            end
+          end
+
+          update_display(uri, diagnostics)
+        end
+
+        def diagnostics_for(uri)
+          @mutex.synchronize { @diagnostics_by_uri[uri] || [] }
+        end
+
+        def all_diagnostics
+          @mutex.synchronize { @diagnostics_by_uri.dup }
+        end
+
+        def diagnostics_at_line(uri, line)
+          diagnostics_for(uri).select do |d|
+            line.between?(d.range.start.line, d.range.end.line)
+          end
+        end
+
+        def clear_all
+          @mutex.synchronize { @diagnostics_by_uri.clear }
+        end
+
+        def clear(uri)
+          @mutex.synchronize { @diagnostics_by_uri.delete(uri) }
+        end
+
+        def counts(uri = nil)
+          diagnostics = uri ? diagnostics_for(uri) : @mutex.synchronize { @diagnostics_by_uri.values.flatten }
+
+          {
+            error: diagnostics.count(&:error?),
+            warning: diagnostics.count(&:warning?),
+            information: diagnostics.count(&:information?),
+            hint: diagnostics.count(&:hint?)
+          }
+        end
+
+        def summary(uri = nil)
+          c = counts(uri)
+          parts = []
+          parts << "E:#{c[:error]}" if c[:error].positive?
+          parts << "W:#{c[:warning]}" if c[:warning].positive?
+          parts << "I:#{c[:information]}" if c[:information].positive?
+          parts << "H:#{c[:hint]}" if c[:hint].positive?
+          parts.empty? ? "" : parts.join(" ")
+        end
+
+        private
+
+        def update_display(uri, diagnostics)
+          # Update message area with summary
+          if diagnostics.empty?
+            @editor.message = "Diagnostics cleared"
+          else
+            error_count = diagnostics.count(&:error?)
+            warning_count = diagnostics.count(&:warning?)
+            @editor.message = "#{diagnostics.length} diagnostics (#{error_count} errors, #{warning_count} warnings)"
+          end
+
+          # Apply custom highlighter if available
+          apply_highlights(uri, diagnostics)
+        end
+
+        def apply_highlights(uri, diagnostics)
+          file_path = TextDocumentSync.uri_to_path(uri)
+          return unless file_path
+
+          # Get current buffer and check if it matches
+          buffer = @editor.buffer
+          return unless buffer&.file_path
+
+          # Compare paths - need to expand to handle relative vs absolute
+          buffer_path = File.expand_path(buffer.file_path)
+          diag_path = File.expand_path(file_path)
+          return unless buffer_path == diag_path
+
+          # Remove existing diagnostic highlighter
+          had_highlighter = buffer.custom_highlighter?(:lsp_diagnostics)
+          buffer.remove_custom_highlighter(:lsp_diagnostics)
+
+          if diagnostics.empty?
+            @editor.window&.refresh_highlighters if had_highlighter
+            return
+          end
+
+          # Create and add new highlighter
+          color_scheme = @editor.color_scheme
+          highlighter = Highlighters::DiagnosticHighlighter.new(color_scheme, diagnostics)
+          buffer.add_custom_highlighter(:lsp_diagnostics, highlighter)
+
+          # Refresh window's highlighters to pick up the change
+          @editor.window&.refresh_highlighters
+        end
+
+        def build_highlighter(diagnostics)
+          # Return a lambda that highlights diagnostic ranges
+          lambda do |line_index, line_content|
+            highlights = []
+
+            diagnostics.each do |d|
+              next unless line_index.between?(d.range.start.line, d.range.end.line)
+
+              start_col = d.range.start.line == line_index ? d.range.start.character : 0
+              end_col = d.range.end.line == line_index ? d.range.end.character : line_content.length
+
+              color = severity_color(d.severity)
+              highlights << { start: start_col, end: end_col, color: color }
+            end
+
+            highlights
+          end
+        end
+
+        def severity_color(severity)
+          case severity
+          when Protocol::DiagnosticSeverity::ERROR
+            :red
+          when Protocol::DiagnosticSeverity::WARNING
+            :yellow
+          when Protocol::DiagnosticSeverity::INFORMATION
+            :blue
+          when Protocol::DiagnosticSeverity::HINT
+            :cyan
+          else
+            :default
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mui/lsp/handlers/hover.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Mui
+  module Lsp
+    module Handlers
+      # Handler for textDocument/hover responses
+      class Hover < Base
+        protected
+
+        def handle_result(result)
+          contents = result["contents"]
+          return handle_empty unless contents
+
+          text = extract_hover_text(contents)
+          return handle_empty unless text && !text.empty?
+
+          # Display hover information in echo area or popup
+          display_hover(text)
+        end
+
+        def handle_empty
+          @editor.message = "No hover information"
+        end
+
+        private
+
+        def extract_hover_text(contents)
+          case contents
+          when String
+            contents
+          when Hash
+            markup_to_text(contents)
+          when Array
+            contents.map { |c| extract_hover_text(c) }.compact.join("\n\n")
+          end
+        end
+
+        def display_hover(text)
+          # Use floating window if available
+          if @editor.respond_to?(:show_floating)
+            @editor.show_floating(text, max_height: 15)
+          else
+            # Fallback to echo area display
+            lines = text.lines.map(&:chomp)
+            @editor.message = if lines.length > 1
+                                "#{lines.first} (#{lines.length - 1} more lines)"
+                              else
+                                lines.first || text
+                              end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mui/lsp/handlers/references.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Mui
+  module Lsp
+    module Handlers
+      # Handler for textDocument/references responses
+      class References < Base
+        protected
+
+        def handle_result(result)
+          return handle_empty unless result.is_a?(Array) && !result.empty?
+
+          locations = result.map { |loc| Protocol::Location.from_hash(loc) }
+          show_references(locations)
+        end
+
+        def handle_empty
+          @editor.message = "No references found"
+        end
+
+        private
+
+        def show_references(locations)
+          count = locations.length
+
+          # Build message with first few references
+          lines = ["Found #{count} reference#{"s" unless count == 1}"]
+
+          # Group by file for display
+          by_file = locations.group_by(&:file_path)
+
+          # Display first few references
+          displayed = 0
+          max_display = 3
+
+          by_file.each do |file_path, file_locations|
+            break if displayed >= max_display
+
+            file_locations.each do |loc|
+              break if displayed >= max_display
+
+              line = loc.range.start.line + 1
+              lines << "  #{file_path || loc.uri}:#{line}"
+              displayed += 1
+            end
+          end
+
+          lines << "  ... and #{count - max_display} more" if count > max_display
+
+          @editor.message = lines.first
+
+          # TODO: Integrate with quickfix list when available
+          # Store references for navigation
+          store_references(locations)
+        end
+
+        def store_references(locations)
+          # Store references for potential :cnext/:cprev navigation
+          # This could be integrated with Mui's quickfix system if available
+          @editor.instance_variable_set(:@lsp_references, locations)
+        end
+      end
+    end
+  end
+end

data/lib/mui/lsp/handlers.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require_relative "handlers/base"
+require_relative "handlers/hover"
+require_relative "handlers/definition"
+require_relative "handlers/references"
+require_relative "handlers/diagnostics"
+require_relative "handlers/completion"

data/lib/mui/lsp/highlighters/diagnostic_highlighter.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Mui
+  module Lsp
+    module Highlighters
+      # Highlighter for LSP diagnostics (errors, warnings, etc.)
+      class DiagnosticHighlighter < Mui::Highlighters::Base
+        PRIORITY_DIAGNOSTICS = 250 # Between selection and search
+
+        def initialize(color_scheme, diagnostics)
+          super(color_scheme)
+          @diagnostics = diagnostics
+        end
+
+        def highlights_for(row, line, _options = {})
+          highlights = []
+
+          @diagnostics.each do |d|
+            next unless row.between?(d.range.start.line, d.range.end.line)
+
+            start_col = d.range.start.line == row ? d.range.start.character : 0
+            end_col = if d.range.end.line == row
+                        d.range.end.character
+                      else
+                        line.length
+                      end
+
+            # Ensure end_col is at least start_col + 1
+            end_col = [end_col, start_col + 1].max
+
+            style = severity_style(d.severity)
+            highlights << Mui::Highlight.new(
+              start_col: start_col,
+              end_col: end_col,
+              style: style,
+              priority: priority
+            )
+          end
+
+          highlights
+        end
+
+        def priority
+          PRIORITY_DIAGNOSTICS
+        end
+
+        # Update diagnostics (called when new diagnostics arrive)
+        def update(diagnostics)
+          @diagnostics = diagnostics
+        end
+
+        private
+
+        def severity_style(severity)
+          case severity
+          when Protocol::DiagnosticSeverity::ERROR
+            :diagnostic_error
+          when Protocol::DiagnosticSeverity::WARNING
+            :diagnostic_warning
+          when Protocol::DiagnosticSeverity::INFORMATION
+            :diagnostic_info
+          when Protocol::DiagnosticSeverity::HINT
+            :diagnostic_hint
+          else
+            :diagnostic_error
+          end
+        end
+      end
+    end
+  end
+end