typeprof 0.21.11 → 0.30.0

data/lib/typeprof/lsp/messages.rb

@@ -0,0 +1,430 @@
+module TypeProf::LSP
+  class Message
+    def initialize(server, json)
+      @server = server
+      @id = json[:id]
+      @method = json[:method]
+      @params = json[:params]
+    end
+
+    def run
+      p [:ignored, @method]
+    end
+
+    def log(msg)
+    end
+
+    def respond(result)
+      raise "do not respond to notification" if @id == nil
+      @server.send_response(id: @id, result: result)
+    end
+
+    def respond_error(error)
+      raise "do not respond to notification" if @id == nil
+      @server.send_response(id: @id, error: error)
+    end
+
+    def notify(method, **params)
+      @server.send_notification(method, **params)
+    end
+
+    def publish_diagnostics(uri)
+      text = @server.open_texts[uri]
+      diags = []
+      if text
+        @server.core.diagnostics(text.path) do |diag|
+          diags << diag.to_lsp
+        end
+      end
+      notify(
+        "textDocument/publishDiagnostics",
+        uri: uri,
+        diagnostics: diags
+      )
+    end
+
+    Classes = []
+    def self.inherited(klass)
+      Classes << klass
+    end
+
+    Table = Hash.new(Message)
+    def self.build_table
+      Classes.each do |klass|
+        Table[klass::METHOD] = klass
+      end
+    end
+
+    def self.find(method)
+      Table[method]
+    end
+  end
+
+  class Message::CancelRequest < Message
+    METHOD = "$/cancelRequest" # notification
+    def run
+      @server.cancel_request(@params[:id])
+    end
+  end
+
+  class Message::Initialize < Message
+    METHOD = "initialize" # request (required)
+    def run
+      folders = @params[:workspaceFolders].map do |folder|
+        folder => { uri:, }
+        TypeProf::LSP.file_uri_to_path(uri)
+      end
+
+      @server.add_workspaces(folders)
+
+      respond(
+        capabilities: {
+          textDocumentSync: {
+            openClose: true,
+            change: 2, # Incremental
+          },
+          hoverProvider: true,
+          definitionProvider: true,
+          typeDefinitionProvider: true,
+          completionProvider: {
+            triggerCharacters: [".", ":"],
+          },
+          #signatureHelpProvider: {
+          #  triggerCharacters: ["(", ","],
+          #},
+          codeLensProvider: {
+            resolveProvider: false,
+          },
+          renameProvider: {
+            prepareProvider: false,
+          },
+          executeCommandProvider: {
+            commands: [
+              "typeprof.createPrototypeRBS",
+              "typeprof.enableSignature",
+              "typeprof.disableSignature",
+            ],
+          },
+          #typeDefinitionProvider: true,
+          referencesProvider: true,
+        },
+        serverInfo: {
+          name: "typeprof",
+          version: TypeProf::VERSION,
+        },
+      )
+
+      log "TypeProf for IDE is started successfully"
+    end
+  end
+
+  class Message::Initialized < Message
+    METHOD = "initialized" # notification
+    def run
+    end
+  end
+
+  class Message::Shutdown < Message
+    METHOD = "shutdown" # request (required)
+    def run
+      respond(nil)
+    end
+  end
+
+  class Message::Exit < Message
+    METHOD = "exit" # notification
+    def run
+      @server.exit
+    end
+  end
+
+  module Message::TextDocument
+  end
+
+  class Message::TextDocument::DidOpen < Message
+    METHOD = "textDocument/didOpen" # notification
+    def run
+      @params => { textDocument: { uri:, version:, text: } }
+
+      path = TypeProf::LSP.file_uri_to_path(uri)
+      return unless @server.target_path?(path)
+
+      text = Text.new(path, text, version)
+      @server.open_texts[uri] = text
+      @server.core.update_rb_file(text.path, text.string)
+      @server.send_request("workspace/codeLens/refresh")
+      publish_diagnostics(uri)
+    end
+  end
+
+  class Message::TextDocument::DidChange < Message
+    METHOD = "textDocument/didChange" # notification
+    def run
+      @params => { textDocument: { uri:, version: }, contentChanges: changes }
+      text = @server.open_texts[uri]
+      return unless text
+      text.apply_changes(changes, version)
+      @server.core.update_rb_file(text.path, text.string)
+      @server.send_request("workspace/codeLens/refresh")
+      publish_diagnostics(uri)
+    end
+  end
+
+  # textDocument/willSave notification
+  # textDocument/willSaveWaitUntil request
+  # textDocument/didSave notification
+
+  class Message::TextDocument::DidClose < Message
+    METHOD = "textDocument/didClose" # notification
+    def run
+      @params => { textDocument: { uri: } }
+      text = @server.open_texts.delete(uri)
+      return unless text
+      @server.core.update_rb_file(text.path, nil)
+    end
+  end
+
+  # textDocument/declaration request
+
+  class Message::TextDocument::Definition < Message
+    METHOD = "textDocument/definition" # request
+    def run
+      @params => {
+        textDocument: { uri: },
+        position: pos,
+      }
+      text = @server.open_texts[uri]
+      unless text
+        respond(nil)
+        return
+      end
+      defs = @server.core.definitions(text.path, TypeProf::CodePosition.from_lsp(pos))
+      if defs.empty?
+        respond(nil)
+      else
+        respond(defs.map do |path, code_range|
+          {
+            uri: "file://" + path,
+            range: code_range.to_lsp,
+          }
+        end)
+      end
+    end
+  end
+
+  class Message::TextDocument::TypeDefinition < Message
+    METHOD = "textDocument/typeDefinition" # request
+    def run
+      @params => {
+        textDocument: { uri: },
+        position: pos,
+      }
+      text = @server.open_texts[uri]
+      unless text
+        respond(nil)
+        return
+      end
+      defs = @server.core.type_definitions(text.path, TypeProf::CodePosition.from_lsp(pos))
+      if defs.empty?
+        respond(nil)
+      else
+        respond(defs.map do |path, code_range|
+          {
+            uri: "file://" + path,
+            range: code_range.to_lsp,
+          }
+        end)
+      end
+    end
+  end
+
+  class Message::TextDocument::References < Message
+    METHOD = "textDocument/references" # request
+    def run
+      @params => {
+        textDocument: { uri: },
+        position: pos,
+      }
+      text = @server.open_texts[uri]
+      unless text
+        respond(nil)
+        return
+      end
+      callsites = @server.core.references(text.path, TypeProf::CodePosition.from_lsp(pos))
+      if callsites
+        respond(callsites.map do |path, code_range|
+          {
+            uri: "file://" + path,
+            range: code_range.to_lsp,
+          }
+        end)
+      else
+        respond(nil)
+      end
+    end
+  end
+
+  class Message::TextDocument::Hover < Message
+    METHOD = "textDocument/hover" # request
+    def run
+      @params => {
+        textDocument: { uri: },
+        position: pos,
+      }
+      text = @server.open_texts[uri]
+      unless text
+        respond(nil)
+        return
+      end
+      str = @server.core.hover(text.path, TypeProf::CodePosition.from_lsp(pos))
+      if str
+        respond(contents: { language: "ruby", value: str })
+      else
+        respond(nil)
+      end
+    end
+  end
+
+  class Message::TextDocument::CodeLens < Message
+    METHOD = "textDocument/codeLens"
+    def run
+      @params => { textDocument: { uri: } }
+      text = @server.open_texts[uri]
+      if !text || !@server.signature_enabled
+        respond(nil)
+        return
+      end
+      ret = []
+      @server.core.code_lens(text.path) do |code_range, title|
+        pos = code_range.first
+        ret << {
+          range: TypeProf::CodeRange.new(pos, pos.right).to_lsp,
+          command: {
+            title: "#: " + title,
+            command: "typeprof.createPrototypeRBS",
+            arguments: [uri, code_range.first.lineno, code_range.first.column, title],
+          },
+        }
+      end
+      respond(ret)
+    end
+  end
+
+  # textDocument/documentSymbol request
+
+  # textDocument/diagnostic request
+  # workspace/diagnostic request
+  #   workspace/diagnostic/refresh request
+
+  class Message::TextDocument::Completion < Message
+    METHOD = "textDocument/completion" # request
+    def run
+      @params => {
+        textDocument: { uri: },
+        position: pos,
+      }
+      #trigger_kind = @params.key?(:context) ? @params[:context][:triggerKind] : 1 # Invoked
+      text = @server.open_texts[uri]
+      unless text
+        respond(nil)
+        return
+      end
+      items = []
+      sort = "aaaa"
+      text.modify_for_completion(text, pos) do |string, trigger, pos|
+        @server.core.update_rb_file(text.path, string)
+        pos = TypeProf::CodePosition.from_lsp(pos)
+        @server.core.completion(text.path, trigger, pos) do |mid, hint|
+          items << {
+            label: mid,
+            kind: 2, # Method
+            sortText: sort,
+            detail: hint,
+          }
+          sort = sort.succ
+        end
+      end
+      respond(
+        isIncomplete: false,
+        items: items,
+      )
+      @server.core.update_rb_file(text.path, text.string)
+    end
+  end
+
+  # textDocument/signatureHelp request
+
+  # textDocument/prepareRename request
+
+  class Message::TextDocument::Rename < Message
+    METHOD = "textDocument/rename" # request
+    def run
+      @params => {
+        textDocument: { uri: },
+        position: pos,
+        newName:,
+      }
+      text = @server.open_texts[uri]
+      unless text
+        respond(nil)
+        return
+      end
+      renames = @server.core.rename(text.path, TypeProf::CodePosition.from_lsp(pos))
+      if renames
+        changes = {}
+        renames.each do |path, cr|
+          (changes["file://" + path] ||= []) << {
+            range: cr.to_lsp,
+            newText: newName,
+          }
+        end
+        respond({
+          changes:,
+        })
+      else
+        respond(nil)
+      end
+    end
+  end
+
+  module Message::Workspace
+  end
+
+  # workspace/symbol request
+  #   workspaceSymbol/resolve request
+
+  # workspace/didChangeWatchedFiles notification
+
+  class Message::Workspace::ExecuteCommand < Message
+    METHOD = "workspace/executeCommand" # request
+    def run
+      case @params[:command]
+      when "typeprof.enableSignature"
+        @server.signature_enabled = true
+        @server.send_request("workspace/codeLens/refresh")
+        respond(nil)
+      when "typeprof.disableSignature"
+        @server.signature_enabled = false
+        @server.send_request("workspace/codeLens/refresh")
+        respond(nil)
+      when "typeprof.createPrototypeRBS"
+        uri, row, col, str = @params[:arguments]
+        @server.send_request(
+          "workspace/applyEdit",
+          edit: {
+            changes: {
+              uri => [{
+                range: TypeProf::CodeRange[row, col, row, col].to_lsp,
+                newText: "#: #{ str }\n" + " " * col,
+              }],
+            },
+          },
+        ) do |res, err|
+        end
+        respond(nil)
+      end
+    end
+  end
+
+  Message.build_table
+end

