sfn 3.0.28 → 3.0.30

data/lib/sfn/monkey_patch/stack.rb

@@ -6,7 +6,6 @@ module Sfn
 
     # Expand stack model functionality
     module Stack
-
       autoload :Azure, 'sfn/monkey_patch/stack/azure'
       autoload :Google, 'sfn/monkey_patch/stack/google'
 
@@ -92,7 +91,7 @@ module Sfn
 
       # @return [String] action currently being performed
       def performing
-        if(in_progress?)
+        if in_progress?
           status.to_s.downcase.split('_').first.to_sym
         end
       end
@@ -140,10 +139,10 @@ module Sfn
       # @param min [Integer] lowest allowed return value (defaults 5)
       # @return [Integer] percent complete (0..100)
       def percent_complete(min = 5)
-        if(self.respond_to?("percent_complete_#{api.provider}"))
+        if self.respond_to?("percent_complete_#{api.provider}")
           self.send("percent_complete_#{api.provider}", min)
         else
-          if(in_progress?)
+          if in_progress?
             total_resources = template.fetch('Resources', []).size
             total_complete = resources.all.find_all do |resource|
               resource.status.downcase.end_with?('complete')
@@ -166,21 +165,21 @@ module Sfn
       # @return [self]
       # @note setting `DisableApply` within parameter hash will
       #   prevent parameters being overridden
-      def apply_stack(remote_stack, opts={}, ignore_params=nil)
-        if(self.respond_to?("apply_stack_#{api.provider}"))
+      def apply_stack(remote_stack, opts = {}, ignore_params = nil)
+        if self.respond_to?("apply_stack_#{api.provider}")
           self.send("apply_stack_#{api.provider}", remote_stack, opts, ignore_params)
         else
-          unless(opts[:mapping])
+          unless opts[:mapping]
             opts[:mapping] = {}
           end
-          if(opts[:parameter_key])
+          if opts[:parameter_key]
             stack_parameters = template[opts[:parameter_key]]
             default_key = opts.fetch(
               :default_key,
-              opts[:parameter_key].to_s[0,1].match(/[a-z]/) ? 'default' : 'Default'
+              opts[:parameter_key].to_s[0, 1].match(/[a-z]/) ? 'default' : 'Default'
             )
           else
-            if(template['Parameters'])
+            if template['Parameters']
               default_key = 'Default'
               stack_parameters = template['Parameters']
             else
@@ -188,11 +187,11 @@ module Sfn
               stack_parameters = template['parameters']
             end
           end
-          if(stack_parameters)
+          if stack_parameters
             valid_parameters = stack_parameters.find_all do |key, val|
               !val['DisableApply'] && !val['disable_apply']
             end.map(&:first)
-            if(ignore_params)
+            if ignore_params
               valid_parameters.reject! do |key|
                 ignore_params.include?(key)
               end
@@ -202,17 +201,17 @@ module Sfn
               p_key = valid_parameters.detect do |v_param|
                 v_param.downcase.tr('_', '') == o_key
               end
-              unless(p_key)
+              unless p_key
                 map_key = opts[:mapping].keys.detect do |map_key|
                   map_key.downcase.tr('_', '') == o_key
                 end
-                if(map_key)
+                if map_key
                   p_key = valid_parameters.detect do |v_param|
                     v_param.downcase.tr('_', '') == opts[:mapping][map_key].downcase.tr('_', '')
                   end
                 end
               end
-              if(p_key)
+              if p_key
                 self.parameters = parameters.merge(p_key => output.value)
               end
             end
@@ -225,30 +224,30 @@ module Sfn
       #
       # @param recurse [TrueClass, FalseClass] recurse to fetch _all_ stacks
       # @return [Array<Miasma::Models::Orchestration::Stack>]
-      def nested_stacks(recurse=true)
-        if(self.respond_to?("nested_stacks_#{api.provider}"))
+      def nested_stacks(recurse = true)
+        if self.respond_to?("nested_stacks_#{api.provider}")
           self.send("nested_stacks_#{api.provider}", recurse)
         else
           resources.reload.all.map do |resource|
-            if(api.data.fetch(:stack_types, []).include?(resource.type))
+            if api.data.fetch(:stack_types, []).include?(resource.type)
               # Custom remote load support
-              if(resource.type == 'Custom::JackalStack')
+              if resource.type == 'Custom::JackalStack'
                 location, stack_id = resource.id.to_s.split('-', 2)
