yoda-language-server 0.7.1 → 0.9.0

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

@@ -0,0 +1,68 @@
+require "yoda/instrument"
+require "ruby-progressbar"
+
+module Yoda
+  module Store
+    class Project
+      class Setuper
+        # @return [Project]
+        attr_reader :project
+
+        # @return [Hash{ Symbol => ProgressBar }]
+        attr_reader :bars
+
+        # @param project [Project]
+        def initialize(project)
+          @project = project
+          @bars = {}
+        end
+
+        # @param rebuild [Boolean]
+        # @return [Array<BaseError>]
+        def run(rebuild: false)
+          build_core_index
+
+          if rebuild
+            clear
+          end
+          project.file_finder.make_dir
+
+          Logger.info 'Building index for the current project...'
+          dependency_importer.run
+          project.rbs_environment
+          load_project_files
+
+          dependency_importer.errors
+        end
+
+        def clear
+          project.file_finder.clear_dir
+        end
+
+        def reset
+          run(rebuild: true)
+        end
+
+        private
+
+        def build_core_index
+          unless Store::Actions::BuildCoreIndex.exists?
+            Instrument.instance.initialization_progress(phase: :core, message: 'Downloading and building core index')
+            Store::Actions::BuildCoreIndex.run
+          end
+        end
+
+        def load_project_files
+          Logger.debug('Loading current project files...')
+          Instrument.instance.initialization_progress(phase: :load_project_files, message: 'Loading current project files')
+          project.root_path && Actions::ReadProjectFiles.for_project(project).run
+        end
+
+        # @return [Actions::ImportProjectDependencies]
+        def dependency_importer
+          Actions::ImportProjectDependencies.new(project)
+        end
+      end
+    end
+  end
+end

data/lib/yoda/store/project.rb

@@ -1,74 +1,132 @@
 require 'fileutils'
+require 'forwardable'
+require 'pathname'
 
 module Yoda
   module Store
     class Project
-      require 'yoda/store/project/cache'
-      require 'yoda/store/project/library_doc_loader'
+      require 'yoda/store/project/file_finder'
+      require 'yoda/store/project/dependency'
+      require 'yoda/store/project/setuper'
+      require 'yoda/store/project/rbs_loader'
+
+      extend Forwardable
+
+      class << self
+        # @param name [String]
+        # @param root_path [String, nil]
+        def for_path(root_path, name: nil)
+          file_tree = FileTree.new(base_path: root_path)
+          name ||= root_path ? File.basename(root_path) : "root"
+          new(name: name, file_tree: file_tree)
+        end
+
+        def temporal(name: "temporal")
+          new(name: name, file_tree: FileTree.new(base_path: nil))
+        end
+      end
+
+      delegate(
+        [
+          :yoda_dir_path,
+          :cache_dir_path,
+          :library_registry_dir_path,
+          :gemfile_lock_path,
+          :config_file_path,
+          :readable_config_file_path,
+          :library_local_yardoc_path,
+          :library_registry_path,
+          :project_registry_path,
+        ] => :file_finder,
+      )
+
+      delegate [:rbs_environment] => :rbs_loader
+      delegate [:clear, :reset] => :setuper
+
+      # @return [FileTree]
+      attr_reader :file_tree
 
       # @return [String]
-      attr_reader :root_path
+      attr_reader :name
 
-      # @return [Registry, nil]
-      attr_reader :registry
+      # @param name [String]
+      # @param file_tree [FileTree]
+      def initialize(name:, file_tree:)
+        @name = name
+        @file_tree = file_tree
+        register_file_tree_events
+      end
 
-      # @param root_path [String]
-      def initialize(root_path)
-        fail ArgumentError, root_path unless root_path.is_a?(String)
+      # @return [String, nil]
+      def root_path
+        file_tree.base_path
+      end
 
-        @root_path = File.absolute_path(root_path)
+      # @return [Registry::ProjectRegistry]
+      def registry
+        @registry ||= Registry.for_project(self)
       end
 
