sparkle_formation 0.4.0 → 1.0.0

data/lib/sparkle_formation/sparkle_formation.rb

@@ -1,25 +1,5 @@
-#
-# Author:: Chris Roberts <chris@hw-ops.com>
-# Copyright:: 2013, Heavy Water Operations, LLC
-# License:: Apache License, Version 2.0
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
 require 'sparkle_formation'
 
-SparkleFormation::SparkleStruct.camel_keys = true
-
 # Formation container
 class SparkleFormation
 
@@ -35,6 +15,9 @@ class SparkleFormation
     'registry'
   ]
 
+  # @return [String] default stack resource name
+  DEFAULT_STACK_RESOURCE = 'AWS::CloudFormation::Stack'
+
   class << self
 
     # @return [Hashish] loaded dynamics
@@ -106,12 +89,16 @@ class SparkleFormation
     #   to pass through when compiling ({:state => {}})
     # @return [Hashish, SparkleStruct]
     def compile(path, *args)
+      opts = args.detect{|i| i.is_a?(Hash) } || {}
+      if(spath = (opts.delete(:sparkle_path) || SparkleFormation.sparkle_path))
+        container = Sparkle.new(:root => spath)
+        path = container.get(:template, path)[:path]
+      end
       formation = self.instance_eval(IO.read(path), path, 1)
       if(args.delete(:sparkle))
         formation
       else
-        comp_arg = args.detect{|i| i.is_a?(Hash) }
-        (comp_arg ? formation.compile(comp_arg) : formation.compile)._dump
+        formation.compile(opts)._dump
       end
     end
 
@@ -121,13 +108,9 @@ class SparkleFormation
     # @yield block to execute
     # @return [SparkleStruct] provided base or new struct
     def build(base=nil, &block)
-      if(base || block.nil?)
-        struct = base || SparkleStruct.new
-        struct.instance_exec(&block)
-        @_struct = struct
-      else
-        block
-      end
+      struct = base || SparkleStruct.new
+      struct.instance_exec(&block)
+      struct
     end
 
     # Load component
@@ -136,6 +119,7 @@ class SparkleFormation
     # @return [SparkleStruct] resulting struct
     def load_component(path)
       self.instance_eval(IO.read(path), path, 1)
+      @_struct
     end
 
     # Load all dynamics within a directory
@@ -205,17 +189,19 @@ class SparkleFormation
     # @return [SparkleStruct]
     def insert(dynamic_name, struct, *args, &block)
       result = false
-      if(@dynamics && @dynamics[dynamic_name])
-        result = struct.instance_exec(*args, &@dynamics[dynamic_name][:block])
+      begin
+        dyn = struct._self.sparkle.get(:dynamic, dynamic_name)
+        raise dyn if dyn.is_a?(Exception)
+        result = struct.instance_exec(*args, &dyn[:block])
         if(block_given?)
           result.instance_exec(&block)
         end
         result = struct
-      else
+      rescue Error::NotFound::Dynamic
         result = builtin_insert(dynamic_name, struct, *args, &block)
       end
       unless(result)
-        raise "Failed to locate requested dynamic block for insertion: #{dynamic_name} (valid: #{(@dynamics || {}).keys.sort.join(', ')})"
+        raise "Failed to locate requested dynamic block for insertion: #{dynamic_name} (valid: #{struct._self.sparkle.dynamics.keys.sort.join(', ')})"
       end
       result
     end
@@ -229,33 +215,18 @@ class SparkleFormation
     # @note if symbol is provided for template, double underscores
     #   will be used for directory separator and dashes will match underscores
     def nest(template, struct, *args, &block)
