yoda-language-server 0.7.1 → 0.9.0

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

@@ -2,6 +2,8 @@ module Yoda
   class Server
     module Providers
       class Signature < Base
+        include WithTimeout
+
         def self.provider_method
           :'textDocument/signatureHelp'
         end
@@ -11,34 +13,45 @@ module Yoda
           calculate(params[:text_document][:uri], params[:position])
         end
 
+        private
+
         def timeout
           10
         end
 
-        private
+        def timeout_message(params)
+          uri = params[:text_document][:uri]
+          position = params[:position]
+
+          "#{self.class.provider_method}: #{uri}:#{position[:line]}:#{position[:character]}"
+        end
 
         # @params uri [String]
         # @params position [{Symbol => Integer}]
         def calculate(uri, position)
-          source = session.file_store.get(uri)
+          workspace = session.workspace_for(uri)
+          source = workspace.read_at(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
+          cut_source = Parsing.fix_parse_error(source: source, location: location)
 
-          signature_worker = Evaluation::SignatureDiscovery.new(session.registry, cut_source, location)
+          signature_worker = Services::SignatureDiscovery.from_source(environment: workspace.project.environment, source: cut_source, location: location)
 
           functions = signature_worker.method_candidates
-          create_signature_help(functions)
+          argument_number = signature_worker.argument_number
+          create_signature_help(functions, argument_number)
         end
 
         # @param code_objects [Array<Model::FunctionSignatures::Base>]
-        def create_signature_help(functions)
+        # @param argument_number [Integer, nil]
+        def create_signature_help(functions, argument_number)
           signatures = functions.map { |func| Model::Descriptions::FunctionDescription.new(func) }
           LanguageServer::Protocol::Interface::SignatureHelp.new(
             signatures: signatures.map { |signature| create_signature_info(signature) },
+            active_parameter: argument_number,
           )
         end
 
-        # @param signature [Evaluation::Descriptions::FunctionDescription]
+        # @param signature [Services::Descriptions::FunctionDescription]
         def create_signature_info(signature)
           LanguageServer::Protocol::Interface::SignatureInformation.new(
             label: signature.title.to_s,

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

@@ -9,7 +9,7 @@ module Yoda
         def provide(params)
           uri = params[:text_document][:uri]
           text = params[:content_changes].first[:text]
-          session.file_store.store(uri, text)
+          session.store_source(uri: uri, source: text)
 
           NO_RESPONSE
         end

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

@@ -9,7 +9,7 @@ module Yoda
         def provide(params)
           uri = params[:text_document][:uri]
           text = params[:text_document][:text]
-          session.file_store.store(uri, text)
+          session.store_source(uri: uri, source: text)
 
           NO_RESPONSE
         end

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

@@ -0,0 +1,36 @@
+require 'timeout'
+
+module Yoda
+  class Server
+    module Providers
+      module WithTimeout
+        module PrependHook
+          def provide(*args)
+            begin
+              Timeout.timeout(timeout) { super }
+            rescue Timeout::Error => err
+              if message = timeout_message(*args)
+                Logger.error("Request expired: " + message)
+              else
+                Logger.error("Request expired")
+              end
+              raise err
+            end
+          end
+        end
+
+        def included(mod)
+          mod.send(:prepend, PrependHook)
+        end
+
+        def timeout
+          nil
+        end
+
+        def timeout_message(*args)
+          nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+module Yoda
+  class Server
+    module Providers
+      class WorkspaceDidChangeWorkspaceFolders < Base
+        def self.provider_method
+          :'workspace/didChangeWorkspaceFolders'
+        end
+
+        def provide(params)
+          added_folders = params[:event][:added].map(&method(:to_folder))
+          removed_folders = params[:event][:added].map(&method(:to_folder))
+
+          added_folders.each do
+            workspace = Workspace.from_workspace_folder(folder)
+            session.add_workspace(workspace)
+          end
+
+          removed_folders.each do
+            session.remove_workspace(id: folder.id)
+          end
+
+          NO_RESPONSE
+        end
+
+        private
+
+        def to_folder(folder_params)
+          LanguageServer::Protocol::Interface::WorkspaceFolder.new(**folder_params)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+module Yoda
+  class Server
+    module Providers
+      class WorkspaceDidCreateFiles < Base
+        def self.provider_method
+          :'workspace/didCreateFiles'
+        end
+
+        # @param params [LanguageServer::Protocol::Interface::CreateFilesParams]
+        def provide(params)
+          files = params[:files]
+          files.each do |file|
+            session.read_source(file[:uri])
+          end
+
+          NO_RESPONSE
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+module Yoda
+  class Server
+    module Providers
+      class WorkspaceDidDeleteFiles < Base
+        def self.provider_method
+          :'workspace/didDeleteFiles'
+        end
+
+        # @param params [LanguageServer::Protocol::Interface::DeleteFilesParams]
+        def provide(params)
+          files = params[:files]
+          files.each do |file|
+            session.remove_source(uri: file[:uri])
+          end
+
+          NO_RESPONSE
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module Yoda
+  class Server
+    module Providers
+      class WorkspaceDidRenameFiles < Base
+        def self.provider_method
+          :'workspace/didRenameFiles'
+        end
+
+        # @param params [LanguageServer::Protocol::Interface::DeleteFilesParams]
+        def provide(params)
+          files = params[:files]
+          files.each do |file|
+            session.remove_source(uri: file[:old_uri])
+            session.read_source(file[:new_uri])
+          end
+
+          NO_RESPONSE
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+require "yoda/server/providers/reportable_progress"
+
+module Yoda
+  class Server
+    module Providers
+      class WorkspaceSymbol < Base
+        include ReportableProgress
+
+        def self.provider_method
+          :'workspace/symbol'
+        end
+
+        def provide(params)
+          query = params[:query]
+
+          results = in_progress(params, title: "Searching symbol") do |reporter|
+            matched_items(query).each do |item|
+              reporter.send_result([item])
+            end
+          end
+
+          results.flatten(1)
+        end
+
+        private
+
+        def matched_items(query_string)
+          Enumerator.new do |yielder|
+            session.workspaces.each do |workspace|
+              query = Store::Query::FindWorkspaceObjects.new(workspace.project.registry)
+              query.select(query_string).each do |item|
+                yielder << to_symbol_information(workspace: workspace, item: item)
+              end
+            end
+          end
+        end
+
+        # @param workspace [Workspace]
+        # @param item [Store::Objects::Base]
+        # @return [LanguageServer::Protocol::Interface::SymbolInformation]
+        def to_symbol_information(workspace:, item:)
+          path, line, column = item.primary_source
+          LanguageServer::Protocol::Interface::SymbolInformation.new(
+            name: item.name,
+            kind: language_server_kind_of(item),
+            location: create_location(workspace.uri_of_path(path), line, column),
+            
+          )
+
+        end
+
+        # @param path [String]
+        # @param line [Integer]
+        # @param column [Integer]
+        def create_location(uri, line, column)
+          location = Parsing::Location.new(row: line - 1, column: column)
+          LanguageServer::Protocol::Interface::Location.new(
+            uri: uri,
+            range: LanguageServer::Protocol::Interface::Range.new(**Parsing::Range.new(location, location).to_language_server_protocol_range),
+          )
+        end
+
+        # @param item [Store::Objects::Base]
+        def language_server_kind_of(item)
+          case item.kind
+          when :constant, :value_object
+            LanguageServer::Protocol::Constant::SymbolKind::CONSTANT
+          when :method
+            LanguageServer::Protocol::Constant::SymbolKind::METHOD
+          when :class, :meta_class
+            LanguageServer::Protocol::Constant::SymbolKind::CLASS
+          when :module
+            LanguageServer::Protocol::Constant::SymbolKind::CLASS
+          else
+            Logger.warn("Unexpected kind for symbol: #{item}")
+            LanguageServer::Protocol::Constant::SymbolKind::NULL
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yoda/server/providers.rb

@@ -2,6 +2,8 @@ module Yoda
   class Server
     module Providers
       require 'yoda/server/providers/base'
+      require 'yoda/server/providers/with_timeout'
+      require 'yoda/server/providers/reportable_progress'
 
       require 'yoda/server/providers/completion'
       require 'yoda/server/providers/signature'
@@ -10,6 +12,11 @@ module Yoda
       require 'yoda/server/providers/text_document_did_change'
       require 'yoda/server/providers/text_document_did_open'
       require 'yoda/server/providers/text_document_did_save'
+      require 'yoda/server/providers/workspace_did_change_workspace_folders'
+      require 'yoda/server/providers/workspace_did_create_files'
+      require 'yoda/server/providers/workspace_did_delete_files'
+      require 'yoda/server/providers/workspace_did_rename_files'
+      require 'yoda/server/providers/workspace_symbol'
 
       CLASSES = [
         Completion,
@@ -19,6 +26,11 @@ module Yoda
         TextDocumentDidChange,
         TextDocumentDidOpen,
         TextDocumentDidSave,
+        WorkspaceDidChangeWorkspaceFolders,
+        WorkspaceDidCreateFiles,
+        WorkspaceDidDeleteFiles,
+        WorkspaceDidRenameFiles,
+        WorkspaceSymbol,
       ].freeze
 
       class << self

data/lib/yoda/server/root_handler.rb

@@ -13,18 +13,13 @@ module Yoda
       # @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
+      # @return [Scheduler]
+      attr_reader :scheduler
 
       # @param writer [ConcurrentWriter]
-      # @param thread_pool [Concurrent::ThreadPoolExecutor]
-      def initialize(writer:, thread_pool: nil)
-        @thread_pool = thread_pool || self.class.default_thread_pool
+      # @param scheduler [Scheduler]
+      def initialize(writer:, scheduler: nil)
+        @scheduler = scheduler || Scheduler.new
         @writer = writer
         @future_map = Concurrent::Map.new
       end
@@ -34,6 +29,7 @@ module Yoda
       # @param params [Hash]
       # @return [Concurrent::Future, nil]
       def handle(id:, method:, params:)
+        Logger.trace("Request (#{id}): #{method}(#{params})")
         if lifecycle_handler.handle?(method)
           return write_response(id, lifecycle_handler.handle(method: method, params: params))
         end
@@ -43,7 +39,11 @@ module Yoda
         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)))