-      def setup
-        return if registry
-        make_dir
-        @registry = cache.prepare_registry
+      # @return [Dependency]
+      def dependency
+        @dependency ||= Dependency.new(self)
       end
 
-      # Delete all data from registry
-      def clear
-        setup
-        registry.clear
+      # @return [RBS::Environment]
+      def rbs_loader
+        @rbs_loader ||= RbsLoader.new(self)
       end
 
-      # @return [Array<BaseError>]
-      def build_cache
-        setup
-        loader = LibraryDocLoader.build_for(self)
-        loader.run
-        load_project_files
-        loader.errors
+      # @return [Model::Environment]
+      def environment
+        @environment ||= Model::Environment.from_project(self)
       end
 
-      def rebuild_cache
-        clear
-        build_cache
+      # @return [Array<BaseError>]
+      def setup(rebuild: false)
+        setuper.run(rebuild: rebuild)
       end
 
-      def yoda_dir
-        File.expand_path('.yoda', root_path)
+      # @return [Config]
+      def config
+        @config ||= begin
+          if readable_config_file_path
+            Config.at(readable_config_file_path)
+          else
+            Config.from_yaml_data('')
+          end
+        end
       end
 
-      # @param source_path [String]
-      def read_source(source_path)
-        Actions::ReadFile.run(registry, source_path)
+      # @return [FileFinder]
+      def file_finder
+        @file_finder ||= FileFinder.new(self)
       end
 
       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
+      def setuper
+        Setuper.new(self)
       end
 
-      def make_dir
-        File.exist?(yoda_dir) || FileUtils.mkdir(yoda_dir)
+      def register_file_tree_events
+        file_tree.on_change do |path:, content:|
+          if content
+            Actions::ReadFile.run(registry, path, content: content)
+          else
+            unread_source(path)
+          end
+        end
+      end
+
+      # @param source_path [String]
+      def unread_source(source_path)
+        patch = registry.local_store.find_file_patch(Actions::ReadFile.patch_id_for_file(source_path))
+        registry.local_store.remove_file_patch(patch) if patch
       end
 
-      # @return [Cache]
-      def cache
-        @cache ||= Cache.build_for(self)
+      def on_memory?
+        !root_path
       end
     end
   end

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

@@ -0,0 +1,126 @@
+require 'set'
+
+module Yoda
+  module Store
+    module Query
+      class AncestorTree
+        class CircularReferenceError < StandardError
+          # @param circular_scope [Objects::NamespaceObject, nil]
+          def initialize(circular_scope)
+            super("#{circular_scope&.path} appears twice")
+          end
+        end
+
+        # An wrapper of {Enumerator::Yielder} to detect circular references.
+        # @private
+        class Visitor
+          # @param yielder [Enumerator::Yielder]
+          def initialize(yielder)
+            @yielder = yielder
+          end
+
+          def <<(object)
+            @yielder << object
+          end
+
+          def meet(object)
+            add_met(object)
+            self << object
+          end
+          
+          private
+
+          def add_met(object)
+            @met ||= Set.new
+            fail CircularReferenceError, object if @met.include?(object)
+            @met.add(object)
+          end
+        end
+
+        # @return [Registry]
+        attr_reader :registry
+
+        # @return [Objects::NamespaceObject]
+        attr_reader :object
+
+        # @param object [Objects::NamespaceObject]
+        # @param registry [Registry]
+        def initialize(registry:, object:)
+          @registry = registry
+          @object = object
+        end
+
+        def ancestors(**kwargs)
+          Enumerator.new do |yielder|
+            walk_ancestors(Visitor.new(yielder), **kwargs)
+          end
+        end
+
+        # @return [Enumerator<Objects::NamespaceObject>]
+        def mixins
+          Enumerator.new do |yielder|
+            object.mixin_addresses.each do |address|
+              if el = registry.get(address.to_s)
+                yielder << el
+              end
+            end
+          end
+        end
+
+        # @return [AncestorTree, nil]
+        def parent
+          @parent ||= superclass && AncestorTree.new(registry: registry, object: superclass)
+        end
+
+        # @return [Objects::NamespaceObject, nil]
+        def superclass
+          return @superclass if instance_variable_defined?(:@superclass)
+          @superclass = begin
+            found_object = begin
+              if object.respond_to?(:base_class_address)
+                base_class_superclass
+              elsif object.respond_to?(:superclass_path)
+                if object.superclass_path
+                  FindConstant.new(registry).find(object.superclass_path)
+                else
+                  nil
+                end
+              else
+                nil
+              end
+            end
+
+            found_object&.namespace? ? found_object : nil
+          end
+        end
+
+        protected
+
+        # @param visitor [Visitor]
+        # @param include_self [Boolean]
+        def walk_ancestors(visitor, include_self: true)
+          visitor.meet(object) if include_self
+          mixins.each { |mixin| visitor << mixin }
+
+          if parent
+            parent.walk_ancestors(visitor, include_self: true)
+          end
+        end
+
+        private
+
+        # @return [Objects::NamespaceObject, nil]
+        def base_class_superclass
+          base_class = registry.get(object.base_class_address)
+          if base_class && base_class.respond_to?(:superclass_path) && base_class.superclass_path
+            FindMetaClass.new(registry).find(base_class.superclass_path)
+          elsif base_class
+            registry.get('Class')
+          else
+            nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yoda/store/query/associators/associate_ancestors.rb

