class SparkleFormation::SparkleStruct

SparkleFormation customized AttributeStruct

Constants

OpenStack

Heat specific struct

Rackspace

Heat specific struct

Attributes

_struct_class[RW]

@return [SparkleStruct]

Public Class Methods

new(*_) click to toggle source

Override initializer to force desired behavior

Calls superclass method
# File lib/sparkle_formation/sparkle_struct.rb, line 56
def initialize(*_)
  super
  @_camel_keys = true
  _set_state :hash_load_struct => true
end

Public Instance Methods

_klass() click to toggle source

@return [Class]

# File lib/sparkle_formation/sparkle_struct.rb, line 148
def _klass
  _struct_class || ::SparkleFormation::SparkleStruct
end
_klass_new(*args, &block) click to toggle source

Instantiation override properly set origin template

@return [SparkleStruct]

Calls superclass method
# File lib/sparkle_formation/sparkle_struct.rb, line 155
def _klass_new(*args, &block)
  inst = super()
  inst._set_self(_self)
  inst._struct_class = _struct_class
  if args.first.is_a?(::Hash)
    inst._load(args.first)
  end
  if block
    inst.build!(&block)
  end
  inst
end
_self(*_) click to toggle source

@return [SparkleFormation]

# File lib/sparkle_formation/sparkle_struct.rb, line 74
def _self(*_)
  unless @self
    if _parent.nil?
      ::Kernel.raise ::ArgumentError.new "Creator did not provide return reference!"
    else
      _parent._self
    end
  else
    @self
  end
end
_set_self(inst) click to toggle source

Set SparkleFormation instance

@param inst [SparkleFormation] @return [SparkleFormation]

# File lib/sparkle_formation/sparkle_struct.rb, line 66
def _set_self(inst)
  unless inst.is_a?(::SparkleFormation)
    ::Kernel.raise ::TypeError.new "Expecting type of `SparkleFormation` but got `#{inst.class}`"
  end
  @self = inst
end
_sparkle_dump() click to toggle source

@return [AttributeStruct::AttributeHash, Mash] dump struct to hashish

# File lib/sparkle_formation/sparkle_struct.rb, line 223
def _sparkle_dump
  processed = @table.keys.map do |key|
    value = @table[key]
    val = _sparkle_dump_unpacker(value)
    [_sparkle_dump_unpacker(key), val] unless val == UNSET_VALUE
  end.compact
  __hashish[*processed.flatten(1)]
end
Also aliased as: sparkle_dump!
_sparkle_dump_unpacker(item) click to toggle source

Process and unpack items for dumping within deeply nested enumerable types

@param item [Object] @return [Object]

# File lib/sparkle_formation/sparkle_struct.rb, line 198
def _sparkle_dump_unpacker(item)
  if item.is_a?(::Enumerable)
    if item.respond_to?(:keys)
      item.class[
        *item.map do |entry|
          _sparkle_dump_unpacker(entry)
        end.flatten(1)
      ]
    else
      item.class[
        *item.map do |entry|
          _sparkle_dump_unpacker(entry)
        end
      ]
    end
  elsif item.is_a?(::AttributeStruct)
    item.nil? ? UNSET_VALUE : item._sparkle_dump
  elsif item.is_a?(::SparkleFormation)
    item.sparkle_dump
  else
    item
  end
end
_state(arg) click to toggle source

Override the state to force helpful error when no value has been provided

@param arg [String, Symbol] name of parameter @return [Object] @raise [ArgumentError]

Calls superclass method
# File lib/sparkle_formation/sparkle_struct.rb, line 174
def _state(arg)
  result = super
  if @self && result.nil?
    if _self.parameters.keys.map(&:to_s).include?(arg.to_s)
      unless _self.parameters[arg.to_sym].key?(:default)
        ::Kernel.raise ::ArgumentError.new "No value provided for compile time parameter: `#{arg}`!"
      else
        result = _self.parameters[arg.to_sym][:default]
      end
    end
  end
  result
end
Also aliased as: state!
function_bubbler(item) click to toggle source

Process value in search for FunctionStruct objects. If found replace with the root item of the structure

@param item [Object] @return [Object]

# File lib/sparkle_formation/sparkle_struct.rb, line 91
def function_bubbler(item)
  if item.is_a?(::Enumerable)
    if item.respond_to?(:keys)
      item.class[
        *item.map do |entry|
          function_bubbler(entry)
        end.flatten(1)
      ]
    else
      item.class[
        *item.map do |entry|
          function_bubbler(entry)
        end
      ]
    end
  elsif item.is_a?(::SparkleFormation::FunctionStruct)
    item._root
  else
    item
  end
end
method_missing(sym, *args, &block) click to toggle source

Override to inspect result value and fetch root if value is a FunctionStruct

Calls superclass method
# File lib/sparkle_formation/sparkle_struct.rb, line 115
def method_missing(sym, *args, &block)
  if sym.is_a?(::String) || sym.is_a?(::Symbol)
    if sym.to_s.start_with?("_") || sym.to_s.end_with?("!")
      ::Kernel.raise ::NoMethodError.new "Undefined method `#{sym}` for #{_klass.name}"
    end
  end
  super(*[sym, *args], &block)
  if sym.is_a?(::String) || sym.is_a?(::Symbol)
    if (s = sym.to_s).end_with?("=")
      s.slice!(-1, s.length)
      sym = s
    end
    sym = _process_key(sym)
  else
    sym = function_bubbler(sym)
  end
  # When setting an AttributeStruct type instance check parent or context if
  # available and reset if it has been moved.
  if @table[sym].is_a?(::AttributeStruct)
    if @table[sym].is_a?(::SparkleFormation::FunctionStruct)
      if @table[sym].respond_to?(:_fn_context) && @table[sym]._fn_context != self
        @table[sym] = @table[sym]._clone
        @table[sym]._fn_context = self
      end
    elsif @table[sym]._parent != self
      @table[sym]._parent(self)
    end
  end
  @table[sym] = function_bubbler(@table[sym])
  @table[sym]
end
sparkle_dump!()
Alias for: _sparkle_dump
state!(arg)
Alias for: _state