yoda-language-server 0.6.2 → 0.7.0

data/lib/yoda/server/providers/signature.rb

@@ -0,0 +1,56 @@
+module Yoda
+  class Server
+    module Providers
+      class Signature < Base
+        def self.provider_method
+          :'textDocument/signatureHelp'
+        end
+
+        # @param params [Hash]
+        def provide(params)
+          calculate(params[:text_document][:uri], params[:position])
+        end
+
+        def timeout
+          10
+        end
+
+        private
+
+        # @params uri [String]
+        # @params position [{Symbol => Integer}]
+        def calculate(uri, position)
+          source = session.file_store.get(uri)
+          location = Parsing::Location.of_language_server_protocol_position(line: position[:line], character: position[:character])
+          cut_source = Parsing::SourceCutter.new(source, location).error_recovered_source
+
+          signature_worker = Evaluation::SignatureDiscovery.new(session.registry, cut_source, location)
+
+          functions = signature_worker.method_candidates
+          create_signature_help(functions)
+        end
+
+        # @param code_objects [Array<Model::FunctionSignatures::Base>]
+        def create_signature_help(functions)
+          signatures = functions.map { |func| Model::Descriptions::FunctionDescription.new(func) }
+          LanguageServer::Protocol::Interface::SignatureHelp.new(
+            signatures: signatures.map { |signature| create_signature_info(signature) },
+          )
+        end
+
+        # @param signature [Evaluation::Descriptions::FunctionDescription]
+        def create_signature_info(signature)
+          LanguageServer::Protocol::Interface::SignatureInformation.new(
+            label: signature.title.to_s,
+            documentation: signature.to_markdown,
+            parameters: signature.parameter_names.map do |parameter|
+              LanguageServer::Protocol::Interface::ParameterInformation.new(
+                label: parameter,
+              )
+            end,
+          )
+        end
+      end
+    end
+  end
+end

data/lib/yoda/server/providers/text_document_did_change.rb

@@ -0,0 +1,19 @@
+module Yoda
+  class Server
+    module Providers
+      class TextDocumentDidChange < Base
+        def self.provider_method
+          :'textDocument/didChange'
+        end
+
+        def provide(params)
+          uri = params[:text_document][:uri]
+          text = params[:content_changes].first[:text]
+          session.file_store.store(uri, text)
+
+          NO_RESPONSE
+        end
+      end
+    end
+  end
+end

data/lib/yoda/server/providers/text_document_did_open.rb

@@ -0,0 +1,19 @@
+module Yoda
+  class Server
+    module Providers
+      class TextDocumentDidOpen < Base
+        def self.provider_method
+          :'textDocument/didOpen'
+        end
+
+        def provide(params)
+          uri = params[:text_document][:uri]
+          text = params[:text_document][:text]
+          session.file_store.store(uri, text)
+
+          NO_RESPONSE
+        end
+      end
+    end
+  end
+end

data/lib/yoda/server/providers/text_document_did_save.rb

@@ -0,0 +1,19 @@
+module Yoda
+  class Server
+    module Providers
+      class TextDocumentDidSave < Base
+        def self.provider_method
+          :'textDocument/didSave'
+        end
+
+        def provide(params)
+          uri = params[:text_document][:uri]
+
+          session.reparse_doc(uri)
+
+          NO_RESPONSE
+        end
+      end
+    end
+  end
+end

data/lib/yoda/server/root_handler.rb