@@ -4,9 +4,8 @@ module Yoda
   module Store
     module Query
       module Associators
+        # @deprecated Use {AncestorTree} instead.
         class AssociateAncestors
-          class CircularReferenceError < StandardError; end
-
           # @return [Registry]
           attr_reader :registry
 
@@ -16,84 +15,12 @@ module Yoda
           end
 
           # @param obj [Objects::Base]
+          # @return [Enumerator<Objects::NamespaceObject>]
           def associate(obj)
             if obj.is_a?(Objects::NamespaceObject)
-              obj.ancestors = Enumerator.new do |yielder|
-                Processor.new(registry).process(obj).each { |klass| yielder << klass }
-              end
-            end
-          end
-
-          private
-
-          class Processor
-            # @return [Registry]
-            attr_reader :registry
-
-            # @param registry [Registry]
-            def initialize(registry)
-              @registry = registry
-            end
-
-
-            # @return [Set<Objects::Base>]
-            def met
-              @met ||= Set.new
-            end
-
-            # @param scope [Objects::NamespaceObject]
-            # @return [Enumerator<Objects::NamespaceObject>]
-            def process(scope)
-              fail CircularReferenceError, scope if met.include?(scope)
-              met.add(scope)
-
-              Enumerator.new do |yielder|
-                if scope.is_a?(Objects::NamespaceObject)
-                  yielder << scope
-                  find_mixins(scope).each { |mixin| yielder << mixin }
-
-                  if scope.is_a?(Objects::MetaClassObject)
-                    find_metaclass_superclass_ancestors(scope).each { |obj| yielder << obj }
-                  elsif scope.is_a?(Objects::ClassObject)
-                    find_superclass_ancestors(scope).each { |obj| yielder << obj }
-                  end
-                end
-              end
-            end
-
-            # @param obj [Objects::NamespaceObject]
-            # @return [Enumerator<Objects::NamespaceObject>]
-            def find_mixins(obj)
-              Enumerator.new do |yielder|
-                obj.mixin_addresses.each do |address|
-                  if el = registry.find(address.to_s)
-                    yielder << el
-                  end
-                end
-              end
-            end
-
-            # @param obj [Objects::ClassObject]
-            # @return [Enumerator<Objects::NamespaceObject>]
-            def find_superclass_ancestors(obj)
-              if obj.superclass_path && super_class = FindConstant.new(registry).find(obj.superclass_path)
-                process(super_class)
-              else
-                []
-              end
-            end
-
-            # @param obj [Objects::MetaClassObject]
-            # @return [Enumerator<Objects::NamespaceObject>]
-            def find_metaclass_superclass_ancestors(obj)
-              base_class = registry.find(obj.base_class_address)
-              if base_class && base_class.is_a?(Objects::ClassObject) && base_class.superclass_path
-                (meta_class = FindMetaClass.new(registry).find(base_class.superclass_path || 'Object')) ? process(meta_class) : []
-              elsif base_class
-                (class_object = registry.find('Class')) ? process(class_object) : []
-              else
-                []
-              end
+              AncestorTree.new(registry: registry, object: obj).ancestors
+            else
+              []
             end
           end
         end

