yoda-language-server 0.7.0 → 0.8.0

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

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

@@ -5,9 +5,17 @@ module Yoda
         # @param namespace [Objects::NamespaceObject]
         # @param method_name [String, Regexp]
         # @param visibility [Array<Symbol>, nil]
-        # @return [Array<Objects::MethodObject>]
+        # @return [Array<Model::FunctionSignatures::Base>]
         def select(namespace, method_name, visibility: nil)
-          FindMethod.new(registry).select(namespace, method_name, visibility: visibility).map { |el| build(namespace, el) }.flatten
+          FindMethod.new(registry).select(namespace, method_name, visibility: visibility).flat_map { |el| build(namespace, el) }
+        end
+
+        # @param namespaces [Array<Objects::NamespaceObject>]
+        # @param method_name [String, Regexp]
+        # @param visibility [Array<Symbol>, nil]
+        # @return [Array<Objects::MethodObject>]
+        def select_on_multiple(namespaces, method_name, visibility: nil)
+          namespaces.flat_map { |namespace| select(namespace, method_name, visibility: visibility) }
         end
 
         private
@@ -30,7 +38,7 @@ module Yoda
         # @return [FunctionSignatures::Constructor, nil]
         def try_to_build_constructor(receiver, method_object)
           if method_object.path == 'Class#new' && receiver.is_a?(Store::Objects::MetaClassObject) && receiver.path != 'Class'
-            base_class = registry.find(receiver.base_class_address) || return
+            base_class = registry.get(receiver.base_class_address) || return
             initialize_object = FindMethod.new(registry).find(base_class, 'initialize') || return
             Model::FunctionSignatures::Constructor.new(base_class, initialize_object)
           else

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

@@ -0,0 +1,36 @@
+module Yoda
+  module Store
+    module Query
+      class FindWorkspaceObjects < Base
+        # @param query [String]
+        # @return [Enumerator<Objects::Base>]
+        def select(query)
+          lazy_select(query)
+        end
+
+        private
+
+        # @param query [String]
+        # @return [Enumerator::Lazy<Objects::Base>]
+        def lazy_select(query)
+          registry.local_store.registry.items.lazy.select do |item|
+            item.primary_source && fuzzy_match?(item.name, query)
+          end
+        end
+
+        # @param name [String]
+        # @param query [String, Regexp]
+        # @return [true, false]
+        def fuzzy_match?(name, query)
+          left_chars = query.chars
+          name.each_char do |c|
+            break if left_chars.empty?
+            left_chars.shift if c == left_chars.first
+          end
+
+          left_chars.empty?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+module Yoda
+  module Store
+    module Query
+      class MethodMemberSet
+        # @return [Registry]
+        attr_reader :registry
+
+        # @return [Objects::NamespaceObject]
+        attr_reader :object
+
+        # @param object [Objects::NamespaceObject]
+        # @param registry [Registry]
+        # @param origin [AncestorTree]
+        def initialize(registry:, object:)
+          @registry = registry
+          @object = object
+        end
+
+        # @return [Enumerator<Objects::MethodObject>]
+        def to_enum(**kwargs)
+          FindMethod.new(registry).all(object, **kwargs)
+        end
+
+        # @param method_name [String, Regexp]
+        # @return [Objects::MethodObject, nil]
+        def find(method_name, **kwargs)
+          FindMethod.new(registry).find(object, method_name, **kwargs)
+        end
+
+        # @param method_name [String, Regexp]
+        # @return [Enumerator<Objects::MethodObject>]
+        def select(method_name, **kwargs)
+          FindMethod.new(registry).select(object, method_name, **kwargs)
+        end
+
+        # @param method_name [String, Regexp]
+        # @return [Model::FunctionSignatures::Base]
+        def find_signature(method_name, **kwargs)
+          FindSignature.new(registry).select(object, method_name, **kwargs).first
+        end
+
+        # @param method_name [String, Regexp]
+        # @return [Array<Model::FunctionSignatures::Base>]
+        def select_signature(method_name, **kwargs)
+          FindSignature.new(registry).select(object, method_name, **kwargs)
+        end
+      end
+    end
+  end
+end

data/lib/yoda/store/query.rb

@@ -6,7 +6,11 @@ module Yoda
       require 'yoda/store/query/find_meta_class'
       require 'yoda/store/query/find_method'
       require 'yoda/store/query/find_signature'
+      require 'yoda/store/query/find_workspace_objects'
       require 'yoda/store/query/associators'
+      require 'yoda/store/query/ancestor_tree'
+      require 'yoda/store/query/constant_member_set'
+      require 'yoda/store/query/method_member_set'
     end
   end
 end

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