-      options = args.detect{|i| i.is_a?(Hash)}
-      if(options)
-        args.delete(options)
-      else
-        options = {}
-      end
-      spath = SparkleFormation.new('stub').sparkle_path
-      resource_name = [template.to_s.gsub(/(\/|__|-)/, '_'), *args].compact.join('_').to_sym
-      path = template.is_a?(Symbol) ? template.to_s.gsub('__', '/') : template.to_s
-      file = Dir.glob(File.join(spath, '**', '**', '*.rb')).detect do |local_path|
-        strip_path = local_path.sub(spath, '').sub(/^\//, '').tr('-', '_').sub('.rb', '')
-        strip_path == path
-      end
-      unless(file)
-        raise ArgumentError.new("Failed to locate nested stack file! (#{template.inspect} -> #{path.inspect})")
-      end
-      instance = self.instance_eval(IO.read(file), file, 1)
-      instance.parent = struct._self
-      instance.name = Bogo::Utility.camel(resource_name)
+      to_nest = struct._self.sparkle.get(:template, template)
+      resource_name = (args.empty? ? template.to_s.gsub('__', '_') : args.map{|a| Bogo::Utility.snake(a)}.join('_')).to_sym
+      nested_template = self.compile(to_nest[:path], :sparkle)
+      nested_template.parent = struct._self
       struct.resources.set!(resource_name) do
-        type 'AWS::CloudFormation::Stack'
+        type DEFAULT_STACK_RESOURCE
       end
-      struct.resources.__send__(resource_name).properties.stack instance.compile(:state => options[:parameters])
+      struct.resources[resource_name].properties.stack nested_template
       if(block_given?)
-        struct.resources.__send__(resource_name).instance_exec(&block)
+        struct.resources[resource_name].instance_exec(&block)
       end
-      struct.resources.__send__(resource_name)
+      struct.resources[resource_name]
     end
 
     # Insert a builtin dynamic into a context
@@ -270,18 +241,19 @@ class SparkleFormation
         _config ||= {}
         return unless _name
         resource_name = "#{_name}_#{_config.delete(:resource_name_suffix) || dynamic_name}".to_sym
-        new_resource = struct.resources.__send__(resource_name)
+        struct.resources.set!(resource_name)
+        new_resource = struct.resources[resource_name]
         new_resource.type lookup_key
         properties = new_resource.properties
+        config_keys = _config.keys.zip(_config.keys.map{|k| snake(k).to_s.tr('_', '')})
         SfnAws.resource(dynamic_name, :properties).each do |prop_name|
-          value = [prop_name, snake(prop_name)].map do |key|
-            _config[key] || _config[key.to_sym]
-          end.compact.first
+          key = (config_keys.detect{|k| k.last == snake(prop_name).to_s.tr('_', '')} || []).first
+          value = _config[key] if key
           if(value)
             if(value.is_a?(Proc))
-              properties.__send__(prop_name).instance_exec(&value)
+              properties[prop_name].to_sym.instance_exec(&value)
             else
-              properties.__send__(prop_name, value)
+              properties.set!(prop_name, value)
             end
           end
         end
@@ -304,8 +276,12 @@ class SparkleFormation
     end
   end
 
+  include Bogo::Memoization
+
   # @return [Symbol] name of formation
-  attr_accessor :name
+  attr_reader :name
+  # @return [Sparkle] parts store
+  attr_reader :sparkle
   # @return [String] base path
   attr_reader :sparkle_path
   # @return [String] components path
@@ -320,11 +296,7 @@ class SparkleFormation
   attr_reader :load_order
   # @return [Hash] parameters for stack generation
   attr_reader :parameters
-  # @return [Hash] state hash for compile time parameters
-  attr_accessor :compile_state
-  # @return [Proc] block to call for setting compile time parameters
-  attr_accessor :compile_time_parameter_setter
-  # @return [SparkleFormation] parent instance
+  # @return [SparkleFormation] parent stack
   attr_accessor :parent
 
   # Create new instance
@@ -340,65 +312,59 @@ class SparkleFormation
   # @yield base context
   def initialize(name, options={}, &block)
     @name = name.to_sym
-    @sparkle_path = options[:sparkle_path] ||
-      self.class.custom_paths[:sparkle_path] ||
-      File.join(Dir.pwd, 'cloudformation')
-    @components_directory = options[:components_directory] ||
-      self.class.custom_paths[:components_directory] ||
-      File.join(sparkle_path, 'components')
-    @dynamics_directory = options[:dynamics_directory] ||
-      self.class.custom_paths[:dynamics_directory] ||
-      File.join(sparkle_path, 'dynamics')
-    @registry_directory = options[:registry_directory] ||
-      self.class.custom_paths[:registry_directory] ||
-      File.join(sparkle_path, 'registry')
-    self.class.load_dynamics!(@dynamics_directory)
-    self.class.load_registry!(@registry_directory)
+    @component_paths = []
+    @sparkle = SparkleCollection.new
+    @sparkle.set_root(
+      Sparkle.new(
+        Smash.new.tap{|h|
+          s_path = options.fetch(:sparkle_path,
+            self.class.custom_paths[:sparkle_path]
+          )
+          if(s_path)
+            h[:root] = s_path
+          end
+        }
+      )
+    )
     unless(options[:disable_aws_builtins])
       require 'sparkle_formation/aws'
       SfnAws.load!
     end
-    @parameters = set_generation_parameters!(
-      options.fetch(:parameters,
-        options.fetch(:compile_time_parameters, {})
-      )
-    )
-    @components = SparkleStruct.hashish.new
+    @parameters = set_generation_parameters!(options.fetch(:parameters, {}))
+    @components = Smash.new
     @load_order = []
     @overrides = []
+    @parent = options[:parent]
     if(block)
       load_block(block)
     end
     @compiled = nil
   end
 
-  # Get or set the compile time parameter setting block. If a get
-  # request the ancestor path will be searched to root
-  #
-  # @yield block to set compile time parameters
-  # @yieldparam [SparkleFormation]
-  # @return [Proc, NilClass]
-  def compile_time_parameter_setter(&block)
-    if(block)
-      @compile_time_parameter_setter = block
+  # @return [SparkleFormation] root stack
+  def root
+    if(parent)
+      parent.root
     else
-      if(@compile_time_parameter_setter)
-        @compile_time_parameter_setter
-      else
-        parent.nil? ? nil : parent.compile_time_parameter_setter
-      end
+      self
     end
   end
 
-  # Set the compile time parameters for the stack if the setter proc
-  # is available
-  def set_compile_time_parameters!
-    if(compile_time_parameter_setter)
-      compile_time_parameter_setter.call(self)
+  # @return [Array<SparkleFormation] path to root
+  def root_path
+    if(parent)
+      [*parent.root_path, self].compact
+    else
+      [self]
     end
   end
 
-  ALLOWED_GENERATION_PARAMETERS = ['type', 'default', 'description', 'multiple', 'prompt_when_nested']
+  # @return [TrueClass, FalseClass] current stack is root
+  def root?
+    root == self
+  end
+
+  ALLOWED_GENERATION_PARAMETERS = ['type', 'default']
   VALID_GENERATION_PARAMETER_TYPES = ['String', 'Number']
 
   # Validation parameters used for template generation to ensure they
@@ -436,13 +402,13 @@ class SparkleFormation
   # @return [self]
   def load(*args)
     args.each do |thing|
-      if(thing.is_a?(Symbol))
-        path = File.join(components_directory, "#{thing}.rb")
+      key = File.basename(thing.to_s).sub('.rb', '')
+      if(thing.is_a?(String))
+        # TODO: Test this!
+        components[key] = ->{ self.class.load_component(thing) }
       else
-        path = thing
+        components[key] = sparkle.get(:component, thing)[:block]
       end
-      key = File.basename(path).sub('.rb', '')
-      components[key] = self.class.load_component(path)
       @load_order << key
     end
     self
@@ -463,16 +429,11 @@ class SparkleFormation
   # @option args [Hash] :state local state parameters
   # @return [SparkleStruct]
   def compile(args={})
-    if(args.has_key?(:state))
-      @compile_state = args[:state]
-      @compiled = nil
-    end
     unless(@compiled)
-      set_compile_time_parameters!
       compiled = SparkleStruct.new
       compiled._set_self(self)
-      if(compile_state)
-        compiled.set_state!(compile_state)
+      if(args[:state])
+        compiled.set_state!(args[:state])
       end
       @load_order.each do |key|
         self.class.build(compiled, &components[key])
@@ -483,9 +444,6 @@ class SparkleFormation
         end
         self.class.build(compiled, &override[:block])
       end
-      if(compile_state)
-        compiled.outputs.compile_state.value MultiJson.dump(compile_state)
-      end
       @compiled = compiled
     end
     @compiled
@@ -494,66 +452,239 @@ class SparkleFormation
   # Clear compiled stack if cached and perform compilation again
   #
   # @return [SparkleStruct]
-  def recompile(args={})
-    @compiled = nil
-    compile(args)
+  def recompile
+    unmemoize(:compile)
+    compile
+  end
+
+  # @return [Array<SparkleFormation>]
+  def nested_stacks(*args)
+    compile.resources.keys!.map do |key|
+      if(compile.resources[key].type == DEFAULT_STACK_RESOURCE)
+        result = [compile.resources[key].properties.stack]
+        if(args.include?(:with_resource))
+          result.push(compile[:resources][key])
+        end
+        if(args.include?(:with_name))
+          result.push(key)
+        end
+        result.size == 1 ? result.first : result
+      end
+    end.compact
   end
 
   # @return [TrueClass, FalseClass] includes nested stacks
-  def nested?
-    !!compile.dump!.fetch('Resources', {}).detect do |r_name, resource|
-      resource['Type'] == 'AWS::CloudFormation::Stack'
+  def nested?(stack_hash=nil)
+    stack_hash = compile.dump! unless stack_hash
+    !!stack_hash.fetch('Resources', {}).detect do |r_name, resource|
+      resource['Type'] == DEFAULT_STACK_RESOURCE
     end
   end
 
   # @return [TrueClass, FalseClass] includes _only_ nested stacks
-  def isolated_nests?
-    hash = compile.dump!
-    hash.fetch('Resources', {}).all? do |name, resource|
-      resource['Type'] == 'AWS::CloudFormation::Stack'
+  def isolated_nests?(stack_hash=nil)
+    stack_hash = compile.dump! unless stack_hash
+    stack_hash.fetch('Resources', {}).all? do |name, resource|
+      resource['Type'] == DEFAULT_STACK_RESOURCE
+    end
+  end
+
+  # @return [TrueClass, FalseClass] policies defined
+  def includes_policies?(stack_hash=nil)
+    stack_hash = compile.dump! unless stack_hash
+    stack_hash.fetch('Resources', {}).any? do |name, resource|
+      resource.has_key?('Policy')
     end
   end
 
-  # Apply stack nesting logic. Will extract unique parameters from
-  # nested stacks, update refs to use sibling stack outputs where
-  # required and extract nested stack templates for remote persistence
+  # Generate policy for stack
   #
-  # @yieldparam template_name [String] nested stack resource name
-  # @yieldparam template [Hash] nested stack template
-  # @yieldreturn [String] remote URL
-  # @return [Hash] dumped template hash
-  def apply_nesting(*args)
-    hash = compile.dump!
-    stacks = Hash[
-      hash['Resources'].find_all do |r_name, resource|
-        [r_name, MultiJson.load(MultiJson.dump(resource))]
+  # @return [Hash]
+  # @todo this is very AWS specific, so make this easy for swapping
+  def generate_policy
+    statements = []
+    compile.resources.keys!.each do |r_name|
+      r_object = compile.resources[r_name]
+      if(r_object['Policy'])
+        r_object['Policy'].keys!.each do |effect|
+          statements.push(
+            'Effect' => effect.to_s.capitalize,
+            'Action' => [r_object['Policy'][effect]].flatten.compact.map{|i| "Update:#{i}"},
+            'Resource' => "LogicalResourceId/#{r_name}",
+            'Principal' => '*'
+          )
+        end
+        r_object.delete!('Policy')
       end
-    ]
-    parameters = hash.fetch('Parameters', {})
-    output_map = {}
-    stacks.each do |stack_name, stack_resource|
-      remap_nested_parameters(hash, parameters, stack_name, stack_resource, output_map)
-    end
-    hash['Parameters'] = parameters
-    hash['Resources'].each do |resource_name, resource|
-      if(resource['Type'] == 'AWS::CloudFormation::Stack')
-        stack = resource['Properties'].delete('Stack')
-        resource['Properties']['TemplateURL'] = yield(resource_name, stack)
+    end
+    statements.push(
+      'Effect' => 'Allow',
+      'Action' => 'Update:*',
+      'Resource' => '*',
+      'Principal' => '*'
+    )
+    Smash.new('Statement' => statements)
+  end
+
+  # Apply nesting logic to stack
+  #
+  # @param nest_type [Symbol] values: :shallow, :deep (default: :deep)
+  # @return [Hash] dumped stack
+  # @note see specific version for expected block parameters
+  def apply_nesting(*args, &block)
+    if(args.include?(:shallow))
+      apply_shallow_nesting(&block)
+    else
+      apply_deep_nesting(&block)
+    end
+  end
+
+  # Apply deeply nested stacks. This is the new nesting approach and
+  # does not bubble parameters up to the root stack. Parameters are
+  # isolated to the stack resource itself and output mapping is
+  # automatically applied.
+  #
+  # @yieldparam stack [SparkleFormation] stack instance
+  # @yieldparam resource [AttributeStruct] the stack resource
+  # @yieldparam s_name [String] stack resource name
+  # @yieldreturn [Hash] key/values to be merged into resource properties
+  # @return [Hash] dumped stack
+  def apply_deep_nesting(*args, &block)
+    outputs = collect_outputs
+    nested_stacks(:with_resource).each do |stack, resource|
+      unless(stack.nested_stacks.empty?)
+        stack.apply_deep_nesting(*args)
+      end
+      stack.compile.parameters.keys!.each do |parameter_name|
+        if(output_name = output_matched?(parameter_name, outputs.keys))
+          next if outputs[output_name] == stack
+          stack_output = stack.make_output_available(output_name, outputs)
+          resource.properties.parameters.set!(parameter_name, stack_output)
+        end
+      end
+    end
+    if(block_given?)
+      extract_templates(&block)
+    end
+    compile.dump!
+  end
+
+  # Check if parameter name matches an output name
+  #
+  # @param p_name [String, Symbol] parameter name
+  # @param output_names [Array<String>] list of available outputs
+  # @return [String, NilClass] matching output name
+  # @note will auto downcase name prior to comparison
+  def output_matched?(p_name, output_names)
+    output_names.detect do |o_name|
+      Bogo::Utility.snake(o_name).tr('_', '') == Bogo::Utility.snake(p_name).tr('_', '')
+    end
+  end
+
+  # Extract output to make available for stack parameter usage at the
+  # current depth
+  #
+  # @param output_name [String] name of output
+  # @param outputs [Hash] listing of outputs
+  # @reutrn [Hash] reference to output value (used for setting parameter)
+  def make_output_available(output_name, outputs)
+    bubble_path = outputs[output_name].root_path - root_path
+    drip_path = root_path - outputs[output_name].root_path
+    bubble_path.each_slice(2) do |base_sparkle, ref_sparkle|
+      next unless ref_sparkle
+      base_sparkle.compile.outputs.set!(output_name).set!(:value, base_sparkle.compile.attr!(ref_sparkle.name, "Outputs.#{output_name}"))
+    end
+    if(bubble_path.empty?)
+      raise ArgumentError.new "Failed to detect available bubbling path for output `#{output_name}`. This may be due to a circular dependency!"
+    end
+    result = compile.attr!(bubble_path.first.name, "Outputs.#{output_name}")
+    if(drip_path.size > 1)
+      parent = drip_path.first.parent
+      drip_path.unshift(parent) if parent
+      drip_path.each_slice(2) do |base_sparkle, ref_sparkle|
+        next unless ref_sparkle
+        base_sparkle.compile.resources[ref_sparkle.name].properties.parameters.set!(output_name, result)
+        ref_sparkle.compile.parameters.set!(output_name){ type 'String' } # TODO <<<<------ type check and prop
+        result = compile.ref!(output_name)
       end
     end
-    if(args.include?(:collect_outputs))
+    result
+  end
+
+  # Extract and process nested stacks
+  #
+  # @yieldparam stack [SparkleFormation] stack instance
+  # @yieldparam resource [AttributeStruct] the stack resource
+  # @yieldparam s_name [String] stack resource name
+  # @yieldreturn [Hash] key/values to be merged into resource properties
+  def extract_templates(&block)
+    stack_template_extractor(nested_stacks(:with_resource, :with_name), &block)
+  end
+
+  # Run the stack extraction
+  #
+  # @param x_stacks [Array<Array<SparkleFormation, SparkleStruct, String>>]
+  def stack_template_extractor(x_stacks, &block)
+    x_stacks.each do |stack, resource, s_name|
+      unless(stack.nested_stacks.empty?)
+        stack_template_extractor(stack.nested_stacks(:with_resource, :with_name), &block)
+      end
+      resource.properties.set!(:stack, stack.compile.dump!)
+      block.call(s_name, stack, resource)
+    end
+  end
+
+  # Apply shallow nesting. This style of nesting will bubble
+  # parameters up to the root stack. This type of nesting is the
+  # original and now deprecated, but remains for compat issues so any
+  # existing usage won't be automatically busted.
+  #
+  # @yieldparam resource_name [String] name of stack resource
+  # @yieldparam stack [SparkleFormation] nested stack
+  # @yieldreturn [String] Remote URL storage for template
+  # @return [Hash]
+  def apply_shallow_nesting(*args, &block)
+    parameters = compile[:parameters] ? compile[:parameters]._dump : {}
+    output_map = {}
+    nested_stacks(:with_resource, :with_name).each do |stack, stack_resource, stack_name|
+      remap_nested_parameters(compile, parameters, stack_name, stack_resource, output_map)
+    end
+    extract_templates(&block)
+    compile.parameters parameters
+    if(args.include?(:bubble_outputs))
       outputs_hash = Hash[
         output_map do |name, value|
           [name, {'Value' => {'Fn::GetAtt' => value}}]
         end
       ]
-      if(hash['Outputs'])
-        hash['Outputs'].merge!(outputs_hash)
+      if(compile.outputs)
+        compile._merge(SparkleStruct.new(outputs_hash))
+      else
+        compile.outputs output_hash
+      end
+    end
+    compile.dump!
+  end
+
+  # @return [Smash<output_name:SparkleFormation>]
+  def collect_outputs(*args)
+    if(args.include?(:force) || root?)
+      if(compile.outputs)
+        outputs = Smash[
+          compile.outputs.keys!.zip(
+            [self] * compile.outputs.keys!.size
+          )
+        ]
       else
-        hash['Outputs'] = outputs_hash
+        outputs = Smash.new
       end
+      nested_stacks.each do |nested_stack|
+        outputs = nested_stack.collect_outputs(:force).merge(outputs)
+      end
+      outputs
+    else
+      root.collect_outputs(:force)
     end
-    hash
   end
 
   # Extract parameters from nested stacks. Check for previous nested
@@ -571,10 +702,9 @@ class SparkleFormation
   # @note if parameter has includes `StackUnique` a new parameter will
   #   be added to container stack and it will not use outputs
   def remap_nested_parameters(template, parameters, stack_name, stack_resource, output_map)
-    stack_parameters = stack_resource['Properties']['Stack']['Parameters']
-    if(stack_parameters)
-      template['Resources'][stack_name]['Properties']['Parameters'] ||= {}
-      stack_parameters.each do |pname, pval|
+    stack_parameters = stack_resource.properties.stack.compile.parameters
+    unless(stack_parameters.nil?)
+      stack_parameters._dump.each do |pname, pval|
         if(pval['StackUnique'])
           check_name = [stack_name, pname].join
         else
@@ -586,24 +716,22 @@ class SparkleFormation
           else
             new_val = {'Ref' => check_name}
           end
-          template['Resources'][stack_name]['Properties']['Parameters'][pname] = new_val
+          template.resources.set!(stack_name).properties.parameters.set!(pname, new_val)
         elsif(output_map[check_name])
-          template['Resources'][stack_name]['Properties']['Parameters'][pname] = {
-            'Fn::GetAtt' => output_map[check_name]
-          }
+          template.resources.set!(stack_name).properties.parameters.set!(pname, 'Fn::GetAtt' => output_map[check_name])
         else
           if(pval['Type'] == 'CommaDelimitedList')
             new_val = {'Fn::Join' => [',', {'Ref' => check_name}]}
           else
             new_val = {'Ref' => check_name}
           end
-          template['Resources'][stack_name]['Properties']['Parameters'][pname] = new_val
+          template.resources.set!(stack_name).properties.parameters.set!(pname, new_val)
           parameters[check_name] = pval
         end
       end
     end
-    if(stack_resource['Properties']['Stack']['Outputs'])
-      stack_resource['Properties']['Stack']['Outputs'].keys.each do |oname|
+    unless(stack_resource.properties.stack.compile.outputs.nil?)
+      stack_resource.properties.stack.compile.outputs.keys!.each do |oname|
         output_map[oname] = [stack_name, "Outputs.#{oname}"]
       end
     end
@@ -616,8 +744,8 @@ class SparkleFormation
   end
 
   # @return [String] dumped hash JSON
-  def to_json
-    MultiJson.dump(compile.dump!)
+  def to_json(*args)
+    MultiJson.dump(compile.dump!, *args)
   end
 
 end