+          if id
+            write_response(id, build_error_response(NotImplementedMethod.new(method)))
+          else
+            Logger.instance.debug("A notification with a not implemented method (#{method}) received")
+          end
         end
       end
 
@@ -52,13 +52,18 @@ module Yoda
         @notifier ||= Notifier.new(writer)
       end
 
+      # Wait pending requests
+      def wait_for_termination(timeout:)
+        scheduler.wait_for_termination(timeout: timeout)
+      end
+
       # @param id [String]
       def cancel_request(id)
-        future_map[id]&.cancel
+        scheduler.cancel(id)
       end
 
       def cancel_all_requests
-        future_map.each_value { |future| future&.cancel }
+        scheduler.cancel_all
       end
 
       private
@@ -73,20 +78,13 @@ module Yoda
 
       # @return [Concurrent::Future]
       def provide_async(provider:, id:, method:, params:)
-        future = Concurrent::Future.new(executor: thread_pool) do
+        future = scheduler.async(id: id) 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
+          reason ? write_response(id, build_error_response(reason)) : write_response(id, value)
         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
 
@@ -95,6 +93,7 @@ module Yoda
       # @return [nil]
       def write_response(id, result)
         return if result == NO_RESPONSE
+        Logger.trace("Response (#{id}): #{result.to_json}")
         if result.is_a?(LanguageServer::Protocol::Interface::ResponseError)
           writer.write(id: id, error: result)
         else