@@ -0,0 +1,134 @@
+require 'concurrent'
+require 'forwardable'
+
+module Yoda
+  class Server
+    class RootHandler
+      extend Forwardable
+      NOT_INITIALIZED = :not_initialized
+      NotImplementedMethod = Struct.new(:method_name)
+
+      delegate session: :lifecycle_handler
+
+      # @return [ConcurrentWriter]
+      attr_reader :writer
+
+      # @return [Concurrent::ThreadPoolExecutor]
+      attr_reader :thread_pool
+
+      # @return [Concurrent::ThreadPoolExecutor]
+      def self.default_thread_pool
+        Concurrent.global_fast_executor
+      end
+
+      # @param writer [ConcurrentWriter]
+      # @param thread_pool [Concurrent::ThreadPoolExecutor]
+      def initialize(writer:, thread_pool: nil)
+        @thread_pool = thread_pool || self.class.default_thread_pool
+        @writer = writer
+        @future_map = Concurrent::Map.new
+      end
+
+      # @param id [String]
+      # @param method [Symbol]
+      # @param params [Hash]
+      # @return [Concurrent::Future, nil]
+      def handle(id:, method:, params:)
+        if lifecycle_handler.handle?(method)
+          return write_response(id, lifecycle_handler.handle(method: method, params: params))
+        end
+
+        return write_response(id, build_error_response(NOT_INITIALIZED)) unless session
+
+        if provider = Providers.build_provider(notifier: notifier, session: session, method: method)
+          provide_async(provider: provider, id: id, method: method, params: params)
+        else
+          write_response(id, build_error_response(NotImplementedMethod.new(method)))
+        end
+      end
+
+      # @return [Notifier]
+      def notifier
+        @notifier ||= Notifier.new(writer)
+      end
+
+      # @param id [String]
+      def cancel_request(id)
+        future_map[id]&.cancel
+      end
+
+      def cancel_all_requests
+        future_map.each_value { |future| future&.cancel }
+      end
+
+      private
+
+      # @return [Concurrent::Map{ String => Future }]
+      attr_reader :future_map
+
+      # @return [LifecycleHandler]
+      def lifecycle_handler
+        @lifecycle_handler ||= LifecycleHandler.new(self)
+      end
+
+      # @return [Concurrent::Future]
+      def provide_async(provider:, id:, method:, params:)
+        future = Concurrent::Future.new(executor: thread_pool) do
+          notifier.busy(type: method, id: id) { provider.provide(params) }
+        end
+        future.add_observer do |_time, value, reason|
+          begin
+            reason ? write_response(id, build_error_response(reason)) : write_response(id, value)
+          ensure
+            future_map.delete(id)
+          end
+        end
+        future_map.put_if_absent(id, future)
+        Concurrent::ScheduledTask.execute(provider.timeout, executor: thread_pool) { future.cancel } if provider.timeout
+        
+        future.execute
+        future
+      end
+
+      # @param id [Object]
+      # @param result [Object]
+      # @return [nil]
+      def write_response(id, result)
+        return if result == NO_RESPONSE
+        if result.is_a?(LanguageServer::Protocol::Interface::ResponseError)
+          writer.write(id: id, error: result)
+        else
+          writer.write(id: id, result: result)
+        end
+
+        nil
+      end
+
+      # @param reason [Exception, Symbol, Struct]
+      def build_error_response(reason)
+        case reason
+        when Concurrent::CancelledOperationError
+          LanguageServer::Protocol::Interface::ResponseError.new(
+            code: LanguageServer::Protocol::Constant::ErrorCodes::REQUEST_CANCELLED,
+            message: 'Request is canceled',
+          )
+        when NOT_INITIALIZED
+          LanguageServer::Protocol::Interface::ResponseError.new(
+            code: LanguageServer::Protocol::Constant::ErrorCodes::SERVER_NOT_INITIALIZED,
+            message: "Server is not initialized",
+          )
+        when NotImplementedMethod
+          LanguageServer::Protocol::Interface::ResponseError.new(
+            code: LanguageServer::Protocol::Constant::ErrorCodes::METHOD_NOT_FOUND,
+            message: "Method (#{reason.method_name}) is not implemented",
+          )
+        else
+          LanguageServer::Protocol::Interface::ResponseError.new(
+            code: LanguageServer::Protocol::Constant::ErrorCodes::INTERNAL_ERROR,
+            message: reason.respond_to?(:message) ? message : 'Internal error',
+          )
+        end
+      end
+    end
+  end
+end

data/lib/yoda/server/session.rb

@@ -12,14 +12,11 @@ module Yoda
       # @return [Store::Project]
       attr_reader :project
 
-      attr_accessor :client_initialized
-
       # @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)
-        @client_initialized = false
       end
 
       def root_path
@@ -48,58 +45,6 @@ module Yoda
         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/store/project.rb

@@ -6,10 +6,10 @@ module Yoda
       require 'yoda/store/project/cache'
       require 'yoda/store/project/library_doc_loader'
 
-      # @type String
+      # @return [String]
       attr_reader :root_path
 
-      # @type Registry
+      # @return [Registry, nil]
       attr_reader :registry
 
       # @param root_path [String]
@@ -17,17 +17,18 @@ module Yoda
         fail ArgumentError, root_path unless root_path.is_a?(String)
 
         @root_path = File.absolute_path(root_path)
-        @registry = Registry.new
       end
 
       def setup
+        return if registry
         make_dir
-        cache.register_adapter(registry)
+        @registry = cache.prepare_registry
       end
 
+      # Delete all data from registry
       def clear
         setup
