sadr 0.1.0

data/lib/sadr/document_sync.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Sadr
+  class DocumentIndex
+    Point = Struct.new(:row, :column)
+    BREAK = /(?:\r\n|[\r\n\u2028\u2029])\z/
+
+    def initialize(text)
+      @text = text
+      @line_starts = [0]
+      offset = 0
+      previous_cr = false
+      text.each_char do |character|
+        offset += character.bytesize
+        case character
+        when "\r"
+          @line_starts << offset
+        when "\n"
+          previous_cr ? @line_starts[-1] = offset : @line_starts << offset
+        when "\u2028", "\u2029"
+          @line_starts << offset
+        end
+        previous_cr = character == "\r"
+      end
+    end
+
+    def line_start(row)
+      @line_starts.fetch(row)
+    rescue IndexError
+      raise RangeError, "line out of bounds"
+    end
+
+    def line(row)
+      start = line_start(row)
+      finish = @line_starts.fetch(row + 1, @text.bytesize)
+      @text.byteslice(start, finish - start).sub(BREAK, "")
+    end
+
+    def utf16_offset_at(byte_offset)
+      prefix = prefix_at(byte_offset)
+      prefix.each_codepoint.sum { |codepoint| codepoint > 0xffff ? 2 : 1 }
+    end
+
+    def offset_at_utf16(utf16_offset)
+      raise RangeError, "UTF-16 offset out of bounds" unless utf16_offset.is_a?(Integer) && utf16_offset >= 0
+
+      units = 0
+      bytes = 0
+      @text.each_codepoint do |codepoint|
+        return bytes if units == utf16_offset
+
+        units += codepoint > 0xffff ? 2 : 1
+        bytes += codepoint.chr(Encoding::UTF_8).bytesize
+        raise RangeError, "UTF-16 offset splits a surrogate pair" if units > utf16_offset
+      end
+      return bytes if units == utf16_offset
+
+      raise RangeError, "UTF-16 offset out of bounds"
+    end
+
+    def utf16_point_at(byte_offset)
+      prefix_at(byte_offset)
+      row = @line_starts.bsearch_index { |start| start > byte_offset }
+      row = row ? row - 1 : @line_starts.length - 1
+      Point.new(row, utf16_offset_at(byte_offset) - utf16_offset_at(line_start(row)))
+    end
+
+    private
+
+    def prefix_at(byte_offset)
+      raise RangeError, "byte offset out of bounds" unless byte_offset.is_a?(Integer) && byte_offset.between?(0, @text.bytesize)
+
+      prefix = @text.byteslice(0, byte_offset)
+      raise RangeError, "byte offset splits a character" unless prefix.valid_encoding?
+
+      prefix
+    end
+  end
+  private_constant :DocumentIndex
+end