-                if(l_conf = api.data[:locations][location])
+                if l_conf = api.data[:locations][location]
                   n_stack = Miasma.api(
                     :type => :orchestration,
                     :provider => l_conf[:provider],
-                    :credentials => l_conf
+                    :credentials => l_conf,
                   ).stacks.get(stack_id)
                 end
               else
                 n_stack = resource.expand
               end
-              if(n_stack)
+              if n_stack
                 n_stack.data[:logical_id] = resource.name
                 n_stack.data[:parent_stack] = self
                 n_stack.api.data[:stack_types] = api.data[:stack_types]
-                if(recurse)
+                if recurse
                   [n_stack] + n_stack.nested_stacks(recurse)
                 else
                   n_stack
@@ -261,7 +260,7 @@ module Sfn
 
       # @return [TrueClass, FalseClass] stack contains nested stacks
       def nested?
-        if(self.respond_to?("nested_#{api.provider}?"))
+        if self.respond_to?("nested_#{api.provider}?")
           self.send("nested_#{api.provider}?")
         else
           !!resources.detect do |resource|
@@ -274,22 +273,22 @@ module Sfn
       #
       # @return [Smash, NilClass]
       def policy
-        if(self.respond_to?("policy_#{api.provider}"))
+        if self.respond_to?("policy_#{api.provider}")
           self.send("policy_#{api.provider}")
         else
-          if(self.api.provider == :aws) # cause this is the only one
+          if (self.api.provider == :aws) # cause this is the only one
             begin
               result = self.api.request(
                 :path => '/',
                 :form => Smash.new(
                   'Action' => 'GetStackPolicy',
-                  'StackName' => self.id
-                )
+                  'StackName' => self.id,
+                ),
               )
               serialized_policy = result.get(:body, 'GetStackPolicyResult', 'StackPolicyBody')
               MultiJson.load(serialized_policy).to_smash
             rescue Miasma::Error::ApiError::RequestError => e
-              if(e.response.code == 404)
+              if e.response.code == 404
                 nil
               else
                 raise
@@ -307,10 +306,10 @@ module Sfn
       #   contain any direct values for parameters (which is what we
       #   are testing for)
       def nesting_style
-        if(self.respond_to?("nesting_style_#{api.provider}"))
+        if self.respond_to?("nesting_style_#{api.provider}")
           self.send("nesting_style_#{api.provider}")
         else
-          if(nested?)
+          if nested?
             self.template['Resources'].find_all do |t_resource|
               t_resource['Type'] == self.api.class.const_get(:RESOURCE_MAPPING).key(self.class)
             end.detect do |t_resource|
@@ -326,7 +325,7 @@ module Sfn
       #
       # @return [Hash]
       def sparkleish_template(*args)
-        if(self.respond_to?("sparkleish_template_#{api.provider}"))
+        if self.respond_to?("sparkleish_template_#{api.provider}")
           self.send("sparkleish_template_#{api.provider}", *args)
         else
           template
@@ -337,13 +336,12 @@ module Sfn
       #
       # @return [Hash]
       def root_parameters
-        if(self.respond_to?("root_parameters_#{api.provider}"))
+        if self.respond_to?("root_parameters_#{api.provider}")
           self.send("root_parameters_#{api.provider}")
         else
           parameters
         end
       end
-
     end
   end
 end

data/lib/sfn/monkey_patch/stack/azure.rb

@@ -16,7 +16,6 @@ module Sfn
           end
           resources.size == new_template[:resources].size ? new_template : template
         end
-
       end
     end
   end

data/lib/sfn/monkey_patch/stack/google.rb

@@ -25,7 +25,7 @@ module Sfn
             collection = Miasma::Models::Orchestration::Stack::Resources.new(self)
             collection.define_singleton_method(:perform_population) do
               valid = stack.sparkleish_template.fetch(:resources, {}).keys
-              stack.custom[:resources].find_all{|r| valid.include?(r[:name])}.map do |attrs|
+              stack.custom[:resources].find_all { |r| valid.include?(r[:name]) }.map do |attrs|
                 Miasma::Models::Orchestration::Stack::Resource.new(stack, attrs).valid_state
               end
             end
@@ -35,7 +35,7 @@ module Sfn
           # Sub-stacks never provide events
           def events
             collection = Miasma::Models::Orchestration::Stack::Events.new(self)
