canopus 0.4.0 → 0.5.0

data/lib/canopus/lsp/client.rb

@@ -1,307 +0,0 @@
-# frozen_string_literal: true
-
-module Canopus
-  module LSP
-    class Client
-      attr_reader :capabilities, :transport, :diagnostics, :state, :errors, :server_info, :position_encoding
-      def initialize(command:, root: Dir.pwd, dispatch: ->(&block) { block.call }, restart: true, env: {}, initialization_options: nil, configuration: {})
-        @command, @root, @dispatch, @restart = command, File.expand_path(root), dispatch, restart
-        @env, @initialization_options, @configuration = env, initialization_options, configuration
-        @pending, @handlers, @documents, @diagnostics, @semantic = {}, {}, {}, {}, {}
-        @sequence, @lock, @state, @restarts, @epoch = 0, Mutex.new, :stopped, 0, 0
-        @errors, @capabilities = [], {}
-      end
-      def start(timeout: 10)
-        raise Error, "language server is already started" if [:starting, :running].include?(@state)
-        @closing = false
-        @state = :starting
-        epoch = (@epoch += 1)
-        @semantic.clear
-        @transport = Transport.new(@command, cwd: @root, env: @env) { |message, error| receive(message, error, epoch) }
-        result = request("initialize", {processId: Process.pid, rootUri: Protocol.uri(@root),
-          clientInfo: {name: "Canopus", version: (defined?(Canopus::VERSION) ? Canopus::VERSION : "0.1.0")},
-          workspaceFolders: [{uri: Protocol.uri(@root), name: File.basename(@root)}], initializationOptions: @initialization_options,
-          capabilities: {general: {positionEncodings: ["utf-16"]},
-            window: {workDoneProgress: true},
-            textDocument: {synchronization: {dynamicRegistration: false, didSave: true},
-              completion: {completionItem: {snippetSupport: true, documentationFormat: %w[markdown plaintext], resolveSupport: {properties: %w[documentation detail additionalTextEdits]}}},
-              hover: {contentFormat: %w[markdown plaintext]},
-              signatureHelp: {signatureInformation: {documentationFormat: %w[markdown plaintext], parameterInformation: {labelOffsetSupport: true}}},
-              documentSymbol: {hierarchicalDocumentSymbolSupport: true},
-              codeAction: {codeActionLiteralSupport: {codeActionKind: {valueSet: %w[quickfix refactor refactor.extract refactor.inline refactor.rewrite source source.organizeImports]}}, resolveSupport: {properties: ["edit"]}},
-              publishDiagnostics: {relatedInformation: true, versionSupport: true},
-              diagnostic: {dynamicRegistration: false, relatedDocumentSupport: false},
-              inlayHint: {dynamicRegistration: false}, codeLens: {dynamicRegistration: false},
-              semanticTokens: {requests: {full: {delta: true}}, tokenTypes: %w[namespace type class enum interface struct typeParameter parameter variable property enumMember event function method macro keyword modifier comment string number regexp operator decorator], tokenModifiers: %w[declaration definition readonly static deprecated abstract async modification documentation defaultLibrary], formats: ["relative"], overlappingTokenSupport: false, multilineTokenSupport: false}},
-            workspace: {applyEdit: true, configuration: true, workspaceFolders: true,
-              workspaceEdit: {documentChanges: true, resourceOperations: %w[create rename delete], failureHandling: "abort"}}}}).await(timeout: timeout)
-        raise Error, "invalid initialize result" unless result.is_a?(Hash) && result["capabilities"].is_a?(Hash)
-        @capabilities, @server_info = result["capabilities"], result["serverInfo"]
-        sync = @capabilities["textDocumentSync"]
-        mode = sync.is_a?(Hash) ? sync.fetch("change", 0) : sync
-        raise Error, "invalid text document synchronization mode" unless mode.nil? || [0, 1, 2].include?(mode)
-        @position_encoding = @capabilities.fetch("positionEncoding", "utf-16")
-        raise Error, "server selected unadvertised position encoding #{@position_encoding}" unless @position_encoding == "utf-16"
-        semantic = @capabilities["semanticTokensProvider"]
-        raise Error, "missing semantic token legend" if semantic && (!semantic.is_a?(Hash) || !semantic["legend"].is_a?(Hash))
-        Protocol.semantic_tokens([], legend: semantic["legend"]) if semantic.is_a?(Hash)
-        notify("initialized", {})
-        reopen_documents if @reopening_documents
-        @state = :running
-        self
-      rescue StandardError => error
-        @transport&.close if epoch
-        fail_pending(error) if epoch
-        @state = :failed if epoch
-        raise
-      end
-      def request(method, params = {})
-        id = @lock.synchronize { @sequence += 1 }
-        future = Future.new(id, on_error: method(:report_error)) { |number| cancel(number) }
-        @lock.synchronize { @pending[id] = future }
-        raise Error, "language server is not connected" unless @transport&.alive?
-        @transport.write(jsonrpc: "2.0", id: id, method: method.to_s, params: params)
-        future
-      rescue StandardError => error
-        @lock.synchronize { @pending.delete(id) }
-        future.fulfill(error: error)
-        future
-      end
-      def notify(method, params = {})
-        raise Error, "language server is not connected" unless @transport&.alive?
-        @transport.write(jsonrpc: "2.0", method: method.to_s, params: params)
-      end
-      def on(method, &handler)
-        raise ArgumentError, "handler required" unless handler
-        @handlers[method.to_s] = handler
-      end
-      def supports?(capability) = !!@capabilities[capability.to_s]
-      def workspace_symbols(query) = request("workspace/symbol", {query: query})
-      def resolve_completion(item) = request("completionItem/resolve", item)
-      def resolve_code_action(action) = request("codeAction/resolve", action)
-      def resolve_code_lens(lens) = request("codeLens/resolve", lens)
-      def execute_command(command, arguments: []) = request("workspace/executeCommand", {command: command, arguments: arguments})
-
-      def open_document(buffer, language_id:)
-        raise Error, "LSP document needs a path" unless buffer.path
-        uri = Protocol.uri(buffer.path)
-        @documents[uri]&.last&.detach
-        subscription = buffer.on_edit { |patch| change_document(uri, buffer, patch) }
-        @documents[uri] = [buffer, language_id, subscription]
-        notify("textDocument/didOpen", {textDocument: {uri: uri, languageId: language_id, version: buffer.version, text: buffer.text}}) if open_close?
-        uri
-      end
-      def close_document(uri)
-        @documents.delete(uri)&.last&.detach
-        @diagnostics.delete(uri)
-        @semantic.delete(uri)
-        notify("textDocument/didClose", {textDocument: {uri: uri}}) if open_close?
-      end
-      def save_document(uri)
-        sync = @capabilities["textDocumentSync"]
-        save = sync.is_a?(Hash) ? sync["save"] : sync.is_a?(Integer) && sync.positive?
-        return unless save
-        params = {textDocument: {uri: uri}}
-        params[:text] = @documents.fetch(uri).first.text if save.is_a?(Hash) && save["includeText"]
-        notify("textDocument/didSave", params)
-      end
-      def at(method, buffer, offset, **params)
-        request("textDocument/#{method}", {textDocument: {uri: Protocol.uri(buffer.path)}, position: Protocol.position(buffer.rope, offset), **params})
-      end
-      %w[completion hover definition typeDefinition implementation references rename signatureHelp].each do |method|
-        define_method(method) { |buffer, offset, **params| at(method, buffer, offset, **params) }
-      end
-      %w[documentSymbol formatting codeAction inlayHint codeLens diagnostic].each do |method|
-        define_method(method) { |buffer, **params| request("textDocument/#{method}", {textDocument: {uri: Protocol.uri(buffer.path)}, **params}) }
-      end
-      def semantic_tokens(buffer)
-        uri = Protocol.uri(buffer.path)
-        version = buffer.version
-        provider = @capabilities["semanticTokensProvider"]
-        return [] unless provider.is_a?(Hash) && provider["full"]
-        previous = @semantic[uri]
-        delta = previous && previous[0] && provider["full"].is_a?(Hash) && provider["full"]["delta"]
-        method = delta ? "textDocument/semanticTokens/full/delta" : "textDocument/semanticTokens/full"
-        params = {textDocument: {uri: uri}}
-        params[:previousResultId] = previous[0] if delta
-        result = request(method, params).await
-        return [] unless result && buffer.version == version
-        raise Error, "invalid semantic token result" unless result.is_a?(Hash) && (!result.key?("resultId") || result["resultId"].is_a?(String))
-        raise Error, "unexpected semantic token delta" if !delta && !result.key?("data")
-        data = result["data"] || Protocol.semantic_delta(previous[1], result["edits"])
-        tokens = Protocol.semantic_tokens(data, legend: provider["legend"])
-        @semantic[uri] = [result["resultId"], data]
-        tokens
-      end
-      def apply_text_edits(buffer, edits)
-        changes = edits.map do |edit|
-          raise Error, "invalid LSP text edit" unless edit.is_a?(Hash) && edit["range"].is_a?(Hash) && edit["newText"].is_a?(String) && edit["newText"].valid_encoding?
-          range = edit.fetch("range")
-          [Protocol.offset(buffer.rope, range.fetch("start"))...Protocol.offset(buffer.rope, range.fetch("end")), edit.fetch("newText")]
-        end
-        buffer.edit(changes, kind: :lsp)
-      end
-      def stop
-        @closing = true
-        begin
-          request("shutdown").await(timeout: 2) if @state == :running
-          notify("exit") if @transport&.alive?
-        rescue Error
-          nil
-        ensure
-          @epoch += 1
-          @documents.each_value { |_, _, subscription| subscription.detach }
-          @documents.clear
-          @semantic.clear
-          @diagnostics.clear
-          @transport&.close
-          fail_pending(Error.new("language server stopped"))
-          @state = :stopped
-        end
-      end
-
-      private
-      def open_close?
-        sync = @capabilities["textDocumentSync"]
-        sync.is_a?(Hash) ? sync["openClose"] : sync.is_a?(Integer) && sync.positive?
-      end
-      def change_document(uri, buffer, patch)
-        sync = @capabilities["textDocumentSync"]
-        mode = sync.is_a?(Hash) ? sync["change"] : sync
-        return unless [1, 2].include?(mode)
-        changes = if mode == 2 && patch.is_a?(Patch)
-          patch.edits.reverse.map { |edit| {range: Protocol.range(patch.before, edit.old_range), text: edit.new_text} }
-        else
-          [{text: buffer.text}]
-        end
-        notify("textDocument/didChange", {textDocument: {uri: uri, version: buffer.version}, contentChanges: changes})
-      rescue Error => error
-        report_error(error)
-      end
-      def cancel(id)
-        @lock.synchronize { @pending.delete(id) }
-        notify("$/cancelRequest", {id: id})
-      rescue Error
-        nil
-      end
-      def fail_pending(error)
-        pending = @lock.synchronize { values = @pending.values; @pending.clear; values }
-        pending.each { |future| future.fulfill(error: error) }
-      end
-      def report_error(error)
-        bounded = Error.new("#{error.class}: #{error.message}".scrub.byteslice(0, 2048).scrub(""))
-        @lock.synchronize do
-          @errors << bounded
-          @errors.shift if @errors.length > 200
-        end
-        @dispatch.call do
-          begin
-            @handlers["error"]&.call(bounded)
-          rescue StandardError
-            nil
-          end
-        end
-      rescue StandardError
-        nil
-      end
-      def receive(message, error, epoch = @epoch)
-        return unless epoch == @epoch
-        if error
-          running = @state == :running
-          @state = :failed
-          fail_pending(Error.new(error.message))
-          report_error(error)
-          restart_server if running && @restart && !@closing && @restarts < 3
-        elsif message.key?("id") && !message.key?("method")
-          future = @lock.synchronize { @pending.delete(message["id"]) }
-          future&.fulfill(message["result"], error: message["error"] && ServerError.new(message["error"]))
-        elsif message["method"]
-          method, params = message["method"], message.fetch("params", {})
-          @dispatch.call do
-            next unless epoch == @epoch && !@closing
-            begin
-              if method == "textDocument/publishDiagnostics"
-                raise Error, "invalid diagnostics notification" unless params.is_a?(Hash) && params["uri"].is_a?(String) && params["diagnostics"].is_a?(Array)
-                document = @documents[params["uri"]]
-                version = params["version"]
-                raise Error, "invalid diagnostic version" if !version.nil? && !version.is_a?(Integer)
-                next if document && version && version < document.first.version
-                @diagnostics[params["uri"]] = Protocol.diagnostics(params["diagnostics"])
-              end
-              known = @handlers.key?(method)
-              result = @handlers[method]&.call(params)
-              next unless message.key?("id")
-              unless known
-                known = true
-                result = case method
-                when "workspace/configuration"
-                  params.fetch("items").map do |item|
-                    section = item["section"]
-                    section ? @configuration.dig(*section.split(".")) : @configuration
-                  end
-                when "workspace/workspaceFolders"
-                  [{uri: Protocol.uri(@root), name: File.basename(@root)}]
-                when "window/workDoneProgress/create", "workspace/semanticTokens/refresh", "workspace/inlayHint/refresh", "workspace/codeLens/refresh", "workspace/diagnostic/refresh"
-                  @semantic.clear if method == "workspace/semanticTokens/refresh"
-                  nil
-                else
-                  known = false
-                  nil
-                end
-              end
-              if !known
-                reply(message["id"], epoch, error: {code: -32601, message: "unsupported client request #{method}"})
-              elsif result.is_a?(Future)
-                result.then do |value, failure|
-                  failure ? reply(message["id"], epoch, error: {code: -32603, message: failure.message.byteslice(0, 2048).scrub}) : reply(message["id"], epoch, value: value)
-                end
-              else
-                reply(message["id"], epoch, value: result)
-              end
-            rescue StandardError => failure
-              report_error(failure)
-              reply(message["id"], epoch, error: {code: -32603, message: "client request handler failed"}) if message.key?("id")
-            end
-          end
-        end
-      rescue StandardError => failure
-        report_error(failure)
-        reply(message["id"], epoch, error: {code: -32603, message: "client dispatch failed"}) if message&.key?("id") && message.key?("method")
-      end
-      def reply(id, epoch, value: nil, error: nil)
-        return unless epoch == @epoch && !@closing
-        response = {jsonrpc: "2.0", id: id}
-        error ? response[:error] = error : response[:result] = value
-        @transport.write(response)
-      rescue StandardError => failure
-        report_error(failure)
-      end
-      def restart_server
-        return if @restart_thread&.alive?
-        previous = @transport
-        @restart_thread = Thread.new do
-          @reopening_documents = true
-          begin
-            previous.close
-            until @closing || @restarts >= 3
-              @restarts += 1
-              sleep(0.2 * @restarts)
-              break if @closing
-              begin
-                start
-                break
-              rescue StandardError => failure
-                report_error(failure)
-              end
-            end
-          ensure
-            @reopening_documents = false
-          end
-        end
-      end
-      def reopen_documents
-        @documents.values.dup.each { |buffer, language, _| open_document(buffer, language_id: language) }
-      end
-    end
-  end
-end