data/lib/sadr/future.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module Sadr
+  class Future
+    class Subscription
+      def initialize(&detach) = @detach = detach
+
+      def detach
+        callback, @detach = @detach, nil
+        callback&.call
+      end
+    end
+
+    attr_reader :id, :callback_errors
+
+    def initialize(id, on_error: nil, &cancel)
+      @id = id
+      @cancel_callback = cancel
+      @on_error = on_error
+      @lock = Mutex.new
+      @ready = ConditionVariable.new
+      @callbacks = []
+      @callback_errors = []
+    end
+
+    def fulfill(value = nil, error: nil)
+      callbacks = @lock.synchronize do
+        return if @done
+
+        @value = value
+        @error = error
+        @done = true
+        @ready.broadcast
+        saved, @callbacks = @callbacks, []
+        saved
+      end
+      callbacks.each { |callback| invoke(callback) }
+      self
+    end
+
+    def then(&callback)
+      raise ArgumentError, "callback required" unless callback
+
+      on_complete { callback.call(@value, @error) }
+      self
+    end
+
+    def done? = @lock.synchronize { !!@done }
+
+    def on_complete(&callback)
+      raise ArgumentError, "callback required" unless callback
+
+      ready = @lock.synchronize do
+        @callbacks << callback unless @done
+        @done
+      end
+      invoke(callback) if ready
+      Subscription.new { @lock.synchronize { @callbacks.delete(callback) } }
+    end
+
+    def await(timeout: 10)
+      valid = timeout.nil? || (timeout.is_a?(Numeric) && timeout.finite? && timeout >= 0)
+      raise ArgumentError, "timeout must be finite and nonnegative" unless valid
+
+      if defined?(Zaniah::TaskExecutor) && Zaniah::TaskExecutor.current && !done?
+        return Zaniah::TaskExecutor.current.await(self, timeout: timeout)
+      end
+
+      deadline = timeout && Process.clock_gettime(Process::CLOCK_MONOTONIC) + timeout
+      @lock.synchronize do
+        until @done
+          remaining = deadline && deadline - Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          raise Timeout, "LSP request #{@id} timed out" if remaining && remaining <= 0
+
+          @ready.wait(@lock, remaining)
+        end
+        raise @error if @error
+
+        @value
+      end
+    rescue StandardError => error
+      if error.is_a?(Timeout) || (defined?(Zaniah::Task::Timeout) && error.is_a?(Zaniah::Task::Timeout))
+        cancel
+        raise Timeout, "LSP request #{@id} timed out"
+      end
+      raise
+    end
+
+    def cancel
+      callback = @lock.synchronize do
+        return false if @done || @cancelling
+
+        @cancelling = true
+        @cancel_callback
+      end
+      invoke(-> { callback.call(@id) }) if callback
+      fulfill(error: Error.new("request cancelled"))
+      true
+    end
+
+    private
+
+    def invoke(callback)
+      callback.call
+    rescue StandardError => error
+      bounded = Error.new("#{error.class}: #{error.message}".scrub.byteslice(0, 2048).scrub(""))
+      @lock.synchronize do
+        @callback_errors << bounded
+        @callback_errors.shift if @callback_errors.length > 32
+      end
+      begin
+        @on_error&.call(bounded)
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end

