yoda-language-server 0.4.0 → 0.5.0

data/lib/yoda/store/project.rb

@@ -1,11 +1,11 @@
-require 'bundler'
-require 'tmpdir'
 require 'fileutils'
-require 'digest'
 
 module Yoda
   module Store
     class Project
+      require 'yoda/store/project/cache'
+      require 'yoda/store/project/library_doc_loader'
+
       # @type String
       attr_reader :root_path
 
@@ -20,20 +20,33 @@ module Yoda
         @registry = Registry.new
       end
 
-      def clean
-      end
-
       def setup
         YARD::Logger.instance(STDERR)
         make_dir
-        cache.setup
+        cache.register_adapter(registry)
+      end
+
+      def clear
+        setup
+        registry.adapter.clear
+      end
+
+      # @return [Array<BaseError>]
+      def build_cache(progress: false)
+        setup
+        loader = LibraryDocLoader.build_for(self)
+        loader.run(progress: progress)
         load_project_files
-        self
+        loader.errors
       end
 
       def rebuild_cache(progress: false)
-        make_dir
-        cache.build(progress: progress)
+        clear
+        build_cache(progress: progress)
+      end
+
+      def yoda_dir
+        File.expand_path('.yoda', root_path)
       end
 
       # @param source_path [String]
@@ -41,118 +54,19 @@ module Yoda
         Actions::ReadFile.run(registry, source_path)
       end
 
-      def yoda_dir
-        File.expand_path('.yoda', root_path)
-      end
-
       private
 
-      def make_dir
-        File.exist?(yoda_dir) || FileUtils.mkdir(yoda_dir)
-      end
-
       def load_project_files
         Actions::ReadProjectFiles.new(registry, root_path).run
       end
 
-      def cache
-        @cache ||= Cache.new(self)
+      def make_dir
+        File.exist?(yoda_dir) || FileUtils.mkdir(yoda_dir)
       end
 
-      class Cache
-        class Builder
-          # @return [Registry]
-          attr_reader :registry
-
-          # @return [String]
-          attr_reader :root_path
-
-          # @return [String]
-          attr_reader :gemfile_lock_path
-
-          def initialize(registry, root_path, gemfile_lock_path)
-            @registry = registry
-            @root_path = root_path
-            @gemfile_lock_path = gemfile_lock_path
-          end
-
-          def run(progress: false)
-            Actions::ImportCoreLibrary.new(registry).run
-            if File.exist?(gemfile_lock_path)
-              Actions::ImportGems.new(registry, gemfile_lock_parser.specs).run
-            end
-            registry.compress_and_save(progress: progress)
-          end
-
-          def gemfile_lock_parser
-            Dir.chdir(root_path) do
-              Bundler::LockfileParser.new(File.read(gemfile_lock_path))
-            end
-          end
-        end
-
-        # @return [Project]
-        attr_reader :project
-
-        def initialize(project)
-          @project = project
-        end
-
-        def build(progress: false)
-          STDERR.puts 'Constructing database for the current project.'
-          YARD::Logger.instance(STDERR)
-          make_cache_dir
-          register_adapter
-          project.registry.adapter.clear
-          Builder.new(project.registry, project.root_path, gemfile_lock_path).run(progress: progress)
-          STDERR.puts 'Finished to construct database for the current project.'
-        end
-
-        def setup
-          if present?
-            register_adapter
-          else
-            build
-          end
-        end
-
-        private
-
-        # @return [true, false]
-        def present?
-          File.exist?(cache_path)
-        end
-
-        def register_adapter
-          return if project.registry.adapter
-          project.registry.adapter = Adapters.default_adapter_class.for(cache_path)
-        end
-
-        def cache_dir
-          File.expand_path('cache', project.yoda_dir)
-        end
-
-        def cache_name
-          @cache_path ||= begin
-            digest = Digest::SHA256.new
-            digest.file(gemfile_lock_path) if File.exist?(gemfile_lock_path)
-            digest.update(Yoda::VERSION)
-            digest.update(Adapters.default_adapter_class.type.to_s)
-            digest.hexdigest
-          end
-        end
-
-        def cache_path
-          File.expand_path(cache_name, cache_dir)
-        end
-
-        def make_cache_dir
-          File.exist?(cache_dir) || FileUtils.mkdir_p(cache_dir)
-        end
-
-        def gemfile_lock_path
-          File.absolute_path('Gemfile.lock', project.root_path)
-        end
+      # @return [Cache]
+      def cache
+        @cache ||= Cache.build_for(self)
       end
     end
   end

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