data/lib/canopus/lsp/error.rb

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-module Canopus
-  module LSP
-    class Error < StandardError; end
-  end
-end

data/lib/canopus/lsp/future/subscription.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-class Canopus::LSP::Future::Subscription
-  def initialize(&detach) = @detach = detach
-  def detach
-    callback, @detach = @detach, nil
-    callback&.call
-  end
-end

data/lib/canopus/lsp/future.rb

@@ -1,87 +0,0 @@
-# frozen_string_literal: true
-
-module Canopus
-  module LSP
-    class Future
-      attr_reader :id, :callback_errors
-      def initialize(id, on_error: nil, &cancel)
-        @id, @cancel, @on_error, @lock, @ready = id, cancel, on_error, Mutex.new, ConditionVariable.new
-        @callbacks, @callback_errors = [], []
-      end
-      def fulfill(value = nil, error: nil)
-        callbacks = @lock.synchronize do
-          return if @done
-          @value, @error, @done = value, error, 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)
-        raise ArgumentError, "timeout must be finite and nonnegative" unless timeout.nil? || (timeout.is_a?(Numeric) && timeout.finite? && timeout >= 0)
-        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
-        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
-end

data/lib/canopus/lsp/protocol.rb

@@ -1,83 +0,0 @@
-# frozen_string_literal: true
-
-module Canopus
-  module LSP
-    module Protocol
-      module_function
-      def uri(path)
-        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)
-        raise Error, "expected local file URI" unless parsed.scheme == "file" && [nil, "", "localhost"].include?(parsed.host) && parsed.query.nil? && parsed.fragment.nil? && parsed.path&.start_with?("/")
-        path = URI::RFC2396_PARSER.unescape(parsed.path)
-        raise Error, "invalid file URI path" if path.include?("\0") || !path.valid_encoding?
-        RUBY_PLATFORM.match?(/mswin|mingw/) ? path.sub(%r{\A/([A-Za-z]:/)}, '\\1') : path
-      rescue URI::InvalidURIError => error
-        raise Error, error.message
-      end
-      def position(rope, offset)
-        point = rope.utf16_point_at(offset)
-        {line: point.row, character: point.column}
-      end
-      def offset(rope, position)
-        raise Error, "invalid LSP position" unless position.is_a?(Hash) && uint?(position["line"]) && uint?(position["character"])
-        row, column = position.fetch("line"), position.fetch("character")
-        start = rope.line_start(row)
-        finish = start + rope.line(row).bytesize
-        units = rope.utf16_offset_at(finish) - rope.utf16_offset_at(start)
-        rope.offset_at_utf16(rope.utf16_offset_at(start) + [column, units].min)
-      end
-      def range(rope, range)
-        {start: position(rope, range.begin), end: position(rope, range.end + (range.exclude_end? ? 0 : 1))}
-      end
-      def semantic_delta(data, edits)
-        raise Error, "invalid semantic token delta" unless data.is_a?(Array) && edits.is_a?(Array)
-        output = data.dup
-        last = 0
-        edits.each do |edit|
-          raise Error, "invalid semantic token delta" unless edit.is_a?(Hash) && uint?(edit["start"]) && uint?(edit["deleteCount"]) && edit.fetch("data", []).is_a?(Array)
-        end
-        sorted = edits.sort_by { |edit| edit.fetch("start") }
-        sorted.each do |edit|
-          start, count = edit.fetch("start"), edit.fetch("deleteCount")
-          raise Error, "invalid semantic token delta" unless start.is_a?(Integer) && count.is_a?(Integer) && start >= last && count >= 0 && start + count <= data.length
-          last = start + count
-        end
-        sorted.reverse_each { |edit| output[edit.fetch("start"), edit.fetch("deleteCount")] = edit.fetch("data", []) }
-        semantic_tokens(output)
-        output
-      end
-      def uint?(value) = value.is_a?(Integer) && value.between?(0, 0x7fffffff)
-      def diagnostics(values)
-        valid = values.is_a?(Array) && values.all? do |value|
-          next false unless value.is_a?(Hash) && value["message"].is_a?(String) && value["range"].is_a?(Hash)
-          range = value["range"]
-          points = %w[start end].map { |key| range[key] }
-          points.all? { |point| point.is_a?(Hash) && uint?(point["line"]) && uint?(point["character"]) } &&
-            ([points[0]["line"], points[0]["character"]] <=> [points[1]["line"], points[1]["character"]]) <= 0 &&
-            (!value.key?("severity") || (value["severity"].is_a?(Integer) && value["severity"].between?(1, 4)))
-        end
-        raise Error, "invalid LSP diagnostics" unless valid
-        values
-      end
-      def semantic_tokens(data, legend: nil)
-        raise Error, "invalid semantic token tuple count" unless data.is_a?(Array) && data.length % 5 == 0
-        if legend
-          raise Error, "invalid semantic token legend" unless legend.is_a?(Hash) && %w[tokenTypes tokenModifiers].all? { |key| legend[key].is_a?(Array) && legend[key].all? { |name| name.is_a?(String) } }
-        end
-        row, column = 0, 0
-        data.each_slice(5).map do |delta_row, delta_column, length, type, modifiers|
-          raise Error, "invalid semantic token value" unless [delta_row, delta_column, length, type, modifiers].all? { |v| uint?(v) } && length.positive?
-          raise Error, "semantic token exceeds legend" if legend && (type >= legend["tokenTypes"].length || modifiers.bit_length > legend["tokenModifiers"].length)
-          row += delta_row
-          column = delta_row.zero? ? column + delta_column : delta_column
-          raise Error, "semantic token position overflow" unless uint?(row) && uint?(column + length)
-          {line: row, character: column, length: length, type: type, modifiers: modifiers}
-        end
-      end
-    end
-  end
-end

