yoda-language-server 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 422bf18a171e2f3f5421297156a6b0ceb1721f6cd1f41027e16f2cba5c10d8e8
-  data.tar.gz: 4651bcac93f48b305317079f61aba37cf8a2fe9d48e516357a48886915a90960
+  metadata.gz: b544f7f3b34a813b4315f584e191ffd2c818dc63bfd24a093eec32fc4521b391
+  data.tar.gz: ba9b8cbc95bdd15d90f23b3921634cf2a3de5c3d61d3a2049e1ea6028d4d880f
 SHA512:
-  metadata.gz: 17072e331769fefa2e0f09c8d6cb1851eaa6c7afdd3159bb6e9c6724a09614d83e544e41a5bfbf2cb3a4772547ef6beffa6c389663d08cc75d374372c5fc850c
-  data.tar.gz: f12118c68f473c909da8e3df94b0f3d30003ebefc70777520a43562de0d75e7cabc70a845483c50868a0a03a322352f3c5cf99e2b33f809cc7aa09729f31a6ef
+  metadata.gz: aa9a0e6cab7d9320eab849a9409706ae3a10ecac15ac5f65d380f07e7fdf5fc89482f327675d0eac4d66764b5198c007504d91ac9a58910677779383084b6f37
+  data.tar.gz: 325f262ab02a095ecc3005b369ffd233b0faa5837de49b9e60a563e192e0fc1cfacd8a80f0863b5a7801a897af34dae02cbe0df075aeb711405aa6cdb4e2379c

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    yoda-language-server (0.5.0)
+    yoda-language-server (0.6.0)
       language_server-protocol (~> 3.7.0.0)
       leveldb (~> 0.1.9)
       lmdb (~> 0.4.8)
@@ -57,10 +57,10 @@ GEM
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.7.0)
     rspec-support (3.7.1)
-    ruby-progressbar (1.9.0)
+    ruby-progressbar (1.10.0)
     stackprof (0.2.11)
     thor (0.20.0)
-    yard (0.9.15)
+    yard (0.9.16)
 
 PLATFORMS
   ruby

data/README.md

@@ -1,7 +1,8 @@
-# Yoda (In Progress) [![Build Status](https://travis-ci.org/tomoasleep/yoda.svg?branch=master)](https://travis-ci.org/tomoasleep/yoda)
+# Yoda [![Build Status](https://travis-ci.org/tomoasleep/yoda.svg?branch=master)](https://travis-ci.org/tomoasleep/yoda)
 
