yoda-language-server 0.7.0 → 0.8.0

data/lib/yoda/store/objects/merger.rb

@@ -1,3 +1,6 @@
+require 'set'
+require 'forwardable'
+
 module Yoda
   module Store
     module Objects
@@ -7,12 +10,13 @@ module Yoda
 
         # @param instances [Array<Base>]
         def initialize(instances)
+          fail ArgumentError, 'instances must not be an empty array' if instances.empty?
           @instances = instances
         end
 
         # @return [Base]
         def merged_instance
-          class_to_generate.new(attributes.select { |k, v| class_to_generate.attr_names.include?(k) }.to_h)
+          class_to_generate.new(**attributes.select { |k, v| class_to_generate.attr_names.include?(k) })
         end
 
         private
@@ -20,13 +24,13 @@ module Yoda
         # @return [Base.class]
         def class_to_generate
           @class_to_generate ||= begin
-            if instances.any? { |el| el.is_a?(MetaClassObject) }
+            if instances.any? { |el| el.kind == :meta_class }
               MetaClassObject
-            elsif instances.any? { |el| el.is_a?(ClassObject) }
+            elsif instances.any? { |el| el.kind == :class }
               ClassObject
-            elsif instances.any? { |el| el.is_a?(ModuleObject) }
+            elsif instances.any? { |el| el.kind == :module }
               ModuleObject
-            elsif instances.any? { |el| el.is_a?(MethodObject) }
+            elsif instances.any? { |el| el.kind == :method }
               MethodObject
             else
               ValueObject
@@ -36,7 +40,7 @@ module Yoda
 
         # @return [Hash{ Symbol => Object }]
         def attributes
-          @attributes ||= instances.map { |i| default_attributes.merge(i.to_h) }.reduce { |a, b| merge_attributes(a, b) }
+          @attributes ||= normalize_attributes(instances.map { |i| default_attributes.merge(i.to_h) }.reduce { |a, b| merge_attributes(a, b) })
         end
 
         # @param one [Hash{ Symbol => Object }]
@@ -45,15 +49,15 @@ module Yoda
           {
             path: one[:path] || another[:path],
             document: one[:document] + (one[:document].empty? || another[:document].empty? ? '' : "\n") + another[:document],
-            tag_list: one[:tag_list] + another[:tag_list],
-            sources: one[:sources] + another[:sources],
+            tag_list: PendingArray.append(one[:tag_list], another[:tag_list]),
+            sources: PendingSet.merge(one[:sources], another[:sources]),
             primary_source: one[:primary_source] || another[:primary_source],
-            instance_method_addresses: (one[:instance_method_addresses] + another[:instance_method_addresses]).uniq,
-            mixin_addresses: (one[:mixin_addresses] + another[:mixin_addresses]).uniq,
-            constant_addresses: (one[:constant_addresses] + another[:constant_addresses]).uniq,
+            instance_method_addresses: PendingSet.merge(one[:instance_method_addresses], another[:instance_method_addresses]),
+            mixin_addresses: PendingSet.merge(one[:mixin_addresses], another[:mixin_addresses]),
+            constant_addresses: PendingSet.merge(one[:constant_addresses], another[:constant_addresses]),
             visibility: one[:visibility] || another[:visibility],
             parameters: one[:parameters].empty? ? another[:parameters] : one[:parameters],
-            overloads: one[:overloads] + another[:overloads],
+            overloads: PendingArray.append(one[:overloads], another[:overloads]),
             superclass_path: select_superclass(one, another),
             value: one[:value] || another[:value],
           }
@@ -78,6 +82,26 @@ module Yoda
           }
         end
 
+        # @param attrs [Hash{ Symbol => Object }]
+        # @return [Hash{ Symbol => Object }]
+        def normalize_attributes(attrs)
+          {
+            path: attrs[:path],
+            document: attrs[:document],
+            tag_list: attrs[:tag_list].to_a,
+            sources: attrs[:sources].to_a,
+            primary_source: attrs[:primary_source],
+            instance_method_addresses: attrs[:instance_method_addresses].to_a,
+            mixin_addresses: attrs[:mixin_addresses].to_a,
+            constant_addresses: attrs[:constant_addresses].to_a,
+            visibility: attrs[:visibility],
+            parameters: attrs[:parameters].to_a,
+            overloads: attrs[:overloads].to_a,
+            superclass_path: attrs[:superclass_path],
+            value: attrs[:value],
+          }
+        end
+
         # @param one [Hash{ Symbol => Object }]
         # @param another [Hash{ Symbol => Object }]
         # @return [ScopedPath]
