sparkle_formation 3.0.26 → 3.0.28

data/lib/sparkle_formation/sparkle_formation.rb

@@ -2,7 +2,6 @@ require 'sparkle_formation'
 
 # Formation container
 class SparkleFormation
-
   include SparkleFormation::Utils::AnimalStrings
   # @!parse include SparkleFormation::Utils::AnimalStrings
   extend SparkleFormation::Utils::AnimalStrings
@@ -12,7 +11,7 @@ class SparkleFormation
   IGNORE_DIRECTORIES = [
     'components',
     'dynamics',
-    'registry'
+    'registry',
   ]
 
   # @return [String] default stack resource name
@@ -21,7 +20,6 @@ class SparkleFormation
   VALID_STACK_RESOURCES = [DEFAULT_STACK_RESOURCE]
 
   class << self
-
     include SparkleFormation::Utils::TypeCheckers
 
     # @return [Hashish] loaded dynamics
@@ -39,8 +37,8 @@ class SparkleFormation
     #
     # @param path [String] path to directory
     # @return [String] path to directory
-    def sparkle_path=(path=nil)
-      if(path)
+    def sparkle_path=(path = nil)
+      if path
         custom_paths[:sparkle_path] = path
         custom_paths[:components_directory] = File.join(path, 'components')
         custom_paths[:dynamics_directory] = File.join(path, 'dynamics')
@@ -48,42 +46,46 @@ class SparkleFormation
       end
       custom_paths[:sparkle_path]
     end
+
     alias_method(:sparkle_path, :sparkle_path=)
 
     # Get/set path to component files
     #
     # @param path [String] path to component files
     # @return [String] path to component files
-    def components_path=(path=nil)
-      if(path)
+    def components_path=(path = nil)
+      if path
         custom_paths[:components_directory] = path
       end
       custom_paths[:components_directory]
     end
+
     alias_method(:components_path, :components_path=)
 
     # Get/set path to dynamic files
     #
     # @param path [String] path to dynamic files
     # @return [String] path to dynamic files
-    def dynamics_path=(path=nil)
-      if(path)
+    def dynamics_path=(path = nil)
+      if path
         custom_paths[:dynamics_directory] = path
       end
       custom_paths[:dynamics_directory]
     end
+
     alias_method(:dynamics_path, :dynamics_path=)
 
     # Get/set path to registry files
     #
     # @param path [String] path to registry files
     # @return [String] path to registry files
-    def registry_path=(path=nil)
-      if(path)
+    def registry_path=(path = nil)
+      if path
         custom_paths[:registry_directory] = path
       end
       custom_paths[:registry_directory]
     end
+
     alias_method(:registry_path, :registry_path=)
 
     # Compile file
@@ -93,16 +95,16 @@ class SparkleFormation
     #   to pass through when compiling ({:state => {}})
     # @return [Hashish, SparkleStruct]
     def compile(path, *args)
-      opts = args.detect{|i| i.is_a?(Hash) } || {}
-      unless(path.is_a?(String) && File.file?(path.to_s))
-        if(spath = (opts.delete(:sparkle_path) || SparkleFormation.custom_paths[:sparkle_path]))
+      opts = args.detect { |i| i.is_a?(Hash) } || {}
+      unless path.is_a?(String) && File.file?(path.to_s)
+        if spath = (opts.delete(:sparkle_path) || SparkleFormation.custom_paths[:sparkle_path])
           container = Sparkle.new(:root => spath)
           path = container.get(:template, path)[:path]
         end
       end
       formation = instance_eval(IO.read(path), path, 1)
       formation.template_path = path
-      if(args.delete(:sparkle))
+      if args.delete(:sparkle)
         formation
       else
         formation.compile(opts)._dump
@@ -114,8 +116,8 @@ class SparkleFormation
     # @param base [SparkleStruct] context for block
     # @yield block to execute
     # @return [SparkleStruct] provided base or new struct
-    def build(base=nil, &block)
-      if(base || block.nil?)
+    def build(base = nil, &block)
+      if base || block.nil?
         struct = base || SparkleStruct.new
         struct.instance_exec(&block)
         struct
@@ -171,7 +173,7 @@ class SparkleFormation
     #   :item_name => {:description => 'Defines item name', :type => 'String'}
     # @yield dynamic block
     # @return [TrueClass]