@@ -112,6 +111,11 @@ module Yoda
             code: LanguageServer::Protocol::Constant::ErrorCodes::REQUEST_CANCELLED,
             message: 'Request is canceled',
           )
+        when Timeout::Error
+          LanguageServer::Protocol::Interface::ResponseError.new(
+            code: LanguageServer::Protocol::Constant::ErrorCodes::INTERNAL_ERROR,
+            message: 'Requiest timeout',
+          )
         when NOT_INITIALIZED
           LanguageServer::Protocol::Interface::ResponseError.new(
             code: LanguageServer::Protocol::Constant::ErrorCodes::SERVER_NOT_INITIALIZED,

data/lib/yoda/server/rootless_workspace.rb

@@ -0,0 +1,62 @@
+require 'uri'
+
+module Yoda
+  class Server
+    class RootlessWorkspace
+      # @return [String]
+      attr_reader :name
+
+      # @param name [String]
+      def initialize(name:)
+        @name = name
+      end
+
+      def setup
+        project.setup
+      end
+
+      # @return [Store::Project, nil]
+      def project
+        @project ||= Store::Project.temporal(name: name)
+      end
+
+      # @param path [String]
+      def uri_of_path(path)
+        FileStore.uri_of_path(File.expand_path(path))
+      end
+
+      # @param uri [String]
+      # @return [String, nil]
+      def read_at(uri)
+        path = UriDecoder.path_of_uri(uri)
+        path && file_tree.read_at(path)
+      end
+
+      # @param path []
+      def read_source(uri)
+        path = UriDecoder.path_of_uri(uri)
+        file_tree.clear_editing_at(path)
+      end
+
+      # @param uri [String]
+      # @param source [String]
+      def store_source(uri:, source:)
+        path = UriDecoder.path_of_uri(uri)
+        file_tree.set_editing_at(path, source)
+      end
+
+      def suburi?(uri)
+        true
+      end
+
+      def subpath?(path)
+        true
+      end
+
+      # @return [Store::FileTree]
+      def file_tree
+        project.file_tree
+      end
+    end
+  end
+end

data/lib/yoda/server/scheduler.rb

@@ -0,0 +1,50 @@
+require 'concurrent'
+
+module Yoda
+  class Server
+    class Scheduler
+      # @return [Concurrent::ThreadPoolExecutor]
+      attr_reader :thread_pool
+
+      # @return [Concurrent::Map{String => Concurrent::Future}]
+      attr_reader :future_map
+
+      # @return [Concurrent::ThreadPoolExecutor]
+      def self.default_thread_pool
+        Concurrent.global_fast_executor
+      end
+
+      # @param thread_pool [Concurrent::ThreadPoolExecutor]
+      def initialize(thread_pool: nil)
+        @thread_pool = thread_pool || self.class.default_thread_pool
+        @future_map = Concurrent::Map.new
+      end
+
+      # @param id [String]
+      # @return [Concurrent::Future]
+      def async(id:, &block)
+        future = Concurrent::Future.new(executor: thread_pool) { block.call }
+        future.add_observer { |_time, value, reason| future_map.delete(id) }
+        future_map.put_if_absent(id, future)
+        future.execute
+        future
+      end
+
+      # @param id [String]
+      def cancel(id)
+        future_map[id]&.cancel
+      end
+
+      # @param timeout [Integer] the maximum number of seconds to wait for shutdown to complete.
+      def wait_for_termination(timeout:)
+        thread_pool.shutdown
+        thread_pool.wait_for_termination(timeout)
+      end
+
+      def cancel_all
+        future_map.each_value { |future| future&.cancel }
+      end
+    end
+  end
+end
+

data/lib/yoda/server/session.rb

@@ -3,24 +3,24 @@ require 'uri'
 module Yoda
   class Server
     class Session
-      # @return [String]
-      attr_reader :root_uri
+      # @return [Array<Workspace>]
+      attr_reader :workspaces
 
-      # @return [FileStore]
-      attr_reader :file_store
-
-      # @return [Store::Project]
-      attr_reader :project
+      def self.from_root_uri(root_uri)
+        workspaces = [Workspace.new(name: 'root', root_uri: root_uri)]
+        Logger.trace("Setting up session for #{root_uri}")
+        new(workspaces: workspaces)
+      end
 
-      # @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)
+      # @param workspace_folders [Array<LanguageServer::Protocol::Interface::WorkspaceFolder>] an uri expression of project root path
+      def self.from_workspace_folders(workspace_folders)
+        workspaces = workspace_folders.map { |folder| Workspace.from_workspace_folder(folder) }
+        new(workspaces: workspaces)
       end
 
-      def root_path
-        @root_path ||= FileStore.path_of_uri(root_uri)
+      # @param workspaces [Array<Workspace>]
+      def initialize(workspaces:)
+        @workspaces = workspaces
       end
 
       # @return [Store::Registry]
@@ -28,22 +28,68 @@ module Yoda
         project.registry
       end
 
+      # @return [Array<Exception>] errors on setup
       def setup
-        unless Store::Actions::BuildCoreIndex.exists?
-          Instrument.instance.initialization_progress(phase: :core, message: 'Downloading and building core index')
-          Store::Actions::BuildCoreIndex.run
-        end
-        project.build_cache
+        workspaces.flat_map(&:setup)
+      end
+
+      # @param new_workspace [Workspace]
+      def add_workspace(new_workspace)
+        return if workspaces.find { |workspace| workspace.id == new_workspace.id }
+        new_workspace.setup
+        workspaces.push(new_workspace)
+      end
+
+      # @param id [String]
+      def remove_workspace(id:)
+        @workspaces = workspaces.reject { |workspace| workspace.id == id }
+      end
+
+      # @return [Store::Project, nil]
+      def project
+        workspaces.first&.project
+      end
+
+      def read_source(uri)
+        workspaces_for(uri).each { |workspace| workspace.read_source(uri) }
       end
+      alias reparse_doc read_source
 
-      # @param path [String]
-      def uri_of_path(path)
-        FileStore.uri_of_path(File.expand_path(path, root_path))
+      # @param uri [String]
+      # @param source [String]
+      def store_source(uri:, source:)
+        workspaces_for(uri).each { |workspace| workspace.store_source(uri: uri, source: source) }
       end
 
-      def reparse_doc(uri)
-        path = FileStore.path_of_uri(uri)
-        project.read_source(path)
+      # @param uri [String]
+      def remove_source(uri:)
+        workspaces_for(uri).each { |workspace| workspace.remove_source(uri: uri) }
+      end
+
+      # @return [Workspace, nil]
+      def workspace_for(uri)
+        workspaces_for(uri).first
+      end
+
+      # @return [Array<Workspace>]
+      def workspaces_for(uri)
+        matched_workspaces = workspaces.select { |workspace| workspace.suburi?(uri) }
+        matched_workspaces.empty? ? [temporal_workspace_for(uri)] : matched_workspaces
+      end
+
+      def temporal_workspace_for(uri)
+        temporal_workspaces[uri] ||= RootlessWorkspace.new(name: uri).tap do |workspace|
+          Logger.trace "Setting up temporal workspace for #{uri}"
+          workspace.setup
+          # Store the file content to the temporally workspace
+          workspace.read_source(uri)
+        end
+      end
+
+      private
+
+      def temporal_workspaces
+        @temporal_workspaces ||= {}
       end
     end
   end