@@ -0,0 +1,65 @@
+require 'concurrent'
+require 'forwardable'
+
+module Yoda
+  module Store
+    # Registry Cache is a cache layer for {Registry}.
+    # This class intended to reduce patch calculations of {PatchSet#patch}.
+    class Registry::Cache
+      class RegistryWrapper
+        extend Forwardable
+        include MissingDelegatable
+
+        delegate_missing :registry
+
+        attr_reader :registry
+
+        def initialize(registry, cache = Registry::Cache.new)
+          @registry = registry
+          @cache = cache
+        end
+
+        def get(key)
+          @cache.fetch_or_calc(key) do
+            @registry.get(key)
+          end
+        end
+
+        def clear_cache
+          @cache.delete_all
+        end
+      end
+
+      def initialize
+        @data = Concurrent::Map.new
+      end
+
+      # @param key [String, Symbol]
+      def fetch_or_calc(key)
+        if cache = data.get(key.to_sym)
+          return cache
+        end
+        yield.tap { |value| data.put_if_absent(key.to_sym, value) }
+      end
+
+      # @param key [String, Symbol]
+      def delete(key)
+        data.delete(key.to_sym)
+      end
+
+      def delete_all
+        data.clear
+      end
+
+      # @param patch [Objects::Patch]
+      def clear_from_patch(patch)
+        patch.keys.each { |key| delete(key) }
+      end
+
+      private
+
+      # @return [Concurrent::Map]
+      attr_reader :data
+    end
+  end
+end

data/lib/yoda/store/registry/composer.rb

@@ -0,0 +1,47 @@
+module Yoda
+  module Store
+    class Registry::Composer 
+      # @return [Symbol]
+      attr_reader :id
+
+      # @return [Hash{Symbol => Registry}]
+      attr_reader :registries
+
+      def initialize(id:, registries: [])
+        @id = id
+        @registries = registries.map { |registry| [registry.id, registry] }.to_h
+      end
+
+      def add_registry(registry)
+        registries[registry.id] = registry
+      end
+
+      def remove_registry(registry)
+        registries.delete(registry.id)
+      end
+
+      def get(address, registry_ids: nil)
+        target_registries = registry_ids ? registry_ids.map { |id| get_registry(id) }.compact : all_registries
+        objects_in_registry = target_registries.map { |registry| registry.get(address) }.compact
+        objects_in_registry.empty? ? nil : Objects::Merger.new(objects_in_registry).merged_instance
+      end
+
+      # @return [Set]
+      def keys
+        registries.values.map(&:keys).reduce(Set.new) { |memo, keys| memo + keys }
+      end
+
+      def get_registry(key)
+        registries[key]
+      end
+
+      def has_registry(key)
+        registries.has_key?(key)
+      end
+
+      def all_registries
+        registries.values.compact
+      end
+    end
+  end
+end

data/lib/yoda/store/registry/index.rb

@@ -0,0 +1,116 @@
+require 'set'
+require 'forwardable'
+
+module Yoda
+  module Store
+    class Registry::Index
+      class ComposerWrapper
+        extend Forwardable
+        include MissingDelegatable
+
+        delegate_missing :composer
+
+        # @return [Registry::Index]
+        attr_reader :index
+
+        # @return [Registry::Composer]
+        attr_reader :composer
+
+        # @param index [Registry::Index]
+        # @param composer [Registry::Composer]
+        def initialize(index:, composer:)
+          fail TypeError, "index must be an instance of Registry::Index but #{index}" unless index.is_a?(Registry::Index)
+          fail TypeError, "composer must be an instance of Registry::Composer but #{composer}" unless composer.is_a?(Registry::Composer)
+          @index = index
+          @composer = composer
+        end
+
+        # @param [String, Symbol]
+        # @return [Objects::Addressable]
+        def get(address)
+          composer.get(address, registry_ids: index.get(address))
+        end
+
+        def add_registry(registry)
+          if old_registry = composer.get_registry(registry.id)
+            index.remove_registry(old_registry)
+          end
+          composer.add_registry(registry)
+          index.add_registry(registry)
+        end
+
+        def remove_registry(registry)
+          composer.remove_registry(registry)
+          index.remove_registry(registry)
+        end
+
+        def keys
+          index.keys
+        end
+
+        # @return [Enumerator<Object>]
+        def items
+          Enumerator.new do |y|
+            keys.each do |key|
+              value = get(key)
+              if value
+                y << value
+              else
+                Logger.warn("Not found value in registry for the key: #{key}")
+              end
+            end
+          end
+        end
+      end
+
+      # @return [Hash]
+      attr_reader :content
+
+      # @return [Set]
+      attr_reader :registry_ids
+
+      def initialize(content: {}, registry_ids: Set.new)
+        @content = content
+        @registry_ids = Set.new(registry_ids)
+      end
+
+      # @param address [String, Symbol]
+      # @return [Set<Symbol>]
+      def get(address)
+        content[address.to_sym] ||= Objects::SerializableSet.new
+      end
+
+      # @param address [String, Symbol]
+      # @param registry_id [String, Symbol]
+      def add(address, registry_id)
+        content[address.to_sym] ||= Objects::SerializableSet.new
+        content[address.to_sym].add(registry_id)
+        content[address.to_sym].select! { |id| registry_ids.member?(id) }
+      end
+
+      # @param address [String, Symbol]
+      # @param registry_id [String, Symbol]
+      def remove(address, registry_id)
+        content[address.to_sym] ||= Objects::SerializableSet.new
+        content[address.to_sym].delete(registry_id)
+      end
+
+      def keys
+        Set.new(content.keys)
+      end
+
+      def add_registry(registry)
+        registry_ids.add(registry.id)
+        registry.keys.each { |key| add(key, registry.id) }
+      end
+
+      def remove_registry(registry)
+        registry_ids.delete(registry.id)
+      end
+
+      def wrap(composer)
+        ComposerWrapper.new(composer: composer, index: self)
+      end
+    end
+  end
+end