-            collection.define_singleton_method(:perform_population){ [] }
+            collection.define_singleton_method(:perform_population) { [] }
             collection
           end
         end
@@ -44,33 +44,33 @@ module Sfn
         #
         # @param recurse [TrueClass, FalseClass] recurse to fetch _all_ stacks
         # @return [Array<Miasma::Models::Orchestration::Stack>]
-        def nested_stacks_google(recurse=true)
+        def nested_stacks_google(recurse = true)
           my_template = sparkleish_template
-          if(my_template[:resources][name])
+          if my_template[:resources][name]
             my_template = my_template.get(:resources, name, :properties, :stack)
           end
           n_stacks = my_template[:resources].map do |s_name, content|
-            if(content[:type] == 'sparkleformation.stack')
+            if content[:type] == 'sparkleformation.stack'
               n_stack = self.class.new(api)
               n_stack.extend PretendStack
-              n_layout = custom.fetch(:layout, {}).fetch(:resources, []).detect{|r| r[:name] == name}
-              n_layout = (n_layout || custom.fetch(:layout, {})).fetch(:resources, []).detect{|r| r[:name] == s_name} || Smash.new
+              n_layout = custom.fetch(:layout, {}).fetch(:resources, []).detect { |r| r[:name] == name }
+              n_layout = (n_layout || custom.fetch(:layout, {})).fetch(:resources, []).detect { |r| r[:name] == s_name } || Smash.new
               n_stack.load_data(
                 :name => s_name,
                 :id => s_name,
                 :template => content.get(:properties, :stack),
-                :outputs => n_layout.fetch('outputs', []).map{|o_val| Smash.new(:key => o_val[:name], :value => o_val['finalValue'])},
+                :outputs => n_layout.fetch('outputs', []).map { |o_val| Smash.new(:key => o_val[:name], :value => o_val['finalValue']) },
                 :custom => {
                   :resources => resources.all.map(&:attributes),
-                  :layout => n_layout
-                }
+                  :layout => n_layout,
+                },
               ).valid_state
               n_stack.data[:logical_id] = s_name
               n_stack.data[:parent_stack] = self
               n_stack
             end
           end.compact
-          if(recurse)
+          if recurse
             (n_stacks + n_stacks.map(&:nested_stacks)).flatten.compact
           else
             n_stacks
@@ -84,18 +84,18 @@ module Sfn
             result = template.to_smash
             (result.delete(:resources) || []).each do |t_resource|
               t_name = t_resource.delete(:name)
-              if(t_resource[:type].to_s.end_with?('.jinja'))
+              if t_resource[:type].to_s.end_with?('.jinja')
                 schema = copy_template.fetch(:config, :content, :imports, []).delete("#{t_resource[:type]}.schema")
                 schema_content = copy_template.fetch(:imports, []).detect do |s_item|
                   s_item[:name] == schema
                 end
-                if(schema_content)
+                if schema_content
                   t_resource.set(:parameters, schema_content.get(:content, :properties))
                 end
                 n_template = copy_template.fetch(:imports, []).detect do |s_item|
                   s_item[:name] == t_resource[:type]
                 end
-                if(n_template)
+                if n_template
                   t_resource[:type] = 'sparkleformation.stack'
                   current_properties = t_resource.delete(:properties)
                   t_resource.set(:properties, :parameters, current_properties) if current_properties
@@ -107,7 +107,7 @@ module Sfn
             result
           end
           s_template = deref.call(Smash.new(:resources => copy_template.get(:config, :content, :resources)))
-          if(s_template.empty?)
+          if s_template.empty?
             template.to_smash
           else
             layout = custom.fetch(:layout, {}).to_smash
@@ -122,7 +122,6 @@ module Sfn
         def root_parameters_google
           sparkleish_template.fetch(:resources, name, :properties, :parameters, Smash.new)
         end
-
       end
     end
   end

data/lib/sfn/planner.rb

@@ -3,7 +3,6 @@ require 'sfn'
 module Sfn
   # Interface for generating plan report
   class Planner
-
     autoload :Aws, 'sfn/planner/aws'
 
     # Value to flag runtime modification
@@ -29,7 +28,7 @@ module Sfn
     # @param opts [Hash]
     #
     # @return [self]
-    def initialize(ui, config, arguments, stack, opts={})
+    def initialize(ui, config, arguments, stack, opts = {})
       @ui = ui
       @config = config
       @arguments = arguments
@@ -46,6 +45,5 @@ module Sfn
     def generate_plan(template, parameters)
       raise NotImplementedError
     end
