yoda-language-server 0.7.2 → 0.10.0

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

data/lib/yoda/server/uri_decoder.rb

@@ -0,0 +1,16 @@
+
+module Yoda
+  class Server
+    module UriDecoder
+      # @param uri_string [String]
+      # @return [String, nil]
+      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
+    end
+  end
+end

data/lib/yoda/server/workspace.rb

@@ -0,0 +1,117 @@
+require 'uri'
+require 'forwardable'
+
+module Yoda
+  class Server
+    # Denotes workspace folder in LSP.
+    # @see: https://microsoft.github.io/language-server-protocol/specifications/specification-current/#workspace_workspaceFolders
+    class Workspace
+      extend Forwardable
+
+      # @return [String]
+      attr_reader :name
+
+      # @return [String]
+      attr_reader :root_uri
+
+      delegate [:subpath?] => :file_tree
+
+      delegate [:uri_of_path] => :uri_encoder
+
+      # @param folder [LanguageServer::Protocol::Interface::WorkspaceFolder]
+      # @return [Workspace]
+      def self.from_workspace_folder(folder)
+        new(name: folder.name, root_uri: folder.uri)
+      end
+
+      # @param name [String]
+      # @param root_uri [String]
+      def initialize(name:, root_uri:)
+        @name = name
+        @root_uri = root_uri
+      end
+
+      # @return [Array<Exception>] errors on setup
+      def setup
+        project.setup
+      end
+
+      # @return [Store::Project, nil]
+      def project
+        @project ||= Store::Project.for_path(root_path)
+      end
+
+      # @return [String]
+      def root_path
+        UriDecoder.path_of_uri(root_uri)
+      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 uri [String]
+      def read_source(uri)
+        path = UriDecoder.path_of_uri(uri)
+        return if !path || !program_file?(path)
+        file_tree.clear_editing_at(path)
+      end
+
+      # @param uri [String]
+      # @param source [String]
+      def store_source(uri:, source:)
+        path = UriDecoder.path_of_uri(uri)
+        return if !path || !program_file?(path)
+        file_tree.set_editing_at(path, source)
+      end
+
+      # @param uri [String]
+      def remove_source(uri:)
+        path = UriDecoder.path_of_uri(uri)
+        file_tree.mark_deleted(path)
+      end
+
+      def suburi?(uri)
+        path = UriDecoder.path_of_uri(uri)
+        path && subpath?(path)
+      end
+
+      private
+
+      # @return [Store::FileTree]
+      def file_tree
+        project.file_tree
+      end
+
+      # @return [UriEncoder]
+      def uri_encoder
+        @uri_encoder ||= UriEncoder.new(root_path)
+      end
+
+      # @param path [String]
+      # @return [Boolean]
+      def program_file?(path)
+        %w(.c .rb).include?(File.extname(path))
+      end
+
+      class UriEncoder
+        # @return [String]
+        attr_reader :base_path
+
+        # @param base_path [String]
+        def initialize(base_path)
+          @base_path = base_path
+        end
+
+        # @param path [String]
+        # @return [String]
+        def uri_of_path(path)
+          "file://#{File.expand_path(path, base_path)}"
+        end
+      end
+    end
+  end
+end

data/lib/yoda/server.rb

@@ -4,13 +4,16 @@ require 'securerandom'
 module Yoda
   class Server
     require 'yoda/server/session'
-    require 'yoda/server/file_store'
     require 'yoda/server/concurrent_writer'
     require 'yoda/server/notifier'
     require 'yoda/server/providers'
     require 'yoda/server/root_handler'
     require 'yoda/server/lifecycle_handler'
     require 'yoda/server/deserializer'
+    require 'yoda/server/scheduler'
+    require 'yoda/server/workspace'
+    require 'yoda/server/uri_decoder'
+    require 'yoda/server/rootless_workspace'
 
     # @return [::LanguageServer::Protocol::Transport::Stdio::Reader]
     attr_reader :reader
@@ -35,14 +38,18 @@ module Yoda
     end
 
     def run
+      Logger.trace "Server initializing..."
       reader.read do |request|
         begin
           root_handler.handle(id: request[:id], method: request[:method].to_sym, params: deserialize(request[:params]))
         rescue StandardError => ex
           Logger.warn ex
-          Logger.warn ex.backtrace
+          Logger.warn ex.full_message
         end
       end
+      Logger.trace "Waiting to finish all pending tasks..."
+      root_handler.wait_for_termination(timeout: 10)
+      Logger.trace "Server finishing..."
     end
 
     def deserialize(hash)

data/lib/yoda/services/code_completion/base_provider.rb

@@ -0,0 +1,52 @@
+module Yoda
+  module Services
+    class CodeCompletion
+      # @abstract
+      # Base class of completion candidates providers for code completion.
+      # This class bridges analysis features such as syntastic analysis {#source_analyzer} and symbolic execiton {#evaluator}.
+      class BaseProvider
+        # @return [Model::Environment]
+        attr_reader :environment
+
+        # @return [AST::Vnode]
+        attr_reader :ast
+
+        # @return [Parsing::Location]
+        attr_reader :location
+
+        # @return [Evaluator]
+        attr_reader :evaluator
+
+        # @param environment [Model::Environment]
+        # @param ast [AST::Vnode]
+        # @param location [Parsing::Location]
+        # @param evaluator [Evaluator]
+        def initialize(environment, ast, location, evaluator)
+          @environment = environment
+          @ast = ast
+          @location = location
+          @evaluator = evaluator
+        end
+
+        # @abstract
+        # @return [true, false]
+        def providable?
+          fail NotImplementedError
+        end
+
+        # @abstract
+        # @return [Array<Model::CompletionItem>]
+        def candidates
+          fail NotImplementedError
+        end
+
+        private
+
+        # @return [AST::Node, nil]
+        def current_node
+          @current_node ||= ast.positionally_nearest_child(location)
+        end
+      end
+    end
+  end
+end