data/lib/typeprof/lsp/server.rb

@@ -0,0 +1,177 @@
+module TypeProf::LSP
+  module ErrorCodes
+    ParseError = -32700
+    InvalidRequest = -32600
+    MethodNotFound = -32601
+    InvalidParams = -32602
+    InternalError = -32603
+  end
+
+  class Server
+    def self.start_stdio(core)
+      $stdin.binmode
+      $stdout.binmode
+      reader = Reader.new($stdin)
+      writer = Writer.new($stdout)
+      # pipe all builtin print output to stderr to avoid conflicting with lsp
+      $stdout = $stderr
+      new(core, reader, writer).run
+    end
+
+    def self.start_socket(core)
+      Socket.tcp_server_sockets("localhost", nil) do |servs|
+        serv = servs[0].local_address
+        $stdout << JSON.generate({
+          host: serv.ip_address,
+          port: serv.ip_port,
+          pid: $$,
+        })
+        $stdout.flush
+
+        $stdout = $stderr
+
+        Socket.accept_loop(servs) do |sock|
+          sock.set_encoding("UTF-8")
+          begin
+            reader = Reader.new(sock)
+            writer = Writer.new(sock)
+            new(core, reader, writer).run
+          ensure
+            sock.close
+          end
+          exit
+        end
+      end
+    end
+
+    def initialize(core, reader, writer)
+      @core = core
+      @workspaces = {}
+      @reader = reader
+      @writer = writer
+      @request_id = 0
+      @running_requests_from_client = {}
+      @running_requests_from_server = {}
+      @open_texts = {}
+      @exit = false
+      @signature_enabled = true
+    end
+
+    attr_reader :core, :open_texts
+    attr_accessor :signature_enabled
+
+    def add_workspaces(folders)
+      folders.each do |path|
+        conf_path = File.join(path, "typeprof.conf.json")
+        if File.readable?(conf_path)
+          conf = TypeProf::LSP.load_json_with_comments(conf_path, symbolize_names: true)
+          if conf
+            if conf[:typeprof_version] == "experimental"
+              if conf[:analysis_unit_dirs].size >= 2
+                 puts "currently analysis_unit_dirs can have only one directory"
+              end
+              conf[:analysis_unit_dirs].each do |dir|
+                dir = File.expand_path(dir, path)
+                @workspaces[dir] = true
+                @core.add_workspace(dir, conf[:rbs_dir])
+              end
+            else
+              puts "Unknown typeprof_version: #{ conf[:typeprof_version] }"
+            end
+          end
+        else
+          puts "typeprof.conf.json is not found"
+        end
+      end
+    end
+
+    def target_path?(path)
+      @workspaces.each do |folder, _|
+        return true if path.start_with?(folder)
+      end
+      return false
+    end
+
+    def run
+      @reader.read do |json|
+        if json[:method]
+          # request or notification
+          msg_class = Message.find(json[:method])
+          if msg_class
+            msg = msg_class.new(self, json)
+            @running_requests_from_client[json[:id]] = msg if json[:id]
+            msg.run
+          else
+
+          end
+        else
+          # response
+          callback = @running_requests_from_server.delete(json[:id])
+          callback&.call(json[:params], json[:error])
+        end
+        break if @exit
+      end
+    end
+
+    def send_response(**msg)
+      @running_requests_from_client.delete(msg[:id])
+      @writer.write(**msg)
+    end
+
+    def send_notification(method, **params)
+      @writer.write(method: method, params: params)
+    end
+
+    def send_request(method, **params, &blk)
+      id = @request_id += 1
+      @running_requests_from_server[id] = blk
+      @writer.write(id: id, method: method, params: params)
+    end
+
+    def cancel_request(id)
+      req = @running_requests_from_client[id]
+      req.cancel if req.respond_to?(:cancel)
+    end
+
+    def exit
+      @exit = true
+    end
+  end
+
+  class Reader
+    class ProtocolError < StandardError
+    end
+
+    def initialize(io)
+      @io = io
+    end
+
+    def read
+      while line = @io.gets
+        line2 = @io.gets
+        if line =~ /\AContent-length: (\d+)\r\n\z/i && line2 == "\r\n"
+          len = $1.to_i
+          json = JSON.parse(@io.read(len), symbolize_names: true)
+          yield json
+        else
+          raise ProtocolError, "LSP broken header"
+        end
+      end
+    end
+  end
+
+  class Writer
+    def initialize(io)
+      @io = io
+      @mutex = Mutex.new
+    end
+
+    def write(**json)
+      json = JSON.generate(json.merge(jsonrpc: "2.0"))
+      @mutex.synchronize do
+        @io << "Content-Length: #{ json.bytesize }\r\n\r\n" << json
+        @io.flush
+      end
+    end
+  end
+end

