rubik 0.3.4 → 0.3.5

data/lib/rubik/lsp/client.rb

@@ -3,6 +3,7 @@
 require "open3"
 require "json"
 require "uri"
+require_relative "server_command"
 require_relative "../platform"
 require_relative "../log"
 
@@ -34,18 +35,20 @@ module Rubik
         "vue" => "vue-language-server --stdio"
       }.freeze
 
-      attr_reader :language, :server_cmd, :root_dir, :running, :diagnostics, :server_capabilities
+      attr_reader :language, :server_cmd, :root_dir, :running, :diagnostics, :server_capabilities,
+                  :sync_capabilities
 
       def initialize(language, root_dir: Dir.pwd, server_cmd: nil)
         @language = language.to_s.downcase
         @root_dir = Rubik::Platform.expand_path(root_dir)
         cmd = server_cmd || SERVERS[@language]
-        if cmd.to_s.start_with?("typeprof", "typescript-language-server") && !cmd.to_s.include?("--stdio")
-          cmd = "#{cmd} --stdio"
-        elsif cmd.to_s.start_with?("solargraph") && !cmd.to_s.include?("stdio")
-          cmd = "#{cmd} stdio"
-        end
         @server_cmd = cmd
+        @server_argv = ServerCommand.argv(cmd)
+        if ["typeprof", "typescript-language-server"].include?(File.basename(@server_argv.first.to_s)) && !@server_argv.include?("--stdio")
+          @server_argv << "--stdio"
+        elsif File.basename(@server_argv.first.to_s) == "solargraph" && !@server_argv.include?("stdio")
+          @server_argv << "stdio"
+        end
         @running = false
         @crashed = false
         @req_id = 0
@@ -56,43 +59,59 @@ module Rubik
         @reader_thr = nil
         @stderr_drain = nil
         @mutex = Mutex.new
+        @document_mutex = Mutex.new
+        @write_mutex = Mutex.new
         @cv = ConditionVariable.new
         @responses = {}
         @pending_requests = {}
         @reader_failure = nil
         @diagnostics = {}
         @open_documents = {}
+        @document_contents = {}
+        @diagnostic_states = {}
         @version_counter = 0
         @server_capabilities = {}
+        @sync_capabilities = {
+          source: :not_advertised, open_close: false, change: 0,
+          save: false, include_text: false
+        }.freeze
       end
 
       def binary_name
-        @server_cmd.to_s.split.first
+        @server_argv.first
       end
 
       def available?
         bin = binary_name
         return false if bin.nil? || bin.empty?
 
-        !Rubik::Platform.which(bin).nil?
+        !resolved_binary(bin).nil?
       end
 
       def start
         return false unless available?
 
-        @mutex.synchronize do
+        @document_mutex.synchronize do
           @req_id = 0
+          @open_documents.clear
+          @document_contents.clear
+          @version_counter = 0
+          @mutex.synchronize do
+            @diagnostics.clear
+            @diagnostic_states.clear
+          end
+        end
+        @mutex.synchronize do
           @responses.clear
           @pending_requests.clear
           @reader_failure = nil
-          @open_documents.clear
-          @diagnostics.clear
-          @version_counter = 0
         end
 
-        cmd_parts = @server_cmd.to_s.split
+        cmd_parts = @server_argv.dup
         bin = cmd_parts.first
-        resolved_bin = Rubik::Platform.which(bin)
+        resolved_bin = resolved_binary(bin)
+        return false unless resolved_bin
+
         cmd_parts[0] = resolved_bin if resolved_bin
 
         @stdin, @stdout, @stderr, @wait_thr = Open3.popen3(*cmd_parts, chdir: @root_dir)
@@ -118,8 +137,14 @@ module Rubik
                                   capabilities: {
                                     textDocument: {
                                       hover: { contentFormat: ["markdown", "plaintext"] },
-                                      definition: { dynamicRegistration: true },
-                                      references: { dynamicRegistration: true },
+                                      synchronization: {
+                                        dynamicRegistration: false,
+                                        willSave: false,
+                                        willSaveWaitUntil: false,
+                                        didSave: true
+                                      },
+                                      definition: { dynamicRegistration: false },
+                                      references: { dynamicRegistration: false },
                                       publishDiagnostics: { relatedInformation: true }
                                     }
                                   }
