sfn 3.0.28 → 3.0.30

data/lib/sfn/command_module/base.rb

@@ -22,11 +22,11 @@ module Sfn
         #
         # @param location [Symbol, String] name of location
         # @return [Sfn::Provider]
-        def provider_for(location=nil)
+        def provider_for(location = nil)
           key = ['provider', location].compact.map(&:to_s).join('_')
-          if(location)
+          if location
             credentials = config.get(:locations, location)
-            unless(credentials)
+            unless credentials
               raise ArgumentError.new "Failed to locate provider credentials for location `#{location}`!"
             end
           else
@@ -37,18 +37,15 @@ module Sfn
               result = Sfn::Provider.new(
                 :miasma => credentials,
                 :async => false,
-                :fetch => false
+                :fetch => false,
               )
-              result.connection.data[:stack_types] = (
-                [
-                  (result.connection.class.const_get(:RESOURCE_MAPPING).detect do |klass, info|
-                    info[:api] == :orchestration
-                  end || []).first
-                ] + custom_stack_types
-              ).compact.uniq
+              result.connection.data[:stack_types] = ([
+                (result.connection.class.const_get(:RESOURCE_MAPPING).detect do |klass, info|
+                  info[:api] == :orchestration
+                end || []).first,
+              ] + custom_stack_types).compact.uniq
               retry_config = config.fetch(:retry,
-                config.fetch(:retries, {})
-              )
+                                          config.fetch(:retries, {}))
               result.connection.data[:retry_ui] = ui
               result.connection.data[:location] = location.to_s
               result.connection.data[:locations] = config.fetch(:locations, {})
@@ -63,19 +60,19 @@ module Sfn
             raise
           end
         end
-        alias_method :provider, :provider_for
 
+        alias_method :provider, :provider_for
 
         # Write exception information if debug is enabled
         #
         # @param e [Exception]
         # @param args [String] extra strings to output
         def _debug(e, *args)
-          if(config[:verbose] || config[:debug])
+          if config[:verbose] || config[:debug]
             ui.fatal "Exception information: #{e.class}: #{e.message}"
-            if(ENV['DEBUG'] || config[:debug])
+            if ENV['DEBUG'] || config[:debug]
               puts "#{e.backtrace.join("\n")}\n"
-              if(e.is_a?(Miasma::Error::ApiError))
+              if e.is_a?(Miasma::Error::ApiError)
                 ui.fatal "Response body: #{e.response.body.to_s.inspect}"
               end
             end
@@ -97,7 +94,7 @@ module Sfn
         #
         # @param name [String] name of stack
         # @return [Miasma::Models::Orchestration::Stack]
-        def stack(name=nil)
+        def stack(name = nil)
           name = name_args.first unless name
           provider.stacks.get(name)
         end
@@ -136,7 +133,7 @@ module Sfn
         # @param message [String] failure message
         # @yield block to wrap error handling
         # @return [Object] result of yield
-        def get_things(stack=nil, message=nil)
+        def get_things(stack = nil, message = nil)
           begin
             yield
           rescue => e
@@ -174,18 +171,16 @@ module Sfn
         # @return [NilClass]
         # @raise [ArgumentError]
         def name_required!
-          if(name_args.empty?)
+          if name_args.empty?
             ui.error 'Name argument must be provided!'
             raise ArgumentError.new 'Missing required name argument'
           end
         end
-
       end
 
       class << self
         def included(klass)
           klass.instance_eval do
-
             include Sfn::CommandModule::Base::InstanceMethods
             include Sfn::CommandModule::Callbacks
             include Sfn::Utils::JSON
@@ -193,12 +188,9 @@ module Sfn
             include Bogo::AnimalStrings
             include Bogo::Memoization
             include Bogo::Constants
-
           end
-
         end
       end
     end
-
   end
 end

data/lib/sfn/command_module/callbacks.rb

@@ -5,7 +5,6 @@ module Sfn
   module CommandModule
     # Callback processor helpers
     module Callbacks
-
       include Bogo::Memoization
 
       # Run expected callbacks around action
@@ -16,9 +15,15 @@ module Sfn
       def api_action!(*args)
         type = self.class.name.split('::').last.downcase
         run_callbacks_for(["before_#{type}", :before], *args)
-        result = yield if block_given?
-        run_callbacks_for(["after_#{type}", :after], *args)
-        result
+        result = nil
+        begin
+          result = yield if block_given?
+          run_callbacks_for(["after_#{type}", :after], *args)
+          result
+        rescue => err
+          run_callbacks_for(["failed_#{type}", :failed], *(args + [err]))
+          raise
+        end
       end
 
       # Process requested callbacks
@@ -34,7 +39,7 @@ module Sfn
           callback_name, callback, quiet = item
           quiet = true if config[:print_only]
           ui.info "Callback #{ui.color(type.to_s, :bold)} #{callback_name}: #{ui.color('starting', :yellow)}" unless quiet