-    def dynamic(name, args={}, &block)
+    def dynamic(name, args = {}, &block)
       @dynamics ||= SparkleStruct.hashish.new
       dynamics[name] = SparkleStruct.hashish[
         :block, block, :args, SparkleStruct.hashish[args.map(&:to_a)]
@@ -184,12 +186,13 @@ class SparkleFormation
     # @param name [String, Symbol] dynamic name
     # @return [Hashish] metadata information
     def dynamic_info(name)
-      if(dynamics[name])
+      if dynamics[name]
         dynamics[name][:args] ||= SparkleStruct.hashish.new
       else
         raise KeyError.new("No dynamic registered with provided name (#{name})")
       end
     end
+
     alias_method :dynamic_information, :dynamic_info
 
     # Insert a dynamic into a context
@@ -200,7 +203,7 @@ class SparkleFormation
     # @return [SparkleStruct]
     def registry(registry_name, struct, *args)
       __t_stringish(registry_name)
-      opts = args.detect{|item| item.is_a?(Hash)} || {}
+      opts = args.detect { |item| item.is_a?(Hash) } || {}
       reg = struct._self.sparkle.get(:registry, registry_name, opts[:provider])
       struct.instance_exec(*args, &reg[:block])
     end
@@ -215,14 +218,14 @@ class SparkleFormation
       __t_stringish(dynamic_name)
       result = false
       begin
-        opts = args.detect{|i| i.is_a?(Hash)} || {}
+        opts = args.detect { |i| i.is_a?(Hash) } || {}
         dyn = struct._self.sparkle.get(:dynamic, dynamic_name, opts[:provider])
         opts = nil
         raise dyn if dyn.is_a?(Exception)
         dyn.monochrome.each do |dynamic_item|
-          if(result)
-            opts = args.detect{|i| i.is_a?(Hash)}
-            if(opts)
+          if result
+            opts = args.detect { |i| i.is_a?(Hash) }
+            if opts
               opts[:previous_layer_result] = result
             else
               args.push(:previous_layer_result => result)
@@ -230,15 +233,15 @@ class SparkleFormation
           end
           result = struct.instance_exec(*args, &dynamic_item[:block])
         end
-        if(block_given?)
+        if block_given?
           result.instance_exec(&block)
         end
       rescue Error::NotFound::Dynamic
         result = builtin_insert(dynamic_name, struct, *args, &block)
-        unless(result)
+        unless result
           message = "Failed to locate requested dynamic block for insertion: #{dynamic_name} " \
-            "(valid: #{struct._self.sparkle.dynamics.fetch(struct._self.sparkle.provider, {}).keys.sort.join(', ')})"
-          if(struct._self.provider_resources && struct._self.provider_resources.registry.keys.size > 1)
+          "(valid: #{struct._self.sparkle.dynamics.fetch(struct._self.sparkle.provider, {}).keys.sort.join(', ')})"
+          if struct._self.provider_resources && struct._self.provider_resources.registry.keys.size > 1
             t_name = struct._self.provider_resources.registry.keys.first
             valid_t_name = Bogo::Utility.snake(
               t_name.split(
@@ -262,8 +265,8 @@ 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)
+      options = args.detect { |i| i.is_a?(Hash) }
+      if options
         args.delete(options)
       else
         options = {}
@@ -273,20 +276,20 @@ class SparkleFormation
       end
       to_nest = struct._self.sparkle.get(:template, template, options[:provider])
       resource_name = template.to_s.gsub('__', '_')
-      unless(args.empty?)
+      unless args.empty?
         resource_name = [
           options.delete(:overwrite_name) ? nil : resource_name,
-          args.map{|a| Bogo::Utility.snake(a)}.join('_')
+          args.map { |a| Bogo::Utility.snake(a) }.join('_'),
         ].flatten.compact.join('_').to_sym
       end
       resource_name = struct._process_key(resource_name.to_sym)
       nested_template = compile(to_nest[:path], :sparkle)
       nested_template.parent = struct._self
       nested_template.name = resource_name
-      if(options[:parameters])
+      if options[:parameters]
         nested_template.compile_state = options[:parameters]
       end
-      unless(struct._self.sparkle.empty?)
+      unless struct._self.sparkle.empty?
         nested_template.sparkle.apply(struct._self.sparkle)
       end
       nested_resource = struct.dynamic!(
@@ -306,15 +309,15 @@ class SparkleFormation
     # @param args [Object] parameters for dynamic
     # @return [SparkleStruct]
     def builtin_insert(dynamic_name, struct, *args, &block)
-      if(struct._self.provider_resources && lookup_key = struct._self.provider_resources.registry_key(dynamic_name))
+      if struct._self.provider_resources && lookup_key = struct._self.provider_resources.registry_key(dynamic_name)
         _name, _config = *args
         _config ||= {}
         __t_hashish(_config)
-        unless(_name.is_a?(SparkleFormation::FunctionStruct))
+        unless _name.is_a?(SparkleFormation::FunctionStruct)
           __t_stringish(_name)
           resource_name = [
             _name,
-            _config.fetch(:resource_name_suffix, dynamic_name)
+            _config.fetch(:resource_name_suffix, dynamic_name),
           ].compact.join('_').to_sym
         else
           resource_name = _name._root
@@ -323,12 +326,12 @@ class SparkleFormation
         new_resource = struct.resources.set!(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('_', '')})
+        config_keys = _config.keys.zip(_config.keys.map { |k| snake(k).to_s.tr('_', '') })
         struct._self.provider_resources.resource(dynamic_name, :properties).each do |prop_name|
-          key = (config_keys.detect{|k| k.last == snake(prop_name).to_s.tr('_', '')} || []).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))
+          if value
+            if value.is_a?(Proc)
               properties.set!(prop_name, &value)
             else
               properties.set!(prop_name, value)