-
   end
 end

data/lib/sfn/planner/aws.rb

@@ -9,7 +9,6 @@ module Sfn
 
       # Customized translator to dereference template
       class Translator < SparkleFormation::Translation
-
         MAP = {}
         REF_MAPPING = {}
         FN_MAPPING = {}
@@ -20,7 +19,7 @@ module Sfn
         attr_reader :flagged
 
         # Override to init flagged array
-        def initialize(template_hash, args={})
+        def initialize(template_hash, args = {})
           super
           @flagged = []
         end
@@ -54,19 +53,19 @@ module Sfn
         # @return [Hash]
         # @note also allows 'Ref' within funcs to provide mapping
         #   replacements using the REF_MAPPING constant
-        def apply_function(hash, funcs=[])
-          if(hash.is_a?(Hash))
-            k,v = hash.first
-            if(hash.size == 1 && (k.start_with?('Fn') || k == 'Ref') && (funcs.include?(:all) || funcs.empty? || funcs.include?(k) || funcs == ['DEREF']))
+        def apply_function(hash, funcs = [])
+          if hash.is_a?(Hash)
+            k, v = hash.first
+            if hash.size == 1 && (k.start_with?('Fn') || k == 'Ref') && (funcs.include?(:all) || funcs.empty? || funcs.include?(k) || funcs == ['DEREF'])
               method_name = Bogo::Utility.snake(k.gsub('::', ''))
-              if((funcs.include?(k) || funcs.include?(:all)) && respond_to?(method_name))
+              if (funcs.include?(k) || funcs.include?(:all)) && respond_to?(method_name)
                 apply_function(send(method_name, v), funcs)
               else
                 case k
                 when 'Fn::GetAtt'
                   funcs.include?('DEREF') ? dereference(hash) : hash
                 when 'Ref'
-                  if(funcs.include?('DEREF'))
+                  if funcs.include?('DEREF')
                     dereference(hash)
                   else
                     {'Ref' => self.class.const_get(:REF_MAPPING).fetch(v, v)}
@@ -89,7 +88,7 @@ module Sfn
         # @return [TrueClass, FalseClass]
         def apply_condition(name)
           condition = conditions[name]
-          if(condition)
+          if condition
             apply_function(condition, [:all, 'DEREF'])
           else
             raise "Failed to locate condition with name `#{name}`!"
@@ -102,7 +101,7 @@ module Sfn
         # @return [Object] true or false value
         def fn_if(value)
           result = apply_condition(value[0])
-          if(result != UNKNOWN_RUNTIME_RESULT)
+          if result != UNKNOWN_RUNTIME_RESULT
             result ? value[1] : value[2]
           else
             UNKNOWN_RUNTIME_RESULT
@@ -118,7 +117,7 @@ module Sfn
           result = value.map do |val|
             apply_condition(val)
           end
-          if(result.to_s.include?(RUNTIME_MODIFIED))
+          if result.to_s.include?(RUNTIME_MODIFIED)
             UNKNOWN_RUNTIME_RESULT
           else
             result.all?
@@ -133,7 +132,7 @@ module Sfn
           result = value.map do |val|
             apply_condition(val)
           end
-          if(result.to_s.include?(RUNTIME_MODIFIED))
+          if result.to_s.include?(RUNTIME_MODIFIED)
             UNKNOWN_RUNTIME_RESULT
           else
             result.any?
@@ -157,7 +156,7 @@ module Sfn
           value = value.map do |val|
             apply_function(val)
           end
-          if(value.to_s.include?(RUNTIME_MODIFIED))
+          if value.to_s.include?(RUNTIME_MODIFIED)
             UNKNOWN_RUNTIME_RESULT
           else
             value.first == value.last
@@ -169,7 +168,7 @@ module Sfn
         # @param value [Array<String,Array<String>>]
         # @return [String]
         def fn_join(value)
-          unless(value.last.is_a?(Array))
+          unless value.last.is_a?(Array)
             val = value.last.to_s.split(',')
           else
             val = value.last
@@ -183,9 +182,9 @@ module Sfn
         # @return [String, Fixnum]
         def fn_find_in_map(value)
           map_holder = mappings[value[0]]
-          if(map_holder)
+          if map_holder
             map_item = map_holder[dereference(value[1])]
-            if(map_item)
+            if map_item
               map_item[value[2]]
             else
               raise "Failed to find mapping item! (#{value[0]} -> #{value[1]})"
