yoda-language-server 0.7.1 → 0.9.0

data/lib/yoda/presentation/code_completion/constant.rb

@@ -0,0 +1,27 @@
+module Yoda
+  module Constant
+    class Candidates
+      def initialize(constant_candidates:, range:, prefix:)
+        @constant_candidates = constant_candidates
+        @range = range
+        @prefix = prefix
+      end
+
+      # @param object [Store::Objects::Base]
+      # @return [Symbol]
+      def complete_item_kind(object)
+        case object.kind
+        when :class
+          :class
+        when :module
+          :module
+        else
+          :constant
+        end
+      end
+    end
+
+    class Candidate
+    end
+  end
+end

data/lib/yoda/server/concurrent_writer.rb

@@ -2,7 +2,7 @@ module Yoda
   class Server
     # Wrapper class for writer to make thread safe
     class ConcurrentWriter
-      # @param [::LanguageServer::Protocol::Transport::Stdio::Writer]
+      # @param channel [::LanguageServer::Protocol::Transport::Stdio::Writer]
       def initialize(channel)
         @channel = channel
         @mutex = Mutex.new

data/lib/yoda/server/lifecycle_handler.rb

@@ -1,9 +1,12 @@
 require 'concurrent'
+require 'yoda/server/providers'
 
 module Yoda
   class Server
     # Handle
     class LifecycleHandler
+      include Providers::ReportableProgress
+
       # @return [Session, nil]
       attr_reader :session
 
@@ -39,32 +42,96 @@ module Yoda
         }
       end
 
+      # @param params [LanguageServer::Protocol::Interface::InitializeParams]
       def handle_initialize(params)