@@ -399,26 +402,25 @@ class SparkleFormation
   # @option options [Hash] :parameters parameters for stack generation
   # @option options [Truthy, Falsey] :disable_aws_builtins do not load builtins
   # @yield base context
-  def initialize(name, options={}, &base_block)
+  def initialize(name, options = {}, &base_block)
     @name = name.to_sym
     @component_paths = []
-    if(options[:sparkle_collection])
+    if options[:sparkle_collection]
       @sparkle = options[:sparkle_collection]
-      if(options[:sparkle])
+      if options[:sparkle]
         @sparkle.add_sparkle(options[:sparkle])
       end
     else
       @sparkle = SparkleCollection.new
-      if(options[:sparkle])
+      if options[:sparkle]
         @sparkle.set_root(options[:sparkle])
       else
         @sparkle.set_root(
           Sparkle.new(
-            Smash.new.tap{|h|
+            Smash.new.tap { |h|
               s_path = options.fetch(:sparkle_path,
-                self.class.custom_paths[:sparkle_path]
-              )
-              if(s_path)
+                                     self.class.custom_paths[:sparkle_path])
+              if s_path
                 h[:root] = s_path
               else
                 h[:root] = :none
@@ -429,26 +431,25 @@ class SparkleFormation
       end
     end
     self.provider = options.fetch(:provider, @parent ? @parent.provider : :aws)
-    if(provider == :aws || !options[:disable_aws_builtins])
+    if provider == :aws || !options[:disable_aws_builtins]
       require 'sparkle_formation/aws'
     end
     @parameters = set_generation_parameters!(
       options.fetch(:compile_time_parameters,
-        options.fetch(:parameters, {})
-      )
+                    options.fetch(:parameters, {}))
     )
     @stack_resource_types = [
       stack_resource_type,
-      *options.fetch(:stack_resource_types, [])
+      *options.fetch(:stack_resource_types, []),
     ].compact.uniq
     @blacklisted_templates = [name]
     @composition = Composition.new(self)
     @parent = options[:parent]
     @seed = Smash.new(
       :inherit => options[:inherit],
-      :layering => options[:layering]
+      :layering => options[:layering],
     )
-    if(base_block)
+    if base_block
       load_block(base_block)
     end
     @compiled = nil
@@ -462,12 +463,12 @@ class SparkleFormation
   def seed_self
     memoize(:seed) do
       options = @seed
-      if(options[:inherit] && options[:layering].to_s == 'merge')
+      if options[:inherit] && options[:layering].to_s == 'merge'
         raise ArgumentError.new 'Cannot merge and inherit!'
       end
-      if(options[:inherit])
+      if options[:inherit]
         inherit_from(options[:inherit])
-      elsif(options[:layering].to_s == 'merge')
+      elsif options[:layering].to_s == 'merge'
         merge_previous!
       end
       true
@@ -491,7 +492,7 @@ class SparkleFormation
   # @param template_name [String] name of template to inherit
   # @return [self]
   def inherit_from(template_name)
-    if(blacklisted_templates.map(&:to_s).include?(template_name.to_s))
+    if blacklisted_templates.map(&:to_s).include?(template_name.to_s)
       raise Error::CircularInheritance.new "Circular inheritance detected between templates `#{template_name}` and `#{name}`" # rubocop:disable Metrics/LineLength
     end
     template = self.class.compile(sparkle.get(:template, template_name)[:path], :sparkle)
@@ -507,7 +508,7 @@ class SparkleFormation
   # @return [self]
   def extract_template_data(template)
     # TODO: Should allow forced override here for cases like: openstack -> rackspace
-    if(provider != template.provider)
+    if provider != template.provider
       raise TypeError.new "This template `#{name}` cannot inherit template `#{template.name}`! Provider mismatch: `#{provider}` != `#{template.provider}`" # rubocop:disable Metrics/LineLength
     end
     template.sparkle.apply(sparkle)
@@ -517,15 +518,14 @@ class SparkleFormation
     )
     @parameters = template.parameters.to_smash.deep_merge(parameters.to_smash)
     new_composition = Composition.new(self,
-      :components => template.composition.composite,
-      :overrides => composition.overrides
-    )
+                                      :components => template.composition.composite,
+                                      :overrides => composition.overrides)
     composition.components.each do |item|
