class SparkleFormation::Composition

Internal template composition

Constants

Component

Component item of composition

Override

Override item of composition

Attributes

components_list[R]
origin[R]

@return [SparkleFormation] owner of composition

overrides_list[R]

Public Class Methods

new(origin, args = {}) click to toggle source

Create a new composition

@param origin [SparkleFormation] owner of composition @param args [Hash] @option args [Array<Component>] :components seed components for composition @option args [Array<Override>] :overrides seed overrides for composition @return [self]

# File lib/sparkle_formation/composition.rb, line 27
def initialize(origin, args = {})
  unless origin.is_a?(SparkleFormation)
    raise TypeError.new "Composition requires `SparkleFormation` instance as origin. " \
                        "Received origin type `#{origin.class}`."
  end
  @origin = origin
  @components_list = []
  @overrides_list = []
  seed_value(args[:overrides], Override).each do |item|
    add_override(item)
  end
  seed_value(args[:components], [Component, Override]).each do |item|
    add_component(item)
  end
end

Public Instance Methods

add_component(item, location = :append) click to toggle source

Add an existing component

@param item [Component, Override] @param location [Symbol] :prepend or :append (defaults to :append) @return [self]

# File lib/sparkle_formation/composition.rb, line 65
def add_component(item, location = :append)
  unless item.is_a?(Component) || item.is_a?(Override)
    raise TypeError.new("Expecting `Component` or `Override` but received `#{item.class}`")
  end
  if item.respond_to?(:key) && component_keys.include?(item.key)
    # do nothing
  else
    case location
    when :append
      components_list.push(item)
    when :prepend
      components_list.unshift(item)
    else
      raise ArgumentError.new "Unknown addition location provided. Valid: `:append, :prepend`. " \
                              "Received: `#{location.inspect}`"
    end
  end
  self
end
add_override(item, location = :append) click to toggle source

Add an existing override

@param item [Override] @param location [Symbol] :prepend or :append (defaults to :append) @return [self]

# File lib/sparkle_formation/composition.rb, line 90
def add_override(item, location = :append)
  unless item.is_a?(Override)
    raise TypeError.new("Expecting `Override` but received `#{item.class}`")
  end
  case location
  when :append
    overrides_list.push(item)
  when :prepend
    overrides_list.unshift(item)
  else
    raise ArgumentError.new "Unknown addition location provided. Valid: " \
                            "`:append, :prepend`. Received: `#{location.inspect}`"
  end
  self
end
components() click to toggle source

@return [Array<Component, Override>]

# File lib/sparkle_formation/composition.rb, line 44
def components
  @components_list.dup.freeze
end
composite() click to toggle source

Provides the full list of items in order

@return [Array<Component, Override>]

# File lib/sparkle_formation/composition.rb, line 56
def composite
  [components + overrides].flatten.freeze
end
each() { |item| ... } click to toggle source

Iterate full composition

@yield block to execute each item @yieldparam [Component, Override] @return [self]

# File lib/sparkle_formation/composition.rb, line 139
def each
  if block_given?
    composite.each do |item|
      yield item
    end
  end
  self
end
new_component(key, location = :append, &block) click to toggle source

Add a new component

@param key [Symbol, String] component identifier @param location [Symbol] :prepend or :append (defaults to :append) @yield component block (optional) @return [self]

# File lib/sparkle_formation/composition.rb, line 112
def new_component(key, location = :append, &block)
  comp = Component.new(origin, key, block)
  add_component(comp, location)
  self
end
new_override(args = {}, location = :append, &block) click to toggle source

Add a new override

@param args [Hash] local state provided to override @param location [Symbol] :prepend or :append (defaults to :append) @yield override block @return [self]

# File lib/sparkle_formation/composition.rb, line 124
def new_override(args = {}, location = :append, &block)
  if args.is_a?(Symbol)
    location = args
    args = {}
  end
  ovr = Override.new(origin, args, block)
  add_override(ovr, location)
  self
end
overrides() click to toggle source

@return [Array<Override>]

# File lib/sparkle_formation/composition.rb, line 49
def overrides
  @overrides_list.dup.freeze
end

Protected Instance Methods

component_keys() click to toggle source

@return [Array<String, Symbol>]

# File lib/sparkle_formation/composition.rb, line 151
def component_keys
  components.map do |item|
    item.respond_to?(:key) ? item.key : nil
  end.compact
end
seed_value(items, type) click to toggle source

If items list provided, validate types and return copy of list. If no list provided, return new list.

@param items [Array] @param type [Class] @return [Array]

# File lib/sparkle_formation/composition.rb, line 163
def seed_value(items, type)
  type = [type].flatten.compact
  if items
    items.each do |item|
      valid_item = type.any? do |klass|
        item.is_a?(klass)
      end
      unless valid_item
        raise TypeError.new "Invalid type encountered within collection `#{item.class}`. " \
                            "Expected `#{type.map(&:to_s).join("`, `")}`."
      end
    end
    items.dup
  else
    []
  end
end