@@ -131,7 +156,11 @@ module Rubik
         end
 
         @server_capabilities = init_res.is_a?(Hash) ? (init_res["capabilities"] || {}) : {}
-        send_notification("initialized", {})
+        @sync_capabilities = normalize_sync_capabilities(@server_capabilities["textDocumentSync"])
+        unless send_notification("initialized", {})
+          stop
+          return false
+        end
         @running = true
         init_res
       rescue StandardError
@@ -246,23 +275,41 @@ module Rubik
       end
 
       def did_open(file_path, content, language_id = @language)
-        return false unless alive?
+        return false unless alive? && @sync_capabilities[:open_close]
 
         abs_path = normalized_document_path(file_path)
-        @mutex.synchronize do
-          @version_counter += 1
-          @open_documents[abs_path] = @version_counter
-        end
+        @document_mutex.synchronize do
+          if @open_documents.key?(abs_path)
+            return true if @document_contents[abs_path] == content
 
-        send_notification("textDocument/didOpen", {
-                            textDocument: {
-                              uri: document_uri(abs_path),
-                              languageId: language_id.to_s,
-                              version: @version_counter,
-                              text: content
-                            }
-                          })
-        true
+            return send_document_change_unlocked(abs_path, content)
+          end
+
+          version = next_document_version
+          @open_documents[abs_path] = version
+          @document_contents[abs_path] = content
+          old_state = @mutex.synchronize do
+            previous = @diagnostic_states[abs_path]
+            @diagnostic_states[abs_path] = pending_diagnostics(version)
+            previous
+          end
+          sent = send_notification("textDocument/didOpen", {
+                                     textDocument: {
+                                       uri: document_uri(abs_path),
+                                       languageId: language_id.to_s,
+                                       version: version,
+                                       text: content
+                                     }
+                                   })
+          unless sent
+            @open_documents.delete(abs_path)
+            @document_contents.delete(abs_path)
+            @mutex.synchronize do
+              old_state ? @diagnostic_states[abs_path] = old_state : @diagnostic_states.delete(abs_path)
+            end
+          end
+          sent
+        end
       rescue StandardError
         false
       end
@@ -271,44 +318,50 @@ module Rubik
         return false unless alive?
 
         abs_path = normalized_document_path(file_path)
-        version = @mutex.synchronize do
-          @version_counter += 1
-          @open_documents[abs_path] = @version_counter
-          @diagnostics.delete(abs_path)
-          @diagnostics.delete(file_path)
-          @diagnostics.delete_if { |k, _| Rubik::Platform.path_equal?(k, abs_path) }
-          @version_counter
-        end
-
-        send_notification("textDocument/didChange", {
-                            textDocument: {
-                              uri: document_uri(abs_path),
-                              version: version
-                            },
-                            contentChanges: [
-                              { text: content }
-                            ]
-                          })
-        true
+        @document_mutex.synchronize { send_document_change_unlocked(abs_path, content) }
       rescue StandardError
         false
       end
 
       def did_close(file_path)
-        return false unless @running
+        return false unless @running && @sync_capabilities[:open_close]
 
         abs_path = normalized_document_path(file_path)
-        raw_abs = Rubik::Platform.expand_path(file_path, @root_dir)
-        @mutex.synchronize do
+        @document_mutex.synchronize do
+          version = @open_documents[abs_path]
+          return false unless version
+
+          content = @document_contents[abs_path]
+          state, diagnostics = @mutex.synchronize do
+            [@diagnostic_states.delete(abs_path), @diagnostics.delete(abs_path)]
+          end
           @open_documents.delete(abs_path)