-      if(item.respond_to?(:key) && item.key == '__base__')
+      if item.respond_to?(:key) && item.key == '__base__'
         item.key = Smash.new(
           :template => name,
           :component => :__base__,
-          :object_id => object_id
+          :object_id => object_id,
         ).checksum.to_s
       end
       new_composition.add_component(item)
@@ -546,10 +546,10 @@ class SparkleFormation
   # @param val [String, Symbol, NilClass, FalseClass] remote provider
   # @return [Symbol, NilClass]
   def provider=(val)
-    if(val)
+    if val
       @provider = Bogo::Utility.snake(val).to_sym
       provider_klass = Bogo::Utility.camel(@provider.to_s)
-      if(Provider.const_defined?(provider_klass))
+      if Provider.const_defined?(provider_klass)
         extend Provider.const_get(provider_klass)
       end
       sparkle.provider = val
@@ -569,7 +569,7 @@ class SparkleFormation
 
   # @return [SparkleFormation] root stack
   def root
-    if(parent)
+    if parent
       parent.root
     else
       self
@@ -578,7 +578,7 @@ class SparkleFormation
 
   # @return [Array<SparkleFormation] path to root
   def root_path
-    if(parent)
+    if parent
       [*parent.root_path, self].compact
     else
       [self]
@@ -594,7 +594,7 @@ class SparkleFormation
   ALLOWED_GENERATION_PARAMETERS = [
     'type', 'default', 'description', 'multiple', 'prompt_when_nested',
     'allowed_values', 'allowed_pattern', 'max_length', 'min_length',
-    'max_value', 'min_value'
+    'max_value', 'min_value',
   ]
   # Allowed data types for parameters
   VALID_GENERATION_PARAMETER_TYPES = ['String', 'Number', 'Complex']
@@ -606,10 +606,10 @@ class SparkleFormation
   # @yieldparam [SparkleFormation]
   # @return [Proc, NilClass]
   def compile_time_parameter_setter(&block)
-    if(block)
+    if block
       @compile_time_parameter_setter = block
     else
-      if(@compile_time_parameter_setter)
+      if @compile_time_parameter_setter
         @compile_time_parameter_setter
       else
         parent.nil? ? nil : parent.compile_time_parameter_setter
@@ -620,7 +620,7 @@ class SparkleFormation
   # Set the compile time parameters for the stack if the setter proc
   # is available
   def set_compile_time_parameters!
-    if(compile_time_parameter_setter)
+    if compile_time_parameter_setter
       compile_time_parameter_setter.call(self)
     end
   end
@@ -633,10 +633,10 @@ class SparkleFormation
   # @raises [ArgumentError]
   def set_generation_parameters!(params)
     params.each do |name, value|
-      unless(value.is_a?(Hash))
+      unless value.is_a?(Hash)
         raise TypeError.new("Expecting `Hash` type. Received `#{value.class}`")
       end
