mui-lsp 0.1.1 → 0.3.0

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

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Mui
+  module Lsp
+    module Handlers
+      # Handler for textDocument/typeDefinition responses
+      class TypeDefinition < 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 type 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)
+          # Store locations for picker navigation
+          @editor.instance_variable_set(:@lsp_picker_locations, locations)
+          @editor.instance_variable_set(:@lsp_picker_type, :type_definition)
+
+          # Build picker content
+          lines = []
+          locations.each_with_index do |loc, idx|
+            file_path = loc.file_path || loc.uri
+            display_path = File.basename(file_path.to_s)
+            line_num = loc.range.start.line + 1
+            lines << "#{idx + 1}. #{display_path}:#{line_num}"
+          end
+
+          # Open scratch buffer for picker
+          content = "Type Definitions (\\Enter:open, Ctrl+t:tab, \\q:close)\n\n#{lines.join("\n")}"
+          @editor.open_scratch_buffer("[LSP Picker]", content)
+        end
+      end
+    end
+  end
+end

data/lib/mui/lsp/handlers.rb

@@ -3,6 +3,8 @@
 require_relative "handlers/base"
 require_relative "handlers/hover"
 require_relative "handlers/definition"
+require_relative "handlers/type_definition"
 require_relative "handlers/references"
 require_relative "handlers/diagnostics"
 require_relative "handlers/completion"
+require_relative "handlers/formatting"

data/lib/mui/lsp/manager.rb

@@ -86,6 +86,20 @@ module Mui
         nil
       end
 
+      def client_for_capability(file_path, capability)
+        @mutex.synchronize do
+          @server_configs.each do |name, config|
+            next unless config.handles_file?(file_path)
+            next unless @clients[name]&.running?
+
+            # Check if server supports the capability
+            capabilities = @clients[name].server_capabilities
+            return @clients[name] if capabilities[capability]
+          end
+        end
+        nil
+      end
+
       def text_sync_for(file_path)
         @mutex.synchronize do
           @server_configs.each do |name, config|
@@ -162,6 +176,23 @@ module Mui
         end
       end
 
+      # Sync immediately without debounce (for completion requests)
+      def sync_now(file_path:, text:)
+        uri = TextDocumentSync.path_to_uri(file_path)
+        text_syncs_for(file_path).each do |text_sync|
+          text_sync.did_change(uri: uri, text: text, debounce: false, force: true)
+        end
+      end
+
+      # Force close and re-open document to reset LSP state
+      def force_reopen(file_path:, text:)
+        uri = TextDocumentSync.path_to_uri(file_path)
+        text_syncs_for(file_path).each do |text_sync|
+          text_sync.did_close(uri: uri) if text_sync.open?(uri)
+          text_sync.did_open(uri: uri, text: text)
+        end
+      end
+
       def did_save(file_path:, text: nil)
         uri = TextDocumentSync.path_to_uri(file_path)
         # Broadcast to all matching servers
@@ -198,21 +229,106 @@ module Mui
       end
 
       def definition(file_path:, line:, character:)
-        client = client_for(file_path)
-        unless client
+        text_syncs = text_syncs_for(file_path)
+        if text_syncs.empty?
           @editor.message = server_unavailable_message(file_path)
           return
         end
 
         uri = TextDocumentSync.path_to_uri(file_path)
-        handler = Handlers::Definition.new(editor: @editor, client: client)
+        handler = Handlers::Definition.new(editor: @editor, client: text_syncs.first.client)
+
+        # Collect results from all clients
+        results_mutex = Mutex.new
+        pending_count = text_syncs.size
+        all_results = []
+
+        text_syncs.each do |text_sync|
+          text_sync.client.definition(uri: uri, line: line, character: character) do |result, _error|
+            results_mutex.synchronize do
+              all_results << result if result
+              pending_count -= 1
+
+              if pending_count.zero?
+                merged = merge_locations(all_results)
+                handler.handle(merged, nil)
+              end
+            end
+          end
+        end
+      end
 
