sadr 0.1.0 → 0.2.0

data/lib/sadr/future.rb

@@ -58,7 +58,7 @@ module Sadr
       Subscription.new { @lock.synchronize { @callbacks.delete(callback) } }
     end
 
-    def await(timeout: 10)
+    def await(timeout: nil)
       valid = timeout.nil? || (timeout.is_a?(Numeric) && timeout.finite? && timeout >= 0)
       raise ArgumentError, "timeout must be finite and nonnegative" unless valid
 

data/lib/sadr/protocol.rb

@@ -9,16 +9,16 @@ module Sadr
 
       absolute = File.expand_path(path).tr("\\", "/")
       absolute = "/#{absolute}" if absolute.match?(/\A[A-Za-z]:/)
-      "file://" + URI::RFC2396_PARSER.escape(absolute, /[^a-zA-Z0-9\-._~\/:]/)
+      "file://" + percent_encode(absolute)
     end
 
     def path(uri)
-      parsed = URI.parse(uri)
+      parsed = URI::DEFAULT_PARSER.parse(uri)
       valid = parsed.scheme == "file" && [nil, "", "localhost"].include?(parsed.host) &&
         parsed.query.nil? && parsed.fragment.nil? && parsed.path&.start_with?("/")
       raise Error, "expected local file URI" unless valid
 
-      value = URI::RFC2396_PARSER.unescape(parsed.path)
+      value = percent_decode(parsed.path)
       raise Error, "invalid file URI path" if value.include?("\0") || !value.valid_encoding?
 
       RUBY_PLATFORM.match?(/mswin|mingw/) ? value.sub(%r{\A/([A-Za-z]:/)}, '\\1') : value
@@ -74,17 +74,19 @@ module Sadr
         inserted = fetch(edit, "data", [])
         raise Error, "invalid semantic token delta" unless valid && inserted.is_a?(Array)
       end
-      sorted = edits.sort_by { |edit| fetch(edit, "start") }
       previous_end = 0
-      sorted.each do |edit|
+      previous_start = nil
+      edits.each do |edit|
         start = fetch(edit, "start")
         count = fetch(edit, "deleteCount")
-        raise Error, "invalid semantic token delta" if start < previous_end || start + count > data.length
+        duplicate = previous_start && start == previous_start
+        raise Error, "invalid semantic token delta" if duplicate || start < previous_end || start + count > data.length
 
+        previous_start = start
         previous_end = start + count
       end
       output = data.dup
-      sorted.reverse_each do |edit|
+      edits.reverse_each do |edit|
         output[fetch(edit, "start"), fetch(edit, "deleteCount")] = fetch(edit, "data", [])
       end
       scan_semantic(output, nil, false)
@@ -108,6 +110,29 @@ module Sadr
       values
     end
 
+    def workspace_edit(value)
+      raise Error, "invalid workspace edit" unless value.is_a?(Hash)
+
+      changes = fetch(value, "changes", nil)
+      if value.key?("changes") || value.key?(:changes)
+        raise Error, "invalid workspace edit changes" unless changes.is_a?(Hash)
+
+        changes.each do |uri, edits|
+          validate_uri(uri)
+          validate_text_edits(edits)
+        end
+      end
+      document_changes = fetch(value, "documentChanges", nil)
+      if value.key?("documentChanges") || value.key?(:documentChanges)
+        raise Error, "invalid workspace document changes" unless document_changes.is_a?(Array)
+
+        document_changes.each { |change| validate_document_change(change) }
+      end
+      value
+    rescue KeyError
+      raise Error, "invalid workspace edit"
+    end
+
     def semantic_tokens(data, legend: nil)
       scan_semantic(data, legend, true)
     end
@@ -122,8 +147,37 @@ module Sadr
         raise Error, "invalid semantic token legend" unless valid
       end
 