-      if(key = value.keys.detect{|k| !ALLOWED_GENERATION_PARAMETERS.include?(k.to_s) })
+      if key = value.keys.detect { |k| !ALLOWED_GENERATION_PARAMETERS.include?(k.to_s) }
         raise ArgumentError.new("Invalid generation parameter key provided `#{key}`")
       end
     end
@@ -651,6 +651,7 @@ class SparkleFormation
     composition.new_component(:__base__, &block)
     true
   end
+
   alias_method :load_block, :block
 
   # Load components into instance
@@ -659,7 +660,7 @@ class SparkleFormation
   # @return [self]
   def load(*args, &user_block)
     args.each do |thing|
-      if(thing.is_a?(String))
+      if thing.is_a?(String)
         # NOTE: This needs to be deprecated and removed
         # TODO: deprecate
         key = File.basename(thing.to_s).sub('.rb', '')
@@ -668,7 +669,7 @@ class SparkleFormation
         composition.new_component(thing)
       end
     end
-    if(block_given?)
+    if block_given?
       block(user_block)
     end
     self
@@ -678,7 +679,7 @@ class SparkleFormation
   #
   # @param args [Hash] optional arguments to provide state
   # @yield override block
-  def overrides(args={}, &block)
+  def overrides(args = {}, &block)
     composition.new_override(args, &block)
     self
   end
@@ -688,8 +689,8 @@ class SparkleFormation
   # @param args [Hash]
   # @option args [Hash] :state local state parameters
   # @return [SparkleStruct]
-  def compile(args={})
-    if(args.key?(:state) && args.is_a?(Hash))
+  def compile(args = {})
+    if args.key?(:state) && args.is_a?(Hash)
       @compile_state = args[:state].to_smash
       unmemoize(:compile)
     end
@@ -698,34 +699,34 @@ class SparkleFormation
       seed_self
 
       set_compile_time_parameters!
-      if(provider && SparkleStruct.const_defined?(camel(provider)))
+      if provider && SparkleStruct.const_defined?(camel(provider))
         struct_class = SparkleStruct.const_get(camel(provider))
         struct_name = [SparkleStruct.name, camel(provider)].join('::')
-        struct_class.define_singleton_method(:name){ struct_name }
-        struct_class.define_singleton_method(:to_s){ struct_name }
+        struct_class.define_singleton_method(:name) { struct_name }
+        struct_class.define_singleton_method(:to_s) { struct_name }
       else
         struct_class = SparkleStruct
       end
-      if(Resources.const_defined?(camel(provider)))
+      if Resources.const_defined?(camel(provider))
         @provider_resources = Resources.const_get(camel(provider))
         provider_resources.load!
       end
       compiled = struct_class.new
       compiled._set_self(self)
       compiled._struct_class = struct_class
-      if(struct_class.const_defined?(:CAMEL_KEYS))
+      if struct_class.const_defined?(:CAMEL_KEYS)
         compiled._camel_keys = struct_class.const_get(:CAMEL_KEYS)
       end
-      if(struct_class.const_defined?(:CAMEL_STYLE))
+      if struct_class.const_defined?(:CAMEL_STYLE)
         compiled._camel_style = struct_class.const_get(:CAMEL_STYLE)
       end
-      if(compile_state)
+      if compile_state
         compiled.set_state!(compile_state)
       end
       composition.each do |item|
         case item
         when Composition::Component
-          if(item.block)
+          if item.block
             self.class.build(compiled, &item.block)
           else
             sparkle.get(:component, item.key).monochrome.each do |component_block|
@@ -733,13 +734,13 @@ class SparkleFormation
             end
           end
         when Composition::Override
-          if(item.args && !item.args.empty?)
+          if item.args && !item.args.empty?
             compiled._set_state(item.args)
           end
           self.class.build(compiled, &item.block)
         end
       end
-      if(compile_state && !compile_state.empty?)
+      if compile_state && !compile_state.empty?
         set_compiled_state(compiled)
       end
       compiled
@@ -754,11 +755,11 @@ class SparkleFormation
   def set_compiled_state(compiled)
     storage_compile_state = Smash.new
     parameters.each do |param_key, param_config|
-      if(param_config.fetch(:type, 'string').to_s.downcase.to_sym != :complex)
+      if param_config.fetch(:type, 'string').to_s.downcase.to_sym != :complex
         storage_compile_state[param_key] = compile_state[param_key]
       end
     end
