yoda-language-server 0.4.0

data/lib/yoda/runner.rb

@@ -0,0 +1,6 @@
+module Yoda
+  module Runner
+    require 'yoda/runner/infer'
+    require 'yoda/runner/setup'
+  end
+end

data/lib/yoda/runner/infer.rb

@@ -0,0 +1,50 @@
+module Yoda
+  module Runner
+    class Infer
+      attr_reader :filename_with_position
+
+      # @param filename_with_position [String]
+      def self.run(filename_with_position)
+        new(filename_with_position).run
+      end
+
+      # @param filename_with_position [String]
+      def initialize(filename_with_position)
+        @filename_with_position = filename_with_position
+      end
+
+      def run
+        project.setup
+        puts create_signature_help(worker.current_node_signature)
+      end
+
+      private
+
+      # @param signature [Model::NodeSignature, nil]
+      # @return [String, nil]
+      def create_signature_help(signature)
+        return nil unless signature
+        signature.descriptions.map(&:title).join("\n")
+      end
+
+      def worker
+        @worker ||= Evaluation::CurrentNodeExplain.new(project.registry, File.read(filename), position)
+      end
+
+      def project
+        @project ||= Store::Project.new(Dir.pwd)
+      end
+
+      def filename
+        @filename ||= filename_with_position.split(':').first
+      end
+
+      def position
+        @position ||= begin
+          row, column = filename_with_position.split(':').slice(1..2)
+          Parsing::Location.new(row: row.to_i, column: column.to_i)
+        end
+      end
+    end
+  end
+end

data/lib/yoda/runner/setup.rb

@@ -0,0 +1,26 @@
+module Yoda
+  module Runner
+    class Setup
+      # @return [String]
+      attr_reader :dir
+
+      # @param dir [String]
+      def initialize(dir = nil)
+        @dir = dir || Dir.pwd
+      end
+
+      # @param dir [String]
+      def self.run(dir = nil)
+        new(dir).run
+      end
+
+      def run
+        project.rebuild_cache(progress: true)
+      end
+
+      def project
+        @project ||= Store::Project.new(dir)
+      end
+    end
+  end
+end

data/lib/yoda/server.rb

