class Yoda::Store::Objects::Merger

Attributes

instances[R]

@return [Array<Base>]

Public Class Methods

new(instances) click to toggle source

@param instances [Array<Base>]

# File lib/yoda/store/objects/merger.rb, line 12
def initialize(instances)
  @instances = instances
end

Public Instance Methods

merged_instance() click to toggle source

@return [Base]

# File lib/yoda/store/objects/merger.rb, line 17
def merged_instance
  class_to_generate.new(attributes.select { |k, v| class_to_generate.attr_names.include?(k) }.to_h)
end

Private Instance Methods

attributes() click to toggle source

@return [Hash{ Symbol => Object }]

# File lib/yoda/store/objects/merger.rb, line 41
def attributes
  @attributes ||= normalize_attributes(instances.map { |i| default_attributes.merge(i.to_h) }.reduce { |a, b| merge_attributes(a, b) })
end
class_to_generate() click to toggle source

@return [Base.class]

# File lib/yoda/store/objects/merger.rb, line 24
def class_to_generate
  @class_to_generate ||= begin
    if instances.any? { |el| el.is_a?(MetaClassObject) }
      MetaClassObject
    elsif instances.any? { |el| el.is_a?(ClassObject) }
      ClassObject
    elsif instances.any? { |el| el.is_a?(ModuleObject) }
      ModuleObject
    elsif instances.any? { |el| el.is_a?(MethodObject) }
      MethodObject
    else
      ValueObject
    end
  end
end
default_attributes() click to toggle source

@return [Hash{ Symbol => Object }]

# File lib/yoda/store/objects/merger.rb, line 66
def default_attributes
  {
    path: nil,
    document: '',
    tag_list: [],
    sources: [],
    primary_source: nil,
    instance_method_addresses: [],
    mixin_addresses: [],
    constant_addresses: [],
    visibility: nil,
    parameters: [],
    overloads: [],
    superclass_path: nil,
    value: nil,
  }
end
merge_attributes(one, another) click to toggle source

@param one [Hash{ Symbol => Object }] @param another [Hash{ Symbol => Object }]

# File lib/yoda/store/objects/merger.rb, line 47
def merge_attributes(one, another)
  {
    path: one[:path] || another[:path],
    document: one[:document] + (one[:document].empty? || another[:document].empty? ? '' : "\n") + another[:document],
    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: 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: PendingArray.append(one[:overloads], another[:overloads]),
    superclass_path: select_superclass(one, another),
    value: one[:value] || another[:value],
  }
end
normalize_attributes(attrs) click to toggle source

@param attrs [Hash{ Symbol => Object }] @return [Hash{ Symbol => Object }]

# File lib/yoda/store/objects/merger.rb, line 86
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
select_superclass(one, another) click to toggle source

@param one [Hash{ Symbol => Object }] @param another [Hash{ Symbol => Object }] @return [ScopedPath]

# File lib/yoda/store/objects/merger.rb, line 107
def select_superclass(one, another)
  if %w(Object Exception).include?(another[:path].to_s)
    one[:superclass_path] || another[:superclass_path]
  else
    another[:superclass_path] || one[:superclass_path]
  end
end