-        registry.adapter.clear
+        registry.clear
       end
 
       # @return [Array<BaseError>]

data/lib/yoda/store/project/cache.rb

@@ -45,11 +45,10 @@ module Yoda
           File.exist?(cache_path)
         end
 
-        # @param registry [Registry]
-        def register_adapter(registry)
-          return if registry.adapter
+        # @return [Registry]
+        def prepare_registry
           make_cache_dir
-          registry.adapter = Adapters.default_adapter_class.for(cache_path)
+          Registry.new(Adapters.default_adapter_class.for(cache_path))
         end
 
         # @return [String]

data/lib/yoda/store/registry.rb

@@ -1,3 +1,4 @@
+require 'concurrent'
 require 'yard'
 
 module Yoda
@@ -6,15 +7,6 @@ module Yoda
       # @note This number must be updated when breaking change is added.
       REGISTRY_VERSION = 1
 
-      # @return [Adapters::LmdbAdapter, nil]
-      attr_reader :adapter
-
-      # @param adapter [Adapters::LmdbAdapter]
-      attr_writer :adapter
-
-      # @return [Objects::PatchSet]
-      attr_reader :patch_set
-
       PROJECT_STATUS_KEY = '%project_status'
 
       def initialize(adapter = nil)
@@ -24,54 +16,83 @@ module Yoda
 
       # @return [Objects::ProjectStatus, nil]
       def project_status
-        adapter&.exist?(PROJECT_STATUS_KEY) && adapter.get(PROJECT_STATUS_KEY)
+        lock.with_read_lock do
+          adapter&.exist?(PROJECT_STATUS_KEY) && adapter.get(PROJECT_STATUS_KEY)
+        end
       end
 
       # @param new_project_status [Objects::ProjectStatus]
       def save_project_status(new_project_status)
-        adapter.put(PROJECT_STATUS_KEY, new_project_status)
+        lock.with_write_lock do
+          adapter.put(PROJECT_STATUS_KEY, new_project_status)
+        end
       end
 
       # @param path [String]
       # @return [Objects::Base, nil]
       def find(path)
-        if adapter&.exist?(path)
-          patch_set.patch(adapter.get(path))
-        else
-          patch_set.find(path)
+        lock.with_read_lock do
+          if adapter&.exist?(path)
+            patch_set.patch(adapter.get(path))
+          else
+            patch_set.find(path)
+          end
         end
       end
 
       # @param patch [Patch]
       def add_patch(patch)
-        patch_set.register(patch)
+        lock.with_write_lock do
+          patch_set.register(patch)
+        end
       end
 
       # @param path [String]
       # @return [true, false]
       def has_key?(path)
-        adapter&.exists?(path) || patch_set.has_key?(path)
+        lock.with_read_lock do
+          adapter&.exists?(path) || patch_set.has_key?(path)
+        end
+      end
+
+      def clear
+        lock.with_write_lock do
+          adapter.clear
+        end
       end
 
       # Store patch set data to the database.
       # old data in the database are discarded.
       def compress_and_save
         return unless adapter
-        el_keys = patch_set.keys
-        progress = Instrument::Progress.new(el_keys.length) { |length:, index:| Instrument.instance.registry_dump(index: index, length: length) }
-
-        data = Enumerator.new do |yielder|
-          el_keys.each { |key| yielder << [key, patch_set.find(key)] }
+        lock.with_write_lock do
+          el_keys = patch_set.keys
+          progress = Instrument::Progress.new(el_keys.length) { |length:, index:| Instrument.instance.registry_dump(index: index, length: length) }
+
+          data = Enumerator.new do |yielder|
+            el_keys.each { |key| yielder << [key, patch_set.find(key)] }
+          end
+
+          adapter.batch_write(data, progress)
+          adapter.sync
+          Logger.info "saved #{el_keys.length} keys."
+          @patch_set = Objects::PatchSet.new
         end
-
-        adapter.batch_write(data, progress)
-        adapter.sync
-        Logger.info "saved #{el_keys.length} keys."
-        @patch_set = Objects::PatchSet.new
       end
 
       private
 
+      # @return [Adapters::LmdbAdapter, nil]
+      attr_reader :adapter
+
+      # @return [Objects::PatchSet]
+      attr_reader :patch_set
+
+      # @return [Concurrent::ReentrantReadWriteLock]
+      def lock
+        @lock ||= Concurrent::ReentrantReadWriteLock.new
+      end
+
       def keys
         Set.new(adapter&.keys.map(&:to_s) || []).union(patch_set.keys)
       end