-          @open_documents.delete(raw_abs)
-          @open_documents.delete_if { |k, _| Rubik::Platform.path_equal?(k, abs_path) }
+          @document_contents.delete(abs_path)
+          sent = send_notification("textDocument/didClose", {
+                                     textDocument: { uri: document_uri(abs_path) }
+                                   })
+          unless sent
+            @open_documents[abs_path] = version
+            @document_contents[abs_path] = content
+            @mutex.synchronize do
+              @diagnostic_states[abs_path] = state if state
+              @diagnostics[abs_path] = diagnostics if diagnostics
+            end
+          end
+          sent
         end
+      rescue StandardError
+        false
+      end
 
-        send_notification("textDocument/didClose", {
-                            textDocument: { uri: document_uri(abs_path) }
-                          })
-        true
+      def did_save(file_path, content = nil)
+        return false unless alive? && @sync_capabilities[:save]
+        return false if @sync_capabilities[:include_text] && content.nil?
+
+        abs_path = normalized_document_path(file_path)
+        params = { textDocument: { uri: document_uri(abs_path) } }
+        params[:text] = content if @sync_capabilities[:include_text] && !content.nil?
+        send_notification("textDocument/didSave", params)
       rescue StandardError
         false
       end
@@ -317,34 +370,54 @@ module Rubik
         return false if file_path.nil? || file_path.to_s.strip.empty?
 
         abs_path = normalized_document_path(file_path)
-        raw_abs = Rubik::Platform.expand_path(file_path, @root_dir)
-        @mutex.synchronize do
-          @open_documents.key?(abs_path) ||
-            @open_documents.key?(raw_abs) ||
-            @open_documents.keys.any? { |k| Rubik::Platform.path_equal?(k, abs_path) }
-        end
+        @document_mutex.synchronize { @open_documents.key?(abs_path) }
       rescue ArgumentError
         false
       end
 
       def diagnostics_for(file_path)
+        diagnostics_snapshot_for(file_path)[:diagnostics]
+      end
+
+      def all_diagnostics
+        @mutex.synchronize do
+          @diagnostics.dup
+        end
+      end
+
+      def diagnostics_snapshot_for(file_path)
+        abs_path = normalized_document_path(file_path)
+        @mutex.synchronize { diagnostics_snapshot_unlocked(abs_path) }
+      rescue ArgumentError, TypeError
+        { state: :unavailable, diagnostics: [], document_version: nil, published_version: nil }
+      end
+
+      def wait_for_diagnostics(file_path, timeout: 0.2)
         abs_path = normalized_document_path(file_path)
-        raw_abs = Rubik::Platform.normalize_path_raw(Rubik::Platform.expand_path(file_path, @root_dir))
-        root_norm = Rubik::Platform.normalize_path_raw(@root_dir)
-        rel_path = raw_abs.start_with?("#{root_norm}/") ? raw_abs.delete_prefix("#{root_norm}/") : file_path.to_s.tr("\\", "/")
+        deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + timeout
         @mutex.synchronize do
-          @diagnostics[abs_path] ||
-            @diagnostics[raw_abs] ||
-            @diagnostics[rel_path] ||
-            @diagnostics[file_path] ||
-            @diagnostics.find { |k, _| Rubik::Platform.path_equal?(k, abs_path) }&.last ||
-            []
+          while @diagnostic_states[abs_path]&.dig(:state) == :pending
+            remaining = deadline - Process.clock_gettime(Process::CLOCK_MONOTONIC)
+            break if remaining <= 0
+
+            @cv.wait(@mutex, remaining)
+          end
+          diagnostics_snapshot_unlocked(abs_path)
         end
+      rescue ArgumentError, TypeError
+        { state: :unavailable, diagnostics: [], document_version: nil, published_version: nil }
       end
 
-      def all_diagnostics
+      def all_diagnostic_snapshots
         @mutex.synchronize do
-          @diagnostics.dup
+          @diagnostic_states.each_with_object({}) do |(path, state), result|
+            result[path] = {
+              state: state[:state],
+              diagnostics: (@diagnostics[path] || []).dup,
+              document_version: state[:document_version],
+              published_version: state[:published_version]
+            }
+          end
         end
       end
 