-      unless data.all? { |value| value.is_a?(Integer) && value.between?(0, 0x7fffffff) }
-        raise Error, "invalid semantic token value"
+      unless data.empty?
+        begin
+          total = data.sum
+          minimum, maximum = data.minmax
+        rescue StandardError
+          raise Error, "invalid semantic token value"
+        end
+        valid = total.is_a?(Integer) && minimum.is_a?(Integer) && maximum.is_a?(Integer) &&
+          minimum >= 0 && maximum <= 0x7fffffff
+        raise Error, "invalid semantic token value" unless valid
+      end
+      unless collect || legend
+        row = 0
+        column = 0
+        index = 2
+        size = data.length
+        while index < size
+          length = data[index]
+          delta_row = data[index - 2]
+          delta_column = data[index - 1]
+          raise Error, "invalid semantic token value" if length.zero?
+
+          row += delta_row
+          column = delta_row.zero? ? column + delta_column : delta_column
+          raise Error, "semantic token position overflow" if column + length > 0x7fffffff
+
+          index += 5
+        end
+        raise Error, "semantic token position overflow" if row > 0x7fffffff
+
+        return nil
       end
       row = 0
       column = 0
@@ -144,12 +198,14 @@ module Sadr
 
         row += delta_row
         column = delta_row.zero? ? column + delta_column : delta_column
-        raise Error, "semantic token position overflow" unless uint?(row) && uint?(column + length)
+        raise Error, "semantic token position overflow" if row > 0x7fffffff || column + length > 0x7fffffff
 
         tokens[index / 5] = Token.new(line: row, character: column, length: length, type: type, modifiers: modifiers) if collect
         index += 5
       end
       tokens
+    rescue TypeError, ArgumentError
+      raise Error, "invalid semantic token value"
     end
 
     def uint?(value)
@@ -173,6 +229,8 @@ module Sadr
         return Range_.new(start: first, end: last) if (position_tuple(first) <=> position_tuple(last)) <= 0
       end
       raise Error, "invalid LSP range"
+    rescue KeyError
+      raise Error, "invalid LSP range"
     end
 
     def position_hash(value)
@@ -185,6 +243,71 @@ module Sadr
       {start: position_hash(value.start), end: position_hash(value.end)}
     end
 
+    def validate_text_edits(edits)
+      raise Error, "invalid LSP text edits" unless edits.is_a?(Array)
+
+      edits.each do |edit|
+        valid = edit.is_a?(Hash) && fetch(edit, "newText", nil).is_a?(String) && fetch(edit, "newText").valid_encoding?
+        raise Error, "invalid LSP text edit" unless valid
+
+        range_value(fetch(edit, "range"))
+      end
+    end
+
+    def validate_document_change(change)
+      raise Error, "invalid workspace document change" unless change.is_a?(Hash)
+
+      kind = fetch(change, "kind", nil)
+      case kind
+      when "create", "delete"
+        validate_uri(fetch(change, "uri"))
+      when "rename"
+        validate_uri(fetch(change, "oldUri"))
+        validate_uri(fetch(change, "newUri"))
+      when nil
+        document = fetch(change, "textDocument", nil)
+        raise Error, "invalid workspace text document" unless document.is_a?(Hash)
+
+        validate_uri(fetch(document, "uri"))
+        unless document.key?("version") || document.key?(:version)
+          raise Error, "invalid workspace document version"
+        end
+        version = fetch(document, "version", nil)
+        valid_version = version.nil? || (version.is_a?(Integer) && version.between?(-0x80000000, 0x7fffffff))
+        raise Error, "invalid workspace document version" unless valid_version
+        validate_text_edits(fetch(change, "edits"))
+      else
+        raise Error, "unknown workspace resource operation"
+      end
+      options = fetch(change, "options", nil)
+      raise Error, "invalid workspace resource options" if options && !options.is_a?(Hash)
+    rescue KeyError
+      raise Error, "invalid workspace document change"
+    end
+
+    def validate_uri(value)
+      valid = value.is_a?(String) && !value.empty? && value.valid_encoding? && !value.include?("\0")
+      parsed = URI::DEFAULT_PARSER.parse(value) if valid
+      raise Error, "invalid URI" unless valid && parsed&.scheme && !parsed.scheme.empty?
+
+      value
+    rescue URI::InvalidURIError
+      raise Error, "invalid URI"
+    end
+
+    def percent_encode(value)
+      value.b.each_byte.map do |byte|
+        character = byte.chr
+        character.match?(/[a-zA-Z0-9\-._~\/:]/) ? character : format("%%%02X", byte)
+      end.join
+    end
+
+    def percent_decode(value)
+      raise Error, "invalid file URI path" if value.match?(/%(?![0-9A-Fa-f]{2})/)
+
+      value.b.gsub(/%([0-9A-Fa-f]{2})/) { Regexp.last_match(1).to_i(16).chr }.force_encoding(Encoding::UTF_8)
+    end
+
     def valid_position?(value)
       value.is_a?(Hash) && uint?(fetch(value, "line")) && uint?(fetch(value, "character"))
     end