data/lib/typeprof/lsp/text.rb

@@ -0,0 +1,69 @@
+module TypeProf::LSP
+  class Text
+    def initialize(path, text, version)
+      @path = path
+      @lines = Text.split(text)
+      @version = version
+    end
+
+    attr_reader :path, :lines, :version
+
+    def self.split(str)
+      lines = str.lines
+      lines << "" if lines.empty? || lines.last.include?("\n")
+      lines
+    end
+
+    def string
+      @lines.join
+    end
+
+    def apply_changes(changes, version)
+      changes.each do |change|
+        change => {
+          range: {
+              start: { line: start_row, character: start_col },
+              end:   { line: end_row  , character: end_col   }
+          },
+          text: new_text,
+        }
+
+        new_text = Text.split(new_text)
+
+        prefix = @lines[start_row][0...start_col]
+        suffix = @lines[end_row][end_col...]
+        if new_text.size == 1
+          new_text[0] = prefix + new_text[0] + suffix
+        else
+          new_text[0] = prefix + new_text[0]
+          new_text[-1] = new_text[-1] + suffix
+        end
+        @lines[start_row .. end_row] = new_text
+      end
+
+      validate
+
+      @version = version
+    end
+
+    def validate
+      raise unless @lines[0..-2].all? {|s| s.count("\n") == 1 && s.end_with?("\n") }
+      raise unless @lines[-1].count("\n") == 0
+    end
+
+    def modify_for_completion(changes, pos)
+      pos => { line: row, character: col }
+      if col >= 2 && @lines[row][col - 1] == "." && (col == 1 || @lines[row][col - 2] != ".")
+        @lines[row][col - 1] = " "
+        yield string, ".", { line: row, character: col - 2}
+        @lines[row][col - 1] = "."
+      elsif col >= 3 && @lines[row][col - 2, 2] == "::"
+        @lines[row][col - 2, 2] = "  "
+        yield string, "::", { line: row, character: col - 3 }
+        @lines[row][col - 2, 2] = "::"
+      else
+        yield string, nil, { line: row, character: col }
+      end
+    end
+  end
+end