@@ -0,0 +1,79 @@
+require 'fileutils'
+require 'bundler'
+require 'tmpdir'
+require 'digest'
+
+module Yoda
+  module Store
+    class Project
+      # Find registry file for the current project settings.
+      class Cache
+        class << self
+          # @param project_dir [String]
+          # @return [String]
+          def cache_dir(project_dir)
+            File.expand_path('.yoda/cache', project_dir)
+          end
+
+          # @param project_dir [String]
+          # @return [String]
+          def gemfile_lock_path(project_dir)
+            File.absolute_path('Gemfile.lock', project_dir)
+          end
+
+          # @param project [Project]
+          def build_for(project)
+            new(cache_dir_path: cache_dir(project.root_path), gemfile_lock_path: gemfile_lock_path(project.root_path))
+          end
+        end
+
+        # @return [String]
+        attr_reader :cache_dir_path
+
+        # @return [String, nil]
+        attr_reader :gemfile_lock_path
+
+        # @param cache_dir_path [String]
+        # @param gemfile_lock_path [String, nil]
+        def initialize(cache_dir_path:, gemfile_lock_path: nil)
+          @cache_dir_path = cache_dir_path
+          @gemfile_lock_path = gemfile_lock_path
+        end
+
+        # @return [true, false]
+        def present?
+          File.exist?(cache_path)
+        end
+
+        # @param registry [Registry]
+        def register_adapter(registry)
+          return if registry.adapter
+          make_cache_dir
+          registry.adapter = Adapters.default_adapter_class.for(cache_path)
+        end
+
+        # @return [String]
+        def cache_path
+          File.expand_path(cache_name, cache_dir_path)
+        end
+
+        private
+
+        # @return [String]
+        def cache_name
+          @cache_path ||= begin
+            digest = Digest::SHA256.new
+            digest.file(gemfile_lock_path) if gemfile_lock_path && File.exist?(gemfile_lock_path)
+            digest.update(Registry::REGISTRY_VERSION.to_s)
+            digest.update(Adapters.default_adapter_class.type.to_s)
+            digest.hexdigest
+          end
+        end
+
+        def make_cache_dir
+          File.exist?(cache_dir_path) || FileUtils.mkdir_p(cache_dir_path)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,102 @@
+module Yoda
+  module Store
+    class Project
+      class LibraryDocLoader
+        # @return [Registry]
+        attr_reader :registry
+
+        # @param gem_specs [Array<Objects::ProjectStatus::GemStatus, Bundler::LazySpecification>]
+        attr_reader :gem_specs
+
+        # @param errors [Array<BaseError>]
+        attr_reader :errors
+
+        class << self
+          # @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 || [])
+          end
+
+          private
+
+          # @return [Bundler::LockfileParser, nil]
+          def parse_gemfile_lock(root_path, gemfile_lock_path)
+            return if !gemfile_lock_path || !File.exists?(gemfile_lock_path)
+            Dir.chdir(root_path) do
+              Bundler::LockfileParser.new(File.read(gemfile_lock_path))
+            end
+          end
+        end
+
+        # @param registry [Registry]
+        # @param gem_specs [Array<Objects::ProjectStatus::GemStatus, Bundler::LazySpecification>]
+        def initialize(registry:, gem_specs:)
+          @registry = registry
+          @gem_specs = gem_specs
+          @errors = []
+        end
+
+        def run(progress: false)
+          project_status = registry.project_status || Objects::ProjectStatus.initial_build(specs: gem_specs)
+          new_bundle_status = update_bundle(project_status.bundle, progress: progress)
+          registry.save_project_status(project_status.derive(bundle: new_bundle_status))
+        end
+
+        private
+
+        # @param bundle_status [Objects::ProjectStatus::BundleStatus]
+        # @return [Objects::ProjectStatus::BundleStatus]
+        def update_bundle(bundle_status, progress: false)
+          unless bundle_status.all_present?
+            STDERR.puts 'Constructing database for the current project.'
+            bundle_status = import_deps(bundle_status)
+            registry.compress_and_save(progress: progress)
+          end
+          bundle_status
+        end
+
+        # Try to import missing gems and core libraries.
+        # @param bundle_status [Objects::ProjectStatus::BundleStatus]
+        # @return [Objects::ProjectStatus::BundleStatus]
+        def import_deps(bundle_status)
+          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)
+        end
+
+        # @param bundle_status [Objects::ProjectStatus::BundleStatus]
+        # @return [Objects::ProjectStatus::BundleStatus]
+        def import_core(bundle_status)
+          result = Actions::ImportCoreLibrary.run(registry)
+          errors.push(CoreImportError.new('core')) unless result
+          bundle_status.derive(std_status: bundle_status.std_status.derive(core_present: !!result))
+        end
+
+        # @param bundle_status [Objects::ProjectStatus::BundleStatus]
+        # @return [Objects::ProjectStatus::BundleStatus]
+        def import_std(bundle_status)
+          result = Actions::ImportStdLibrary.run(registry)
+          errors.push(CoreImportError.new('std')) unless result
+          bundle_status.derive(std_status: bundle_status.std_status.derive(std_present: !!result))
+        end
+
+        # @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
+          end
+          bundle_status.derive(gem_statuses: gem_statuses)
+        end
+      end
+    end
+  end
+end

