yoda-language-server 0.6.2 → 0.7.0

data/lib/yoda/server/lifecycle_handler.rb

@@ -0,0 +1,148 @@
+require 'concurrent'
+
+module Yoda
+  class Server
+    # Handle
+    class LifecycleHandler
+      # @return [Session, nil]
+      attr_reader :session
+
+      # @return [Notifier]
+      attr_reader :notifier
+
+      def initialize(root_handler)
+        @root_handler = root_handler
+        @notifier = root_handler.notifier
+      end
+
+      # @param method [Symbol]
+      # @return [true, false]
+      def handle?(method)
+        lifecycle_handlers.key?(method)
+      end
+
+      # @param method [Symbol]
+      # @param params [Object]
+      def handle(method:, params:)
+        lifecycle_handlers[method].call(params)
+      end
+
+      private
+
+      def lifecycle_handlers
+        @lifecycle_handlers ||= {
+          initialize: method(:handle_initialize),
+          initialized: method(:handle_initialized),
+          shutdown: method(:handle_shutdown),
+          exit: method(:handle_exit),
+          '$/cancelRequest': method(:handle_cancel),
+        }
+      end
+
+      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: ['(', ','],
+              ),
+            ),
+          )
+        end
+      rescue => e
+        LanguageServer::Protocol::Interface::ResponseError.new(
+          message: "Failed to initialize yoda: #{e.class} #{e.message}",
+          code: LanguageServer::Protocol::Constant::ErrorCodes::SERVER_ERROR_START,
+          data: LanguageServer::Protocol::Interface::InitializeError.new(retry: false),
+        )
+      end
+
+      def handle_initialized(_params)
+        NO_RESPONSE
+      end
+
+      def handle_shutdown(_params)
+      end
+
+      def handle_cancel(params)
+        @root_handler.cancel_request(params[:id])
+
+        NO_RESPONSE
+      end
+
+      def handle_exit(_params)
+        NO_RESPONSE
+      end
+
+      # @param errors [Array<BaseError>]
+      # @return [Array<Object>]
+      def send_warnings(errors)
+        return [] if errors.empty?
+        gem_import_errors = errors.select { |error| error.is_a?(GemImportError) }
+        core_import_errors = errors.select { |error| error.is_a?(CoreImportError) }
+
+        notifier.show_message(
+          type: :warning,
+          message: "Failed to load some libraries (Please check console for details)",
+        )
+
+        if gem_message = gem_import_warnings(gem_import_errors)
+          notifier.log_message(
+            type: :warning,
+            message: gem_message,
+          )
+        end
+
+        if core_message = core_import_warnings(core_import_errors)
+          notifier.log_message(
+            type: :warning,
+            message: core_message,
+          )
+        end
+      end
+
+      # @param gem_import_errors [Array<GemImportError>]
+      # @return [String, nil]
+      def gem_import_warnings(gem_import_errors)
+        return if gem_import_errors.empty?
+        warnings = gem_import_errors.map { |error| "- #{error.name} (#{error.version})" }
+
+        <<~EOS
+        Failed to import some gems.
+        Please check these gems are installed for Ruby version #{RUBY_VERSION}.
+        #{warnings.join("\n")}
+        EOS
+      end
+
+      # @param gem_import_errors [Array<GemImportError>]
+      # @return [String, nil]
+      def core_import_warnings(core_import_errors)
+        return if core_import_errors.empty?
+
+        <<~EOS
+        Failed to import some core libraries (Ruby version: #{RUBY_VERSION}).
+        Please execute `yoda setup` with Ruby version #{RUBY_VERSION}.
+        EOS
+      end
+
+      def notify_initialization_progress(phase: nil, message: nil, **params)
+        notifier.event(type: :initialization, phase: phase, message: message)
+      end
+    end
+  end
+end

data/lib/yoda/server/notifier.rb

@@ -1,28 +1,28 @@
 module Yoda
   class Server
     class Notifier
-      # @param server [Server]
-      def initialize(server)
-        @server = server
+      # @param writer [ConcurrentWriter]
+      def initialize(writer)
+        @writer = writer
       end
 
       # @param type [Symbol]
-      def busy(type:)
-        event(type: type, phase: :begin)
+      def busy(type:, id: nil)
+        event(type: type, phase: :begin, id: id)
         yield
       ensure
-        event(type: type, phase: :end)
+        event(type: type, phase: :end, id: id)
       end
 
       # @param params [Hash]
       def event(params)
-        server.send_notification(method: 'telemetry/event', params: params)
+        write(method: 'telemetry/event', params: params)
       end
 
       # @param type [String, Symbol]
       # @param message [String]
       def show_message(type:, message:)
-        server.send_notification(
+        write(
           method: 'window/showMessage',
           params: LanguageServer::Protocol::Interface::ShowMessageParams.new(
             type: message_type(type),
@@ -34,7 +34,7 @@ module Yoda
       # @param type [String, Symbol]
       # @param message [String]
       def log_message(type:, message:)
-        server.send_notification(
+        write(
           method: 'window/logMessage',
           params: LanguageServer::Protocol::Interface::ShowMessageParams.new(
             type: message_type(type),
@@ -45,6 +45,10 @@ module Yoda
 
       private
 
+      def write(params)
+        @writer.write(params)
+      end
+
       # @param type [String, Symbol]
       def message_type(type)
         case type.to_sym

data/lib/yoda/server/providers.rb

@@ -0,0 +1,41 @@
+module Yoda
+  class Server
+    module Providers
+      require 'yoda/server/providers/base'
+
+      require 'yoda/server/providers/completion'
+      require 'yoda/server/providers/signature'
+      require 'yoda/server/providers/hover'
+      require 'yoda/server/providers/definition'
+      require 'yoda/server/providers/text_document_did_change'
+      require 'yoda/server/providers/text_document_did_open'
+      require 'yoda/server/providers/text_document_did_save'
+
+      CLASSES = [
+        Completion,
+        Definition,
+        Hover,
+        Signature,
+        TextDocumentDidChange,
+        TextDocumentDidOpen,
+        TextDocumentDidSave,
+      ].freeze
+
+      class << self
+        # @param method [Symbol]
+        # @param notifier [Notifier]
+        # @param session [Session]
+        # @return [Class<Providers::Base>, nil]
+        def build_provider(method:, notifier:, session:)
+          find_provider_class(method)&.new(notifier: notifier, session: session)
+        end
+
+        # @param method [Symbol]
+        # @return [Class<Providers::Base>, nil]
+        def find_provider_class(method)
+          CLASSES.find { |provider_class| provider_class.provide?(method) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+module Yoda
+  class Server
+    module Providers
+      # @abstract
+      class Base
+        class << self
+          # @abstract
+          # @return [Symbol]
+          def provider_method
+            fail NotImplementedError
+          end
+
+          # @param method [Symbol]
+          def provide?(method)
+            provider_method == method
+          end
+        end
+
+        # @return [Notifier]
+        attr_reader :notifier
+
+        # @return [Session]
+        attr_reader :session
+
+        # @param notifier [Notifier]
+        # @param session [Notifier]
+        def initialize(notifier:, session:)
+          @notifier = notifier
+          @session = session
+        end
+
+        # @abstract
+        # @param params [Hash]
+        def provide(params)
+          fail NotImplementedError
+        end
+
+        # @return [Integer, nil] Seconds to timeout the task. if nil, the task does not timeout.
+        def timeout
+          nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+module Yoda
+  class Server
+    module Providers
+      class Completion < Base
+        def self.provider_method
+          :'textDocument/completion'
+        end
+
+        def provide(params)
+          uri = params[:text_document][:uri]
+          position = params[:position]
+
+          calculate(uri, position)
+        end
+
+        def timeout
+          10
+        end
+
+        private
+
+        # @param uri      [String]
+        # @param 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])
+
+          if candidates = comment_complete(source, location)
+            return candidates
+          end
+          complete_from_cut_source(source, location)
+        end
+
+        # @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(session.registry, ast, comments, location)
+          return nil unless completion_worker.available?
+
+          completion_items = completion_worker.candidates
+
+          LanguageServer::Protocol::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(session.registry, cut_source, location)
+          completion_items = method_completion_worker.candidates
+
+          LanguageServer::Protocol::Interface::CompletionList.new(
+            is_incomplete: false,
+            items: completion_items.map { |completion_item| create_completion_item(completion_item) },
+          )
+        end
+
+        # @param completion_item [Model::CompletionItem]
+        # @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,
+            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: LanguageServer::Protocol::Interface::TextEdit.new(
+              range: LanguageServer::Protocol::Interface::Range.new(completion_item.range.to_language_server_protocol_range),
+              new_text: completion_item.edit_text,
+            ),
+            data: {},
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+module Yoda
+  class Server
+    module Providers
+      class Definition < Base
+        def self.provider_method
+          :'textDocument/definition'
+        end
+
+        def provide(params)
+          calculate(params[:text_document][:uri], params[:position])
+        end
+
+        def timeout
+          10
+        end
+
+        private
+
+        # @param uri      [String]
+        # @param position [{Symbol => Integer}]
+        # @param include_declaration [Boolean]
+        def calculate(uri, position, include_declaration = false)
+          source = session.file_store.get(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
+
+        # @param path [String]
+        # @param line [Integer]
+        # @param column [Integer]
+        def create_location(path, line, column)
+          location = Parsing::Location.new(row: line - 1, 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),
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+module Yoda
+  class Server
+    module Providers
+      class Hover < Base
+        def self.provider_method
+          :'textDocument/hover'
+        end
+
+        def provide(params)
+          calculate(params[:text_document][:uri], params[:position])
+        end
+
+        def timeout
+          10
+        end
+
+        private
+
+        # @param uri      [String]
+        # @param 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])
+
+          node_worker = Evaluation::CurrentNodeExplain.new(session.registry, source, location)
+
+          current_node_signature = node_worker.current_node_signature
+          create_hover(current_node_signature) if current_node_signature
+        end
+
+        # @param signature [Evaluation::NodeSignature]
+        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),
+          )
+        end
+
+        # @param description [Evaluation::Descriptions::Base]
+        # @return [String]
+        def create_hover_text(description)
+          description.to_markdown
+        end
+      end
+    end
+  end
+end