-          if(args.empty?)
+          if args.empty?
             callback.call
           else
             callback.call(*args)
@@ -57,15 +62,14 @@ module Sfn
               klass.new(ui, config, arguments, provider)
             rescue NameError => e
               ui.debug "Callback type lookup error: #{e.class} - #{e}"
-              raise "Unknown #{type} callback requested: #{c_name} (not found)"
+              raise NameError.new("Unknown #{type} callback requested: #{c_name} (not found)")
             end
           end
-          if(instance.respond_to?(type))
+          if instance.respond_to?(type)
             [c_name, instance.method(type), instance.respond_to?(:quiet) ? instance.quiet : false]
           end
         end.compact
       end
-
     end
   end
 end

data/lib/sfn/command_module/stack.rb

@@ -5,7 +5,6 @@ module Sfn
   module CommandModule
     # Stack handling helper methods
     module Stack
-
       module InstanceMethods
 
         # maximum number of attempts to get valid parameter value
@@ -30,7 +29,7 @@ module Sfn
             stack_info.unshift(nil) if stack_info.size == 1
             stack_location, stack_name = stack_info
             remote_stack = provider_for(stack_location).stack(stack_name)
-            if(remote_stack)
+            if remote_stack
               apply_nested_stacks!(remote_stack, stack)
               mappings = generate_custom_apply_mappings(remote_stack)
               execute_apply_stack(remote_stack, stack, mappings)
@@ -49,7 +48,7 @@ module Sfn
         # @return [Miasma::Models::Orchestration::Stack]
         def apply_nested_stacks!(remote_stack, stack)
           remote_stack.resources.all.each do |resource|
-            if(valid_stack_types.include?(resource.type))
+            if valid_stack_types.include?(resource.type)
               nested_stack = resource.expand
               apply_nested_stacks!(nested_stack, stack)
               mappings = generate_custom_apply_mappings(nested_stack)
@@ -64,7 +63,7 @@ module Sfn
         # @param provider_stack [Miasma::Models::Orchestration::Stack] stack providing outputs
         # @return [Hash] output to parameter mapping
         def generate_custom_apply_mappings(provider_stack)
-          if(config[:apply_mapping])
+          if config[:apply_mapping]
             valid_keys = config[:apply_mapping].keys.find_all do |a_key|
               a_key = a_key.to_s
               key_parts = a_key.split('__')
@@ -81,7 +80,7 @@ module Sfn
               end
             end
             to_remove = valid_keys.find_all do |key|