data/lib/yoda/store/query/associators/associate_methods.rb

@@ -12,23 +12,26 @@ module Yoda
           end
 
           # @param obj [Object::Base]
+          # @return [Enumerator<Objects::MethodObject>]
           def associate(obj)
-            if obj.is_a?(Objects::NamespaceObject)
-              AssociateMethods.new(registry).associate(obj)
-              obj.methods = Enumerator.new do |yielder|
+            if obj.namespace?
+              Enumerator.new do |yielder|
                 name_set = Set.new
 
-                obj.ancestors.each do |ancestor|
+                AssociateAncestors.new(registry).associate(obj).each do |ancestor|
                   ancestor.instance_method_addresses.each do |method_address|
                     method_name = Objects::MethodObject.name_of_path(method_address)
-                    next name_set.has_key?(method_name)
-                    name_set.add(method_name)
-                    if el = registry.find(method_address)
-                      yielder << el
+                    if !name_set.member?(method_name)
+                      name_set.add(method_name)
+                      if el = registry.get(method_address)
+                        yielder << el
+                      end
                     end
                   end
                 end
               end
+            else
+              []
             end
           end
         end

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

@@ -0,0 +1,33 @@
+module Yoda
+  module Store
+    module Query
+      class ConstantMemberSet
+        # @return [Registry]
+        attr_reader :registry
+
+        # @return [Objects::NamespaceObject]
+        attr_reader :object
+
+        # @param object [Objects::NamespaceObject]
+        # @param registry [Registry]
+        def initialize(registry:, object:)
+          @registry = registry
+          @object = object
+        end
+
+        # @param name [String]
+        # @return [Objects::Base, nil]
+        def find(name, **kwargs)
+          scoped_path = Model::ScopedPath.new([object.path], name)
+          FindConstant.new(registry).find(scoped_path, **kwargs)
+        end
+
+        # @param name [String]
+        # @return [Enumerator<Objects::Base>]
+        def select(name, **kwargs)
+          FindConstant.new(registry).select_by_base_and_pattern(base: object, pattern: name)
+        end
+      end
+    end
+  end
+end

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

@@ -7,9 +7,27 @@ module Yoda
         def find(path)
           lexical_scope_paths = lexical_scopes_of(path)
           base_name, *constant_names = path_of(path).split
-          base_namespace = select_base_namespace(base_name, lexical_scope_paths).first
+          # if path start with '::', base_name becomes ''.
+          base_namespace_key = base_name == '' ? 'Object' : base_name
+          base_namespace = select_base_namespace(base_namespace_key, lexical_scope_paths).first
 
-          find_constant(constant_names.join('::'), base_namespace)
+          if constant_names.empty?
+            # When the path does not contain separator (`::`)
+            base_namespace
+          else
+            if base_namespace
+              find_constant(constant_names.join('::'), base_namespace)
+            else
+              nil
+            end
+          end
+        end
+
+        # @param base [Store::Object]
+        # @param pattern [RegExp]
+        # @return [Enumerator<Objects::Base>]
+        def select_by_base_and_pattern(base:, pattern:)
+          select_constants_from_ancestors(base, pattern)
         end
 
         # @param path [String, Model::Path, Model::ScopedPath]