@@ -202,32 +201,31 @@ module Sfn
         # @return [Hash, String]
         def dereference(hash)
           result = nil
-          if(hash.is_a?(Hash))
-            if(hash.keys.first == 'Ref' && flagged?(hash.values.first))
+          if hash.is_a?(Hash)
+            if hash.keys.first == 'Ref' && flagged?(hash.values.first)
               result = RUNTIME_MODIFIED
-            elsif(hash.keys.first == 'Fn::GetAtt')
-              if(hash.values.last.last.start_with?('Outputs.'))
-                if(flagged?(hash.values.join('_')))
+            elsif hash.keys.first == 'Fn::GetAtt'
+              if hash.values.last.last.start_with?('Outputs.')
+                if flagged?(hash.values.join('_'))
                   result = RUNTIME_MODIFIED
                 end
-              elsif(flagged?(hash.values.first))
+              elsif flagged?(hash.values.first)
                 result = RUNTIME_MODIFIED
               end
             end
           end
           result = result.nil? ? super : result
-          unless(result.is_a?(Enumerable))
+          unless result.is_a?(Enumerable)
             result = result.to_s
           end
           result
         end
-
       end
 
       # Resources that will be replaced on metadata init updates
       REPLACE_ON_CFN_INIT_UPDATE = [
         'AWS::AutoScaling::LaunchConfiguration',
-        'AWS::EC2::Instance'
+        'AWS::EC2::Instance',
       ]
 
       # @return [Smash] initialized translators
@@ -248,21 +246,21 @@ module Sfn
       #
       # @return [Hash] report
       def generate_plan(template, parameters)
-        parameters = Smash[parameters.map{|k,v| [k, v.to_s]}]
+        parameters = Smash[parameters.map { |k, v| [k, v.to_s] }]
         result = Smash.new(
           :stacks => Smash.new(
             origin_stack.name => plan_stack(
               origin_stack,
               template,
               parameters
-            )
+            ),
           ),
           :added => Smash.new,
           :removed => Smash.new,
           :replace => Smash.new,
           :interrupt => Smash.new,
           :unavailable => Smash.new,
-          :unknown => Smash.new
+          :unknown => Smash.new,
         )
         result
       end
@@ -274,9 +272,9 @@ module Sfn
       # @param template [Hash]
       # @return [TrueClass]
       def scrub_stack_properties(template)
-        if(template['Resources'])
+        if template['Resources']
           template['Resources'].each do |name, info|
-            if(is_stack?(info['Type']) && info['Properties'].is_a?(Hash))
+            if is_stack?(info['Type']) && info['Properties'].is_a?(Hash)
               info['Properties'].delete('Stack')
             end
           end
@@ -295,7 +293,7 @@ module Sfn
           'AWS::AccountId' => stack.id.split(':')[4],
           'AWS::NotificationARNs' => stack.notification_topics,
           'AWS::StackId' => stack.id,
-          'AWS::StackName' => stack.name
+          'AWS::StackName' => stack.name,
         ).merge(config.fetch(:planner, :global_parameters, {}))
       end
 
@@ -315,14 +313,14 @@ module Sfn
           :unavailable => Smash.new,
           :unknown => Smash.new,
           :outputs => Smash.new,
-          :n_outputs => []
+          :n_outputs => [],
         )
 
         origin_template = dereference_template(
           "#{stack.data.checksum}_origin",
           stack.template,
           Smash[
-            stack.parameters.map do |k,v|
+            stack.parameters.map do |k, v|
               [k, v.to_s]
             end
           ].merge(get_global_parameters(stack))
@@ -333,7 +331,7 @@ module Sfn
 
         new_checksum = nil
         current_checksum = false
-        until(new_checksum == current_checksum)
+        until new_checksum == current_checksum
           current_checksum = plan_results.checksum
           run_stack_diff(stack, translator_key, plan_results, origin_template, new_template, new_parameters)
           new_checksum = plan_results.checksum
@@ -357,7 +355,7 @@ module Sfn
       # @return [NilClass]
       def scrub_plan(results)
         precedence = [:unavailable, :replace, :interrupt, :unavailable, :unknown]
-        until(precedence.empty?)
+        until precedence.empty?
           key = precedence.shift
           results[key].keys.each do |k|
             precedence.each do |p_key|
@@ -380,9 +378,9 @@ module Sfn
       def run_stack_diff(stack, t_key, plan_results, origin_template, new_template, new_parameters)
         translator = translator_for(t_key)
         new_parameters = new_parameters.dup
-        if(stack.parameters)
-          stack.parameters.each do |k,v|
-            if(new_parameters[k].is_a?(Hash))
+        if stack.parameters
+          stack.parameters.each do |k, v|
+            if new_parameters[k].is_a?(Hash)
               val = translator.dereference(new_parameters[k])
               new_parameters[k] = val == new_parameters[k] ? v : val
             end
@@ -406,7 +404,7 @@ module Sfn
             plan_results, a_path, diff_items, translator_for(t_key),
             Smash.new(
               :origin => origin_template,
-              :update => update_template
+              :update => update_template,
             )
           )
         end