data/lib/canopus/lsp/server_error.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-module Canopus
-  module LSP
-    class ServerError < Error
-      attr_reader :code, :data
-      def initialize(error)
-        @code, @data = error["code"], error["data"]
-        super(error["message"])
-      end
-    end
-  end
-end

data/lib/canopus/lsp/timeout.rb

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-module Canopus
-  module LSP
-    class Timeout < Error; end
-  end
-end

data/lib/canopus/lsp/transport.rb

@@ -1,123 +0,0 @@
-# frozen_string_literal: true
-
-module Canopus
-  module LSP
-    class Transport
-      MAX_MESSAGE = 32 << 20
-      attr_reader :stderr_lines, :pid
-      def initialize(command, cwd: nil, env: {}, &receive)
-        raise ArgumentError, "command must be a nonempty argument array" unless command.is_a?(Array) && !command.empty? && command.all? { |part| part.is_a?(String) && !part.include?("\0") }
-        raise ArgumentError, "receiver required" unless receive
-        options = cwd ? {chdir: cwd} : {}
-        @stdin, @stdout, @stderr, @process = Open3.popen3(env, *command, **options)
-        @stdin.binmode
-        @stdout.binmode
-        @pid, @write_lock, @stderr_lines = @process.pid, Mutex.new, []
-        @reader = Thread.new do
-          begin
-            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
-        end
-        @logger = Thread.new do
-          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
-      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 > 16384
-          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?
-          raise Error, "invalid JSON-RPC parameters" if message.key?("params") && !message["params"].is_a?(Hash) && !message["params"].is_a?(Array)
-          raise Error, "request contains a response" if message.key?("result") || message.key?("error")
-        else
-          raise Error, "invalid JSON-RPC response" unless message.key?("id") && (message.key?("result") ^ message.key?("error"))
-          if message.key?("error")
-            error = message["error"]
-            raise Error, "invalid JSON-RPC error" unless error.is_a?(Hash) && error["code"].is_a?(Integer) && error["message"].is_a?(String)
-          end
-        end
-        id = message["id"]
-        raise Error, "invalid JSON-RPC id" if message.key?("id") && !id.is_a?(Integer) && !id.is_a?(String) && !(id.nil? && !message.key?("method"))
-        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)
-          Process.kill("TERM", @pid) rescue Errno::ESRCH
-          unless @process.join(1)
-            Process.kill("KILL", @pid) rescue Errno::ESRCH
-            @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
-    end
-  end
-end

data/lib/canopus/lsp.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-require "json"
-require "open3"
-require "uri"
-require "thread"
-
-module Canopus
-  module LSP; end
-end
-
-require_relative "lsp/error"
-require_relative "lsp/timeout"
-require_relative "lsp/server_error"
-require_relative "lsp/protocol"
-require_relative "lsp/future"
-require_relative "lsp/future/subscription"
-require_relative "lsp/transport"
-require_relative "lsp/client"