data/lib/sadr/protocol.rb

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+module Sadr
+  module Protocol
+    module_function
+
+    def uri(path)
+      raise Error, "path must be a String" unless path.is_a?(String) && !path.include?("\0")
+
+      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\-._~\/:]/)
+    end
+
+    def path(uri)
+      parsed = URI.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)
+      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
+    rescue URI::InvalidURIError => error
+      raise Error, error.message
+    end
+
+    def position(index, offset)
+      point = index.utf16_point_at(offset)
+      Position.new(line: point.row, character: point.column)
+    rescue NoMethodError => error
+      raise Error, "invalid text index: #{error.message}"
+    end
+
+    def offset(index, position)
+      point = position_value(position)
+      start = index.line_start(point.line)
+      finish = start + index.line(point.line).bytesize
+      units = index.utf16_offset_at(finish) - index.utf16_offset_at(start)
+      index.offset_at_utf16(index.utf16_offset_at(start) + [point.character, units].min)
+    rescue NoMethodError => error
+      raise Error, "invalid text index: #{error.message}"
+    end
+
+    def range(index, byte_range)
+      raise Error, "invalid byte range" unless byte_range.is_a?(Range) && byte_range.begin.is_a?(Integer) && byte_range.end.is_a?(Integer)
+
+      finish = byte_range.end + (byte_range.exclude_end? ? 0 : 1)
+      Range_.new(start: position(index, byte_range.begin), end: position(index, finish))
+    end
+
+    def text_edits(index, edits)
+      raise Error, "invalid LSP text edits" unless edits.is_a?(Array)
+
+      edits.map do |edit|
+        valid = edit.is_a?(Hash) && fetch(edit, "range").is_a?(Hash) && fetch(edit, "newText").is_a?(String)
+        raise Error, "invalid LSP text edit" unless valid && fetch(edit, "newText").valid_encoding?
+
+        value = fetch(edit, "range")
+        first = offset(index, fetch(value, "start"))
+        last = offset(index, fetch(value, "end"))
+        raise Error, "invalid LSP text edit range" if last < first
+
+        [first...last, fetch(edit, "newText")]
+      end
+    end
+
+    def semantic_delta(data, edits)
+      raise Error, "invalid semantic token delta" unless data.is_a?(Array) && edits.is_a?(Array)
+
+      edits.each do |edit|
+        valid = edit.is_a?(Hash) && uint?(fetch(edit, "start")) && uint?(fetch(edit, "deleteCount"))
+        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|
+        start = fetch(edit, "start")
+        count = fetch(edit, "deleteCount")
+        raise Error, "invalid semantic token delta" if start < previous_end || start + count > data.length
+
+        previous_end = start + count
+      end
+      output = data.dup
+      sorted.reverse_each do |edit|
+        output[fetch(edit, "start"), fetch(edit, "deleteCount")] = fetch(edit, "data", [])
+      end
+      scan_semantic(output, nil, false)
+      output
+    end
+
+    def diagnostics(values)
+      valid = values.is_a?(Array) && values.all? do |value|
+        next false unless value.is_a?(Hash) && fetch(value, "message").is_a?(String) && fetch(value, "range").is_a?(Hash)
+
+        range = fetch(value, "range")
+        points = %w[start end].map { |key| fetch(range, key, nil) }
+        severity = fetch(value, "severity", nil)
+        has_severity = value.key?("severity") || value.key?(:severity)
+        points.all? { |point| valid_position?(point) } &&
+          (position_tuple(points[0]) <=> position_tuple(points[1])) <= 0 &&
+          (!has_severity || (severity.is_a?(Integer) && severity.between?(1, 4)))
+      end
+      raise Error, "invalid LSP diagnostics" unless valid
+
+      values
+    end
+
+    def semantic_tokens(data, legend: nil)
+      scan_semantic(data, legend, true)
+    end
+
+    def scan_semantic(data, legend, collect)
+      raise Error, "invalid semantic token tuple count" unless data.is_a?(Array) && (data.length % 5).zero?
+      if legend
+        valid = legend.is_a?(Hash) && %w[tokenTypes tokenModifiers].all? do |key|
+          value = fetch(legend, key)
+          value.is_a?(Array) && value.all? { |name| name.is_a?(String) }
+        end
+        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"
+      end
+      row = 0
+      column = 0
+      tokens = collect ? Array.new(data.length / 5) : nil
+      index = 0
+      while index < data.length
+        delta_row = data[index]
+        delta_column = data[index + 1]
+        length = data[index + 2]
+        type = data[index + 3]
+        modifiers = data[index + 4]
+        raise Error, "invalid semantic token value" unless length.positive?
+        if legend
+          types = fetch(legend, "tokenTypes")
+          token_modifiers = fetch(legend, "tokenModifiers")
+          raise Error, "semantic token exceeds legend" if type >= types.length || modifiers.bit_length > token_modifiers.length
+        end
+
+        row += delta_row
+        column = delta_row.zero? ? column + delta_column : delta_column
+        raise Error, "semantic token position overflow" unless uint?(row) && uint?(column + length)
+
+        tokens[index / 5] = Token.new(line: row, character: column, length: length, type: type, modifiers: modifiers) if collect
+        index += 5
+      end
+      tokens
+    end
+
+    def uint?(value)
+      value.is_a?(Integer) && value.between?(0, 0x7fffffff)
+    end
+
+    def position_value(value)
+      return value if value.is_a?(Position) && uint?(value.line) && uint?(value.character)
+      return Position.new(line: fetch(value, "line"), character: fetch(value, "character")) if valid_position?(value)
+
+      raise Error, "invalid LSP position"
+    end
+
+    def range_value(value)
+      if value.is_a?(Range_)
+        valid = (position_tuple(value.start) <=> position_tuple(value.end)) <= 0
+        return Range_.new(start: position_value(value.start), end: position_value(value.end)) if valid
+      elsif value.is_a?(Hash)
+        first = position_value(fetch(value, "start"))
+        last = position_value(fetch(value, "end"))
+        return Range_.new(start: first, end: last) if (position_tuple(first) <=> position_tuple(last)) <= 0
+      end
+      raise Error, "invalid LSP range"
+    end
+
+    def position_hash(value)
+      point = position_value(value)
+      {line: point.line, character: point.character}
+    end
+
+    def range_hash(value)
+      value = range_value(value)
+      {start: position_hash(value.start), end: position_hash(value.end)}
+    end
+
+    def valid_position?(value)
+      value.is_a?(Hash) && uint?(fetch(value, "line")) && uint?(fetch(value, "character"))
+    end
+
+    def position_tuple(value)
+      point = value.is_a?(Position) ? value : position_value(value)
+      [point.line, point.character]
+    end
+
+    def fetch(hash, key, default = :__missing__)
+      return hash[key] if hash.key?(key)
+      symbol = key.to_sym
+      return hash[symbol] if hash.key?(symbol)
+      return default unless default == :__missing__
+
+      raise KeyError, "key not found: #{key}"
+    end
+
+    private_class_method :scan_semantic, :valid_position?, :position_tuple, :fetch
+  end
+end