-        Instrument.instance.hear(initialization_progress: method(:notify_initialization_progress)) do
-          @session = Session.new(params[:root_uri])
-          send_warnings(@session.setup || [])
-
-          LanguageServer::Protocol::Interface::InitializeResult.new(
-            capabilities: LanguageServer::Protocol::Interface::ServerCapabilities.new(
-              text_document_sync: LanguageServer::Protocol::Interface::TextDocumentSyncOptions.new(
-                change: LanguageServer::Protocol::Constant::TextDocumentSyncKind::FULL,
-                save: LanguageServer::Protocol::Interface::SaveOptions.new(
-                  include_text: true,
-                ),
-              ),
-              completion_provider: LanguageServer::Protocol::Interface::CompletionOptions.new(
-                resolve_provider: false,
-                trigger_characters: ['.', '@', '[', ':', '!', '<'],
-              ),
-              hover_provider: true,
-              definition_provider: true,
-              signature_help_provider: LanguageServer::Protocol::Interface::SignatureHelpOptions.new(
-                trigger_characters: ['(', ','],
+        in_progress(params, title: "Initializing Yoda") do |progress_reporter|
+          reporter = InitializationProgressReporter.new(progress_reporter)
+
+          subscriptions = {
+            initialization_progress: reporter.public_method(:notify_initialization_progress),
+            build_library_registry: reporter.public_method(:notify_build_library_registry),
+          }
+
+          Instrument.instance.hear(**subscriptions) do
+            @session = begin
+              if params[:workspace_folders]
+                workspace_folders = params[:workspace_folders].map { |hash| LanguageServer::Protocol::Interface::WorkspaceFolder.new(name: hash[:name], uri: hash[:uri]) }
+                Session.from_workspace_folders(workspace_folders)
+              elsif params[:root_uri]
+                Session.from_root_uri(params[:root_uri])
+              else
+                Session.new(workspaces: [])
+              end
+            end
+
+            send_warnings(@session.setup || [])
+          end
+        end
+
+        LanguageServer::Protocol::Interface::InitializeResult.new(
+          server_info: {
+            name: "yoda",
+            version: Yoda::VERSION,
+          },
+          capabilities: LanguageServer::Protocol::Interface::ServerCapabilities.new(
+            text_document_sync: LanguageServer::Protocol::Interface::TextDocumentSyncOptions.new(
+              open_close: true,
+              change: LanguageServer::Protocol::Constant::TextDocumentSyncKind::FULL,
+              save: LanguageServer::Protocol::Interface::SaveOptions.new(
+                include_text: true,
               ),
             ),
-          )
-        end
+            completion_provider: LanguageServer::Protocol::Interface::CompletionOptions.new(
+              resolve_provider: false,
+              trigger_characters: ['.', '@', '[', ':', '!', '<'],
+            ),
+            hover_provider: true,
+            definition_provider: true,
+            signature_help_provider: LanguageServer::Protocol::Interface::SignatureHelpOptions.new(
+              trigger_characters: ['(', ','],
+            ),
+            workspace_symbol_provider: LanguageServer::Protocol::Interface::WorkspaceSymbolOptions.new(
+              work_done_progress: true,
+            ),
+            workspace: {
+              workspaceFolders: LanguageServer::Protocol::Interface::WorkspaceFoldersServerCapabilities.new(
+                supported: true,
+                change_notifications: true,
+              ),
+              fileOperations: {
+                didCreate: LanguageServer::Protocol::Interface::FileOperationRegistrationOptions.new(
+                  filters: [
+                    LanguageServer::Protocol::Interface::FileOperationFilter.new(
+                      pattern: LanguageServer::Protocol::Interface::FileOperationPattern.new(
+                        glob: "**/*",
+                      ),
+                    ),
+                  ],
+                ),
+                didRename: LanguageServer::Protocol::Interface::FileOperationRegistrationOptions.new(
+                  filters: [
+                    LanguageServer::Protocol::Interface::FileOperationFilter.new(
+                      pattern: LanguageServer::Protocol::Interface::FileOperationPattern.new(
+                        glob: "**/*",
+                      ),
+                    ),
+                  ],
+                ),
+                didDelete: LanguageServer::Protocol::Interface::FileOperationRegistrationOptions.new(
+                  filters: [
+                    LanguageServer::Protocol::Interface::FileOperationFilter.new(
+                      pattern: LanguageServer::Protocol::Interface::FileOperationPattern.new(
+                        glob: "**/*",
+                      ),
+                    ),
+                  ],
+                ),
+              },
+            },
+          ),
+        )
       rescue => e
+        Logger.warn e.full_message
         LanguageServer::Protocol::Interface::ResponseError.new(
           message: "Failed to initialize yoda: #{e.class} #{e.message}",
           code: LanguageServer::Protocol::Constant::ErrorCodes::SERVER_ERROR_START,
@@ -98,7 +165,7 @@ module Yoda
 
         notifier.show_message(
           type: :warning,
-          message: "Failed to load some libraries (Please check console for details)",
+          message: warning_summary(core_import_errors, gem_import_errors),
         )
 
         if gem_message = gem_import_warnings(gem_import_errors)
@@ -116,6 +183,17 @@ module Yoda
         end
       end
 
+      def warning_summary(core_import_errors, gem_import_errors)
+        error_list = []
+        error_list += ["- core library"] unless core_import_errors.empty?
+        error_list += gem_import_errors.map { |error| "- #{error.name} (#{error.version})" }
+
+        <<~EOS
+        Failed to load some libraries
+        #{error_list.join("\n")}
+        EOS
+      end
+
       # @param gem_import_errors [Array<GemImportError>]
       # @return [String, nil]
       def gem_import_warnings(gem_import_errors)
@@ -140,8 +218,30 @@ module Yoda
         EOS
       end
 
-      def notify_initialization_progress(phase: nil, message: nil, **params)
-        notifier.event(type: :initialization, phase: phase, message: message)
+      class InitializationProgressReporter
+        # @return [Providers::ReportableProgress::ProgressReporter]
+        attr_reader :progress_reporter
+
+        # @param progress_reporter [Providers::ReportableProgress::ProgressReporter]
+        def initialize(progress_reporter)
+          @progress_reporter = progress_reporter
+        end
+
+        def notify_initialization_progress(phase: nil, message: nil, index:, length:)
+          if length && length > 0
+            percentage = (index || 0) * 100 / length
+
+            progress_reporter.report(message: message, percentage: percentage)
+          else
+            progress_reporter.report(message: message)
+          end
+
+          progress_reporter.notifier.event(type: :initialization, phase: phase, message: message)
+        end
+
+        def notify_build_library_registry(message: nil, name: nil, version: nil)
+          progress_reporter.report(message: message)
+        end
       end
     end
   end

data/lib/yoda/server/notifier.rb

@@ -8,17 +8,94 @@ module Yoda
 
       # @param type [Symbol]
       def busy(type:, id: nil)
+        failed = false
         event(type: type, phase: :begin, id: id)
         yield
+      rescue => e
+        Logger.warn(e.full_message)
+        failed = true
+        event(type: type, phage: :failed, id: id)
+        raise e 
       ensure
         event(type: type, phase: :end, id: id)
       end
 
       # @param params [Hash]
-      def event(params)
+      def event(**params)
         write(method: 'telemetry/event', params: params)
       end
 
+      # @param token [Integer, String]
+      # @param title [String]
+      # @param cancellable [Boolean, nil]
+      # @param message [String]
+      # @param percentage [Integer]
+      # @see https://microsoft.github.io/language-server-protocol/specifications/specification-current/#workDoneProgressBegin
+      def work_done_progress_begin(token:, title:, cancellable: nil, message: nil, percentage: nil)
+        write(
+          method: '$/progress',
+          params: LanguageServer::Protocol::Interface::ProgressParams.new(
+            token: token,
+            value: LanguageServer::Protocol::Interface::WorkDoneProgressBegin.new(
+              kind: "begin",
+              title: title,
+              cancellable: cancellable,
+              message: message,
+              percentage: percentage,
+            )
+          ),
+        )
+      end
+
+      # @param token [Integer, String]
+      # @param cancellable [Boolean, nil]
+      # @param message [String]
+      # @param percentage [Integer]
+      # @see https://microsoft.github.io/language-server-protocol/specifications/specification-current/#workDoneProgressReport
+      def work_done_progress_report(token:, cancellable: nil, message: nil, percentage: nil)
+        write(
+          method: '$/progress',
+          params: LanguageServer::Protocol::Interface::ProgressParams.new(
+            token: token,
+            value: LanguageServer::Protocol::Interface::WorkDoneProgressReport.new(
+              kind: "report",
+              cancellable: cancellable,
+              message: message,
+              percentage: percentage,
+            )
+          ),
+        )
+      end
+
+      # @param token [Integer, String]
+      # @param message [String]
+      # @see https://microsoft.github.io/language-server-protocol/specifications/specification-current/#workDoneProgressEnd
+      def work_done_progress_end(token:, message: nil)
+        write(
+          method: '$/progress',
+          params: LanguageServer::Protocol::Interface::ProgressParams.new(
+            token: token,
+            value: LanguageServer::Protocol::Interface::WorkDoneProgressEnd.new(
+              kind: "end",
+              message: message,
+            )
+          ),
+        )
+      end
+
+      # @param token [Integer, String]
+      # @param value [Object] The partial result to send. In most cases, the type of this becomes the result type of the request.
+      # @see https://microsoft.github.io/language-server-protocol/specifications/specification-current/#partialResults
+      def partial_result(token:, value:)
+        write(
+          method: '$/progress',
+          params: LanguageServer::Protocol::Interface::ProgressParams.new(
+            token: token,
+            value: value,
+          ),
+        )
+      end
+
       # @param type [String, Symbol]
       # @param message [String]
       def show_message(type:, message:)
@@ -46,6 +123,7 @@ module Yoda
       private
 
       def write(params)
+        Logger.trace("Notify: #{params}")
         @writer.write(params)
       end
 

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

@@ -2,6 +2,8 @@ module Yoda
   class Server
     module Providers
       class Completion < Base
+        include WithTimeout
+
         def self.provider_method
           :'textDocument/completion'
         end
@@ -13,31 +15,42 @@ module Yoda
           calculate(uri, 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
 
         # @param uri      [String]
         # @param 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])
 
-          if candidates = comment_complete(source, location)
-            return candidates
-          end
-          complete_from_cut_source(source, location)
+          Logger.trace("Trying comment completion for #{uri}, #{position}")
+          candidates = comment_complete(workspace, source, location)
+          return candidates if candidates
+
+          Logger.trace("Trying code completion for #{uri}, #{position}")
+          complete_from_cut_source(workspace, source, location)
         end
 
+        # @param workspace [Workspace]
         # @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)
+        def comment_complete(workspace, source, location)
+          ast, comments = Parsing.parse_with_comments(source)
           return nil unless Parsing::Query::CurrentCommentQuery.new(comments, location).current_comment
-          completion_worker = Evaluation::CommentCompletion.new(session.registry, ast, comments, location)
+          completion_worker = Services::CommentCompletion.new(workspace.project.environment, ast, comments, location)
           return nil unless completion_worker.available?
 
           completion_items = completion_worker.candidates
@@ -50,12 +63,13 @@ module Yoda
           nil
         end
 
+        # @param workspace [Workspace]
         # @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(session.registry, cut_source, location)
+        def complete_from_cut_source(workspace, source, location)
+          cut_source = Parsing.fix_parse_error(source: source, location: location)
+          method_completion_worker = Services::CodeCompletion.new(workspace.project.environment, cut_source, location)
           completion_items = method_completion_worker.candidates
 
           LanguageServer::Protocol::Interface::CompletionList.new(
@@ -68,13 +82,13 @@ module Yoda
         # @return            [LanguageServer::Protocol::Interface::CompletionItem]
         def create_completion_item(completion_item)
           LanguageServer::Protocol::Interface::CompletionItem.new(
-            label: completion_item.description.is_a?(Model::Descriptions::FunctionDescription) ? completion_item.description.signature : completion_item.description.sort_text,
+            label: completion_item.label,
             kind: completion_item.language_server_kind,
-            detail: completion_item.description.title,
-            documentation: completion_item.description.to_markdown,
-            sort_text: completion_item.description.sort_text,
+            detail: completion_item.title,
+            documentation: completion_item.to_markdown,
+            sort_text: completion_item.sort_text,
             text_edit: LanguageServer::Protocol::Interface::TextEdit.new(
-              range: LanguageServer::Protocol::Interface::Range.new(completion_item.range.to_language_server_protocol_range),
+              range: LanguageServer::Protocol::Interface::Range.new(**completion_item.language_server_range),
               new_text: completion_item.edit_text,
             ),
             data: {},

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

@@ -2,6 +2,8 @@ module Yoda
   class Server
     module Providers
       class Definition < Base
+        include WithTimeout
+
         def self.provider_method
           :'textDocument/definition'
         end
@@ -10,32 +12,58 @@ 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
 
         # @param uri      [String]
         # @param position [{Symbol => Integer}]
         # @param include_declaration [Boolean]
         def calculate(uri, position, include_declaration = false)
-          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])
 
-          node_worker = Evaluation::CurrentNodeExplain.new(session.registry, source, location)
-          references = node_worker.defined_files
-          references.map { |(path, line, column)| create_location(path, line, column) }
-        end
+          session.workspaces.each do |workspace|
+            next unless workspace.suburi?(uri)
+
+            node_worker = Services::CurrentNodeExplain.from_source(environment: workspace.project.environment, source: source, location: location)
+
+            if (current_comment_signature = node_worker.current_comment_signature)&.providable?
+              references = current_comment_signature.defined_files
+              locations = references.map { |(path, line, column)| create_location(workspace.uri_of_path(path), line, column) }
 
+              return locations unless locations.empty?
+            elsif current_node_signature = node_worker.current_node_signature
+              references = current_node_signature.defined_files
+              locations = references.map { |(path, line, column)| create_location(workspace.uri_of_path(path), line, column) }
+
+              return locations unless locations.empty?
+            else
+              nil
+            end
+          end
+
+          []
+        end
+        
         # @param path [String]
         # @param line [Integer]
         # @param column [Integer]
-        def create_location(path, line, column)
-          location = Parsing::Location.new(row: line - 1, column: column)
+        def create_location(uri, line, column)
+          location = Parsing::Location.new(row: line, column: column)
           LanguageServer::Protocol::Interface::Location.new(
-            uri: session.uri_of_path(path),
-            range: LanguageServer::Protocol::Interface::Range.new(Parsing::Range.new(location, location).to_language_server_protocol_range),
+            uri: uri,
+            range: LanguageServer::Protocol::Interface::Range.new(**Parsing::Range.new(location, location).to_language_server_protocol_range),
           )
         end
       end

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

@@ -2,6 +2,8 @@ module Yoda
   class Server
     module Providers
       class Hover < Base
+        include WithTimeout
+
         def self.provider_method
           :'textDocument/hover'
         end
@@ -10,36 +12,50 @@ 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
+
 
         # @param uri      [String]
         # @param 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])
 
-          node_worker = Evaluation::CurrentNodeExplain.new(session.registry, source, location)
+          node_worker = Services::CurrentNodeExplain.from_source(environment: workspace.project.environment, source: source, location: location)
 
-          current_node_signature = node_worker.current_node_signature
-          create_hover(current_node_signature) if current_node_signature
+          if (current_comment_signature = node_worker.current_comment_signature)&.providable?
+            create_hover(current_comment_signature)
+          elsif current_node_signature = node_worker.current_node_signature
+            create_hover(current_node_signature)
+          else
+            nil
+          end
         end
 
-        # @param signature [Evaluation::NodeSignature]
+        # @param signature [Model::NodeSignatures::Base]
         def create_hover(signature)
           LanguageServer::Protocol::Interface::Hover.new(
             contents: signature.descriptions.map { |value| create_hover_text(value) },
-            range: LanguageServer::Protocol::Interface::Range.new(signature.node_range.to_language_server_protocol_range),
+            range: LanguageServer::Protocol::Interface::Range.new(**signature.node_range.to_language_server_protocol_range),
           )
         end
 
-        # @param description [Evaluation::Descriptions::Base]
-        # @return [String]
+        # @param description [Model::Descriptions::Base]
+        # @return [String, Hash]
         def create_hover_text(description)
-          description.to_markdown
+          description.markup_content
         end
       end
     end

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

@@ -0,0 +1,75 @@
+module Yoda
+  class Server
+    module Providers
+      module ReportableProgress
+        # @param params [Hash] The parameter of the request
+        def in_progress(params, title:)
+          begin
+            reporter = ProgressReporter.new(
+              work_done_token: params[:work_done_token],
+              partial_result_token: params[:partial_result_token],
+              notifier: notifier,
+            )
+
+            reporter.send_begin(title: title)
+            yield reporter
+
+           reporter.results
+          ensure
+            reporter.send_end
+          end
+        end
+
+        class ProgressReporter
+          # @param [String, Integer, nil]
+          attr_reader :work_done_token
+
+          # @param [String, Integer, nil]
+          attr_reader :partial_result_token
+
+          # @param [Notifier]
+          attr_reader :notifier
+
+          # @param [Array]
+          attr_reader :results
+
+          # @param work_done_token [String, Integer, nil]
+          # @param partial_result_token [String, Integer, nil]
+          # @param notifier [Notifier]
+          def initialize(work_done_token:, partial_result_token:, notifier:)
+            @work_done_token = work_done_token
+            @partial_result_token = partial_result_token
+            @notifier = notifier
+            @results = []
+          end
+
+          def send_begin(**kwargs)
+            if work_done_token
+              notifier.work_done_progress_begin(token: work_done_token, **kwargs)
+            end
+          end
+
+          def send_end(**kwargs)
+            if work_done_token
+              notifier.work_done_progress_end(token: work_done_token, **kwargs)
+            end
+          end
+
+          def report(**kwargs)
+            if work_done_token
+              notifier.work_done_progress_report(token: work_done_token, **kwargs)
+            end
+          end
+
+          def send_result(value)
+            if partial_result_token
+              notifier.partial_result(token: partial_result_token, value: value)
+            else
+              results.push(value)
+            end
+          end
+        end
+      end
+    end
+  end
+end