-        client.definition(uri: uri, line: line, character: character) do |result, error|
-          handler.handle(result, error)
+      def type_definition(file_path:, line:, character:)
+        # Only send to servers that support typeDefinitionProvider
+        text_syncs = text_syncs_for(file_path).select do |ts|
+          ts.client.server_capabilities["typeDefinitionProvider"]
+        end
+
+        if text_syncs.empty?
+          # Fallback message: check if any server is running but doesn't support typeDefinition
+          any_text_sync = text_syncs_for(file_path).first
+          @editor.message = if any_text_sync
+                              "LSP: no server supports typeDefinition for this file"
+                            else
+                              server_unavailable_message(file_path)
+                            end
+          return
+        end
+
+        uri = TextDocumentSync.path_to_uri(file_path)
+        handler = Handlers::TypeDefinition.new(editor: @editor, client: text_syncs.first.client)
+
+        # Collect results from all clients
+        results_mutex = Mutex.new
+        pending_count = text_syncs.size
+        all_results = []
+
+        text_syncs.each do |text_sync|
+          text_sync.client.type_definition(uri: uri, line: line, character: character) do |result, _error|
+            results_mutex.synchronize do
+              all_results << result if result
+              pending_count -= 1
+
+              if pending_count.zero?
+                merged = merge_locations(all_results)
+                handler.handle(merged, nil)
+              end
+            end
+          end
         end
       end
 
       def references(file_path:, line:, character:)
+        text_syncs = text_syncs_for(file_path)
+        if text_syncs.empty?
+          @editor.message = server_unavailable_message(file_path)
+          return
+        end
+
+        uri = TextDocumentSync.path_to_uri(file_path)
+        handler = Handlers::References.new(editor: @editor, client: text_syncs.first.client)
+
+        # Collect results from all clients
+        results_mutex = Mutex.new
+        pending_count = text_syncs.size
+        all_results = []
+
+        text_syncs.each do |text_sync|
+          text_sync.client.references(uri: uri, line: line, character: character) do |result, _error|
+            results_mutex.synchronize do
+              all_results << result if result
+              pending_count -= 1
+
+              if pending_count.zero?
+                merged = merge_locations(all_results)
+                handler.handle(merged, nil)
+              end
+            end
+          end
+        end
+      end
+
+      def completion(file_path:, line:, character:)
         client = client_for(file_path)
         unless client
           @editor.message = server_unavailable_message(file_path)
@@ -220,14 +336,14 @@ module Mui
         end
 
         uri = TextDocumentSync.path_to_uri(file_path)
-        handler = Handlers::References.new(editor: @editor, client: client)
+        handler = Handlers::Completion.new(editor: @editor, client: client)
 
-        client.references(uri: uri, line: line, character: character) do |result, error|
+        client.completion(uri: uri, line: line, character: character) do |result, error|
           handler.handle(result, error)
         end
       end
 
-      def completion(file_path:, line:, character:)
+      def format(file_path:, tab_size: 2, insert_spaces: true)
         client = client_for(file_path)
         unless client
           @editor.message = server_unavailable_message(file_path)
@@ -235,13 +351,48 @@ module Mui
         end
 
         uri = TextDocumentSync.path_to_uri(file_path)
-        handler = Handlers::Completion.new(editor: @editor, client: client)
+        handler = Handlers::Formatting.new(editor: @editor, client: client)
 
-        client.completion(uri: uri, line: line, character: character) do |result, error|
+        client.formatting(uri: uri, tab_size: tab_size, insert_spaces: insert_spaces) do |result, error|
           handler.handle(result, error)
         end
       end
 