@@ -0,0 +1,191 @@
+require 'language_server-protocol'
+
+module Yoda
+  class Server
+    require 'yoda/server/completion_provider'
+    require 'yoda/server/signature_provider'
+    require 'yoda/server/hover_provider'
+    require 'yoda/server/definition_provider'
+    require 'yoda/server/deserializer'
+    require 'yoda/server/client_info'
+
+    LSP = ::LanguageServer::Protocol
+
+    def self.deserialize(hash)
+      Deserializer.new.deserialize(hash || {})
+    end
+
+    # @type ::LanguageServer::Protocol::Transport::Stdio::Reader
+    attr_reader :reader
+
+    # @type ::LanguageServer::Protocol::Transport::Stdio::Writer
+    attr_reader :writer
+
+    # @type ClientInfo
+    attr_reader :client_info
+
+    # @type CompletionProvider
+    attr_reader :completion_provider
+
+    # @type HoverProvider
+    attr_reader :hover_provider
+
+    # @type SignatureProvider
+    attr_reader :signature_provider
+
+    # @type DefinitionProvider
+    attr_reader :definition_provider
+
+    def initialize
+      @reader = LSP::Transport::Stdio::Reader.new
+      @writer = LSP::Transport::Stdio::Writer.new
+    end
+
+    def run
+      reader.read do |request|
+        begin
+          if result = callback(request)
+            writer.write(id: request[:id], result: result)
+          end
+        rescue StandardError => ex
+          STDERR.puts ex
+          STDERR.puts ex.backtrace
+        end
+      end
+    end
+
+    def callback(request)
+      if method_name = resolve(request_registrations, request[:method])
+        send(method_name, self.class.deserialize(request[:params] || {}))
+      elsif method_name = resolve(notification_registrations, request[:method])
+        send(method_name, self.class.deserialize(request[:params] || {}))
+        nil
+      end
+    end
+
+    # @param hash [Hash]
+    # @param key [String, Symbol]
+    def resolve(hash, key)
+      key.to_s.split('/').reduce(hash) do |scope, key|
+        (scope || {})[key.to_sym]
+      end
+    end
+
+    def request_registrations
+      {
+        initialize: :handle_initialize,
+        shutdown: :handle_shutdown,
+        textDocument: {
+          completion: :handle_text_document_completion,
+          hover: :handle_text_document_hover,
+          signatureHelp: :handle_text_document_signature_help,
+          definition: :handle_text_document_definition,
+        },
+      }
+    end
+
+    def notification_registrations
+      {
+        initialized: :handle_initialized,
+        exit: :handle_exit,
+        textDocument: {
+          didChange: :handle_text_document_did_change,
+          didOpen: :handle_text_document_did_open,
+          didSave: :handle_text_document_did_save,
+        },
+      }
+    end
+
+    def handle_initialize(params)
+      @client_info = ClientInfo.new(params[:root_uri])
+      @completion_provider = CompletionProvider.new(@client_info)
+      @hover_provider = HoverProvider.new(@client_info)
+      @signature_provider = SignatureProvider.new(@client_info)
+      @definition_provider = DefinitionProvider.new(@client_info)
+      client_info.setup
+
+      LSP::Interface::InitializeResult.new(
+        capabilities: LSP::Interface::ServerCapabilities.new(
+          text_document_sync: LSP::Interface::TextDocumentSyncOptions.new(
+            change: LSP::Constant::TextDocumentSyncKind::FULL,
+            save: LSP::Interface::SaveOptions.new(
+              include_text: true,
+            ),
+          ),
+          completion_provider: LSP::Interface::CompletionOptions.new(
+            resolve_provider: true,
+            trigger_characters: ['.', '@', '[', ':', '!', '<'],
+          ),
+          hover_provider: true,
+          definition_provider: true,
+          signature_help_provider: LSP::Interface::SignatureHelpOptions.new(
+            trigger_characters: ['(', ','],
+          ),
+        ),
+      )
+    end
+
+    def handle_initialized(_params)
+    end
+
+    def handle_shutdown(_params)
+    end
+
+    def handle_exit(_params)
+    end
+
+    module TextDocument
+      module CompletionTrigggerKind
+        INVOKED = 1
+        TRIGGER_CHARACTER = 2
+      end
+
+      def handle_text_document_did_open(params)
+        uri = params[:text_document][:uri]
+        text = params[:text_document][:text]
+        client_info.file_store.store(uri, text)
+      end
+
+      def handle_text_document_did_save(params)
+        uri = params[:text_document][:uri]
+
+        client_info.reparse_doc(uri)
+      end
+
+      def handle_text_document_did_change(params)
+        uri = params[:text_document][:uri]
+        text = params[:content_changes].first[:text]
+        client_info.file_store.store(uri, text)
+      end
+
+      def handle_text_document_completion(params)
+        uri = params[:text_document][:uri]
+        position = params[:position]
+
+        completion_provider&.complete(uri, position)
+      end
+
+      def handle_text_document_hover(params)
+        uri = params[:text_document][:uri]
+        position = params[:position]
+
+        hover_provider&.request_hover(uri, position)
+      end
+
+      def handle_text_document_signature_help(params)
+        uri = params[:text_document][:uri]
+        position = params[:position]
+
+        signature_provider&.provide(uri, position)
+      end
+
+      def handle_text_document_definition(params)
+        uri = params[:text_document][:uri]
+        position = params[:position]
+
+        definition_provider&.provide(uri, position)
+      end
+    end
+    include TextDocument
+  end
+end

data/lib/yoda/server/client_info.rb