data/lib/sadr/transport.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+module Sadr
+  class Transport
+    MAX_MESSAGE = 32 << 20
+
+    attr_reader :stderr_lines, :pid
+
+    def initialize(command, cwd: nil, env: {}, &receive)
+      valid = command.is_a?(Array) && !command.empty? && command.all? do |part|
+        part.is_a?(String) && !part.include?("\0")
+      end
+      raise ArgumentError, "command must be a nonempty argument array" unless valid
+      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
+      @write_lock = Mutex.new
+      @stderr_lines = []
+      @reader = Thread.new { read(receive) }
+      @logger = Thread.new { read_stderr }
+    end
+
+    def self.read_message(io)
+      headers = {}
+      count = 0
+      loop do
+        line = io.gets("\r\n", 8193)
+        return nil if line.nil? && headers.empty?
+        raise Error, "truncated or oversized LSP header" unless line && line.end_with?("\r\n") && line.bytesize <= 8192
+        break if line == "\r\n"
+
+        count += line.bytesize
+        raise Error, "oversized LSP headers" if count > 16_384
+        raise Error, "non-ASCII LSP header" unless line.ascii_only?
+
+        key, value = line.strip.split(":", 2)
+        raise Error, "invalid LSP header" unless value && key.match?(/\A[A-Za-z][A-Za-z0-9-]*\z/)
+
+        key = key.downcase
+        raise Error, "duplicate LSP header" if headers.key?(key)
+
+        headers[key] = value.strip
+      end
+      raw_length = headers["content-length"]
+      raise Error, "missing or invalid Content-Length" unless raw_length&.match?(/\A\d+\z/)
+
+      length = Integer(raw_length, 10)
+      raise Error, "oversized LSP message" unless length.between?(1, MAX_MESSAGE)
+
+      charset = headers["content-type"]&.match(/charset\s*=\s*"?([^;"\s]+)/i)&.[](1)
+      raise Error, "unsupported LSP character encoding" if charset && !%w[utf-8 utf8].include?(charset.downcase)
+
+      body = io.read(length)
+      raise Error, "truncated LSP body" unless body && body.bytesize == length
+
+      body.force_encoding(Encoding::UTF_8)
+      raise Error, "invalid LSP UTF-8 body" unless body.valid_encoding?
+
+      validate_message(JSON.parse(body))
+    rescue JSON::ParserError => error
+      raise Error, "invalid LSP JSON: #{error.message.byteslice(0, 256)}"
+    end
+
+    def self.validate_message(message)
+      raise Error, "invalid JSON-RPC message" unless message.is_a?(Hash) && message["jsonrpc"] == "2.0"
+      if message.key?("method")
+        raise Error, "invalid JSON-RPC method" unless message["method"].is_a?(String) && !message["method"].empty?
+        invalid_params = message.key?("params") && !message["params"].is_a?(Hash) && !message["params"].is_a?(Array)
+        raise Error, "invalid JSON-RPC parameters" if invalid_params
+        raise Error, "request contains a response" if message.key?("result") || message.key?("error")
+      else
+        valid_response = message.key?("id") && (message.key?("result") ^ message.key?("error"))
+        raise Error, "invalid JSON-RPC response" unless valid_response
+        if message.key?("error")
+          error = message["error"]
+          valid_error = error.is_a?(Hash) && error["code"].is_a?(Integer) && error["message"].is_a?(String)
+          raise Error, "invalid JSON-RPC error" unless valid_error
+        end
+      end
+      id = message["id"]
+      valid_id = id.is_a?(Integer) || id.is_a?(String) || (id.nil? && !message.key?("method"))
+      raise Error, "invalid JSON-RPC id" if message.key?("id") && !valid_id
+
+      message
+    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)
+
+      @write_lock.synchronize do
+        @stdin.write("Content-Length: #{body.bytesize}\r\n\r\n")
+        @stdin.write(body)
+        @stdin.flush
+      end
+    rescue IOError, Errno::EPIPE => error
+      raise Error, "language server write failed: #{error.message}"
+    end
+
+    def alive? = @process.alive?
+
+    def close
+      return if @closing
+
+      @closing = true
+      @stdin.close unless @stdin.closed?
+      unless @process.join(1)
+        begin
+          Process.kill("TERM", @pid)
+        rescue Errno::ESRCH
+          nil
+        end
+        unless @process.join(1)
+          begin
+            Process.kill("KILL", @pid)
+          rescue Errno::ESRCH
+            nil
+          end
+          @process.join
+        end
+      end
+      [@stdout, @stderr].each { |io| io.close unless io.closed? }
+      [@reader, @logger].each do |thread|
+        next if thread == Thread.current
+
+        thread.kill unless thread.join(1)
+      end
+    end
+
+    private
+
+    def read(receive)
+      loop do
+        message = self.class.read_message(@stdout)
+        break unless message
+
+        receive.call(message, nil)
+      end
+      receive.call(nil, Error.new("language server closed stdout")) unless @closing
+    rescue StandardError => error
+      begin
+        receive.call(nil, error) unless @closing
+      rescue StandardError
+        nil
+      end
+    end
+
+    def read_stderr
+      while (line = @stderr.gets("\n", 8192))
+        @stderr_lines << line.scrub.byteslice(0, 8192).scrub("")
+        @stderr_lines.shift if @stderr_lines.length > 200
+      end
+    rescue IOError
+      nil
+    end
+  end
+end