+      def jump_to_type_file(file_path:, line: nil, character: nil)
+        # For Ruby/RBS files, use custom toggle behavior
+        if file_path&.end_with?(".rb", ".rbs")
+          jump_to_ruby_type_file(file_path)
+        else
+          # For other languages, use LSP typeDefinition
+          type_definition(file_path: file_path, line: line, character: character)
+        end
+      end
+
+      private
+
+      def jump_to_ruby_type_file(file_path)
+        target_path = if file_path.end_with?(".rb")
+                        find_rbs_file(file_path)
+                      else
+                        find_ruby_file(file_path)
+                      end
+
+        unless target_path
+          ext = File.extname(file_path)
+          target_ext = ext == ".rb" ? ".rbs" : ".rb"
+          @editor.message = "No #{target_ext} file found for #{File.basename(file_path)}"
+          return
+        end
+
+        # Open the target file
+        new_buffer = Mui::Buffer.new
+        new_buffer.load(target_path)
+        @editor.window.buffer = new_buffer
+        @editor.message = "Opened #{File.basename(target_path)}"
+      end
+
+      public
+
       def running_servers
         @mutex.synchronize do
           @clients.select { |_, client| client.running? }.keys
@@ -276,6 +427,80 @@ module Mui
 
       private
 
+      def merge_locations(results)
+        # Flatten all results into a single array
+        merged = results.flat_map do |result|
+          case result
+          when Array then result
+          when Hash then [result]
+          else []
+          end
+        end
+
+        # Remove duplicates based on uri and range
+        merged.uniq do |loc|
+          uri = loc["uri"] || loc["targetUri"]
+          range = loc["range"] || loc["targetSelectionRange"]
+          [uri, range]
+        end
+      end
+
+      def find_rbs_file(ruby_file_path)
+        # Find project root
+        project_root = find_project_root(ruby_file_path)
+
+        # Get relative path from project root
+        abs_path = File.expand_path(ruby_file_path)
+        rel_path = abs_path.sub("#{project_root}/", "")
+
+        # Try different RBS path patterns
+        candidates = []
+
+        # Pattern 1: sig/relative_path.rbs (e.g., lib/mui/config.rb -> sig/lib/mui/config.rbs)
+        candidates << File.join(project_root, "sig", rel_path.sub(/\.rb$/, ".rbs"))
+
+        # Pattern 2: sig/without_lib.rbs (e.g., lib/mui/config.rb -> sig/mui/config.rbs)
+        if rel_path.start_with?("lib/")
+          candidates << File.join(project_root, "sig", rel_path.sub(%r{^lib/}, "").sub(/\.rb$/, ".rbs"))
+        end
+
+        # Pattern 3: sig/basename.rbs (e.g., lib/mui/config.rb -> sig/config.rbs)
+        candidates << File.join(project_root, "sig", "#{File.basename(ruby_file_path, ".rb")}.rbs")
+
+        # Return first existing file
+        candidates.find { |path| File.exist?(path) }
+      end
+
+      def find_ruby_file(rbs_file_path)
+        # Find project root
+        project_root = find_project_root(rbs_file_path)
+
+        # Get relative path from project root
+        abs_path = File.expand_path(rbs_file_path)
+        rel_path = abs_path.sub("#{project_root}/", "")
+
+        # Remove sig/ prefix if present
+        rel_path = rel_path.sub(%r{^sig/}, "")
+
+        # Try different Ruby path patterns
+        candidates = []
+
+        # Pattern 1: lib/relative_path.rb (e.g., sig/mui/config.rbs -> lib/mui/config.rb)
+        candidates << File.join(project_root, "lib", rel_path.sub(/\.rbs$/, ".rb"))
+
+        # Pattern 2: relative_path.rb without lib (e.g., sig/lib/mui/config.rbs -> lib/mui/config.rb)
+        candidates << File.join(project_root, rel_path.sub(/\.rbs$/, ".rb")) if rel_path.start_with?("lib/")
+
+        # Pattern 3: Search in lib directory for basename
+        basename = File.basename(rbs_file_path, ".rbs")
+        Dir.glob(File.join(project_root, "lib", "**", "#{basename}.rb")).each do |path|
+          candidates << path
+        end
+
+        # Return first existing file
+        candidates.find { |path| File.exist?(path) }
+      end
+
       def send_pending_documents(server_name)
         text_sync = @mutex.synchronize { @text_syncs[server_name] }
         config = @mutex.synchronize { @server_configs[server_name] }