-              valid_keys.any?{|v_key| v_key.match(/__#{Regexp.escape(key)}$/)}
+              valid_keys.any? { |v_key| v_key.match(/__#{Regexp.escape(key)}$/) }
             end
             valid_keys -= to_remove
             Hash[
@@ -130,15 +129,14 @@ module Sfn
 
         # Format config defined parameters to ensure expected layout
         def format_config_parameters!
-          if(config.get(:parameter).is_a?(Array))
+          if config.get(:parameter).is_a?(Array)
             config[:parameter] = Smash[
               *config.get(:parameter).map(&:to_a).flatten
             ]
           end
-          if(config.get(:parameters))
+          if config.get(:parameters)
             config.set(:parameters,
-              config.get(:parameters).merge(config.fetch(:parameter, Smash.new))
-            )
+                       config.get(:parameters).merge(config.fetch(:parameter, Smash.new)))
           else
             config.set(:parameters, config.fetch(:parameter, Smash.new))
           end
@@ -151,16 +149,16 @@ module Sfn
         # @return [Array<String>] [expected_template_key, configuration_used_key]
         def locate_config_parameter_key(parameter_prefix, parameter_name, root_name)
           check_name = parameter_name.downcase.tr('-_', '')
-          check_prefix = parameter_prefix.map{|i| i.downcase.tr('-_', '') }
+          check_prefix = parameter_prefix.map { |i| i.downcase.tr('-_', '') }
           key_match = config[:parameters].keys.detect do |cp_key|
-            cp_key = cp_key.to_s.downcase.split('__').map{|i| i.tr('-_', '') }.join('__')
+            cp_key = cp_key.to_s.downcase.split('__').map { |i| i.tr('-_', '') }.join('__')
             non_root_matcher = (check_prefix + [check_name]).join('__')
             root_matcher = ([root_name] + check_prefix + [check_name]).join('__')
             cp_key == non_root_matcher ||
               cp_key == root_matcher
           end
           actual_key = (parameter_prefix + [parameter_name]).compact.join('__')
-          if(key_match)
+          if key_match
             ui.debug "Remapping configuration runtime parameter `#{key_match}` -> `#{actual_key}`"
             config[:parameters][actual_key] = config[:parameters].delete(key_match)
           end
@@ -179,23 +177,23 @@ module Sfn
         def set_parameter(sparkle, ns_key, param_name, param_value, current_parameters, param_banner)
           valid = false
           attempt = 0
-          if(!valid && !param_banner)
-            if(sparkle.is_a?(SparkleFormation))
+          if !valid && !param_banner
+            if sparkle.is_a?(SparkleFormation)
               ui.info "#{ui.color('Stack runtime parameters:', :bold)} - template: #{ui.color(sparkle.root_path.map(&:name).map(&:to_s).join(' > '), :green, :bold)}"
             else
               ui.info ui.color('Stack runtime parameters:', :bold)
             end
             param_banner = true
           end
-          until(valid)
+          until valid
             attempt += 1
             default = config[:parameters].fetch(
               ns_key, current_parameters.fetch(
-                param_name, TEMPLATE_PARAMETER_DEFAULTS.map{|loc_key| param_value[loc_key]}.compact.first
+                param_name, TEMPLATE_PARAMETER_DEFAULTS.map { |loc_key| param_value[loc_key] }.compact.first
               )
             )
-            if(config[:interactive_parameters])
-              no_echo = !!TEMPLATE_PARAMETER_NOECHO.detect{|loc_key|
+            if config[:interactive_parameters]
+              no_echo = !!TEMPLATE_PARAMETER_NOECHO.detect { |loc_key|
                 param_value[loc_key].to_s.downcase == 'true'
               }
               sfn_no_echo = TEMPLATE_PARAMETER_SFN_NOECHO.map do |loc_key|
@@ -204,16 +202,16 @@ module Sfn
               end.compact.first
               no_echo = sfn_no_echo if sfn_no_echo
               answer = ui.ask_question(
-                "#{param_name.split(/([A-Z]+[^A-Z]*)/).find_all{|s|!s.empty?}.join(' ')}",
+                "#{param_name.split(/([A-Z]+[^A-Z]*)/).find_all { |s| !s.empty? }.join(' ')}",
                 :default => default,
                 :hide_default => sfn_no_echo == 'all',
-                :no_echo => !!no_echo
+                :no_echo => !!no_echo,
               )
             else
               answer = default
             end
             validation = validate_parameter(answer, param_value)
-            if(validation == true)
+            if validation == true
               config[:parameters][ns_key] = answer
               valid = true
             else
@@ -221,7 +219,7 @@ module Sfn
                 ui.error validation_error.last
               end
             end
-            if(attempt > MAX_PARAMETER_ATTEMPTS)
+            if attempt > MAX_PARAMETER_ATTEMPTS
               ui.fatal 'Failed to receive allowed parameter!'
               exit 1
             end
@@ -236,29 +234,29 @@ module Sfn
         # @option opts [Hash] :current_parameters current stack parameter values
         # @option opts [Miasma::Models::Orchestration::Stack] :stack existing stack
         # @return [Hash]
-        def populate_parameters!(sparkle, opts={})
+        def populate_parameters!(sparkle, opts = {})
           current_parameters = opts[:current_parameters] || {}
           current_stack = opts[:stack]
           parameter_prefix, stack_parameters = prefix_parameters_setup(sparkle)
           sparkle_root_name = sparkle.is_a?(SparkleFormation) ? sparkle.root.name : nil
-          unless(stack_parameters.empty?)
+          unless stack_parameters.empty?
             format_config_parameters!
             param_banner = false
             stack_parameters.each do |param_name, param_value|
               ns_key = locate_config_parameter_key(parameter_prefix, param_name, sparkle_root_name)
               # When parameter is a hash type, it is being set via
               # intrinsic function and we don't modify
-              if(function_set_parameter?(current_parameters[param_name]))
-                if(!config[:parameters][ns_key].nil?)
+              if function_set_parameter?(current_parameters[param_name])
+                if !config[:parameters][ns_key].nil?
                   ui.warn "Overriding mapped parameter value with explicit assignment `#{ns_key}`!"
                 else
-                  if(current_stack)
+                  if current_stack
                     enable_set = validate_stack_parameter(current_stack, param_name, ns_key, current_parameters[param_name])
                   else
                     enable_set = true
                   end
                 end
-                if(enable_set)
+                if enable_set
                   # NOTE: direct set dumps the stack (nfi). Smash will
                   # auto dup it, and works, so yay i guess.
                   config[:parameters][ns_key] = current_parameters[param_name].is_a?(Hash) ?
@@ -267,22 +265,22 @@ module Sfn
                   valid = true
                 end
               else
-                if(current_stack && current_stack.data[:parent_stack])
+                if current_stack && current_stack.data[:parent_stack]
                   use_expected = validate_stack_parameter(current_stack, param_name, ns_key, current_parameters[param_name])
-                  unless(use_expected)
+                  unless use_expected
                     current_parameters[param_name] = current_stack.parameters[param_name]
                   end
                 end
               end
-              unless(valid)
+              unless valid
                 param_banner = set_parameter(sparkle, ns_key, param_name, param_value, current_parameters, param_banner)
               end
             end
           end
           Smash[
-            config.fetch(:parameters, {}).map do |k,v|
+            config.fetch(:parameters, {}).map do |k, v|
               strip_key = parameter_prefix ? k.sub(/#{parameter_prefix.join('__')}_{2}?/, '') : k
-              unless(strip_key.include?('__'))
+              unless strip_key.include?('__')
                 [strip_key, v]
               end
             end.compact
@@ -300,7 +298,7 @@ module Sfn
         # @return [Hash] parameters for root stack create/update
         def config_root_parameters
           Hash[
-            config.fetch(:parameters, {}).find_all do |k,v|
+            config.fetch(:parameters, {}).find_all do |k, v|
               !k.include?('__')
             end
           ]
@@ -320,19 +318,19 @@ module Sfn
         def validate_stack_parameter(c_stack, p_key, p_ns_key, c_value)
           stack_value = c_stack.parameters[p_key]
           p_stack = c_stack.data[:parent_stack]
-          unless(config[:parameter_validation] == 'none')
-            if(c_value.is_a?(Hash))
+          unless config[:parameter_validation] == 'none'
+            if c_value.is_a?(Hash)
               case c_value.keys.first
               when 'Ref'
                 current_value = p_stack.parameters[c_value.values.first]
               when 'Fn::Att'
                 resource_name, output_name = c_value.values.first.split('.', 2)
-                ref_stack = p_stack.nested_stacks.detect{|i| i.data[:logical_id] == resource_name}
-                if(ref_stack)
+                ref_stack = p_stack.nested_stacks.detect { |i| i.data[:logical_id] == resource_name }
+                if ref_stack
                   output = ref_stack.outputs.detect do |o|
                     o.key == output_name
                   end
-                  if(output)
+                  if output
                     current_value = output.value
                   end
                 end
@@ -340,8 +338,8 @@ module Sfn
             else
               current_value = c_value
             end
-            if(current_value && current_value.to_s != stack_value.to_s)
-              if(config[:parameter_validation] == 'default')
+            if current_value && current_value.to_s != stack_value.to_s
+              if config[:parameter_validation] == 'default'
                 ui.warn 'Nested stack has been altered directly! This update may cause unexpected modifications!'
                 ui.warn "Stack name: #{c_stack.name}. Parameter: #{p_key}. Current value: #{stack_value}. Expected value: #{current_value} (via: #{c_value.inspect})"
                 answer = ui.ask_question("Use current value or expected value for #{p_key} [current/expected]?", :valid => ['current', 'expected'])
@@ -356,7 +354,6 @@ module Sfn
             true
           end
         end
-
       end
 
       module ClassMethods
@@ -372,7 +369,6 @@ module Sfn
           include Utils::StackParameterValidator
         end
       end
-
     end
   end
 end

data/lib/sfn/command_module/template.rb

@@ -22,9 +22,9 @@ module Sfn
         # @param thing [SparkleFormation, Hash]
         # @param scrub [Truthy, Falsey] scrub nested templates
         # @return [Hash]
-        def template_content(thing, scrub=false)
-          if(thing.is_a?(SparkleFormation))
-            if(scrub)
+        def template_content(thing, scrub = false)
+          if thing.is_a?(SparkleFormation)
+            if scrub
               dump_stack_for_storage(thing)
             else
               config[:sparkle_dump] ? thing.sparkle_dump : thing.dump
@@ -45,41 +45,41 @@ module Sfn
         # @option p_config [String, Symbol] :description
         # @option p_config [String, Symbol] :multiple
         # @return [Object]
-        def request_compile_parameter(p_name, p_config, cur_val, nested=false)
+        def request_compile_parameter(p_name, p_config, cur_val, nested = false)
           result = nil
           attempts = 0
           parameter_type = p_config.fetch(:type, 'string').to_s.downcase.to_sym
-          if(parameter_type == :complex)
+          if parameter_type == :complex
             ui.debug "Compile time parameter `#{p_name}` is a complex type. Not requesting value from user."
-            if(cur_val.nil?)
+            if cur_val.nil?
               raise ArgumentError.new "No value provided for `#{p_name}` parameter (Complex data type)"
             else
               cur_val
             end
           else
-            unless(cur_val || p_config[:default].nil?)
+            unless cur_val || p_config[:default].nil?
               cur_val = p_config[:default]
             end
-            if(cur_val.is_a?(Array))
+            if cur_val.is_a?(Array)
               cur_val = cur_val.map(&:to_s).join(',')
             end
-            until(result && (!result.respond_to?(:empty?) || !result.empty?))
+            until result && (!result.respond_to?(:empty?) || !result.empty?)
               attempts += 1
-              if(config[:interactive_parameters] && (!nested || !p_config.key?(:prompt_when_nested) || p_config[:prompt_when_nested] == true))
+              if config[:interactive_parameters] && (!nested || !p_config.key?(:prompt_when_nested) || p_config[:prompt_when_nested] == true)
                 result = ui.ask_question(
                   p_name.to_s.split('_').map(&:capitalize).join,
-                  :default => cur_val.to_s.empty? ? nil : cur_val.to_s
+                  :default => cur_val.to_s.empty? ? nil : cur_val.to_s,
                 )
               else
                 result = cur_val.to_s
               end
               case parameter_type
               when :string
-                if(p_config[:multiple])
+                if p_config[:multiple]
                   result = result.split(',').map(&:strip)
                 end
               when :number
-                if(p_config[:multiple])
+                if p_config[:multiple]
                   result = result.split(',').map(&:strip)
                   new_result = result.map do |item|
                     new_item = item.to_i
@@ -94,14 +94,14 @@ module Sfn
                 raise ArgumentError.new "Unknown compile time parameter type provided: `#{p_config[:type].inspect}` (Parameter: #{p_name})"
               end
               valid = validate_parameter(result, p_config.to_smash)
-              unless(valid == true)
+              unless valid == true
                 result = nil
                 valid.each do |invalid_msg|
                   ui.error invalid_msg.last
                 end
               end
-              if(result.nil? || (result.respond_to?(:empty?) && result.empty?))
-                if(attempts > MAX_PARAMETER_ATTEMPTS)
+              if result.nil? || (result.respond_to?(:empty?) && result.empty?)
+                if attempts > MAX_PARAMETER_ATTEMPTS
                   ui.fatal "Failed to receive allowed parameter! (Parameter: #{p_name})"
                   exit 1
                 end
@@ -135,17 +135,17 @@ module Sfn
         def sparkle_collection
           memoize(:sparkle_collection) do
             collection = SparkleFormation::SparkleCollection.new(
-              :provider => config.fetch(:credentials, :provider, DEFAULT_PROVIDER_NAME)
+              :provider => config.fetch(:credentials, :provider, DEFAULT_PROVIDER_NAME),
             )
             begin
-              if(config[:base_directory])
+              if config[:base_directory]
                 root_pack = SparkleFormation::SparklePack.new(
                   :root => config[:base_directory],
-                  :provider => config.fetch(:credentials, :provider, DEFAULT_PROVIDER_NAME)
+                  :provider => config.fetch(:credentials, :provider, DEFAULT_PROVIDER_NAME),
                 )
               else
                 root_pack = SparkleFormation::SparklePack.new(
-                  :provider => config.fetch(:credentials, :provider, DEFAULT_PROVIDER_NAME)
+                  :provider => config.fetch(:credentials, :provider, DEFAULT_PROVIDER_NAME),
                 )
               end
               collection.set_root(root_pack)
@@ -164,30 +164,30 @@ module Sfn
         # @param args [Symbol] options (:allow_missing)
         # @return [Hash] loaded template
         def load_template_file(*args)
-          c_stack = (args.detect{|i| i.is_a?(Hash)} || {})[:stack]
-          unless(config[:template])
+          c_stack = (args.detect { |i| i.is_a?(Hash) } || {})[:stack]
+          unless config[:template]
             set_paths_and_discover_file!
-            unless(config[:file])
-              unless(args.include?(:allow_missing))
+            unless config[:file]
+              unless args.include?(:allow_missing)
                 ui.fatal "Invalid formation file path provided: #{config[:file]}"
                 raise IOError.new "Failed to locate file: #{config[:file]}"
               end
             end
           end
-          if(config[:template])
+          if config[:template]
             config[:template]
-          elsif(config[:file])
-            if(config[:processing])
+          elsif config[:file]
+            if config[:processing]
               compile_state = merge_compile_time_parameters
               sf = SparkleFormation.compile(config[:file], :sparkle)
-              if(name_args.first)
+              if name_args.first
                 sf.name = name_args.first
               end
               sf.compile_time_parameter_setter do |formation|
                 f_name = formation.root_path.map(&:name).map(&:to_s)
                 pathed_name = f_name.join(' > ')
                 f_name = f_name.join('__')
-                if(formation.root? && compile_state[f_name].nil?)
+                if formation.root? && compile_state[f_name].nil?
                   current_state = compile_state
                 else
                   current_state = compile_state.fetch(f_name, Smash.new)
@@ -196,40 +196,39 @@ module Sfn
                 # NOTE: Prevent nesting stack compile state within stack compile state
                 current_state.delete("#{f_name}__#{f_name}")
 
-                if(formation.compile_state)
+                if formation.compile_state
                   current_state = current_state.merge(formation.compile_state)
                 end
-                unless(formation.parameters.empty?)
+                unless formation.parameters.empty?
                   ui.info "#{ui.color('Compile time parameters:', :bold)} - template: #{ui.color(pathed_name, :green, :bold)}" unless config[:print_only]
-                  formation.parameters.each do |k,v|
+                  formation.parameters.each do |k, v|
                     valid_keys = [
                       "#{f_name}__#{k}",
                       Bogo::Utility.camel("#{f_name}__#{k}").downcase,
                       k,
-                      Bogo::Utility.camel(k).downcase
+                      Bogo::Utility.camel(k).downcase,
                     ]
                     current_value = valid_keys.map do |key|
                       current_state[key]
                     end.compact.first
                     primary_key, secondary_key = ["#{f_name}__#{k}", k]
                     current_state[k] = request_compile_parameter(k, v,
-                      current_value,
-                      !!formation.parent
-                    )
+                                                                 current_value,
+                                                                 !!formation.parent)
                   end
                   formation.compile_state = current_state
                 end
               end
               sf.sparkle.apply sparkle_collection
               custom_stack_types.each do |s_type|
-                unless(sf.stack_resource_types.include?(s_type))
+                unless sf.stack_resource_types.include?(s_type)
                   sf.stack_resource_types.push(s_type)
                 end
               end
               run_callbacks_for(:template, :stack_name => arguments.first, :sparkle_stack => sf)
-              if(sf.nested? && config[:apply_nesting])
+              if sf.nested? && config[:apply_nesting]
                 validate_nesting_bucket!
-                if(config[:apply_nesting] == true)
+                if config[:apply_nesting] == true
                   config[:apply_nesting] = :deep
                 end
                 case config[:apply_nesting].to_sym
@@ -262,12 +261,15 @@ module Sfn
           compile_state = config.fetch(:compile_parameters, Smash.new)
           ui.debug "Initial compile parameters - #{compile_state}"
           compile_state.keys.each do |cs_key|
-            unless(cs_key.to_s.start_with?("#{arguments.first}__"))
+            unless cs_key.to_s.start_with?("#{arguments.first}__")
               named_cs_key = [arguments.first, cs_key].compact.join('__')
               non_named = compile_state.delete(cs_key)
-              if(non_named && !compile_state.key?(named_cs_key))
+              if non_named && !compile_state.key?(named_cs_key)
                 ui.debug "Setting non-named compile parameter `#{cs_key}` into `#{named_cs_key}`"
                 compile_state[named_cs_key] = non_named
+              elsif non_named && compile_state.key?(named_cs_key)
+                ui.debug "Merging none-named `#{cs_key}` with named `#{named_cs_key}`"
+                compile_state[named_cs_key].merge!(non_named)
               else
                 ui.debug "Discarding non-named compile parameter due to set named - `#{cs_key}` </> `#{named_cs_key}`"
               end
@@ -279,7 +281,7 @@ module Sfn
 
         # Force user friendly error if nesting bucket is not set within configuration
         def validate_nesting_bucket!
-          if(config[:nesting_bucket].to_s.empty?)
+          if config[:nesting_bucket].to_s.empty?
             ui.error 'Missing required configuration value for `nesting_bucket`. Cannot generated nested templates!'
             raise ArgumentError.new 'Required configuration value for `nesting_bucket` not provided.'
           end
@@ -290,17 +292,17 @@ module Sfn
         # @param sf [SparkleFormation] stack formation
         # @param c_stack [Miasma::Models::Orchestration::Stack] existing stack
         # @return [Hash] dumped stack
-        def process_nested_stack_shallow(sf, c_stack=nil)
+        def process_nested_stack_shallow(sf, c_stack = nil)
           sf.apply_nesting(:shallow) do |stack_name, stack, resource|
             run_callbacks_for(:template, :stack_name => stack_name, :sparkle_stack => stack)
             bucket = provider.connection.api_for(:storage).buckets.get(
               config[:nesting_bucket]
             )
-            if(config[:print_only])
+            if config[:print_only]
               template_url = "http://example.com/bucket/#{name_args.first}_#{stack_name}.json"
             else
               stack_definition = dump_stack_for_storage(stack)
-              unless(bucket)
+              unless bucket
                 raise "Failed to locate configured bucket for stack template storage (#{bucket})!"
               end
               file = bucket.files.build
@@ -320,13 +322,13 @@ module Sfn
         # @param sf [SparkleFormation] stack
         # @param c_stack [Miasma::Models::Orchestration::Stack] existing stack
         # @return [SparkleFormation::SparkleStruct] compiled structure
-        def process_nested_stack_deep(sf, c_stack=nil)
+        def process_nested_stack_deep(sf, c_stack = nil)
           sf.apply_nesting(:deep) do |stack_name, stack, resource|
             run_callbacks_for(:template, :stack_name => stack_name, :sparkle_stack => stack)
             stack_resource = resource._dump
-            current_stack = c_stack ? c_stack.nested_stacks.detect{|s| s.data[:logical_id] == stack_name} : nil
+            current_stack = c_stack ? c_stack.nested_stacks.detect { |s| s.data[:logical_id] == stack_name } : nil
             current_parameters = extract_current_nested_template_parameters(stack, stack_name, current_stack)
-            if(current_stack && current_stack.data[:parent_stack])
+            if current_stack && current_stack.data[:parent_stack]
               current_parameters.merge!(
                 current_stack.data[:parent_stack].template.fetch(
                   'Resources', stack_name, 'Properties', 'Parameters', current_stack.data[:parent_stack].template.fetch(
@@ -337,22 +339,21 @@ module Sfn
             end
             full_stack_name = [
               config[:nesting_prefix],
-              stack.root_path.map(&:name).map(&:to_s).join('_')
+              stack.root_path.map(&:name).map(&:to_s).join('_'),
             ].compact.join('/')
-            unless(config[:print_only])
+            unless config[:print_only]
               result = Smash.new(
                 :parameters => populate_parameters!(stack,
-                  :stack => current_stack,
-                  :current_parameters => current_parameters
-                )
+                                                    :stack => current_stack,
+                                                    :current_parameters => current_parameters),
               )
               store_template(full_stack_name, stack, result)
             else
               result = Smash.new(
-                :url => "http://example.com/bucket/#{full_stack_name}.json"
+                :url => "http://example.com/bucket/#{full_stack_name}.json",
               )
             end
-            format_nested_stack_results(resource._self.provider, result).each do |k,v|
+            format_nested_stack_results(resource._self.provider, result).each do |k, v|
               resource.properties.set!(k, v)
             end
           end
@@ -364,8 +365,8 @@ module Sfn
         # @param stack_name [String]
         # @param c_stack [Miasma::Models::Orchestration::Stack]
         # @return [Hash]
-        def extract_current_nested_template_parameters(template, stack_name, c_stack=nil)
-          if(template.parent)
+        def extract_current_nested_template_parameters(template, stack_name, c_stack = nil)
+          if template.parent
             current_parameters = template.parent.compile.resources.set!(stack_name).properties.parameters
             current_parameters.nil? ? Smash.new : current_parameters._dump
           else
@@ -384,7 +385,7 @@ module Sfn
           bucket = provider.connection.api_for(:storage).buckets.get(
             config[:nesting_bucket]
           )
-          unless(bucket)
+          unless bucket
             raise "Failed to locate configured bucket for stack template storage (#{config[:nesting_bucket]})!"
           end
           file = bucket.files.build
@@ -393,7 +394,7 @@ module Sfn
           file.body = MultiJson.dump(parameter_scrub!(stack_definition))
           file.save
           result.merge!(
-            :url => file.url
+            :url => file.url,
           )
         end
 
@@ -407,7 +408,7 @@ module Sfn
             [nested_name, nested_resource, nested_resource.properties.delete!(:stack)]
           end
           stack_definition = template.dump
-          if(config[:plan])
+          if config[:plan]
             nested_stacks.each do |nested_name, nested_resource, nested_data|
               nested_resource.properties.set!(:stack, nested_data)
             end
@@ -422,7 +423,7 @@ module Sfn
         def scrub_template(template)
           template = parameter_scrub!(template)
           (template['Resources'] || {}).each do |r_name, r_content|
-            if(valid_stack_types.include?(r_content['Type']))
+            if valid_stack_types.include?(r_content['Type'])
               result = (r_content['Properties'] || {}).delete('Stack')
             end
           end
@@ -437,10 +438,10 @@ module Sfn
         def format_nested_stack_results(provider, results)
           case provider
           when :aws
-            if(results[:parameters])
+            if results[:parameters]
               results['Parameters'] = results.delete(:parameters)
             end
-            if(results[:url])
+            if results[:url]
               url = URI.parse(results.delete(:url))
               results['TemplateURL'] = "#{url.scheme}://#{url.host}#{url.path}"
             end
@@ -449,18 +450,18 @@ module Sfn
             results[:template] = results.delete(:url)
             results
           when :azure
-            if(results[:parameters])
+            if results[:parameters]
               results[:parameters] = Smash[
                 results[:parameters].map do |key, value|
                   [key,
-                    value.is_a?(Hash) ? value : Smash.new(:value => value)]
+                   value.is_a?(Hash) ? value : Smash.new(:value => value)]
                 end
               ]
             end
-            if(results[:url])
+            if results[:url]
               results[:templateLink] = Smash.new(
                 :uri => results.delete(:url),
-                :contentVersion => '1.0.0.0'
+                :contentVersion => '1.0.0.0',
               )
             end
             results[:mode] = 'Incremental'
@@ -475,16 +476,16 @@ module Sfn
         # @param template [Hash]
         # @return [Hash]
         def translate_template(template)
-          if(klass_name = config[:translate])
+          if klass_name = config[:translate]
             klass = SparkleFormation::Translation.const_get(camel(klass_name))
             args = {
-              :parameters => config.fetch(:options, :parameters, Smash.new)
+              :parameters => config.fetch(:options, :parameters, Smash.new),
             }
-            if(chunk_size = config[:translate_chunk_size])
+            if chunk_size = config[:translate_chunk_size]
               args.merge!(
                 :options => {
-                  :serialization_chunk_size => chunk_size
-                }
+                  :serialization_chunk_size => chunk_size,
+                },
               )
             end
             translator = klass.new(template, args)
@@ -499,12 +500,12 @@ module Sfn
         #
         # @return [TrueClass]
         def set_paths_and_discover_file!
-          if(config[:processing])
-            if(!config[:file] && config[:file_path_prompt])
+          if config[:processing]
+            if !config[:file] && config[:file_path_prompt]
               config[:file] = prompt_for_template
             else
               file_lookup_path = File.expand_path(config[:file])
-              unless(File.exists?(file_lookup_path))
+              unless File.exists?(file_lookup_path)
                 file_lookup_path = config[:file]
               end
               config[:file] = sparkle_collection.get(
@@ -512,8 +513,8 @@ module Sfn
               )[:path]
             end
           else
-            if(config[:file])
-              unless(File.exists?(config[:file]))
+            if config[:file]
+              unless File.exists?(config[:file])
                 raise Errno::ENOENT.new("No such file - #{config[:file]}")
               end
             else
@@ -527,8 +528,8 @@ module Sfn
         #
         # @param prefix [String] prefix filter for names
         # @return [String] path to template
-        def prompt_for_template(prefix=nil)
-          if(prefix)
+        def prompt_for_template(prefix = nil)
+          if prefix
             collection_name = prefix.split('__').map do |c_name|
               c_name.split('_').map(&:capitalize).join(' ')
             end.join(' / ')
@@ -541,26 +542,26 @@ module Sfn
           end
           collections = template_names.map do |t_name|
             t_name = t_name.to_s.sub(/^#{Regexp.escape(prefix.to_s)}/, '')
-            if(t_name.include?('__'))
+            if t_name.include?('__')
               c_name = t_name.split('__').first
               [[prefix, c_name].compact.join('') + '__', c_name]
             end
           end.compact.uniq(&:first)
           templates = template_names.map do |t_name|
             t_name = t_name.to_s.sub(/^#{Regexp.escape(prefix.to_s)}/, '')
-            unless(t_name.include?('__'))
+            unless t_name.include?('__')
               [[prefix, t_name].compact.join(''), t_name]
             end
           end.compact
-          if(collections.empty? && templates.empty?)
+          if collections.empty? && templates.empty?
             ui.error 'Failed to locate any templates!'
             return nil
           end
-          ui.info "Please select an entry#{ '(or collection to list)' unless collections.empty?}:"
+          ui.info "Please select an entry#{'(or collection to list)' unless collections.empty?}:"
           output = []
           idx = 1
           valid = {}
-          unless(collections.empty?)
+          unless collections.empty?
             output << ui.color('Collections:', :bold)
             collections.each do |full_name, part_name|
               valid[idx] = {:name => full_name, :type => :collection}
@@ -568,7 +569,7 @@ module Sfn
               idx += 1
             end
           end
-          unless(templates.empty?)
+          unless templates.empty?
             output << ui.color('Templates:', :bold)
             templates.each do |full_name, part_name|
               valid[idx] = {:name => full_name, :type => :template}
@@ -578,7 +579,7 @@ module Sfn
           end
           max = idx.to_s.length
           output.map! do |line|
-            if(line.is_a?(Array))
+            if line.is_a?(Array)
               "  #{line.first}.#{' ' * (max - line.first.to_s.length)} #{line.last}"
             else
               line
@@ -586,17 +587,16 @@ module Sfn
           end
           ui.puts "#{output.join("\n")}\n"
           response = nil
-          until(valid[response])
+          until valid[response]
             response = ui.ask_question('Enter selection').to_i
           end
           entry = valid[response]
-          if(entry[:type] == :collection)
+          if entry[:type] == :collection
             prompt_for_template(entry[:name])
           else
             sparkle_collection.get(:template, entry[:name])[:path]
           end
         end
-
       end
 
       module ClassMethods
@@ -614,7 +614,6 @@ module Sfn
           include Sfn::Utils::StackParameterValidator
         end
       end
-
     end
   end
 end