data/lib/yoda/store/query/find_constant.rb

@@ -62,7 +62,8 @@ module Yoda
           constant_names = path_of(name).split
           namespace = registry.find('Object') unless namespace
           constant_names.reduce(namespace) do |namespace, name|
-            if namespace
+            # @todo resolve its value if namespace is ValueObject
+            if namespace && namespace.is_a?(Objects::NamespaceObject)
               select_constants_from_ancestors(namespace, name).first
             else
               return nil

data/lib/yoda/store/registry.rb

@@ -4,6 +4,9 @@ require 'ruby-progressbar'
 module Yoda
   module Store
     class Registry
+      # @note This number must be updated when breaking change is added.
+      REGISTRY_VERSION = 1
+
       # @return [Adapters::LmdbAdapter, nil]
       attr_reader :adapter
 
@@ -13,11 +16,23 @@ module Yoda
       # @return [Objects::PatchSet]
       attr_reader :patch_set
 
+      PROJECT_STATUS_KEY = '%project_status'
+
       def initialize(adapter = nil)
         @patch_set = Objects::PatchSet.new
         @adapter = adapter
       end
 
+      # @return [Objects::ProjectStatus, nil]
+      def project_status
+        adapter&.exist?(PROJECT_STATUS_KEY) && adapter.get(PROJECT_STATUS_KEY)
+      end
+
+      # @param new_project_status [Objects::ProjectStatus]
+      def save_project_status(new_project_status)
+        adapter.put(PROJECT_STATUS_KEY, new_project_status)
+      end
+
       # @param path [String]
       # @return [Objects::Base, nil]
       def find(path)

data/lib/yoda/store/yard_importer.rb

@@ -73,26 +73,33 @@ module Yoda
       # @param code_object [::YARD::CodeObjects::NamespaceObject]
       # @return [Objects::ClassObject]
       def convert_root_object(code_object)