@@ -60,7 +78,7 @@ module Yoda
         # @return [Objects::Base, nil]
         def find_constant(name, namespace = nil)
           constant_names = path_of(name).split
-          namespace = registry.find('Object') unless namespace
+          namespace = registry.get('Object') unless namespace
           constant_names.reduce(namespace) do |namespace, name|
             # @todo resolve its value if namespace is ValueObject
             if namespace && namespace.is_a?(Objects::NamespaceObject)
@@ -78,8 +96,7 @@ module Yoda
           Enumerator.new do |yielder|
             met = Set.new
 
-            Associators::AssociateAncestors.new(registry).associate(scope)
-            scope.ancestors.each do |ancestor|
+            Associators::AssociateAncestors.new(registry).associate(scope).each do |ancestor|
               select_child_constants(ancestor, name).each do |obj|
                 next if met.include?(obj.name)
                 met.add(obj.name)
@@ -96,7 +113,7 @@ module Yoda
           Enumerator.new do |yielder|
             if scope.is_a?(Objects::NamespaceObject)
               scope.constant_addresses.select { |address| match_name?(Model::Path.new(address).basename, name) }.each do |address|
-                obj = registry.find(address)
+                obj = registry.get(address)
                 yielder << obj if obj
               end
             end

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

@@ -6,7 +6,7 @@ module Yoda
         # @return [Objects::NamespaceObject, nil]
         def find(path)
           constant = FindConstant.new(registry).find(path)
-          if constant && meta_class = registry.find(Objects::MetaClassObject.address_of(constant.path))
+          if constant && meta_class = registry.get(constant.meta_class_address)
             meta_class
           else
             nil

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

@@ -2,7 +2,7 @@ module Yoda
   module Store
     module Query
       class FindMethod < Base
-        # @param namespace [Objects::Namespace]
+        # @param namespace [Objects::NamespaceObject]
         # @param method_name [String, Regexp]
         # @param visibility [Array<Symbol>, nil]
         # @return [Objects::MethodObject, nil]
@@ -15,7 +15,14 @@ module Yoda
         # @param visibility [Array<Symbol>, nil]
         # @return [Array<Objects::MethodObject>]
         def select(namespace, method_name, visibility: nil)
-          lazy_select(namespace, method_name, visibility: nil).to_a
+          lazy_select(namespace, method_name, visibility: visibility).to_a
+        end
+
+        # @param namespace [Objects::Namespace]
+        # @param visibility [Array<Symbol>, nil]
+        # @return [Enumerator<Objects::MethodObject>]
+        def all(namespace, visibility: nil)
+          lazy_select(namespace, //, visibility: visibility)
         end
 
         private
@@ -27,29 +34,9 @@ module Yoda
         def lazy_select(namespace, expected, visibility: nil)
           visibility ||=  %i(public private protected)
           Enumerator.new do |yielder|
-            met = Set.new
-
-            all_method_addresses(namespace).each do |address|
-              name = Objects::MethodObject.name_of_path(address)
-              if match_name?(name, expected)
-                next if met.include?(name)
-                if el = registry.find(address)
-                  met.add(name)
-                  yielder << el if visibility.include?(el.visibility)
-                end
-              end
-            end
-          end
-        end
-
-        # @param namespace [Objects::Namespace]
-        # @return [Enumerator<Objects::MethodObject>]
-        def all_method_addresses(namespace)
-          Enumerator.new do |yielder|
-            Associators::AssociateAncestors.new(registry).associate(namespace)
-            namespace.ancestors.each do |ancestor|
-              ancestor.instance_method_addresses.each do |address|
-                yielder << address
+            Associators::AssociateMethods.new(registry).associate(namespace).each do |method|
+              if match_name?(method.name, expected) && visibility.include?(method.visibility)
+                yielder << method
               end
             end
           end