@@ -417,16 +490,22 @@ module Rubik
           uri = params["uri"].to_s
           raw_path = Rubik::Platform.from_file_uri(uri)
           norm_path = normalized_document_path(raw_path)
-          abs_path = Rubik::Platform.normalize_path_raw(Rubik::Platform.expand_path(raw_path, @root_dir))
-          root_norm = Rubik::Platform.normalize_path_raw(@root_dir)
-          rel_path = abs_path.start_with?("#{root_norm}/") ? abs_path.delete_prefix("#{root_norm}/") : abs_path
-          diags = params["diagnostics"] || []
-
-          @mutex.synchronize do
-            @diagnostics[norm_path] = diags
-            @diagnostics[abs_path] = diags
-            @diagnostics[rel_path] = diags
-            @diagnostics[raw_path] = diags
+          diags = params["diagnostics"].is_a?(Array) ? params["diagnostics"] : []
+          published_version = params["version"]
+
+          @document_mutex.synchronize do
+            current_version = @open_documents[norm_path]
+            next if published_version.is_a?(Numeric) && current_version && published_version < current_version
+
+            @mutex.synchronize do
+              @diagnostics[norm_path] = diags
+              @diagnostic_states[norm_path] = {
+                state: published_version.is_a?(Numeric) ? :fresh : :unversioned,
+                document_version: current_version,
+                published_version: published_version
+              }
+              @cv.broadcast
+            end
           end
         end
       end
@@ -443,7 +522,13 @@ module Rubik
           method: method,
           params: params
         }
-        write_message(msg)
+        unless write_message(msg)
+          @mutex.synchronize do
+            @pending_requests.delete(req_id)
+            @responses.delete(req_id)
+          end
+          raise RequestError.new(:transport_failure, @reader_failure || "LSP request write failed")
+        end
         wait_for_response(req_id, timeout: timeout)
       end
 
@@ -501,10 +586,133 @@ module Rubik
       end
 
       def normalized_document_path(file_path)
+        raise ArgumentError, "file_path cannot be nil or empty" if file_path.nil? || file_path.to_s.strip.empty?
+
+        return normalize_windows_document_path(file_path) if windows_document_path?(file_path) || windows_document_path?(@root_dir)
+
         path = Rubik::Platform.expand_path(file_path, @root_dir)
         Rubik::Platform.normalize_path(path)
       end
 