-        # @todo Add meta class for main object.
-        Objects::ClassObject.new(
-          path: 'Object',
+        object_class = Objects::ClassObject.new(
+          path: path_to_store(code_object),
           document: code_object.docstring.to_s,
           tag_list: code_object.tags.map { |tag| convert_tag(tag, '') },
           sources: code_object.files.map(&method(:convert_source)),
           primary_source: code_object[:current_file_has_comments] ? convert_source(code_object.files.first) : nil,
           instance_method_addresses: code_object.meths(included: false, scope: :instance).map(&:path),
-          mixin_addresses: code_object.instance_mixins.map { |mixin| mixin.path },
+          mixin_addresses: code_object.instance_mixins.map { |mixin| path_to_store(mixin) },
           constant_addresses: (code_object.children.select{ |child| %i(constant module class).include?(child.type) }.map { |constant| constant.path } + ['Object']).uniq,
         )
+        object_meta_class = Objects::MetaClassObject.new(
+          path: path_to_store(code_object),
+          sources: code_object.files.map(&method(:convert_source)),
+          primary_source: code_object[:current_file_has_comments] ? convert_source(code_object.files.first) : nil,
+          instance_method_addresses: code_object.meths(included: false, scope: :class).map(&:path),
+          mixin_addresses: code_object.instance_mixins.map { |mixin| path_to_store(mixin) },
+        )
+        [object_class, object_meta_class]
       end
 
       # @param code_object [::YARD::CodeObjects::ConstantObject]
       # @return [Objects::ValueObject]
       def convert_constant_object(code_object)
         Objects::ValueObject.new(
-          path: code_object.path,
+          path: path_to_store(code_object),
           document: code_object.docstring.to_s,
-          tag_list: code_object.tags.map { |tag| convert_tag(tag, code_object.namespace.path) },
+          tag_list: code_object.tags.map { |tag| convert_tag(tag, path_to_store(code_object.namespace)) },
           sources: code_object.files.map(&method(:convert_source)),
           primary_source: code_object[:current_file_has_comments] ? convert_source(code_object.files.first) : nil,
           value: code_object.value,
@@ -107,8 +114,8 @@ module Yoda
           method_object = Objects::MethodObject.new(
             path: "Object#{code_object.sep}#{code_object.name}",
             document: code_object.docstring.to_s,
-            tag_list: code_object.tags.map { |tag| convert_tag(tag, code_object.namespace.path) },
-            overloads: code_object.tags(:overload).map { |tag| convert_overload_tag(tag, code_object.namespace.path) },
+            tag_list: code_object.tags.map { |tag| convert_tag(tag, path_to_store(code_object.namespace)) },
+            overloads: code_object.tags(:overload).map { |tag| convert_overload_tag(tag, path_to_store(code_object.namespace)) },
             sources: code_object.files.map(&method(:convert_source)),
             primary_source: code_object[:current_file_has_comments] ? convert_source(code_object.files.first) : nil,
             parameters: code_object.parameters,
@@ -121,10 +128,10 @@ module Yoda
           [method_object, object_object]
         else
           Objects::MethodObject.new(
-            path: code_object.path,
+            path: path_to_store(code_object),
             document: code_object.docstring.to_s,
-            tag_list: code_object.tags.map { |tag| convert_tag(tag, code_object.namespace.path) },
-            overloads: code_object.tags(:overload).map { |tag| convert_overload_tag(tag, code_object.namespace.path) },
+            tag_list: code_object.tags.map { |tag| convert_tag(tag, path_to_store(code_object.namespace)) },
+            overloads: code_object.tags(:overload).map { |tag| convert_overload_tag(tag, path_to_store(code_object.namespace)) },
             sources: code_object.files.map(&method(:convert_source)),
             primary_source: code_object[:current_file_has_comments] ? convert_source(code_object.files.first) : nil,
             parameters: code_object.parameters,
@@ -137,22 +144,22 @@ module Yoda
       # @return [Array<Objects::ModuleObject, Objects::MetaClassObject>]
       def convert_module_object(code_object)
         module_object = Objects::ModuleObject.new(
-          path: code_object.path,
+          path: path_to_store(code_object),
           document: code_object.docstring.to_s,
-          tag_list: code_object.tags.map { |tag| convert_tag(tag, code_object.path) },
+          tag_list: code_object.tags.map { |tag| convert_tag(tag, path_to_store(code_object)) },
           sources: code_object.files.map(&method(:convert_source)),
           primary_source: code_object[:current_file_has_comments] ? convert_source(code_object.files.first) : nil,
           instance_method_addresses: code_object.meths(included: false, scope: :instance).map(&:path),
-          mixin_addresses: code_object.instance_mixins.map { |mixin| mixin.path },
+          mixin_addresses: code_object.instance_mixins.map { |mixin| path_to_store(mixin) },
           constant_addresses: code_object.children.select{ |child| %i(constant module class).include?(child.type) }.map { |constant| constant.path },
         )
 
         meta_class_object = Objects::MetaClassObject.new(
-          path: code_object.path,
+          path: path_to_store(code_object),
           sources: code_object.files.map(&method(:convert_source)),
           primary_source: code_object[:current_file_has_comments] ? convert_source(code_object.files.first) : nil,
           instance_method_addresses: code_object.meths(included: false, scope: :class).map(&:path),
-          mixin_addresses: code_object.instance_mixins.map { |mixin| mixin.path },
+          mixin_addresses: code_object.instance_mixins.map { |mixin| path_to_store(mixin) },
         )
 
         [module_object, meta_class_object]
@@ -162,23 +169,23 @@ module Yoda
       # @return [Array<Objects::ClassObject, Objects::MetaClassObject>]
       def convert_class_object(code_object)
         class_object = Objects::ClassObject.new(
-          path: code_object.path,
+          path: path_to_store(code_object),
           document: code_object.docstring.to_s,
-          tag_list: code_object.tags.map { |tag| convert_tag(tag, code_object.path) },
+          tag_list: code_object.tags.map { |tag| convert_tag(tag, path_to_store(code_object)) },
           sources: code_object.files.map(&method(:convert_source)),
           primary_source: code_object[:current_file_has_comments] ? convert_source(code_object.files.first) : nil,
           instance_method_addresses: code_object.meths(included: false, scope: :instance).map(&:path),
-          mixin_addresses: code_object.instance_mixins.map { |mixin| mixin.path },
-          constant_addresses: code_object.children.select{ |child| %i(constant module class).include?(child.type) }.map { |constant| constant.path },
-          superclass_path: code_object.superclass&.path == 'Qnil' ? nil : code_object.superclass&.path,
+          mixin_addresses: code_object.instance_mixins.map { |mixin| path_to_store(mixin) },
+          constant_addresses: code_object.children.select{ |child| %i(constant module class).include?(child.type) }.map { |constant| path_to_store(constant) },
+          superclass_path: !code_object.superclass || code_object.superclass&.path == 'Qnil' ? nil : path_to_store(code_object.superclass),
         )
 
         meta_class_object = Objects::MetaClassObject.new(
-          path: code_object.path,
+          path: path_to_store(code_object),
           sources: code_object.files.map(&method(:convert_source)),
           primary_source: code_object[:current_file_has_comments] ? convert_source(code_object.files.first) : nil,
           instance_method_addresses: code_object.meths(included: false, scope: :class).map(&:path),
-          mixin_addresses: code_object.class_mixins.map { |mixin| mixin.path },
+          mixin_addresses: code_object.class_mixins.map { |mixin| path_to_store(mixin) },
         )
 
         [class_object, meta_class_object]
@@ -220,7 +227,7 @@ module Yoda
       # @return [Array<Objects::ModuleObject>]
       def create_proxy_module(code_object)
         module_object = Objects::ModuleObject.new(
-          path: code_object.path,
+          path: path_to_store(code_object),
           document: '',
           tag_list: [],
           sources: [],
@@ -231,7 +238,7 @@ module Yoda
         )
 
         meta_class_object = Objects::MetaClassObject.new(
-          path: code_object.path,
+          path: path_to_store(code_object),
           sources: [],
           primary_source: nil,
           instance_method_addresses: [],
@@ -244,9 +251,9 @@ module Yoda
       # @param code_object [::YARD::CodeObjects::Base]
       # @return [vaid]
       def register_to_parent_proxy(code_object)
-        proxy_module = patch.find(code_object.parent.path)
-        proxy_module.instance_method_addresses.push(code_object.path) if code_object.type == :method
-        proxy_module.constant_addresses.push(code_object.path) if [:class, :module, :proxy].include?(code_object.type)
+        proxy_module = patch.find(path_to_store(code_object.parent))
+        proxy_module.instance_method_addresses.push(path_to_store(code_object)) if code_object.type == :method
+        proxy_module.constant_addresses.push(path_to_store(code_object)) if [:class, :module, :proxy].include?(code_object.type)
       end
 
       # @param source [(String, Integer)]
@@ -255,6 +262,29 @@ module Yoda
         file, line = source
         [root_path ? File.expand_path(file, root_path) : file, line, 0]
       end
+
+      # @param code_object [::YARD::CodeObjects::Base]
+      # @return [String]
+      def path_to_store(object)
+        @paths_to_store ||= {}
+        @paths_to_store[[object.type, object.path]] ||= calc_path_to_store(object)
+      end
+
+      # @param code_object [::YARD::CodeObjects::Base]
+      # @return [String]
+      def calc_path_to_store(object)
+        return 'Object' if object.root?
+        parent_path = path_to_store(object.parent)
+
+        if object.type == :proxy || object.is_a?(YARD::CodeObjects::Proxy)
+          # For now, we suppose the proxy object exists directly under its lexical namespace.
+          [path_to_store(object.parent), object.name].join('::')
+        elsif object.parent.path == path_to_store(object.parent)
+          object.path
+        else
+          [path_to_store(object.parent), object.name].join(object.sep)
+        end.gsub(/^Object::/, '')
+      end
     end
   end
 end