@@ -88,6 +112,66 @@ module Yoda
             another[:superclass_path] || one[:superclass_path]
           end
         end
+
+        class PendingArray
+          extend Forwardable
+
+          # @param els1 [Array<Object>, PendingArray]
+          # @param others [Array<Array<Object>, PendingArray>]
+          def self.append(els, *others)
+            if els.is_a?(PendingArray)
+              others.reduce(els) { |array, item| array.append(item) }
+            else
+              append(PendingArray.new(els), *others)
+            end
+          end
+
+          # @return [Array<Object>]
+          attr_reader :array
+
+          delegate %i(to_a each) => :array
+
+          # @param els [Array<Object>]
+          def initialize(els)
+            @array = els.dup
+          end
+
+          # @param els [Array<Object>]
+          def append(els)
+            array.push(*els)
+            self
+          end
+        end
+
+        class PendingSet
+          extend Forwardable
+
+          # @param els1 [Array<Object>, PendingSet]
+          # @param els2 [Array<Object>, PendingSet]
+          def self.merge(els1, els2)
+            if els1.is_a?(PendingSet)
+              els1.merge(els2)
+            else
+              PendingSet.new(els1).merge(els2)
+            end
+          end
+
+          # @return [Set<Object>]
+          attr_reader :set
+
+          delegate %i(to_a each) => :set
+
+          # @param els [Array<Object>]
+          def initialize(els)
+            @set = Set.new(els)
+          end
+
+          # @param els [Array<Object>]
+          def merge(els)
+            set.merge(els)
+            self
+          end
+        end
       end
     end
   end

data/lib/yoda/store/objects/meta_class_object.rb

@@ -1,20 +1,47 @@
 module Yoda
   module Store
     module Objects
+      # @todo Rename to SingletonClassObject
       class MetaClassObject < NamespaceObject
+        class Connected < NamespaceObject::Connected
+          delegate_to_object :base_class_address
+
+          # @return [NamespaceObject::Connected]
+          def superclass
+            ancestor_tree.superclass.with_connection(**connection_options)
+          end
+
+          # @return [Base::Connected, nil]
+          def instance
+            registry.get(path)&.with_connection(**connection_options)
+          end
+        end
+
         # @param path [String]
         # @return [String]
         def self.address_of(path)
           "#{path}%class"
         end
 
+        # @param address [String]
+        # @return [true, false]
+        def self.meta_class_address?(address)
+          address.end_with?('%class')
+        end
+
+        # @param address [String]
+        # @return [String]
+        def self.path_of(address)
+          address.sub(/%class$/, '')
+        end
+
         # @param path [String]
         # @param document [Document, nil]
         # @param tag_list [TagList, nil]
         # @param instance_method_paths [Array<String>]
         # @param instance_mixin_paths [Array<String>]
         def initialize(**kwargs)
-          super(kwargs)
+          super(**kwargs)
         end
 
         # @return [String]

data/lib/yoda/store/objects/method_object.rb

@@ -2,6 +2,10 @@ module Yoda
   module Store
     module Objects
       class MethodObject < Base
+        class Connected < Base::Connected
+          delegate_to_object :parameters, :visibility, :overloads, :sep, :namespace_path, :parent_address, :namespace_path
+        end
+
         # @return [Array<(String, String)>]
         attr_reader :parameters
 
@@ -12,38 +16,53 @@ module Yoda
         attr_reader :overloads
 
         class << self