@@ -203,6 +326,7 @@ module Sadr
       raise KeyError, "key not found: #{key}"
     end
 
-    private_class_method :scan_semantic, :valid_position?, :position_tuple, :fetch
+    private_class_method :scan_semantic, :validate_text_edits, :validate_document_change, :validate_uri, :percent_encode, :percent_decode,
+      :valid_position?, :position_tuple, :fetch
   end
 end

data/lib/sadr/testing/fake_client.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Sadr
+  module Testing
+    class FakeClient < Client
+      attr_reader :server
+
+      def initialize(server: FakeServer.new, **options)
+        @server = server
+        super(**{command: FakeServer.command, restart: false}.merge(options))
+      end
+
+      private
+
+      def build_transport(epoch)
+        @server.transport { |message, error| receive(message, error, epoch) }
+      end
+    end
+  end
+end

data/lib/sadr/testing/fake_server.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+require "rbconfig"
+
+module Sadr
+  module Testing
+    class FakeServer
+      DEFAULT_CAPABILITIES = {
+        "positionEncoding" => "utf-16",
+        "textDocumentSync" => {"openClose" => true, "change" => 2, "save" => {"includeText" => true}}
+      }.freeze
+
+      SCRIPT = <<~'RUBY'
+        require "json"
+        STDIN.binmode
+        STDOUT.binmode
+        STDOUT.sync = true
+
+        def send_message(message)
+          body = JSON.generate(message)
+          STDOUT.write("Content-Length: #{body.bytesize}\r\n\r\n#{body}")
+        end
+
+        range = {start: {line: 0, character: 0}, end: {line: 0, character: 1}}
+        command = {title: "Run", command: "run", arguments: []}
+        messages = []
+        semantic_refreshed = false
+        pending_semantic = nil
+        loop do
+          headers = {}
+          while (line = STDIN.gets) && line != "\r\n"
+            key, value = line.strip.split(":", 2)
+            headers[key] = value.strip
+          end
+          break unless line
+
+          message = JSON.parse(STDIN.read(headers.fetch("Content-Length").to_i))
+          messages << message
+          break if message["method"] == "exit"
+          next unless message.key?("id") && message.key?("method")
+
+          case message["method"]
+          when "initialize"
+            result = {capabilities: {positionEncoding: "utf-16", textDocumentSync: {openClose: true, change: 2, save: {includeText: true}}, semanticTokensProvider: {legend: {tokenTypes: ["variable"], tokenModifiers: []}, full: {delta: true}}}}
+          when "probe"
+            result = messages
+          when "server_request"
+            send_message(jsonrpc: "2.0", id: "server-1", method: message["params"]["method"], params: message["params"].fetch("params", {}))
+            result = true
+          when "server_notification"
+            send_message(jsonrpc: "2.0", method: message["params"]["method"], params: message["params"].fetch("params", {}))
+            result = true
+          when "stderr"
+            STDERR.write("x" * (2 << 20))
+            STDERR.flush
+            result = true
+          when "never"
+            next
+          when "crash"
+            exit!(1)
+          when "textDocument/semanticTokens/full"
+            if ENV["SADR_SEMANTIC_REVERSE"]
+              unless pending_semantic
+                pending_semantic = message
+                send_message(jsonrpc: "2.0", method: "semantic_started", params: {})
+                next
+              end
+              send_message(jsonrpc: "2.0", id: message["id"], result: {resultId: "new", data: [0, 0, 2, 0, 0]})
+              send_message(jsonrpc: "2.0", id: pending_semantic["id"], result: {resultId: "old", data: [0, 0, 1, 0, 0]})
+              pending_semantic = nil
+              next
+            end
+            if ENV["SADR_SEMANTIC_REFRESH"] && !semantic_refreshed
+              semantic_refreshed = true
+              send_message(jsonrpc: "2.0", id: "semantic-refresh", method: "workspace/semanticTokens/refresh", params: {})
+              sleep(0.02)
+            end
+            if ENV["SADR_SEMANTIC_DELAY"]
+              send_message(jsonrpc: "2.0", method: "semantic_started", params: {})
+              sleep(Float(ENV["SADR_SEMANTIC_DELAY"]))
+            end
+            result = {resultId: "first", data: [0, 0, 1, 0, 0]}
+          when "textDocument/semanticTokens/full/delta"
+            result = {resultId: "second", edits: [{start: 2, deleteCount: 1, data: [2]}]}
+          when "shutdown"
+            result = nil
+          when "textDocument/completion"
+            result = {isIncomplete: false, items: [{label: "x", detail: "optional"}], itemDefaults: {commitCharacters: ["."]}}
+          when "textDocument/hover"
+            result = {contents: {kind: "markdown", value: "hover"}, range: range, extension: true}
+          when "textDocument/signatureHelp"
+            result = {signatures: [{label: "f(x)", parameters: [{label: [2, 3]}]}], activeSignature: 0}
+          when "textDocument/documentSymbol"
+            result = [{name: "x", kind: 13, range: range, selectionRange: range, children: []}]
+          when "workspace/symbol"
+            result = [{name: "x", kind: 13, location: {uri: "file:///tmp/test.rb"}, data: {optional: true}}]
+          when "textDocument/codeAction"
+            result = [{title: "Fix", command: command}]
+          when "textDocument/codeLens"
+            result = [{range: range, command: command, data: {optional: true}}]
+          when "textDocument/inlayHint"
+            result = [{position: {line: 0, character: 0}, label: [{value: "x", tooltip: "optional"}]}]
+          when "textDocument/definition", "textDocument/typeDefinition", "textDocument/implementation", "textDocument/references", "textDocument/formatting"
+            result = []
+          when "textDocument/rename"
+            result = {changes: {}}
+          when "textDocument/diagnostic"
+            result = {kind: "full", items: []}
+          else
+            result = message["params"]
+          end
+          if ENV["SADR_INVALID_METHOD"] == message["method"]
+            result = message["method"] == "textDocument/formatting" ? [{range: {}, newText: "x"}] : "invalid"
+          end
+          if ENV["SADR_INVALID_ELEMENTS"]
+            result = case message["method"]
+            when "textDocument/completion" then [{}]
+            when "textDocument/definition" then {}
+            when "textDocument/codeAction", "textDocument/codeLens", "textDocument/inlayHint" then [1]
+            when "textDocument/diagnostic" then {}
+            else result
+            end
+          end
+          if ENV["SADR_INVALID_STRUCTURES"]
+            result = case message["method"]
+            when "textDocument/completion" then {items: [{label: "x"}]}
+            when "textDocument/hover" then {contents: {}}
+            when "textDocument/signatureHelp" then {signatures: [{}]}
+            when "textDocument/documentSymbol" then [{name: "x", kind: 13, range: range}]
+            when "workspace/symbol" then [{name: "x", kind: 13, location: {}}]
+            when "completionItem/resolve" then {}
+            when "textDocument/codeLens" then [{range: range, command: {title: "Run"}}]
+            else result
+            end
+          end
+          send_message(jsonrpc: "2.0", id: message["id"], result: result)
+        end
+      RUBY
+
+      def self.command = [RbConfig.ruby, "-e", SCRIPT]
+
+      attr_reader :capabilities
+
+      def initialize(responses: {}, capabilities: DEFAULT_CAPABILITIES)
+        raise ArgumentError, "responses must be a Hash" unless responses.is_a?(Hash)
+        raise ArgumentError, "capabilities must be a Hash" unless capabilities.is_a?(Hash)
+
+        @responses = responses.transform_keys(&:to_s)
+        @capabilities = capabilities
+        @messages = []
+        @lock = Mutex.new
+      end
+
+      def transport(&receive) = FakeTransport.new(self, &receive)
+
+      def messages = @lock.synchronize { @messages.dup }
+
+      def dispatch(message)
+        @lock.synchronize { @messages << message }
+        return [] unless message.key?("id") && message.key?("method")
+
+        result = case message["method"]
+        when "initialize" then {"capabilities" => @capabilities}
+        when "shutdown" then nil
+        else
+          response = @responses.fetch(message["method"], message["params"])
+          response.respond_to?(:call) ? response.call(message["params"], message) : response
+        end
+        [{"jsonrpc" => "2.0", "id" => message["id"], "result" => result}]
+      end
+    end
+  end
+end

