spoom 1.0.3 → 1.0.8

data/lib/spoom/sorbet/lsp.rb

@@ -0,0 +1,192 @@
+# typed: true
+# frozen_string_literal: true
+
+require 'open3'
+require 'json'
+
+require_relative 'lsp/base'
+require_relative 'lsp/structures'
+require_relative 'lsp/errors'
+
+module Spoom
+  module LSP
+    class Client
+      def initialize(sorbet_bin, *sorbet_args, path: ".")
+        @id = 0
+        @in, @out, @err, @status = T.unsafe(Open3).popen3(sorbet_bin, *sorbet_args, chdir: path)
+      end
+
+      def next_id
+        @id += 1
+      end
+
+      def send_raw(json_string)
+        @in.puts("Content-Length:#{json_string.length}\r\n\r\n#{json_string}")
+      end
+
+      def send(message)
+        send_raw(message.to_json)
+        read if message.is_a?(Request)
+      end
+
+      def read_raw
+        header = @out.gets
+
+        # Sorbet returned an error and forgot to answer
+        raise Error::BadHeaders, "bad response headers" unless header&.match?(/Content-Length: /)
+
+        len = header.slice(::Range.new(16, nil)).to_i
+        @out.read(len + 2) # +2 'cause of the final \r\n
+      end
+
+      def read
+        json = JSON.parse(read_raw)
+
+        # Handle error in the LSP protocol
+        raise ResponseError.from_json(json['error']) if json['error']
+
+        # Handle typechecking errors
+        raise Error::Diagnostics.from_json(json['params']) if json['method'] == "textDocument/publishDiagnostics"
+
+        json
+      end
+
+      # LSP requests
+
+      def open(workspace_path)
+        raise Error::AlreadyOpen, "Error: CLI already opened" if @open
+        send(Request.new(
+          next_id,
+          'initialize',
+          {
+            'rootPath' => workspace_path,
+            'rootUri' => "file://#{workspace_path}",
+            'capabilities' => {},
+          },
+        ))
+        send(Notification.new('initialized', {}))
+        @open = true
+      end
+
+      def hover(uri, line, column)
+        json = send(Request.new(
+          next_id,
+          'textDocument/hover',
+          {
+            'textDocument' => {
+              'uri' => uri,
+            },
+            'position' => {
+              'line' => line,
+              'character' => column,
+            },
+          }
+        ))
+        return nil unless json['result']
+        Hover.from_json(json['result'])
+      end
+
+      def signatures(uri, line, column)
+        json = send(Request.new(
+          next_id,
+          'textDocument/signatureHelp',
+          {
+            'textDocument' => {
+              'uri' => uri,
+            },
+            'position' => {
+              'line' => line,
+              'character' => column,
+            },
+          }
+        ))
+        json['result']['signatures'].map { |loc| SignatureHelp.from_json(loc) }
+      end
+
+      def definitions(uri, line, column)
+        json = send(Request.new(
+          next_id,
+          'textDocument/definition',
+          {
+            'textDocument' => {
+              'uri' => uri,
+            },
+            'position' => {
+              'line' => line,
+              'character' => column,
+            },
+          }
+        ))
+        json['result'].map { |loc| Location.from_json(loc) }
+      end
+
+      def type_definitions(uri, line, column)
+        json = send(Request.new(
+          next_id,
+          'textDocument/typeDefinition',
+          {
+            'textDocument' => {
+              'uri' => uri,
+            },
+            'position' => {
+              'line' => line,
+              'character' => column,
+            },
+          }
+        ))
+        json['result'].map { |loc| Location.from_json(loc) }
+      end
+
+      def references(uri, line, column, include_decl = true)
+        json = send(Request.new(
+          next_id,
+          'textDocument/references',
+          {
+            'textDocument' => {
+              'uri' => uri,
+            },
+            'position' => {
+              'line' => line,
+              'character' => column,
+            },
+            'context' => {
+              'includeDeclaration' => include_decl,
+            },
+          }
+        ))
+        json['result'].map { |loc| Location.from_json(loc) }
+      end
+
+      def symbols(query)
+        json = send(Request.new(
+          next_id,
+          'workspace/symbol',
+          {
+            'query' => query,
+          }
+        ))
+        json['result'].map { |loc| DocumentSymbol.from_json(loc) }
+      end
+
+      def document_symbols(uri)
+        json = send(Request.new(
+          next_id,
+          'textDocument/documentSymbol',
+          {
+            'textDocument' => {
+              'uri' => uri,
+            },
+          }
+        ))
+        json['result'].map { |loc| DocumentSymbol.from_json(loc) }
+      end
+
+      def close
+        send(Request.new(next_id, "shutdown", nil))
+        @in.close
+        @out.close
+        @err.close
+      end
+    end
+  end
+end

data/lib/spoom/sorbet/lsp/base.rb