@@ -436,14 +434,13 @@ module Sfn
           new_stack_template = new_template_hash.fetch('Resources', stack_name, 'Properties', 'Stack', Smash.new)
           new_stack_parameters = new_template_hash.fetch('Resources', stack_name, 'Properties', 'Parameters', Smash.new)
           new_stack_type = new_template_hash.fetch('Resources', stack_name, 'Type',
-            origin_template.get('Resources', stack_name, 'Type')
-          )
+                                                   origin_template.get('Resources', stack_name, 'Type'))
           resource = Smash.new(
             :name => stack_name,
             :type => new_stack_type,
-            :properties => []
+            :properties => [],
           )
-          if(original_stack && new_stack_template)
+          if original_stack && new_stack_template
             new_stack_parameters = Smash[
               new_stack_parameters.map do |new_param_key, new_param_value|
                 [new_param_key, translator.dereference(new_param_value)]
@@ -454,9 +451,9 @@ module Sfn
               translator.flag_ref("#{stack_name}_Outputs.#{modified_output}")
             end
             plan_results[:stacks][stack_name] = result
-          elsif(original_stack && (!new_stack_template && !new_stack_exists))
+          elsif original_stack && (!new_stack_template && !new_stack_exists)
             plan_results[:removed][stack_name] = resource
-          elsif(new_stack_template && !original_stack)
+          elsif new_stack_template && !original_stack
             plan_results[:added][stack_name] = resource
           end
         end
@@ -470,15 +467,15 @@ module Sfn
       # @return [Smash]
       def diff_init(diff, path)
         Smash.new.tap do |di|
-          if(diff.size > 1)
-            updated = diff.detect{|x| x.first == '+'}
-            original = diff.detect{|x| x.first == '-'}
+          if diff.size > 1
+            updated = diff.detect { |x| x.first == '+' }
+            original = diff.detect { |x| x.first == '-' }
             di[:original] = original.last.to_s
             di[:updated] = updated.last.to_s
           else
             diff_data = diff.first
             di[:path] = path
-            if(diff_data.size == 3)
+            if diff_data.size == 3
               di[diff_data.first == '+' ? :updated : :original] = diff_data.last
             else
               di[:original] = diff_data[diff_data.size - 2].to_s
@@ -498,9 +495,9 @@ module Sfn
       # @option :templates [Smash] :update
       def register_diff(results, path, diff, translator, templates)
         diff_info = diff_init(diff, path)
-        if(path.start_with?('Resources'))
+        if path.start_with?('Resources')
           p_path = path.split('.')
-          if(p_path.size == 2)
+          if p_path.size == 2
             diff = diff.first
             key = diff.first == '+' ? :added : :removed
             type = (key == :added ? templates[:update] : templates[:origin]).get('Resources', p_path.last, 'Type')
@@ -509,13 +506,13 @@ module Sfn
               :type => type,
               :properties => [],
               :diffs => [
-                diff_info
-              ]
+                diff_info,
+              ],
             )
           else
-            if(p_path.include?('Properties'))
+            if p_path.include?('Properties')
               resource_name = p_path[1]
-              if(p_path.size < 4 && p_path.last == 'Properties')
+              if p_path.size < 4 && p_path.last == 'Properties'
                 property_name = diff.flatten.compact.last.keys.first
               else
                 property_name = p_path[3].to_s.sub(/\[\d+\]$/, '')
@@ -526,16 +523,16 @@ module Sfn
                 :type => type,
                 :properties => [property_name],
                 :diffs => [
-                  diff_info.merge(:property_name => property_name)
-                ]
+                  diff_info.merge(:property_name => property_name),
+                ],
               )
               begin