+          METHOD_SEPARATOR_PATTERN = /[#.]|(::)/
+
           # @param path [String]
           # @return [String]
           def namespace_of_path(path)
-            path.slice(0, (path.rindex(/[#.]/) || 0))
+            divide_by_separator(path)&.at(0)
           end
 
           # @param path [String]
           # @return [String]
           def name_of_path(path)
-            path.slice((path.rindex(/[#.]/) || -1) + 1, path.length)
+            divide_by_separator(path)&.at(2)
           end
 
           # @param path [String]
-          # @return [String]
+          # @return [String, nil]
           def sep_of_path(path)
-            path.slice(path.rindex(/[#.]/))
+            divide_by_separator(path)&.at(1)
           end
 
           # @return [Array<Symbol>]
           def attr_names
             super + %i(parameters visibility overloads)
           end
+
+          private
+
+          # @param path [String]
+          # @return [(String, String, String), nil]
+          def divide_by_separator(path)
+            rev_path = path.reverse
+            if match_data = rev_path.match(METHOD_SEPARATOR_PATTERN)
+              [match_data.post_match.reverse, match_data.to_s, match_data.pre_match.reverse]
+            else
+              nil
+            end
+          end
         end
 
         # @param path [String]
         # @param document [Document, nil]
-        # @param tag_list [TagList, nil]
+        # @param tag_list [Array<Tag>, nil]
         # @param visibility [Symbol]
         # @param overloads [Array<Overload>]
         # @param parameters [Array<(String, String)>, nil]
         def initialize(parameters: [], visibility: :public, overloads: [], **kwargs)
-          super(kwargs)
+          super(**kwargs)
           fail ArgumentError, visibility unless %i(public private protected)
           @visibility = visibility.to_sym
           @parameters = parameters
@@ -65,6 +84,20 @@ module Yoda
           @namespace_path ||= MethodObject.namespace_of_path(path)
         end
 
+        # @return [String]
+        def parent_address
+          @parent_address ||= begin
+            case MethodObject.sep_of_path(path)
+            when '#'
+              namespace_path
+            when '.', '::'
+              MetaClassObject.address_of(namespace_path)
+            else
+              fail TypeError
+            end
+          end
+        end
+
         def kind
           :method
         end

data/lib/yoda/store/objects/module_object.rb

@@ -2,6 +2,9 @@ module Yoda
   module Store
     module Objects
       class ModuleObject < NamespaceObject
+        class Connected < NamespaceObject::Connected
+        end
+
         def kind
           :module
         end

data/lib/yoda/store/objects/namespace_object.rb

@@ -3,6 +3,36 @@ module Yoda
     module Objects
       # @abstract
       class NamespaceObject < Base
+        class Connected < Base::Connected
+          delegate_to_object :instance_method_addresses, :mixin_addresses, :constant_addresses, :ancestors, :methods
+
+          # @return [Enumerator<NamespaceObject::Connected>]
+          def ancestors
+            ancestor_tree.ancestors.map { |object| object.with_connection(**connection_options) }
+          end
+
+          # @return [Enumerator<NamespaceObject::Connected>]
+          def mixins
+            ancestor_tree.mixins.map { |object| object.with_connection(**connection_options) }
+          end
+
+          # @return [Query::MethodMemberSet]
+          def method_members
+            @method_members ||= Query::MethodMemberSet.new(registry: registry, object: object)
+          end
+
+          # @return [Query::ConstantMemberSet]
+          def constant_members
+            @constant_members ||= Query::ConstantMemberSet.new(registry: registry, object: object)
+          end
+
+          private
+
+          def ancestor_tree
+            @ancestor_tree ||= Query::AncestorTree.new(registry: registry, object: object)
+          end
+        end
+
         # @return [Array<String>]
         attr_reader :instance_method_addresses
 
@@ -30,18 +60,20 @@ module Yoda
         # @param constant_addresses [Array<String>]
         # @param mixin_addresses [Array<String>]
         def initialize(instance_method_addresses: [], mixin_addresses: [], constant_addresses: [], **kwargs)
-          super(kwargs)
+          super(**kwargs)
           @instance_method_addresses = instance_method_addresses
           @mixin_addresses = mixin_addresses
           @constant_addresses = constant_addresses
           @ancestors ||= []
         end
 
+        # @note Override of {Base#name}
         # @return [String]
         def name
           @name ||= path.match(MODULE_TAIL_PATTERN) { |md| md[1] || md[2] }
         end
 
+        # @note Override of {Base#to_h}
         def to_h
           super.merge(
             instance_method_addresses: instance_method_addresses,
@@ -50,6 +82,11 @@ module Yoda
           )
         end
 
+        # @note Override of {Base#namespace?}
+        def namespace?
+          true
+        end
+
         private
 
         # @param another [self]

data/lib/yoda/store/objects/overload.rb

@@ -9,7 +9,7 @@ module Yoda
 
           # @param params [Hash]
           def json_create(params)
-            new(params.map { |k, v| [k.to_sym, v] }.select { |(k, v)| %i(name tag_list document parameters).include?(k) }.to_h)
+            new(**params.map { |k, v| [k.to_sym, v] }.select { |(k, v)| %i(name tag_list document parameters).include?(k) }.to_h)
           end
         end
 

data/lib/yoda/store/objects/patch.rb

@@ -9,19 +9,10 @@ module Yoda
         attr_reader :registry
 
         # @param id [String]
-        def initialize(id)
+        # @param  [Array[Addressable], nil]
+        def initialize(id, contents = nil)
           @id = id
-          @registry = Hash.new
-        end
-
-        # @param addressable [Addressable]
-        # @return [void]
-        def register(addressable)
-          if el = @registry[addressable.address.to_sym]
-            @registry[addressable.address.to_sym] = el.merge(addressable)
-          else
-            @registry[addressable.address.to_sym] = addressable
-          end
+          @registry = (contents || []).map { |content| [content.address.to_sym, content] }.to_h
         end
 
         # @param address [String, Symbol]
@@ -29,6 +20,7 @@ module Yoda
         def find(address)
           @registry[address.to_sym]
         end
+        alias get find
 
         # @param address [String, Symbol]
         # @return [true, false]
@@ -40,6 +32,58 @@ module Yoda
         def keys
           @registry.keys
         end
+
+        # @param addressable [Addressable]
+        # @return [void]
+        def register(addressable)
+          parent_modifier.add_address_to_parent(addressable)
+
+          if el = @registry[addressable.address.to_sym]
+            @registry[addressable.address.to_sym] = el.merge(addressable)
+          else
+            @registry[addressable.address.to_sym] = addressable
+          end
+        end
+
+        private
+
+        def parent_modifier
+          @parent_modifier ||= ParentModifier.new(self)
+        end
+
+        class ParentModifier
+          attr_reader :patch
+
+          # @param patch [Patch]
+          def initialize(patch)
+            @patch = patch
+          end
+
+          # @param code_object [Base]
+          # @return [void]
+          def add_address_to_parent(code_object)
+            parent_module = patch.find(code_object.parent_address) || create_parent_module(code_object)
+            return unless parent_module.namespace?
+            patch.register(parent_module) if !patch.has_key?(parent_module.address) && parent_module.address != code_object.address
+
+            case code_object.kind
+            when :method
+              parent_module.instance_method_addresses.push(code_object.address) unless parent_module.instance_method_addresses.include?(code_object.address)
+            when :class, :module, :value
+              parent_module.constant_addresses.push(code_object.address) unless parent_module.constant_addresses.include?(code_object.address)
+            end
+          end
+
+          def create_parent_module(code_object)
+            if code_object.address == code_object.parent_address
+              code_object
+            elsif MetaClassObject.meta_class_address?(code_object.parent_address)
+              MetaClassObject.new(path: MetaClassObject.path_of(code_object.parent_address))
+            else
+              ModuleObject.new(path: code_object.parent_address)
+            end
+          end
+        end
       end
     end
   end

data/lib/yoda/store/objects/patch_set.rb

@@ -1,78 +1,110 @@
+require 'set'
+
 module Yoda
   module Store
     module Objects
       # PatchSet manages patch updates and patch outdates.
       # Besides, this class provides api to modify objects by using owning patches.
       class PatchSet
-        # @return [{ Symbol => Array<Symbol> }]
-        attr_reader :address_index
+        class AddressIndex
+          def initialize
+            @index = Hash.new
+          end
 
-        # @return [{ Symbol => Patch }]
-        attr_reader :patches
+          # @param address [Symbol]
+          # @return [Set<Symbol>]
+          def get(address)
+            index[address] ||= Set.new
+          end
+
+          # @return [Set<Symbol>]
+          def keys
+            index.keys
+          end
+
+          # @param patch [Patch]
+          # @return [void]
+          def register(patch)
+            patch.keys.each do |key|
+              index[key.to_sym] ||= Set.new
+              index[key.to_sym].add(patch.id.to_sym)
+            end
+          end
+
+          # @param patch [Patch]
+          # @return [void]
+          def delete(patch)
+            patch.keys.each do |key|
+              (index[key.to_sym] || []).delete(patch.id.to_sym)
+            end
+          end
+
+          private
+          # @return [{ Symbol => Array<Symbol> }]
+          attr_reader :index
+        end
 
         def initialize
           @patches = Hash.new
-          @address_index = Hash.new
+          @address_index = AddressIndex.new
         end
 
         # @param patch [Patch]
         # @return [void]
         def register(patch)
-          register_to_index(patch)
+          address_index.register(patch)
           patches[patch.id.to_sym] = patch
         end
 
         # @param id [String, Symbol]
         def delete(id)
+          if patch = patches[id.to_sym]
+            address_index.delete(patch)
+          end
           patches.delete(id.to_sym)
         end
 
         # @param object [Addressable]
         # @return [Addressable]
         def patch(object)
-          check_outdated_index(object.address.to_sym)
-          objects_in_patch = (address_index[object.address.to_sym] || []).map { |patch_id| patches[patch_id].find(object.address.to_sym) }
+          objects_in_patch = get_patches(object.address)
           Merger.new([object, *objects_in_patch]).merged_instance
         end
 
         # @param address [String, Symbol]
         # @return [Addressable, nil]
         def find(address)
-          check_outdated_index(address.to_sym)
-          if (patch_ids = address_index[address.to_sym] || []).empty?
+          if (patches = get_patches(address)).empty?
             nil
           else
-            objects = patch_ids.map { |id| patches[id].find(address.to_sym) }
-            Merger.new(objects).merged_instance
+            Merger.new(patches).merged_instance
           end
         end
 
         # @return [Array<Symbol>]
         def keys
-          address_index.keys
+          address_index.keys.to_a
         end
 
         # @param address [String, Symbol]
         # @return [true, false]
         def has_key?(address)
-          check_outdated_index(address.to_sym)
-          address_index[address.to_sym] && !address_index[address.to_sym].empty?
+          !address_index.get(address.to_sym).empty?
         end
 
         private
 
-        # @param patch [Patch]
-        # @return [void]
-        def register_to_index(patch)
-          patch.keys.each do |key|
-            address_index[key.to_sym] ||= []
-            address_index[key.to_sym].push(patch.id.to_sym)
-          end
-        end
+        # @return [AddressIndex]
+        attr_reader :address_index
+
+        # @return [{ Symbol => Patch }]
+        attr_reader :patches
 
-        # @param address [Symbol]
-        def check_outdated_index(address)
-          (address_index[address] || []).select! { |patch_id| patches[patch_id].has_key?(address) }
+        # @param address [String, Symbol]
+        # @return [Array<Patch>]
+        def get_patches(address)
+          patch_ids = address_index.get(address.to_sym)
+          patch_ids.map { |id| patches[id].find(address.to_sym) }
         end
       end
     end

data/lib/yoda/store/objects/serializable.rb

@@ -9,7 +9,7 @@ module Yoda
 
           # @param params [Hash]
           def json_create(params)
-            new(params.reject { |k, _v| k.to_sym == :json_class }.map { |k, v| [k.to_sym, v] }.to_h)
+            new(**params.reject { |k, _v| k.to_sym == :json_class }.map { |k, v| [k.to_sym, v] }.to_h)
           end
         end
 
@@ -31,7 +31,22 @@ module Yoda
         # Create a new instance which has the original parameters and overrided parameters.
         # @param params [Hash{Symbol => Object}] parameters to override
         def derive(params = {})
-          self.class.new(to_h.merge(params))
+          self.class.new(**to_h.merge(params))
+        end
+
+        def eql?(another)
+          return object.eql?(another) if respond_to?(:object) && !object.respond_to?(:object)
+          return eql?(another.object) if another.respond_to?(:object) && !another.object.respond_to?(:object)
+          return false unless self.class.name == another.class.name
+          to_h.eql?(another.to_h)
+        end
+
+        def ==(another)
+          eql?(another)
+        end
+
+        def hash
+          to_h.hash
         end
       end
     end

data/lib/yoda/store/objects/serializable_set.rb

@@ -0,0 +1,23 @@
+module Yoda
+  module Store
+    module Objects
+      class SerializableSet
+        include MissingDelegatable
+        include Serializable
+
+        delegate_missing :set
+
+        # @return [Set]
+        attr_reader :set
+
+        def initialize(els = nil, elements: nil)
+          @set = Set.new(els || elements)
+        end
+
+        def to_h
+          { elements: set.to_a }
+        end
+      end
+    end
+  end
+end

data/lib/yoda/store/objects/tag.rb

@@ -9,7 +9,7 @@ module Yoda
 
           # @param params [Hash]
           def json_create(params)
-            new(params.map { |k, v| [k.to_sym, v] }.select { |(k, v)| %i(tag_name name yard_types text lexical_scope).include?(k) }.to_h)
+            new(**params.map { |k, v| [k.to_sym, v] }.select { |(k, v)| %i(tag_name name yard_types text lexical_scope).include?(k) }.to_h)
           end
         end