-Yoda is a Language Server for Ruby and provides autocompletion and code analysis (go-to-definition, code information, etc...).
-(To know Language Server, please see http://langserver.org/)
+Yoda is a Language Server (http://langserver.org/) for Ruby and provides autocompletion and code analysis (go-to-definition, code information, etc...).  
+
+**Note: Yoda is alpha version. Please use with caution. Contributions are welcome!**
 
 ## Instation and Usage
 
@@ -27,16 +28,23 @@ $ yoda complete <path-to-your-code>:<line-num>:<char-num> # Show completion at t
 ### Atom
 
 ```
-apm install github.com/tomoasleep/yoda
+apm install tomoasleep/yoda
 ```
 
 ### VSCode
 
 TBW
 
-### Vim
+### Vim/NeoVim
 
-TBW
+Please use language server client such as [LanguageClient-neovim](https://github.com/autozimu/LanguageClient-neovim).
+Here is a configuration example for LanguageClient-neovim.
+
+```vim
+let g:LanguageClient_serverCommands = {
+    \ 'ruby': ['yoda', 'server'],
+    \ }
+```
 
 ### Emacs
 
@@ -46,13 +54,13 @@ TBW
 
 ### YARD utilization
 
-Yoda figures structures of your source codes and library codes with YARD.
+Yoda figures structures of your source codes and library codes with YARD.  
 Yoda intepret YARD tags such as `@return` tags and `@param` tags and infer code types from these information.
 
 ### Indexing
 
-Yoda built index files for fast inference under `<your-project-dir>/.yoda` at startup.
-These index files contains structures of external sources (gems and standard libraries).
+Yoda built index files for fast inference under `<your-project-dir>/.yoda` at startup.  
+These index files contains structures of external sources (gems and standard libraries).  
 Your project codes are parsed at startup but does not stored in indexes.
 
 ### Supporting Features

data/client/atom/main.js

@@ -7,6 +7,26 @@ class YodaClient extends AutoLanguageClient {
     super()
   }
 
+  preInitialization(connection) {
+    connection.onTelemetryEvent(({ type, phase, message }) => {
+      if (!this.busySignalService) { return; }
+      if (type != 'initialization') { return; }
+
+      if (this.initializationBusyMessage) {
+        this.initializationBusyMessage.setTitle(message);
+      } else {
+        this.initializationBusyMessage = this.busySignalService.reportBusy(message);
+      }
+    });
+  }
+
+  postInitialization(_server) {
+    if (this.initializationBusyMessage) {
+      this.initializationBusyMessage.dispose();
+      this.initializationBusyMessage = null;
+    }
+  }
+
   getGrammarScopes () { return ['source.ruby', 'source.rb', 'source.ruby.rails'] }
   getLanguageName () { return 'Ruby' }
   getServerName () { return 'Yoda' }

data/lib/yoda.rb

@@ -1,5 +1,7 @@
 module Yoda
   require "yoda/version"
+  require "yoda/logger"
+  require "yoda/instrument"
   require "yoda/commands"
   require "yoda/errors"
   require "yoda/evaluation"
@@ -10,3 +12,5 @@ module Yoda
   require "yoda/typing"
   require "yoda/yard_extensions"
 end
+
+YARD::Logger.instance.io = Yoda::Logger.instance.pipeline(tag: 'YARD')

data/lib/yoda/commands.rb

@@ -10,25 +10,42 @@ module Yoda
     require 'yoda/commands/complete'
 
     class Top < Thor
+      class_option :log_level, type: :string, 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"
       def setup
-        Commands::Setup.run
+        process_class_options
+        Commands::Setup.run(force_build: options[:force_build])
       end
 
       desc 'infer POSITION', 'Infer the type of value at the specified position'
       def infer(position)
+        process_class_options
         Commands::Infer.run(position)
       end
 
       desc 'complete POSITION', 'Provide completion candidates for the specified position'
       def complete(position)
+        process_class_options
         Commands::Complete.run(position)
       end
 
       desc 'server', 'Start Language Server'
       def server
+        process_class_options
         Server.new.run
       end
+
+      private
+
+      def process_class_options
+        set_log_level
+      end
+
+      def set_log_level
+        Yoda::Logger.log_level = options[:log_level].to_sym if options[:log_level]
+      end
     end
   end
 end

data/lib/yoda/commands/setup.rb

@@ -1,3 +1,5 @@
+require 'ruby-progressbar'
+
 module Yoda
   module Commands
     class Setup < Base
@@ -7,19 +9,25 @@ module Yoda
       # @return [true, false]
       attr_reader :force_build
 
+      # @return [Hash{ Symbol => ProgressBar }]
+      attr_reader :bars
+
       # @param dir [String]
       def initialize(dir: nil, force_build: false)
         @dir = dir || Dir.pwd
         @force_build = force_build
+        @bars = {}
       end
 
       def run
         build_core_index
         if File.exist?(File.expand_path('Gemfile.lock', dir)) || force_build
-          STDERR.puts 'Building index for the current project...'
-          force_build ? project.rebuild_cache(progress: true) : project.build_cache(progress: true)
+          Logger.info 'Building index for the current project...'
+          Instrument.instance.hear(initialization_progress: method(:on_progress), registry_dump: method(:on_progress)) do
+            force_build ? project.rebuild_cache : project.build_cache
+          end
         else
-          STDERR.puts 'Skipped building project index because Gemfile.lock is not exist for the current dir'
+          Logger.info 'Skipped building project index because Gemfile.lock is not exist for the current dir'
         end
       end
 
@@ -32,6 +40,12 @@ module Yoda
       def build_core_index
         Store::Actions::BuildCoreIndex.run unless Store::Actions::BuildCoreIndex.exists?
       end
+
+      def on_progress(phase: :save_keys, index: nil, length: nil, **params)
+        return unless index
+        bar = bars[phase] ||= ProgressBar.create(format: "%t: %c/%C |%w>%i| %e ", title: phase.to_s.gsub('_', ' '), starting_at: index, total: length)
+        bar.progress = index if index <= bar.total
+      end
     end
   end
 end

data/lib/yoda/instrument.rb

@@ -0,0 +1,113 @@
+module Yoda
+  class Instrument
+    class Subscription
+      # @return [Instrument]
+      attr_reader :instrument
+
+      # @return [String]
+      attr_reader :name
+
+      # @return [#call]
+      attr_reader :callback
+
+      # @param instrument [Instrument]
+      # @param name [String]
+      # @param callback [#call]
+      def initialize(instrument:, name:, callback:)
+        @instrument = instrument
+        @name = name
+        @callback = callback
+      end
+
+      def unsubscribe
+        instrument.unsubscribe(self)
+      end
+
+      def call(params)
+        callback.call(params)
+      end
+    end
+
+    class Progress
+      # @return [Integer]
+      attr_reader :length, :index
+
+      # @return [#call]
+      attr_reader :callback
+
+      # @param length [Integer]
+      # @param callback [#call]
+      def initialize(length, &callback)
+        @length = length
+        @index = 0
+        @callback = callback
+        call
+      end
+
+      def increment
+        @index += 1
+        call
+      end
+
+      def call
+        callback.call(length: length, index: index)
+      end
+    end
+
+    # @return [Array<Subscription>]
+    attr_reader :subscriptions
+
+    # @return [Instrument]
+    def self.instance
+      @instance ||= new
+    end
+
+    def initialize
+      @subscriptions = []
+    end
+
+    # Add subscriptions and eval the given block. these subscriptions are unsubscribed after the block.
+    # @param subscription_hash [Hash{ Symbol, String => #call }]
+    def hear(subscription_hash = {})
+      subscriptions = subscription_hash.map { |key, value| subscribe(key, &value) }
+      value = yield
+      subscriptions.each(&:unsubscribe)
+      value
+    end
+
+    # @param name [String, Symbol]
+    # @param callback [#call]
+    # @return [Subsctiption]
+    def subscribe(name, &callback)
+      Subscription.new(instrument: self, name: name, callback: callback).tap { |subscription| subscriptions.push(subscription) }
+    end
+
+    # @param name [String]
+    # @param [String]
+    def emit(name, params)
+      Logger.trace("#{name}: #{params}")
+      subscriptions.select { |subscription| subscription.name === name }.each { |subscription| subscription.call(params) }
+    end
+
+    # @param subscription [Subscription]
+    def unsubscribe(subscription)
+      subscriptions.delete(subscription)
+    end
+
+    # @!group event_name
+
+    # @param phase [Symbol]
+    # @param message [String]
+    # @param index [Integer, nil]
+    # @param length [Integer, nil]
+    def initialization_progress(phase:, message:, index: nil, length: nil)
+      emit(:initialization_progress, phase: phase, message: message, index: index, length: length)
+    end
+
+    # @param index [Integer, nil]
+    # @param length [Integer, nil]
+    def registry_dump(index: nil, length: nil)
+      emit(:registry_dump, index: index, length: length)
+    end
+  end
+end

data/lib/yoda/logger.rb

@@ -0,0 +1,68 @@
+require 'forwardable'
+
+module Yoda
+  class Logger
+    LOG_LEVELS = %i(trace debug info warn error fatal).freeze
+
+    class << self
+      extend Forwardable
+      def_delegators :instance, *%i(pipeline trace debug info warn error fatal log_level allow_debug? allow_info? allow_warn? allow_error? allow_fatal? log_level=)
+
+      # @return [Yoda::Logger]
+      def instance
+        @instance ||= Yoda::Logger.new(STDERR)
+      end
+
+      # @!macro [attach]
+      #   @!method $1(content, tag: nil)
+      #     @param content [String]
+      #     @param tag [String, nil]
+      #   @!method allow_$1?
+      #     @return [true, false]
+      def define_logging_method(level)
+        define_method(level) do |content, tag: nil|
+          return unless public_send("allow_#{level}?")
+          prefix = "[#{level}]#{tag ? ' (' + tag + ')' : '' } "
+          io.puts(prefix + content.to_s.split("\n").join(prefix))
+        end
+
+        define_method("allow_#{level}?") do
+          allowed_log_levels.include?(level)
+        end
+      end
+    end
+
+    # @return [IO]
+    attr_accessor :io
+
+    # @return [Hash<Thread>]
+    attr_reader :threads
+
+    # @return [Symbol]
+    attr_accessor :log_level
+
+    LOG_LEVELS.each { |level| define_logging_method(level) }
+
+    def initialize(io)
+      @io = io
+      @threads = {}
+      @log_level = :info
+    end
+
+    def allowed_log_levels
+      LOG_LEVELS.drop_while { |level| level != log_level }
+    end
+
+    def pipeline(tag:)
+      threads[tag] ||= begin
+        r, w = IO.pipe
+        Thread.new do
+          r.each do |content|
+            debug(content.chomp, tag: tag)
+          end
+        end
+        w
+      end
+    end
+  end
+end

data/lib/yoda/server.rb

@@ -3,6 +3,7 @@ require 'securerandom'
 
 module Yoda
   class Server
+    require 'yoda/server/notifier'
     require 'yoda/server/completion_provider'
     require 'yoda/server/signature_provider'
     require 'yoda/server/hover_provider'
@@ -47,6 +48,11 @@ module Yoda
       @after_notifications = []
     end
 
+    # @return [Notifier]
+    def notifier
+      @notifier ||= Notifier.new(self)
+    end
+
     def run
       reader.read do |request|
         begin
@@ -59,8 +65,8 @@ module Yoda
           end
           process_after_notifications if session&.client_initialized
         rescue StandardError => ex
-          STDERR.puts ex
-          STDERR.puts ex.backtrace
+          Logger.warn ex
+          Logger.warn ex.backtrace
         end
       end
     end
@@ -140,7 +146,7 @@ module Yoda
       @signature_provider = SignatureProvider.new(@session)
       @definition_provider = DefinitionProvider.new(@session)
 
-      (InitializationProvider.new(@session).provide || []).each { |notification| after_notifications.push(notification) }
+      (InitializationProvider.new(session: session, notifier: notifier).provide || []).each { |notification| after_notifications.push(notification) }
 
       LSP::Interface::InitializeResult.new(
         capabilities: LSP::Interface::ServerCapabilities.new(

data/lib/yoda/server/initialization_provider.rb

@@ -4,14 +4,21 @@ module Yoda
       # @return [Session]
       attr_reader :session
 
+      # @return [Notifier]
+      attr_reader :notifier
+
       # @param session [Session]
-      def initialize(session)
+      # @param nofitier [Notifier]
+      def initialize(session:, notifier:)
         @session = session
+        @notifier = notifier
       end
 
       # @return [LanguageServer::Protocol::Interface::ShowMessageParams, nil]
       def provide
-        errors = session.setup
+        errors = Instrument.instance.hear(initialization_progress: method(:notify_initialization_progress)) do
+          session.setup
+        end
         build_complete_message(errors)
       end
 
@@ -80,6 +87,10 @@ module Yoda
         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

@@ -0,0 +1,61 @@
+module Yoda
+  class Server
+    class Notifier
+      # @param server [Server]
+      def initialize(server)
+        @server = server
+      end
+
+      # @param params [Hash]
+      def event(params)
+        server.send_notification(method: 'telemetry/event', params: params)
+      end
+
+      # @param type [String, Symbol]
+      # @param message [String]
+      def show_message(type:, message:)
+        server.send_notification(
+          method: 'window/showMessage',
+          params: LanguageServer::Protocol::Interface::ShowMessageParams.new(
+            type: message_type(type),
+            message: message,
+          )
+        )
+      end
+
+      # @param type [String, Symbol]
+      # @param message [String]
+      def log_message(type:, message:)
+        server.send_notification(
+          method: 'window/logMessage',
+          params: LanguageServer::Protocol::Interface::ShowMessageParams.new(
+            type: message_type(type),
+            message: message,
+          )
+        )
+      end
+
+      private
+
+      # @param type [String, Symbol]
+      def message_type(type)
+        case type.to_sym
+        when :error
+          LanguageServer::Protocol::Constant::MessageType::ERROR
+        when :warning
+          LanguageServer::Protocol::Constant::MessageType::WARNING
+        when :info
+          LanguageServer::Protocol::Constant::MessageType::INFO
+        when :log
+          LanguageServer::Protocol::Constant::MessageType::LOG
+        else
+          Logger.warn("#{type} is not valie message type")
+          LanguageServer::Protocol::Constant::MessageType::INFO
+        end
+      end
+
+      # @return [Server]
+      attr_reader :server
+    end
+  end
+end

data/lib/yoda/server/session.rb

@@ -32,7 +32,10 @@ module Yoda
       end
 
       def setup
-        Store::Actions::BuildCoreIndex.run unless Store::Actions::BuildCoreIndex.exists?
+        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
       end
 

data/lib/yoda/store/actions/build_core_index.rb

@@ -31,11 +31,11 @@ module Yoda
 
         def build_core_index
           o, e = Open3.capture2e(script_path)
-          STDERR.puts o unless o.empty?
+          Logger.debug o unless o.empty?
           if e.success?
-            STDERR.puts "Success to build yard index"
+            Logger.info "Success to build yard index"
           else
-            STDERR.puts "Failed to build #{gem_name} #{gem_version}"
+            Logger.warn "Failed to build #{gem_name} #{gem_version}"
           end
         end
       end

data/lib/yoda/store/actions/import_gem.rb

@@ -42,22 +42,22 @@ module Yoda
 
         def create_dependency_doc
           if yardoc_path
-            STDERR.puts "Gem docs for #{gem_name} #{gem_version} already exist"
+            Logger.info "Gem docs for #{gem_name} #{gem_version} already exist"
             return true
           end
-          STDERR.puts "Building gem docs for #{gem_name} #{gem_version}"
+          Logger.info "Building gem docs for #{gem_name} #{gem_version}"
           begin
             o, e = Open3.capture2e("yard gems #{gem_name} #{gem_version}")
-            STDERR.puts o unless o.empty?
+            Logger.debug o unless o.empty?
             if e.success?
-              STDERR.puts "Done building gem docs for #{gem_name} #{gem_version}"
+              Logger.info "Done building gem docs for #{gem_name} #{gem_version}"
             else
-              STDERR.puts "Failed to build #{gem_name} #{gem_version}"
+              Logger.warn "Failed to build #{gem_name} #{gem_version}"
             end
           rescue => ex
-            STDERR.puts ex
-            STDERR.puts ex.backtrace
-            STDERR.puts "Failed to build #{gem_name} #{gem_version}"
+            Logger.debug ex
+            Logger.debug ex.backtrace
+            Logger.warn "Failed to build #{gem_name} #{gem_version}"
           end
         end
 
@@ -68,9 +68,9 @@ module Yoda
           begin
             YardImporter.import(yardoc_file, root_path: gem_source_path)
           rescue => ex
-            STDERR.puts ex
-            STDERR.puts ex.backtrace
-            STDERR.puts "Failed to load #{yardoc_file}"
+            Logger.debug ex
+            Logger.debug ex.backtrace
+            Logger.warn "Failed to load #{yardoc_file}"
             nil
           end
         end
@@ -79,8 +79,8 @@ module Yoda
         def yardoc_path
           YARD::Registry.yardoc_file_for_gem(gem_name, gem_version)
         rescue Bundler::BundlerError => ex
-          STDERR.puts ex
-          STDERR.puts ex.backtrace
+          Logger.debug ex
+          Logger.debug ex.backtrace
           nil
         end
 

data/lib/yoda/store/actions/read_project_files.rb

@@ -14,7 +14,15 @@ module Yoda
         end
 
         def run
-          project_files.each { |file| ReadFile.run(registry, file) }
+          files = project_files
+          progress = Instrument::Progress.new(files.length) do |index:, length:|
+            Instrument.instance.initialization_progress(phase: :load_project_files, message: "Loading current project files (#{index} / #{length})", index: index, length: length)
+          end
+
+          files.each do |file|
+            ReadFile.run(registry, file)
+            progress.increment
+          end
         end
 
         private

data/lib/yoda/store/adapters/base.rb

@@ -52,6 +52,12 @@ module Yoda
         def clear
           fail NotImplementedError
         end
+
+        # @param data [Enumerator<(String, Object)>]
+        # @param bar [#increment, nil]
+        # @abstract
+        def batch_write(data, bar)
+        end
       end
     end
   end

data/lib/yoda/store/adapters/leveldb_adapter.rb

@@ -38,7 +38,7 @@ module Yoda
         end
 
         # @param data [Enumerator<(String, Object)>]
-        # @param bar [ProgressBar, nil]
+        # @param bar [#increment, nil]
         def batch_write(data, bar)
           data.each do |(k, v)|
             @db.put(k, v)

data/lib/yoda/store/adapters/lmdb_adapter.rb

@@ -33,7 +33,7 @@ module Yoda
         end
 
         # @param data [Enumerator<(String, Object)>]
-        # @param bar [ProgressBar, nil]
+        # @param bar [#increment, nil]
         def batch_write(data, bar)
           env = LMDB.new(@path, mapsize: @env.info[:mapsize], writemap: true, mapasync: true, nosync: true)
           db = env.database('main', create: true)

data/lib/yoda/store/adapters/memory_adapter.rb

@@ -33,7 +33,7 @@ module Yoda
         end
 
         # @param data [Enumerator<(String, Object)>]
-        # @param bar [ProgressBar, nil]
+        # @param bar [#increment, nil]
         def batch_write(data, bar)
           data.each do |(k, v)|
             put(k, v)

data/lib/yoda/store/project.rb

@@ -21,7 +21,6 @@ module Yoda
       end
 
       def setup
-        YARD::Logger.instance(STDERR)
         make_dir
         cache.register_adapter(registry)
       end
@@ -32,17 +31,17 @@ module Yoda
       end
 
       # @return [Array<BaseError>]
-      def build_cache(progress: false)
+      def build_cache
         setup
         loader = LibraryDocLoader.build_for(self)
-        loader.run(progress: progress)
+        loader.run
         load_project_files
         loader.errors
       end
 
-      def rebuild_cache(progress: false)
+      def rebuild_cache
         clear
-        build_cache(progress: progress)
+        build_cache
       end
 
       def yoda_dir
@@ -57,6 +56,8 @@ module Yoda
       private
 
       def load_project_files
+        Logger.debug('Loading current project files...')
+        Instrument.instance.initialization_progress(phase: :load_project_files, message: 'Loading current project files')
         Actions::ReadProjectFiles.new(registry, root_path).run
       end
 

data/lib/yoda/store/project/library_doc_loader.rb

@@ -15,8 +15,7 @@ module Yoda
           # @param project [Project]
           # @return [LibraryDocLoader]
           def build_for(project)
-            lockfile_parser = parse_gemfile_lock(project.root_path, Cache.gemfile_lock_path(project.root_path))
-            new(registry: project.registry, gem_specs: lockfile_parser&.specs || [])
+            new(registry: project.registry, gem_specs: gem_specs(project))
           end
 
           private
@@ -28,6 +27,13 @@ module Yoda
               Bundler::LockfileParser.new(File.read(gemfile_lock_path))
             end
           end
+
+          def gem_specs(project)
+            lockfile_parser = parse_gemfile_lock(project.root_path, Cache.gemfile_lock_path(project.root_path))
+            (lockfile_parser&.specs || []).reject do |spec|
+              spec.source.is_a?(Bundler::Source::Path) && (File.expand_path(spec.source.path) == File.expand_path(project.root_path))
+            end
+          end
         end
 
         # @param registry [Registry]
@@ -38,9 +44,9 @@ module Yoda
           @errors = []
         end
 
-        def run(progress: false)
+        def run
           project_status = registry.project_status || Objects::ProjectStatus.initial_build(specs: gem_specs)
-          new_bundle_status = update_bundle(project_status.bundle, progress: progress)
+          new_bundle_status = update_bundle(project_status.bundle)
           registry.save_project_status(project_status.derive(bundle: new_bundle_status))
         end
 
@@ -48,11 +54,11 @@ module Yoda
 
         # @param bundle_status [Objects::ProjectStatus::BundleStatus]
         # @return [Objects::ProjectStatus::BundleStatus]
-        def update_bundle(bundle_status, progress: false)
+        def update_bundle(bundle_status)
           unless bundle_status.all_present?
-            STDERR.puts 'Constructing database for the current project.'
+            Logger.info 'Constructing database for the current project.'
             bundle_status = import_deps(bundle_status)
-            registry.compress_and_save(progress: progress)
+            registry.compress_and_save
           end
           bundle_status
         end
@@ -61,6 +67,7 @@ module Yoda
         # @param bundle_status [Objects::ProjectStatus::BundleStatus]
         # @return [Objects::ProjectStatus::BundleStatus]
         def import_deps(bundle_status)
+          Instrument.instance.initialization_progress(phase: :load_core, message: 'Loading core index')
           bundle_status = import_core(bundle_status) unless bundle_status.std_status.core_present?
           bundle_status = import_std(bundle_status) unless bundle_status.std_status.std_present?
           import_gems(bundle_status)
@@ -85,16 +92,20 @@ module Yoda
         # @param bundle_status [Objects::ProjectStatus::BundleStatus]
         # @return [Objects::ProjectStatus::BundleStatus]
         def import_gems(bundle_status)
-          gem_statuses = bundle_status.gem_statuses.map do |gem_status|
-            if gem_status.present?
-              gem_status
-            else
-              result = Actions::ImportGem.run(registry: registry, gem_name: gem_status.name, gem_version: gem_status.version)
-              errors.push(GemImportError.new(name: gem_status.name, version: gem_status.version)) unless result
-              gem_status.derive(present: result)
-            end
+          present_gem_statuses, absent_gem_statuses = bundle_status.gem_statuses.partition { |gem_status| gem_status.present? }
+
+          progress = Instrument::Progress.new(absent_gem_statuses.length) do |index:, length:|
+            Instrument.instance.initialization_progress(phase: :load_gems, message: "Loading gems (#{index} / #{length})", index: index, length: length)
           end
-          bundle_status.derive(gem_statuses: gem_statuses)
+
+          new_gem_statuses = absent_gem_statuses.map do |gem_status|
+            result = Actions::ImportGem.run(registry: registry, gem_name: gem_status.name, gem_version: gem_status.version)
+            progress.increment
+            errors.push(GemImportError.new(name: gem_status.name, version: gem_status.version)) unless result
+            gem_status.derive(present: result)
+          end
+
+          bundle_status.derive(gem_statuses: present_gem_statuses + new_gem_statuses)
         end
       end
     end

data/lib/yoda/store/registry.rb

@@ -1,5 +1,4 @@
 require 'yard'
-require 'ruby-progressbar'
 
 module Yoda
   module Store
@@ -56,19 +55,18 @@ module Yoda
 
       # Store patch set data to the database.
       # old data in the database are discarded.
-      # @param progress [true, false]
-      def compress_and_save(progress: false)
+      def compress_and_save
         return unless adapter
         el_keys = patch_set.keys
-        bar = ProgressBar.create(format: " %c/%C |%w>%i| %e ", total: el_keys.length) if progress
+        progress = Instrument::Progress.new(el_keys.length) { |length:, index:| Instrument.instance.registry_dump(index: index, length: length) }
 
         data = Enumerator.new do |yielder|
           el_keys.each { |key| yielder << [key, patch_set.find(key)] }
         end
 
-        adapter.batch_write(data, bar)
+        adapter.batch_write(data, progress)
         adapter.sync
-        STDERR.puts "saved #{el_keys.length} keys."
+        Logger.info "saved #{el_keys.length} keys."
         @patch_set = Objects::PatchSet.new
       end
 

data/lib/yoda/version.rb

@@ -1,3 +1,3 @@
 module Yoda
-  VERSION = "0.5.0"
+  VERSION = "0.6.0"
 end

data/yarn.lock

@@ -2,12 +2,46 @@
 # yarn lockfile v1
 
 
-atom-languageclient@^0.7.3:
-  version "0.7.3"
-  resolved "https://registry.yarnpkg.com/atom-languageclient/-/atom-languageclient-0.7.3.tgz#4d5c859baab3f3394dc45129935b3037719542fb"
+"@types/atom@^1.28.0":
+  version "1.28.0"
+  resolved "https://registry.yarnpkg.com/@types/atom/-/atom-1.28.0.tgz#1c80cfa41381b6609e3eac4f84c013cd5069d36d"
   dependencies:
-    vscode-jsonrpc "^3.5.0"
+    "@types/node" "*"
 
-vscode-jsonrpc@^3.5.0:
-  version "3.5.0"
-  resolved "https://registry.yarnpkg.com/vscode-jsonrpc/-/vscode-jsonrpc-3.5.0.tgz#87239d9e166b2d7352245b8a813597804c1d63aa"
+"@types/node@*":
+  version "10.9.2"
+  resolved "https://registry.yarnpkg.com/@types/node/-/node-10.9.2.tgz#f0ab8dced5cd6c56b26765e1c0d9e4fdcc9f2a00"
+
+"@types/node@^8.0.41":
+  version "8.10.28"
+  resolved "https://registry.yarnpkg.com/@types/node/-/node-8.10.28.tgz#03bf70dd7f1de7826251331ce57beddf7f9dd253"
+
+atom-languageclient@^0.9.5:
+  version "0.9.6"
+  resolved "https://registry.yarnpkg.com/atom-languageclient/-/atom-languageclient-0.9.6.tgz#2bbb8fad72ae183c0a7d5ac3cbeea87358ecf260"
+  dependencies:
+    "@types/atom" "^1.28.0"
+    "@types/node" "^8.0.41"
+    fuzzaldrin-plus "^0.6.0"
+    vscode-jsonrpc "^3.6.0"
+    vscode-languageserver-protocol "3.6.0-next.5"
+    vscode-languageserver-types "^3.6.0-next.1"
+
+fuzzaldrin-plus@^0.6.0:
+  version "0.6.0"
+  resolved "https://registry.yarnpkg.com/fuzzaldrin-plus/-/fuzzaldrin-plus-0.6.0.tgz#832f6489fbe876769459599c914a670ec22947ee"
+
+vscode-jsonrpc@^3.6.0, vscode-jsonrpc@^3.6.0-next.1:
+  version "3.6.2"
+  resolved "https://registry.yarnpkg.com/vscode-jsonrpc/-/vscode-jsonrpc-3.6.2.tgz#3b5eef691159a15556ecc500e9a8a0dd143470c8"
+
+vscode-languageserver-protocol@3.6.0-next.5:
+  version "3.6.0-next.5"
+  resolved "https://registry.yarnpkg.com/vscode-languageserver-protocol/-/vscode-languageserver-protocol-3.6.0-next.5.tgz#ed2ec2db759826f753c0a13977dfb2bedc4d31b3"
+  dependencies:
+    vscode-jsonrpc "^3.6.0-next.1"
+    vscode-languageserver-types "^3.6.0-next.1"
+
+vscode-languageserver-types@^3.6.0-next.1:
+  version "3.12.0"
+  resolved "https://registry.yarnpkg.com/vscode-languageserver-types/-/vscode-languageserver-types-3.12.0.tgz#f96051381b6a050b7175b37d6cb5d2f2eb64b944"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: yoda-language-server
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Tomoya Chiba
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-07-28 00:00:00.000000000 Z
+date: 2018-08-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: yard
@@ -292,6 +292,8 @@ files:
 - lib/yoda/evaluation/current_node_explain.rb
 - lib/yoda/evaluation/evaluator.rb
 - lib/yoda/evaluation/signature_discovery.rb
+- lib/yoda/instrument.rb
+- lib/yoda/logger.rb
 - lib/yoda/model.rb
 - lib/yoda/model/completion_item.rb
 - lib/yoda/model/descriptions.rb
@@ -362,6 +364,7 @@ files:
 - lib/yoda/server/deserializer.rb
 - lib/yoda/server/hover_provider.rb
 - lib/yoda/server/initialization_provider.rb
+- lib/yoda/server/notifier.rb
 - lib/yoda/server/session.rb
 - lib/yoda/server/signature_provider.rb
 - lib/yoda/store.rb