@@ -0,0 +1,58 @@
+# typed: true
+# frozen_string_literal: true
+
+module Spoom
+  module LSP
+    # Base messaging
+    # We don't use T::Struct for those so we can subclass them
+
+    # A general message as defined by JSON-RPC.
+    #
+    # The language server protocol always uses `"2.0"` as the `jsonrpc` version.
+    class Message
+      attr_reader :jsonrpc
+
+      def initialize
+        @jsonrpc = '2.0'
+      end
+
+      def as_json
+        instance_variables.each_with_object({}) do |var, obj|
+          val = instance_variable_get(var)
+          obj[var.to_s.delete('@')] = val if val
+        end
+      end
+
+      def to_json(*args)
+        as_json.to_json(*args)
+      end
+    end
+
+    # A request message to describe a request between the client and the server.
+    #
+    # Every processed request must send a response back to the sender of the request.
+    class Request < Message
+      attr_reader :id, :method, :params
+
+      def initialize(id, method, params)
+        super()
+        @id = id
+        @method = method
+        @params = params
+      end
+    end
+
+    # A notification message.
+    #
+    # A processed notification message must not send a response back. They work like events.
+    class Notification < Message
+      attr_reader :method, :params
+
+      def initialize(method, params)
+        super()
+        @method = method
+        @params = params
+      end
+    end
+  end
+end

data/lib/spoom/sorbet/lsp/errors.rb

@@ -0,0 +1,45 @@
+# typed: true
+# frozen_string_literal: true
+
+module Spoom
+  module LSP
+    class Error < StandardError
+      class AlreadyOpen < Error; end
+      class BadHeaders < Error; end
+
+      class Diagnostics < Error
+        attr_reader :uri, :diagnostics
+
+        def self.from_json(json)
+          Diagnostics.new(
+            json['uri'],
+            json['diagnostics'].map { |d| Diagnostic.from_json(d) }
+          )
+        end
+
+        def initialize(uri, diagnostics)
+          @uri = uri
+          @diagnostics = diagnostics
+        end
+      end
+    end
+
+    class ResponseError < Error
+      attr_reader :code, :message, :data
+
+      def self.from_json(json)
+        ResponseError.new(
+          json['code'],
+          json['message'],
+          json['data']
+        )
+      end
+
+      def initialize(code, message, data)
+        @code = code
+        @message = message
+        @data = data
+      end
+    end
+  end
+end

data/lib/spoom/sorbet/lsp/structures.rb