data/lib/sadr/testing/fake_transport.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module Sadr
+  module Testing
+    class FakeTransport < Transport
+      MAX_TRY_FRAME = 512
+      STOP = Object.new.freeze
+      private_constant :MAX_TRY_FRAME, :STOP
+
+      attr_reader :stderr_lines, :pid
+
+      def initialize(server, &receive)
+        raise ArgumentError, "receiver required" unless receive
+
+        @server = server
+        @receive = receive
+        @stderr_lines = []
+        @pid = Process.pid
+        @lock = Mutex.new
+        @write_lock = Mutex.new
+        @responses = Queue.new
+        @alive = true
+        @reader = Thread.new { read }
+        @reader.report_on_exception = false
+      end
+
+      def write(message)
+        message, = wire(message)
+        responses = @write_lock.synchronize do
+          raise Error, "language server write failed: closed transport" unless alive?
+
+          @server.dispatch(message)
+        end
+        enqueue(responses)
+        nil
+      end
+
+      def try_write(message)
+        message, bytesize = wire(message)
+        return false if bytesize > MAX_TRY_FRAME || !@write_lock.try_lock
+
+        begin
+          return false unless alive?
+
+          responses = @server.dispatch(message)
+        ensure
+          @write_lock.unlock
+        end
+        enqueue(responses)
+        true
+      end
+
+      def alive? = @lock.synchronize { @alive }
+
+      def close
+        reader = @lock.synchronize do
+          @responses.clear
+          if @alive
+            @alive = false
+            @responses << STOP
+          end
+          @reader
+        end
+        return if reader == Thread.current
+
+        reader.kill unless reader.join(1)
+        reader.join
+        nil
+      end
+
+      private
+
+      def wire(message)
+        value = frame(message)
+        body_start = value.index("\r\n\r\n") + 4
+        [JSON.parse(value.byteslice(body_start, value.bytesize - body_start)), value.bytesize]
+      rescue JSON::ParserError => error
+        raise Error, "invalid LSP JSON: #{error.message.byteslice(0, 256)}"
+      end
+
+      def enqueue(responses)
+        messages = responses.map { |response| wire(response).first }
+        @lock.synchronize do
+          return unless @alive
+
+          messages.each { |message| @responses << message }
+        end
+      end
+
+      def read
+        loop do
+          message = @responses.pop
+          break if message.equal?(STOP)
+
+          @receive.call(message, nil)
+        end
+      rescue StandardError => error
+        begin
+          @receive.call(nil, error) if alive?
+        rescue StandardError
+          nil
+        end
+      ensure
+        @lock.synchronize { @alive = false }
+      end
+    end
+  end
+end