-                if(templates.get(:update, 'Resources', resource_name, 'Properties', property_name) == Translator::UNKNOWN_RUNTIME_RESULT)
+                if templates.get(:update, 'Resources', resource_name, 'Properties', property_name) == Translator::UNKNOWN_RUNTIME_RESULT
                   effect = :unknown
                 else
                   r_info = SparkleFormation::Resources::Aws.resource_lookup(type)
                   r_property = r_info.property(property_name)
-                  if(r_property)
+                  if r_property
                     effect = r_property.update_causes(
                       templates.get(:update, 'Resources', resource_name),
                       templates.get(:origin, 'Resources', resource_name)
@@ -559,32 +556,31 @@ module Sfn
               rescue KeyError
                 set_resource(:unknown, results, resource_name, resource)
               end
-            elsif(p_path.include?('AWS::CloudFormation::Init'))
+            elsif p_path.include?('AWS::CloudFormation::Init')
               resource_name = p_path[1]
               type = templates[:origin]['Resources'][resource_name]['Type']
-              if(REPLACE_ON_CFN_INIT_UPDATE.include?(type))
+              if REPLACE_ON_CFN_INIT_UPDATE.include?(type)
                 set_resource(:replace, results, resource_name,
-                  Smash.new(
-                    :name => resource_name,
-                    :type => type,
-                    :properties => ['AWS::CloudFormation::Init'],
-                    :diffs => [
-                      diff_info
-                    ]
-                  )
-                )
+                             Smash.new(
+                  :name => resource_name,
+                  :type => type,
+                  :properties => ['AWS::CloudFormation::Init'],
+                  :diffs => [
+                    diff_info,
+                  ],
+                ))
               end
             end
           end
-        elsif(path.start_with?('Outputs'))
+        elsif path.start_with?('Outputs')
           o_resource_name = path.split('.')[1]
-          if(o_resource_name)
+          if o_resource_name
             set_resource(
               :outputs, results, o_resource_name,
               :properties => [],
               :diffs => [
-                diff_info
-              ]
+                diff_info,
+              ],
             )
           end
         end
@@ -597,7 +593,7 @@ module Sfn
       # @param name [String]
       # @param resource [Hash]
       def set_resource(kind, results, name, resource)
-        if(results[kind][name])
+        if results[kind][name]
           results[kind][name][:properties] += resource[:properties]
           results[kind][name][:properties].uniq!
           results[kind][name][:diffs] += resource[:diffs]
@@ -616,7 +612,7 @@ module Sfn
       # @param flagged [Array<String>]
       #
       # @return [Hash]
-      def dereference_template(t_key, template, parameters, flagged=[])
+      def dereference_template(t_key, template, parameters, flagged = [])
         template = template.to_smash
         translator = translator_for(t_key, template, parameters)
         flagged.each do |item|
@@ -630,16 +626,16 @@ module Sfn
         end
         translator.original.replace(template)
         ['Outputs', 'Resources'].each do |t_key|
-          if(template[t_key])
+          if template[t_key]
             template[t_key] = translator.dereference_processor(
               template[t_key], ['DEREF', :all]
             )
           end
         end
-        if(template['Resources'])
+        if template['Resources']
           valid_resources = template['Resources'].map do |resource_name, resource_value|
-            if(resource_value['OnCondition'])
-              if(translator.apply_condition(resource_value['OnCondition']))
+            if resource_value['OnCondition']
+              if translator.apply_condition(resource_value['OnCondition'])
                 resource_name
               end
             else
@@ -660,13 +656,12 @@ module Sfn
       # @param template [Hash] stack template
       # @param parameters [Hash] stack parameters
       # @return [Translator]
-      def translator_for(t_key, template=nil, parameters=nil)
+      def translator_for(t_key, template = nil, parameters = nil)
         o_translator = translators[t_key]
-        if(template)
+        if template
           translator = Translator.new(template,
-            :parameters => parameters
-          )
-          if(o_translator)
+                                      :parameters => parameters)
+          if o_translator
             o_translator.flagged.each do |i|
               translator.flag_ref(i)
             end
@@ -674,15 +669,13 @@ module Sfn
           translators[t_key] = translator
           o_translator = translator
         else
-          unless(o_translator)
+          unless o_translator
             o_translator = Translator.new({},
-              :parameters => {}
-            )
+                                          :parameters => {})
           end
         end
         o_translator
       end
-
     end
   end
 end