yoda-language-server 0.6.2 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 45f3bb7e65e24213b3d1c0e60110c08498d765e6a27732800d2c02e3508b03e4
-  data.tar.gz: 4e99d7cba046557256be92cfcf747e194086c52dedd94e7db344cc6fb8e9a2b1
+  metadata.gz: 3c06ab67892292a50ff422a252b794cf49f38dad60a8b32e7faf14936a2b648e
+  data.tar.gz: 20546678432670fae9b613a6d55e23f6ee3b2c544d6a6b62ff3ff80d6bd3e376
 SHA512:
-  metadata.gz: a278106001664f9468805400c571a333765c16f9557345d9295e2afee2a1a1a82e7d3a3022aaaefee04c7ee6b2c9d3dd23b3f634bca35c5150d5f99dd7cc8916
-  data.tar.gz: d13b8b7bde1b5b0dc7028f8df270186e767bae83e901885288b677ca64c9e0326ef788eed7c1578a5a0b359fb33716c89fdad2f203244fb3b14eb796d3fca465
+  metadata.gz: 0eac21b1b1b73f3d3864c2cdb37c2f8df39c9be6841518b59282d5b89c8b64d54972c9c8b9318d35273250c9c740465d7c2156098e0629ee0df831a05ad41e2a
+  data.tar.gz: 9b9991e147783643687d6c259c45c9ab45cfa009df5a60a23f1dce36571c5dc9a61d8a12bb70d57a79f30bf2288ed24933ea84e4a54c0df583b820ed54357cc6

data/client/atom/main.js