data/lib/sadr/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Sadr
+  VERSION = "0.1.0"
+end

data/lib/sadr.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "json"
+require "open3"
+require "thread"
+require "uri"
+
+require_relative "sadr/version"
+
+module Sadr
+  class Error < StandardError; end
+  class Timeout < Error; end
+
+  class ServerError < Error
+    attr_reader :code, :data
+
+    def initialize(error)
+      @code = error["code"]
+      @data = error["data"]
+      super(error["message"])
+    end
+  end
+
+  module Value
+    module_function
+
+    def define(*members)
+      return Data.define(*members) if defined?(Data)
+
+      Struct.new(*members, keyword_init: true) do
+        def initialize(**values)
+          super
+          freeze
+        end
+      end
+    end
+  end
+
+  Position = Value.define(:line, :character)
+  Range_ = Value.define(:start, :end)
+  ContentChange = Value.define(:range, :text)
+  Document = Value.define(:uri, :language_id, :version, :text)
+  Token = Value.define(:line, :character, :length, :type, :modifiers)
+  private_constant :Value
+
+  # Text indexes are accepted by protocol conversion methods through duck typing.
+  # Required methods are documented in sig/sadr.rbs.
+  module TextIndex; end
+end
+
+require_relative "sadr/protocol"
+require_relative "sadr/future"
+require_relative "sadr/transport"
+require_relative "sadr/document_sync"
+require_relative "sadr/client"