+      def windows_document_path?(path)
+        path.to_s.match?(%r{\A[A-Za-z]:[\\/]}) || path.to_s.start_with?("\\\\")
+      end
+
+      def normalize_windows_document_path(file_path)
+        raw = file_path.to_s.tr("\\", "/")
+        root = @root_dir.to_s.tr("\\", "/")
+        combined = if raw.match?(%r{\A[A-Za-z]:/}) || raw.start_with?("//")
+                     raw
+                   else
+                     "#{root}/#{raw}"
+                   end
+
+        prefix = combined.match(%r{\A([A-Za-z]:|//[^/]+/[^/]+)})&.[](1)
+        segments = combined.delete_prefix(prefix.to_s).split("/").each_with_object([]) do |segment, result|
+          next if segment.empty? || segment == "."
+
+          segment == ".." ? result.pop : result << segment
+        end
+        [prefix, *segments].compact.reject(&:empty?).join("/").downcase
+      end
+
+      def next_document_version
+        @version_counter += 1
+      end
+
+      def resolved_binary(bin)
+        if bin.include?("/") || (Rubik::Platform.windows? && bin.include?("\\"))
+          path = File.expand_path(bin, @root_dir)
+          return path if Rubik::Platform.executable_file?(path)
+
+          return nil
+        end
+
+        Rubik::Platform.which(bin)
+      end
+
+      def pending_diagnostics(version)
+        {
+          state: :pending,
+          document_version: version,
+          published_version: nil
+        }
+      end
+
+      def diagnostics_snapshot_unlocked(abs_path)
+        state = @diagnostic_states[abs_path]
+        {
+          state: state ? state[:state] : :unavailable,
+          diagnostics: (@diagnostics[abs_path] || []).dup,
+          document_version: state && state[:document_version],
+          published_version: state && state[:published_version]
+        }
+      end
+
+      def send_document_change_unlocked(abs_path, content)
+        return false unless @sync_capabilities[:change].to_i.positive?
+
+        previous_version = @open_documents[abs_path]
+        return false unless previous_version
+        return true if @document_contents[abs_path] == content
+
+        previous_content = @document_contents[abs_path]
+        previous_state = @mutex.synchronize { @diagnostic_states[abs_path] }
+        version = next_document_version
+        @open_documents[abs_path] = version
+        @document_contents[abs_path] = content
+        @mutex.synchronize { @diagnostic_states[abs_path] = pending_diagnostics(version) }
+
+        sent = send_notification("textDocument/didChange", {
+                                   textDocument: {
+                                     uri: document_uri(abs_path),
+                                     version: version
+                                   },
+                                   # A text-only event is a full-document replacement,
+                                   # which is valid for both Full and Incremental sync.
+                                   contentChanges: [{ text: content }]
+                                 })
+        unless sent
+          @open_documents[abs_path] = previous_version
+          @document_contents[abs_path] = previous_content
+          @mutex.synchronize do
+            previous_state ? @diagnostic_states[abs_path] = previous_state : @diagnostic_states.delete(abs_path)
+          end
+        end
+        sent
+      end
+
+      def normalize_sync_capabilities(value)
+        case value
+        when Numeric
+          change = value.to_i.clamp(0, 2)
+          {
+            source: :legacy_numeric,
+            open_close: change.positive?,
+            change: change,
+            save: false,
+            include_text: false
+          }.freeze
+        when Hash
+          save = value["save"]
+          {
+            source: :options,
+            open_close: value["openClose"] == true,
+            change: (value["change"] || 0).to_i.clamp(0, 2),
+            save: !!save,
+            include_text: save.is_a?(Hash) && save["includeText"] == true
+          }.freeze
+        else
+          {
+            source: :not_advertised,
+            open_close: false,
+            change: 0,
+            save: false,
+            include_text: false
+          }.freeze
+        end
+      end
+
       def document_uri(file_path)
         Rubik::Platform.to_file_uri(normalized_document_path(file_path))
       end
@@ -515,7 +723,12 @@ module Rubik
           params = msg["params"]
           items = params.is_a?(Hash) && params["items"].is_a?(Array) ? params["items"] : []
           write_message({ jsonrpc: "2.0", id: msg["id"], result: items.map { {} } })
-        when "client/registerCapability", "client/unregisterCapability", "window/workDoneProgress/create"
+        when "client/registerCapability", "client/unregisterCapability"
+          write_message({
+                          jsonrpc: "2.0", id: msg["id"],
+                          error: { code: -32_602, message: "Dynamic capability registration is not supported" }
+                        })
+        when "window/workDoneProgress/create"
           write_message({ jsonrpc: "2.0", id: msg["id"], result: nil })
         else
           write_message({
@@ -538,16 +751,27 @@ module Rubik
       def write_message(msg_hash)
         json = JSON.dump(msg_hash)
         header = "Content-Length: #{json.bytesize}\r\n\r\n"
-        begin
-          @stdin.write(header + json)
-        rescue IOError, SystemCallError
-          nil
-        end
-        begin
+        bytes = header + json
+        @write_mutex.synchronize do
+          offset = 0
+          while offset < bytes.bytesize
+            written = @stdin.write(bytes.byteslice(offset, bytes.bytesize - offset))
+            raise IOError, "LSP transport made no write progress" unless written&.positive?
+
+            offset += written
+          end
           @stdin.flush
-        rescue IOError, SystemCallError
-          nil
         end
+        true
+      rescue IOError, SystemCallError, NoMethodError => e
+        message = "LSP transport write failed: #{e.class}: #{e.message}"
+        @mutex.synchronize do
+          @reader_failure ||= message
+          @running = false
+          @crashed = true if @wait_thr
+          @cv.broadcast
+        end
+        false
       end
     end
   end