@@ -3,10 +3,10 @@ const { spawn } = require('child_process')
 const { resolve } = require('path')
 
 const busyMessages = {
-  text_document_hover: 'Preparing hover help',
-  text_document_signature_help: 'Preparing signature help',
-  text_document_completion: 'Completing',
-  text_document_definition: 'Finding definition',
+  'textDocument/hover': 'Preparing hover help',
+  'textDocument/signatureHelp': 'Preparing signature help',
+  'textDocument/completion': 'Completing',
+  'textDocument/definition': 'Finding definition',
 };
 
 class YodaClient extends AutoLanguageClient {
@@ -57,10 +57,10 @@ class YodaClient extends AutoLanguageClient {
     switch (eventBody.type) {
       case 'initialization':
         return this.handleInitializationEvent(eventBody);
-      case 'text_document_hover':
-      case 'text_document_completion':
-      case 'text_document_signature_help':
-      case 'text_document_completion':
+      case 'textDocument/hover':
+      case 'textDocument/completion':
+      case 'textDocument/signatureHelp':
+      case 'textDocument/completion':
         return this.handleBusyEvent(eventBody.type, eventBody);
       default:
     }
@@ -74,17 +74,24 @@ class YodaClient extends AutoLanguageClient {
     }
   }
 
-  handleBusyEvent(handlerName, { phase, message }) {
+  handleBusyEvent(handlerName, { phase, id }) {
     switch (phase) {
       case 'begin':
         if (!this.busyHandlers[handlerName]) {
-          this.busyHandlers[handlerName] = this.busySignalService.reportBusy("(Yoda) " + busyMessages[handlerName]);
+          this.busyHandlers[handlerName] = {
+            handler: this.busySignalService.reportBusy("(Yoda) " + (busyMessages[handlerName] || 'Processing')),
+            ids: new Set([]),
+          };
+          if (id) { this.busyHandlers[handlerName].ids.add(id); }
         }
         break;
       case 'end':
         if (this.busyHandlers[handlerName]) {
-          this.busyHandlers[handlerName].dispose();
-          this.busyHandlers[handlerName] = null;
+          if (id) { this.busyHandlers[handlerName].ids.delete(id); }
+          if (!this.busyHandlers[handlerName].ids.size) {
+            this.busyHandlers[handlerName].handler.dispose();
+            this.busyHandlers[handlerName] = null;
+          }
         }
         break;
     }

data/lib/yoda/commands.rb

@@ -11,6 +11,7 @@ module Yoda
 
     class Top < Thor
       class_option :log_level, type: :string, desc: 'Set log level (debug info warn error fatal)'
+      class_option :profile, type: :boolean, desc: 'Set log level (debug info warn error fatal)'
 
       desc 'setup', 'Setup indexes for current Ruby version and project gems'
       option :force_build, type: :boolean, desc: "If enabled, (re)build current project's index forcibly"
@@ -41,11 +42,28 @@ module Yoda
 
       def process_class_options
         set_log_level
+        use_profiler_if_enabled
       end
 
       def set_log_level
         Yoda::Logger.log_level = options[:log_level].to_sym if options[:log_level]
       end
+
+      def use_profiler_if_enabled
+        if options[:profile]
+          require 'stackprof'
+          require 'securerandom'
+          Logger.info('Enabled profiler')
+          StackProf.start(mode: :wall, raw: true)
+
+          at_exit do
+            StackProf.stop
+            tmpfile_path = File.expand_path(SecureRandom.hex(12), Dir.tmpdir)
+            StackProf.results(tmpfile_path)
+            Logger.fatal("Dumped file to: #{tmpfile_path}")
+          end
+        end
+      end
     end
   end
 end

data/lib/yoda/instrument.rb

@@ -1,3 +1,5 @@
+require 'concurrent'
+
 module Yoda
   class Instrument
     class Subscription
@@ -57,9 +59,19 @@ module Yoda
     # @return [Array<Subscription>]
     attr_reader :subscriptions
 
-    # @return [Instrument]
-    def self.instance
-      @instance ||= new
+    class << self
+      # Returns Instrument instance (thread local).
+      # @return [Instrument]
+      def instance
+        local.value
+      end
+
+      private
+
+      # @return [Concurrent::ThreadLocalVar<Instrument>]
+      def local
+        @local ||= Concurrent::ThreadLocalVar.new { Instrument.new }
+      end
     end
 
     def initialize

data/lib/yoda/server.rb

@@ -3,67 +3,41 @@ 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/completion_provider'
-    require 'yoda/server/signature_provider'
-    require 'yoda/server/hover_provider'
-    require 'yoda/server/definition_provider'
-    require 'yoda/server/initialization_provider'
+    require 'yoda/server/providers'
+    require 'yoda/server/root_handler'
+    require 'yoda/server/lifecycle_handler'
     require 'yoda/server/deserializer'
-    require 'yoda/server/session'
-
-    LSP = ::LanguageServer::Protocol
 
-    def self.deserialize(hash)
-      Deserializer.new.deserialize(hash || {})
-    end
-
-    # @type ::LanguageServer::Protocol::Transport::Stdio::Reader
+    # @return [::LanguageServer::Protocol::Transport::Stdio::Reader]
     attr_reader :reader
 
-    # @type ::LanguageServer::Protocol::Transport::Stdio::Writer
+    # @return [ConcurrentWriter]
     attr_reader :writer
 
-    # @return [Responser]
-    attr_reader :session
-
-    # @type CompletionProvider
-    attr_reader :completion_provider
-
-    # @type HoverProvider
-    attr_reader :hover_provider
-
-    # @type SignatureProvider
-    attr_reader :signature_provider
+    # @return [RootHandler]
+    attr_reader :root_handler
 
-    # @type DefinitionProvider
-    attr_reader :definition_provider
+    # Use this value as return value for notification handling
+    NO_RESPONSE = :no_response
 
-    # @return [Array<Hash>]
-    attr_reader :after_notifications
-
-    def initialize
-      @reader = LSP::Transport::Stdio::Reader.new
-      @writer = LSP::Transport::Stdio::Writer.new
-      @after_notifications = []
-    end
-
-    # @return [Notifier]
-    def notifier
-      @notifier ||= Notifier.new(self)
+    def initialize(
+      reader: LanguageServer::Protocol::Transport::Stdio::Reader.new,
+      writer: LanguageServer::Protocol::Transport::Stdio::Writer.new,
+      root_handler_class: RootHandler
+    )
+      @reader = reader
+      @writer = ConcurrentWriter.new(writer)
+      @root_handler = RootHandler.new(writer: @writer)
     end
 
     def run
       reader.read do |request|
         begin
-          if result = callback(request)
-            if result.is_a?(LanguageServer::Protocol::Interface::ResponseError)
-              send_error(id: request[:id], error: result)
-            else
-              send_response(id: request[:id], result: result)
-            end
-          end
-          process_after_notifications if session&.client_initialized
+          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
@@ -71,180 +45,8 @@ module Yoda
       end
     end
 
-    def process_after_notifications
-      while notification = after_notifications.pop
-        send_notification(**notification)
-      end
-    end
-
-    # @param method [String]
-    # @param params [Object]
-    def send_notification(method:, params:)
-      writer.write(method: method, params: params)
-    end
-
-    # @param id [String]
-    # @param result [Object]
-    def send_response(id:, result:)
-      writer.write(id: id, result: result)
-    end
-
-    # @param method [String]
-    # @param error [Object]
-    def send_error(id:, error:)
-      writer.write(id: id, error: error)
-    end
-
-    def callback(request)
-      if method_name = resolve(request_registrations, request[:method])
-        send(method_name, self.class.deserialize(request[:params] || {}))
-      elsif method_name = resolve(notification_registrations, request[:method])
-        send(method_name, self.class.deserialize(request[:params] || {}))
-        nil
-      end
-    end
-
-    # @param hash [Hash]
-    # @param key [String, Symbol]
-    # @return [Symbol, nil]
-    def resolve(hash, key)
-      resolved = key.to_s.split('/').reduce(hash) do |scope, key|
-        (scope || {})[key.to_sym]
-      end
-      resolved.is_a?(Symbol) && resolved
-    end
-
-    def request_registrations
-      {
-        initialize: :handle_initialize,
-        shutdown: :handle_shutdown,
-        textDocument: {
-          completion: :handle_text_document_completion,
-          hover: :handle_text_document_hover,
-          signatureHelp: :handle_text_document_signature_help,
-          definition: :handle_text_document_definition,
-        },
-      }
-    end
-
-    def notification_registrations
-      {
-        initialized: :handle_initialized,
-        exit: :handle_exit,
-        textDocument: {
-          didChange: :handle_text_document_did_change,
-          didOpen: :handle_text_document_did_open,
-          didSave: :handle_text_document_did_save,
-        },
-      }
-    end
-
-    def handle_initialize(params)
-      @session = Session.new(params[:root_uri])
-      @completion_provider = CompletionProvider.new(@session)
-      @hover_provider = HoverProvider.new(@session)
-      @signature_provider = SignatureProvider.new(@session)
-      @definition_provider = DefinitionProvider.new(@session)
-
-      (InitializationProvider.new(session: session, notifier: notifier).provide || []).each { |notification| after_notifications.push(notification) }
-
-      LSP::Interface::InitializeResult.new(
-        capabilities: LSP::Interface::ServerCapabilities.new(
-          text_document_sync: LSP::Interface::TextDocumentSyncOptions.new(
-            change: LSP::Constant::TextDocumentSyncKind::FULL,
-            save: LSP::Interface::SaveOptions.new(
-              include_text: true,
-            ),
-          ),
-          completion_provider: LSP::Interface::CompletionOptions.new(
-            resolve_provider: false,
-            trigger_characters: ['.', '@', '[', ':', '!', '<'],
-          ),
-          hover_provider: true,
-          definition_provider: true,
-          signature_help_provider: LSP::Interface::SignatureHelpOptions.new(
-            trigger_characters: ['(', ','],
-          ),
-        ),
-      )
-    rescue => e
-      LanguageServer::Protocol::Interface::ResponseError.new(
-        message: "Failed to initialize yoda: #{e.class} #{e.message}",
-        code: LanguageServer::Protocol::Constant::InitializeError::UNKNOWN_PROTOCOL_VERSION,
-        data: LanguageServer::Protocol::Interface::InitializeError.new(retry: false),
-      )
-    end
-
-    def handle_initialized(_params)
-      session.client_initialized = true
-    end
-
-    def handle_shutdown(_params)
-    end
-
-    def handle_exit(_params)
-    end
-
-    module TextDocument
-      module CompletionTrigggerKind
-        INVOKED = 1
-        TRIGGER_CHARACTER = 2
-      end
-
-      def handle_text_document_did_open(params)
-        uri = params[:text_document][:uri]
-        text = params[:text_document][:text]
-        session.file_store.store(uri, text)
-      end
-
-      def handle_text_document_did_save(params)
-        uri = params[:text_document][:uri]
-
-        session.reparse_doc(uri)
-      end
-
-      def handle_text_document_did_change(params)
-        uri = params[:text_document][:uri]
-        text = params[:content_changes].first[:text]
-        session.file_store.store(uri, text)
-      end
-
-      def handle_text_document_completion(params)
-        uri = params[:text_document][:uri]
-        position = params[:position]
-
-        notifier.busy(type: :text_document_completion) do
-          completion_provider&.complete(uri, position)
-        end
-      end
-
-      def handle_text_document_hover(params)
-        uri = params[:text_document][:uri]
-        position = params[:position]
-
-        notifier.busy(type: :text_document_hover) do
-          hover_provider&.request_hover(uri, position)
-        end
-      end
-
-      def handle_text_document_signature_help(params)
-        uri = params[:text_document][:uri]
-        position = params[:position]
-
-        notifier.busy(type: :text_document_signature_help) do
-          signature_provider&.provide(uri, position)
-        end
-      end
-
-      def handle_text_document_definition(params)
-        uri = params[:text_document][:uri]
-        position = params[:position]
-
-        notifier.busy(type: :text_document_definition) do
-          definition_provider&.provide(uri, position)
-        end
-      end
+    def deserialize(hash)
+      Deserializer.new.deserialize(hash || {})
     end
-    include TextDocument
   end
 end

data/lib/yoda/server/concurrent_writer.rb

@@ -0,0 +1,16 @@
+module Yoda
+  class Server
+    # Wrapper class for writer to make thread safe
+    class ConcurrentWriter
+      # @param [::LanguageServer::Protocol::Transport::Stdio::Writer]
+      def initialize(channel)
+        @channel = channel
+        @mutex = Mutex.new
+      end
+
+      def write(*args)
+        @mutex.synchronize { @channel.write(*args) }
+      end
+    end
+  end
+end

data/lib/yoda/server/file_store.rb

@@ -0,0 +1,57 @@
+require 'concurrent'
+
+module Yoda
+  class Server
+    class FileStore
+      def initialize
+        @cache = Concurrent::Map.new
+      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