@@ -0,0 +1,312 @@
+# typed: true
+# frozen_string_literal: true
+
+require_relative "../../printer"
+
+module Spoom
+  module LSP
+    module PrintableSymbol
+      extend T::Sig
+      extend T::Helpers
+
+      interface!
+
+      sig { abstract.params(printer: SymbolPrinter).void }
+      def accept_printer(printer); end
+    end
+
+    class Hover < T::Struct
+      extend T::Sig
+      include PrintableSymbol
+
+      const :contents, String
+      const :range, T.nilable(Range)
+
+      def self.from_json(json)
+        Hover.new(
+          contents: json['contents']['value'],
+          range: json['range'] ? Range.from_json(json['range']) : nil
+        )
+      end
+
+      sig { override.params(printer: SymbolPrinter).void }
+      def accept_printer(printer)
+        printer.print("#{contents}\n")
+        printer.print_object(range) if range
+      end
+
+      def to_s
+        "#{contents} (#{range})."
+      end
+    end
+
+    class Position < T::Struct
+      extend T::Sig
+      include PrintableSymbol
+
+      const :line, Integer
+      const :char, Integer
+
+      def self.from_json(json)
+        Position.new(
+          line: json['line'].to_i,
+          char: json['character'].to_i
+        )
+      end
+
+      sig { override.params(printer: SymbolPrinter).void }
+      def accept_printer(printer)
+        printer.print_colored("#{line}:#{char}", :light_black)
+      end
+
+      def to_s
+        "#{line}:#{char}"
+      end
+    end
+
+    class Range < T::Struct
+      extend T::Sig
+      include PrintableSymbol
+
+      const :start, Position
+      const :end, Position
+
+      def self.from_json(json)
+        Range.new(
+          start: Position.from_json(json['start']),
+          end: Position.from_json(json['end'])
+        )
+      end
+
+      sig { override.params(printer: SymbolPrinter).void }
+      def accept_printer(printer)
+        printer.print_object(start)
+        printer.print_colored("-", :light_black)
+        printer.print_object(self.end)
+      end
+
+      def to_s
+        "#{start}-#{self.end}"
+      end
+    end
+
+    class Location < T::Struct
+      extend T::Sig
+      include PrintableSymbol
+
+      const :uri, String
+      const :range, LSP::Range
+
+      def self.from_json(json)
+        Location.new(
+          uri: json['uri'],
+          range: Range.from_json(json['range'])
+        )
+      end
+
+      sig { override.params(printer: SymbolPrinter).void }
+      def accept_printer(printer)
+        printer.print_colored("#{printer.clean_uri(uri)}:", :light_black)
+        printer.print_object(range)
+      end
+
+      def to_s
+        "#{uri}:#{range}"
+      end
+    end
+
+    class SignatureHelp < T::Struct
+      extend T::Sig
+      include PrintableSymbol
+
+      const :label, T.nilable(String)
+      const :doc, Object # TODO
+      const :params, T::Array[T.untyped] # TODO
+
+      def self.from_json(json)
+        SignatureHelp.new(
+          label: json['label'],
+          doc: json['documentation'],
+          params: json['parameters'],
+        )
+      end
+
+      sig { override.params(printer: SymbolPrinter).void }
+      def accept_printer(printer)
+        printer.print(label)
+        printer.print("(")
+        printer.print(params.map { |l| "#{l['label']}: #{l['documentation']}" }.join(", "))
+        printer.print(")")
+      end
+
+      def to_s
+        "#{label}(#{params})."
+      end
+    end
+
+    class Diagnostic < T::Struct
+      extend T::Sig
+      include PrintableSymbol
+
+      const :range, LSP::Range
+      const :code, Integer
+      const :message, String
+      const :informations, Object
+
+      def self.from_json(json)
+        Diagnostic.new(
+          range: Range.from_json(json['range']),
+          code: json['code'].to_i,
+          message: json['message'],
+          informations: json['relatedInformation']
+        )
+      end
+
+      sig { override.params(printer: SymbolPrinter).void }
+      def accept_printer(printer)
+        printer.print(to_s)
+      end
+
+      def to_s
+        "Error: #{message} (#{code})."
+      end
+    end
+
+    class DocumentSymbol < T::Struct
+      extend T::Sig
+      include PrintableSymbol
+
+      const :name, String
+      const :detail, T.nilable(String)
+      const :kind, Integer
+      const :location, T.nilable(Location)
+      const :range, T.nilable(Range)
+      const :children, T::Array[DocumentSymbol]
+
+      def self.from_json(json)
+        DocumentSymbol.new(
+          name: json['name'],
+          detail: json['detail'],
+          kind: json['kind'],
+          location: json['location'] ? Location.from_json(json['location']) : nil,
+          range: json['range'] ? Range.from_json(json['range']) : nil,
+          children: json['children'] ? json['children'].map { |symbol| DocumentSymbol.from_json(symbol) } : [],
+        )
+      end
+
+      sig { override.params(printer: SymbolPrinter).void }
+      def accept_printer(printer)
+        h = serialize.hash
+        return if printer.seen.include?(h)
+        printer.seen.add(h)
+
+        printer.printt
+        printer.print(kind_string)
+        printer.print(' ')
+        printer.print_colored(name, :blue, :bold)
+        printer.print_colored(' (', :light_black)
+        if range
+          printer.print_object(range)
+        elsif location
+          printer.print_object(location)
+        end
+        printer.print_colored(')', :light_black)
+        printer.printn
+        unless children.empty?
+          printer.indent
+          printer.print_objects(children)
+          printer.dedent
+        end
+        # TODO: also display details?
+      end
+
+      def to_s
+        "#{name} (#{range})"
+      end
+
+      def kind_string
+        return "<unknown:#{kind}>" unless SYMBOL_KINDS.key?(kind)
+        SYMBOL_KINDS[kind]
+      end
+
+      SYMBOL_KINDS = {
+        1 => "file",
+        2 => "module",
+        3 => "namespace",
+        4 => "package",
+        5 => "class",
+        6 => "def",
+        7 => "property",
+        8 => "field",
+        9 => "constructor",
+        10 => "enum",
+        11 => "interface",
+        12 => "function",
+        13 => "variable",
+        14 => "const",
+        15 => "string",
+        16 => "number",
+        17 => "boolean",
+        18 => "array",
+        19 => "object",
+        20 => "key",
+        21 => "null",
+        22 => "enum_member",
+        23 => "struct",
+        24 => "event",
+        25 => "operator",
+        26 => "type_parameter",
+      }
+    end
+
+    class SymbolPrinter < Printer
+      extend T::Sig
+
+      attr_accessor :seen, :prefix
+
+      sig do
+        params(
+          out: T.any(IO, StringIO),
+          colors: T::Boolean,
+          indent_level: Integer,
+          prefix: T.nilable(String)
+        ).void
+      end
+      def initialize(out: $stdout, colors: true, indent_level: 0, prefix: nil)
+        super(out: out, colors: colors, indent_level: indent_level)
+        @seen = Set.new
+        @out = out
+        @colors = colors
+        @indent_level = indent_level
+        @prefix = prefix
+      end
+
+      sig { params(object: T.nilable(PrintableSymbol)).void }
+      def print_object(object)
+        return unless object
+        object.accept_printer(self)
+      end
+
+      sig { params(objects: T::Array[PrintableSymbol]).void }
+      def print_objects(objects)
+        objects.each { |object| print_object(object) }
+      end
+
+      sig { params(uri: String).returns(String) }
+      def clean_uri(uri)
+        return uri unless prefix
+        uri.delete_prefix(prefix)
+      end
+
+      sig { params(objects: T::Array[PrintableSymbol]).void }
+      def print_list(objects)
+        objects.each do |object|
+          printt
+          print "* "
+          print_object(object)
+          printn
+        end
+      end
+    end
+  end
+end