data/lib/sadr/testing.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require_relative "../sadr"
+require_relative "testing/fake_transport"
+require_relative "testing/fake_server"
+require_relative "testing/fake_client"

data/lib/sadr/transport.rb

@@ -3,10 +3,12 @@
 module Sadr
   class Transport
     MAX_MESSAGE = 32 << 20
+    MAX_TRY_FRAME = 512
+    private_constant :MAX_TRY_FRAME
 
     attr_reader :stderr_lines, :pid
 
-    def initialize(command, cwd: nil, env: {}, &receive)
+    def initialize(command, cwd: nil, env: {}, on_spawn: nil, &receive)
       valid = command.is_a?(Array) && !command.empty? && command.all? do |part|
         part.is_a?(String) && !part.include?("\0")
       end
@@ -14,14 +16,28 @@ module Sadr
       raise ArgumentError, "receiver required" unless receive
 
       options = cwd ? {chdir: cwd} : {}
-      @stdin, @stdout, @stderr, @process = Open3.popen3(env, *command, **options)
-      @stdin.binmode
-      @stdout.binmode
-      @pid = @process.pid
+      @close_lock = Mutex.new
+      @closing = false
+      @reader = @logger = nil
       @write_lock = Mutex.new
       @stderr_lines = []
-      @reader = Thread.new { read(receive) }
-      @logger = Thread.new { read_stderr }
+      initialized = false
+      begin
+        @stdin, @stdout, @stderr, @process = Open3.popen3(env, *command, **options)
+        @pid = @process.pid
+        on_spawn&.call(self)
+        @close_lock.synchronize do
+          raise Error, "language server connection was cancelled" if @closing
+
+          @stdin.binmode
+          @stdout.binmode
+          @reader = Thread.new { read(receive) }
+          @logger = Thread.new { read_stderr }
+        end
+        initialized = true
+      ensure
+        close if @process && !initialized
+      end
     end
 
     def self.read_message(io)