-    unless(storage_compile_state.empty?)
+    unless storage_compile_state.empty?
       compiled.outputs.compile_state.value MultiJson.dump(storage_compile_state)
     end
     compiled
@@ -774,15 +775,15 @@ class SparkleFormation
 
   # @return [Array<SparkleFormation>]
   def nested_stacks(*args)
-    if(compile[:resources])
+    if compile[:resources]
       compile.resources.keys!.map do |key|
-        if(stack_resource_type?(compile.resources[key].type))
-          if(!compile.resources[key].properties.stack.nil?)
+        if stack_resource_type?(compile.resources[key].type)
+          if !compile.resources[key].properties.stack.nil?
             result = [compile.resources[key].properties.stack]
-            if(args.include?(:with_resource))
+            if args.include?(:with_resource)
               result.push(compile[:resources][key])
             end
-            if(args.include?(:with_name))
+            if args.include?(:with_name)
               result.push(key)
             end
             result.size == 1 ? result.first : result
@@ -795,11 +796,11 @@ class SparkleFormation
   end
 
   # @return [TrueClass, FalseClass] includes nested stacks
-  def nested?(stack_hash=nil)
-    if(stack_hash)
+  def nested?(stack_hash = nil)
+    if stack_hash
       raise Error::Deprecated.new "Hash parameter no longer valid for this method (`#{self.class}##{__callee__}`)"
     end
-    unless(compile.resources.nil?)
+    unless compile.resources.nil?
       compile.resources._data.any? do |r_name, r_value|
         stack_resource_type?(r_value.type)
       end
@@ -807,11 +808,11 @@ class SparkleFormation
   end
 
   # @return [TrueClass, FalseClass] includes _only_ nested stacks
-  def isolated_nests?(stack_hash=nil)
-    if(stack_hash)
+  def isolated_nests?(stack_hash = nil)
+    if stack_hash
       raise Error::Deprecated.new "Hash parameter no longer valid for this method (`#{self.class}##{__callee__}`)"
     end
-    unless(compile.resources.nil?)
+    unless compile.resources.nil?
       compile.resources._data.all? do |r_name, r_value|
         stack_resource_type?(r_value.type)
       end
@@ -819,11 +820,11 @@ class SparkleFormation
   end
 
   # @return [TrueClass, FalseClass] policies defined
-  def includes_policies?(stack_hash=nil)
-    if(stack_hash)
+  def includes_policies?(stack_hash = nil)
+    if stack_hash
       raise Error::Deprecated.new "Hash parameter no longer valid for this method (`#{self.class}##{__callee__}`)"
     end
-    unless(compile.resources.nil?)
+    unless compile.resources.nil?
       compile.resources._data.any? do |r_name, r_value|
         !r_value.policy.nil?
       end
@@ -843,7 +844,7 @@ class SparkleFormation
   # @return [SparkleFormation::SparkleStruct] compiled structure
   # @note see specific version for expected block parameters
   def apply_nesting(*args, &block)
-    if(args.include?(:shallow))
+    if args.include?(:shallow)
       apply_shallow_nesting(&block)
     else
       apply_deep_nesting(&block)
@@ -901,7 +902,7 @@ class SparkleFormation
   # @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?)
+      unless stack.nested_stacks.empty?
         stack_template_extractor(stack.nested_stacks(:with_resource, :with_name), &block)
       end
       resource.properties._delete(:stack)
@@ -927,8 +928,8 @@ class SparkleFormation
 
   # @return [Smash<output_name:SparkleFormation>]
   def collect_outputs(*args)
-    if(args.include?(:force) || root?)
-      if(!compile.outputs.nil? && !root?)
+    if args.include?(:force) || root?
+      if !compile.outputs.nil? && !root?
         outputs = Smash[
           compile.outputs.keys!.zip(
             [self] * compile.outputs.keys!.size
@@ -938,7 +939,11 @@ class SparkleFormation
         outputs = Smash.new
       end
       nested_stacks.each do |nested_stack|
-        n_stack = nested_stack.is_a?(self.class) ? nested_stack : nested_stack._self
+        if nested_stack.is_a?(self.class) === true
+          n_stack = nested_stack
+        else
+          n_stack = nested_stack._self
+        end
         outputs = n_stack.collect_outputs(:force).merge(outputs)
       end
       outputs
@@ -989,5 +994,4 @@ class SparkleFormation
     end
     MultiJson.dump(compile.dump!, *args)
   end
-
 end