@@ -0,0 +1,98 @@
+require 'uri'
+
+module Yoda
+  class Server
+    class ClientInfo
+      # @return [String]
+      attr_reader :root_uri
+
+      # @return [FileStore]
+      attr_reader :file_store
+
+      # @return [Store::Project]
+      attr_reader :project
+
+      # @param root_uri [String] an uri expression of project root path
+      def initialize(root_uri)
+        @root_uri = root_uri
+        @file_store = FileStore.new
+        @project = Store::Project.new(root_path)
+      end
+
+      def root_path
+        @root_path ||= FileStore.path_of_uri(root_uri)
+      end
+
+      # @return [Store::Registry]
+      def registry
+        project.registry
+      end
+
+      def setup
+        project.setup
+      end
+
+      # @param path [String]
+      def uri_of_path(path)
+        FileStore.uri_of_path(File.expand_path(path, root_path))
+      end
+
+      def reparse_doc(uri)
+        path = FileStore.path_of_uri(uri)
+        project.read_source(path)
+      end
+
+      class FileStore
+        def initialize
+          @cache = {}
+        end
+
+        # @param uri_string [String]
+        # @return [String, nil]
+        def get(uri_string)
+          @cache[uri_string]
+        end
+
+        # @param uri_string [String]
+        # @param text [String]
+        def store(uri_string, text)
+          return unless program_file_uri?(uri_string)
+          @cache[uri_string] = text
+        end
+
+        # @param uri_string [String]
+        def load(uri_string)
+          store(uri_string, read(uri_string))
+        end
+
+        # @param uri_string [String]
+        def read(uri_string)
+          path = self.class.path_of_uri(uri_string)
+          fail ArgumentError unless path
+          File.read(path)
+        end
+
+        # @param path [String]
+        def self.uri_of_path(path)
+          "file://#{File.expand_path(path)}"
+        end
+
+        # @param uri_string [String]
+        def self.path_of_uri(uri_string)
+          uri = URI.parse(uri_string)
+          return nil unless uri.scheme == 'file'
+          uri.path
+        rescue URI::InvalidURIError
+          nil
+        end
+
+        # @param uri_string [String]
+        def program_file_uri?(uri_string)
+          %w(.c .rb).include?(File.extname(URI.parse(uri_string).path))
+        rescue URI::InvalidURIError => _e
+          false
+        end
+      end
+    end
+  end
+end

data/lib/yoda/server/completion_provider.rb

@@ -0,0 +1,78 @@
+module Yoda
+  class Server
+    class CompletionProvider
+      # @type ClientInfo
+      attr_reader :client_info
+
+      # @param client_info [ClientInfo]
+      def initialize(client_info)
+        @client_info = client_info
+      end
+
+      # @param uri      [String]
+      # @param position [{Symbol => Integer}]
+      def complete(uri, position)
+        source = client_info.file_store.get(uri)
+        location = Parsing::Location.of_language_server_protocol_position(line: position[:line], character: position[:character])
+
+        if candidates = comment_complete(source, location)
+          return candidates
+        end
+        complete_from_cut_source(source, location)
+      end
+
+      private
+
+      # @param source   [String]
+      # @param location [Parsing::Location]
+      # @return [LanguageServerProtocol::Interface::CompletionList, nil]
+      def comment_complete(source, location)
+        ast, comments = Parsing::Parser.new.parse_with_comments(source)
+        return nil unless Parsing::Query::CurrentCommentQuery.new(comments, location).current_comment
+        completion_worker = Evaluation::CommentCompletion.new(client_info.registry, ast, comments, location)
+        return nil unless completion_worker.available?
+
+        completion_items = completion_worker.candidates
+
+        LSP::Interface::CompletionList.new(
+          is_incomplete: false,
+          items: completion_worker.candidates.map { |completion_item| create_completion_item(completion_item) },
+        )
+      rescue ::Parser::SyntaxError
+        nil
+      end
+
+      # @param source   [String]
+      # @param location [Parsing::Location]
+      # @return [LanguageServerProtocol::Interface::CompletionList, nil]
+      def complete_from_cut_source(source, location)
+        cut_source = Parsing::SourceCutter.new(source, location).error_recovered_source
+        method_completion_worker = Evaluation::CodeCompletion.new(client_info.registry, cut_source, location)
+        completion_items = method_completion_worker.candidates
+        return nil if completion_items.empty?
+
+        LSP::Interface::CompletionList.new(
+          is_incomplete: false,
+          items: completion_items.map { |completion_item| create_completion_item(completion_item) },
+        )
+      end
+
+      # @param completion_item [Model::CompletionItem]
+      # @return            [LSP::Interface::CompletionItem]
+      def create_completion_item(completion_item)
+        LSP::Interface::CompletionItem.new(
+          label: completion_item.description.is_a?(Model::Descriptions::FunctionDescription) ? completion_item.description.signature : completion_item.description.sort_text,
+          kind: completion_item.language_server_kind,
+          detail: completion_item.description.title,
+          documentation: completion_item.description.to_markdown,
+          sort_text: completion_item.description.sort_text,
+          text_edit: LSP::Interface::TextEdit.new(
+            range: LSP::Interface::Range.new(completion_item.range.to_language_server_protocol_range),
+            new_text: completion_item.edit_text,
+          ),
+          data: {},
+        )
+      end
+    end
+  end
+end