@@ -89,39 +105,55 @@ module Sadr
     end
 
     def write(message)
-      raise Error, "expected JSON-RPC object" unless message.is_a?(Hash)
-
-      normalized = message.transform_keys(&:to_s)
-      normalized["error"] = normalized["error"].transform_keys(&:to_s) if normalized["error"].is_a?(Hash)
-      self.class.validate_message(normalized)
-      body = JSON.generate(message).b
-      raise Error, "oversized LSP message" unless body.bytesize.between?(1, MAX_MESSAGE)
+      frame = frame(message)
 
       @write_lock.synchronize do
-        @stdin.write("Content-Length: #{body.bytesize}\r\n\r\n")
-        @stdin.write(body)
+        @stdin.write(frame)
         @stdin.flush
       end
     rescue IOError, Errno::EPIPE => error
       raise Error, "language server write failed: #{error.message}"
     end
 
+    def try_write(message)
+      value = frame(message)
+      return false if value.bytesize > MAX_TRY_FRAME || !@write_lock.try_lock
+
+      begin
+        written = @stdin.write_nonblock(value, exception: false)
+        return false if written == :wait_writable
+        return true if written == value.bytesize
+
+        @stdin.close unless @stdin.closed?
+        false
+      rescue IOError, SystemCallError
+        false
+      ensure
+        @write_lock.unlock
+      end
+    end
+
     def alive? = @process.alive?
 
     def close
-      return if @closing
+      closing = @close_lock.synchronize do
+        next false if @closing
+
+        @closing = true
+      end
+      return unless closing
 
-      @closing = true
       @stdin.close unless @stdin.closed?
+      pid = @pid || @process.pid
       unless @process.join(1)
         begin
-          Process.kill("TERM", @pid)
+          Process.kill("TERM", pid)
         rescue Errno::ESRCH
           nil
         end
         unless @process.join(1)
           begin
-            Process.kill("KILL", @pid)
+            Process.kill("KILL", pid)
           rescue Errno::ESRCH
             nil
           end
@@ -129,7 +161,7 @@ module Sadr
         end
       end
       [@stdout, @stderr].each { |io| io.close unless io.closed? }
-      [@reader, @logger].each do |thread|
+      [@reader, @logger].compact.each do |thread|
         next if thread == Thread.current
 
         thread.kill unless thread.join(1)
@@ -138,6 +170,20 @@ module Sadr
 
     private
 
+    def frame(message)
+      raise Error, "expected JSON-RPC object" unless message.is_a?(Hash)
+
+      normalized = message.transform_keys(&:to_s)
+      normalized["error"] = normalized["error"].transform_keys(&:to_s) if normalized["error"].is_a?(Hash)
+      self.class.validate_message(normalized)
+      body = JSON.generate(message).b
+      raise Error, "oversized LSP message" unless body.bytesize.between?(1, MAX_MESSAGE)
+
+      "Content-Length: #{body.bytesize}\r\n\r\n".b + body
+    rescue JSON::GeneratorError => error
+      raise Error, "invalid LSP JSON: #{error.message.byteslice(0, 256)}"
+    end
+
     def read(receive)
       loop do
         message = self.class.read_message(@stdout)