sparkle_formation 3.0.26 → 3.0.28

data/lib/sparkle_formation/sparkle_attribute/aws.rb

@@ -16,13 +16,14 @@ class SparkleFormation
       #   @option options [String] :delimiter value used for joining items. Defaults to ''
       # @return [Hash]
       def _cf_join(*args)
-        options = args.detect{|i| i.is_a?(Hash) && i[:options]} || {:options => {}}
+        options = args.detect { |i| i.is_a?(Hash) && i[:options] } || {:options => {}}
         args.delete(options)
-        unless(args.size == 1)
+        unless args.size == 1
           args = [args]
         end
         {'Fn::Join' => [options[:options][:delimiter] || '', *args]}
       end
+
       alias_method :join!, :_cf_join
 
       # Split generator
@@ -35,6 +36,7 @@ class SparkleFormation
         __t_stringish(delimiter) unless delimiter.is_a?(Hash)
         {'Fn::Split' => [delimiter, string]}
       end
+
       alias_method :split!, :_cf_split
 
       # Sub generator
@@ -43,9 +45,14 @@ class SparkleFormation
       # @param variables [Hash] key value mappings for substitution
       # @return [Hash]
       def _cf_sub(string, variables = nil)
-        __t_hashish(variables) if variables
-        {'Fn::Sub' => [string, variables].compact}
+        if variables.nil?
+          {'Fn::Sub' => string}
+        else
+          __t_hashish(variables)
+          {'Fn::Sub' => [string, variables]}
+        end
       end
+
       alias_method :_sub, :_cf_sub
       alias_method :sub!, :_cf_sub
 
@@ -58,6 +65,7 @@ class SparkleFormation
         __t_stringish(thing)
         {'Ref' => __attribute_key(thing)}
       end
+
       alias_method :_ref, :_cf_ref
       alias_method :ref!, :_cf_ref
 
@@ -69,6 +77,7 @@ class SparkleFormation
         __t_stringish(thing) unless thing.is_a?(Hash)
         {'Fn::ImportValue' => __attribute_key(thing)}
       end
+
       alias_method :_import_value, :_cf_value_import
       alias_method :import_value!, :_cf_value_import
 
@@ -81,18 +90,19 @@ class SparkleFormation
       def _cf_map(thing, key, *suffix)
         __t_stringish(thing)
         suffix = suffix.map do |item|
-          if(item.is_a?(Symbol))
+          if item.is_a?(Symbol)
             _process_key(item, :force)
           else
             item
           end
         end
         thing = __attribute_key(thing)
-        if(key.is_a?(Symbol))
+        if key.is_a?(Symbol)
           key = ref!(key)
         end
         {'Fn::FindInMap' => [thing, key, *suffix]}
       end
+
       alias_method :_cf_find_in_map, :_cf_map
       alias_method :find_in_map!, :_cf_map
       alias_method :map!, :_cf_map
@@ -107,7 +117,7 @@ class SparkleFormation
         args = args.slice(1, args.size)
         __t_stringish(r_name)
         args = args.map do |thing|
-          if(thing.is_a?(Symbol))
+          if thing.is_a?(Symbol)
             _process_key(thing, :force)
           else
             thing
@@ -115,6 +125,7 @@ class SparkleFormation
         end
         {'Fn::GetAtt' => [__attribute_key(r_name), *args]}
       end
+
       alias_method :_cf_get_att, :_cf_attr
       alias_method :get_att!, :_cf_attr
       alias_method :attr!, :_cf_attr
@@ -126,13 +137,14 @@ class SparkleFormation
       def _cf_base64(arg)
         {'Fn::Base64' => arg}
       end
+
       alias_method :base64!, :_cf_base64
 
       # Fn::GetAZs generator
       #
       # @param region [String, Symbol] String will pass through. Symbol will be converted to ref
       # @return [Hash]
-      def _cf_get_azs(region=nil)
+      def _cf_get_azs(region = nil)
         region = case region
                  when Symbol
                    _cf_ref(region)
@@ -143,6 +155,7 @@ class SparkleFormation
                  end
         {'Fn::GetAZs' => region}
       end
+
       alias_method :get_azs!, :_cf_get_azs
       alias_method :azs!, :_cf_get_azs
 
@@ -156,6 +169,7 @@ class SparkleFormation
         item = _cf_ref(item) if item.is_a?(Symbol)
         {'Fn::Select' => [index, item]}
       end
+
       alias_method :select!, :_cf_select
 
       # Condition generator
@@ -166,6 +180,7 @@ class SparkleFormation
         __t_stringish(name)
         {'Condition' => __attribute_key(name)}
       end
+
       alias_method :condition!, :_condition
 
       # Condition setter
@@ -177,6 +192,7 @@ class SparkleFormation
       def _on_condition(name)
         _set(*_condition(name).to_a.flatten)
       end
+
       alias_method :on_condition!, :_on_condition
 
       # Fn::If generator
@@ -188,6 +204,7 @@ class SparkleFormation
       def _if(cond, true_value, false_value)
         {'Fn::If' => _array(__attribute_key(cond), true_value, false_value)}
       end
+
       alias_method :if!, :_if
 
       # Fn::And generator
@@ -199,16 +216,17 @@ class SparkleFormation
       def _and(*args)
         {
           'Fn::And' => _array(
-            *args.map{|v|
-              if(v.is_a?(Symbol) || v.is_a?(String))
-                _condition(v)
-              else
-                v
-              end
-            }
-          )
+            *args.map { |v|
+            if v.is_a?(Symbol) || v.is_a?(String)
+              _condition(v)
+            else
+              v
+            end
+          }
+          ),
         }
       end
+
       alias_method :and!, :_and
 
       # Fn::Equals generator
@@ -219,6 +237,7 @@ class SparkleFormation
       def _equals(v1, v2)
         {'Fn::Equals' => _array(v1, v2)}
       end
+
       alias_method :equals!, :_equals
 
       # Fn::Not generator
@@ -226,13 +245,14 @@ class SparkleFormation
       # @param arg [Object]
       # @return [Hash]
       def _not(arg)
-        if(arg.is_a?(String) || arg.is_a?(Symbol))
+        if arg.is_a?(String) || arg.is_a?(Symbol)
           arg = _condition(arg)
         else
           arg = _array(arg).first
         end
         {'Fn::Not' => [arg]}
       end
+
       alias_method :not!, :_not
 
       # Fn::Or generator
@@ -243,16 +263,17 @@ class SparkleFormation
       def _or(*args)
         {
           'Fn::Or' => _array(
-            *args.map{|v|
-              if(v.is_a?(Symbol) || v.is_a?(String))
-                _condition(v)
-              else
-                v
-              end
-            }
-          )
+            *args.map { |v|
+            if v.is_a?(Symbol) || v.is_a?(String)
+              _condition(v)
+            else
+              v
+            end
+          }
+          ),
         }
       end
+
       alias_method :or!, :_or
 
       # No value generator
@@ -261,6 +282,7 @@ class SparkleFormation
       def _no_value
         _ref('AWS::NoValue')
       end
+
       alias_method :no_value!, :_no_value
 
       # Region generator
@@ -269,6 +291,7 @@ class SparkleFormation
       def _region
         _ref('AWS::Region')
       end
+
       alias_method :region!, :_region
 
       # Notification ARNs generator
@@ -277,6 +300,7 @@ class SparkleFormation
       def _notification_arns
         _ref('AWS::NotificationARNs')
       end
+
       alias_method :notification_arns!, :_notification_arns
 
       # Account ID generator
@@ -285,6 +309,7 @@ class SparkleFormation
       def _account_id
         _ref('AWS::AccountId')
       end
+
       alias_method :account_id!, :_account_id
 
       # Stack ID generator
@@ -293,6 +318,7 @@ class SparkleFormation
       def _stack_id
         _ref('AWS::StackId')
       end
+
       alias_method :stack_id!, :_stack_id
 
       # Stack name generator
@@ -301,6 +327,7 @@ class SparkleFormation
       def _stack_name
         _ref('AWS::StackName')
       end
+
       alias_method :stack_name!, :_stack_name
 
       # Resource dependency generator
@@ -313,8 +340,9 @@ class SparkleFormation
       # @return [Array<String>]
       # @note this will directly modify the struct at its current context to inject depends on structure
       def _depends_on(*args)
-        _set('DependsOn', [args].flatten.compact.map{|s| __attribute_key(s)})
+        _set('DependsOn', [args].flatten.compact.map { |s| __attribute_key(s) })
       end
+
       alias_method :depends_on!, :_depends_on
 
       # Reference output value from nested stack
@@ -324,15 +352,16 @@ class SparkleFormation
       def _stack_output(stack_name, output_name)
         _cf_attr(_process_key(stack_name), "Outputs.#{__attribute_key(output_name)}")
       end
+
       alias_method :stack_output!, :_stack_output
 
       # @return [TrueClass, FalseClass] resource can be tagged
       def taggable?
-        if(self[:type])
+        if self[:type]
           resource = _self._provider._resources.lookup(self[:type].gsub('::', '_').downcase)
           resource && resource[:properties].include?('Tags')
         else
-          if(_parent)
+          if _parent
             _parent.taggable?
           end
         end
@@ -345,14 +374,12 @@ class SparkleFormation
       def _tags(hash)
         __t_hashish(hash)
         _set('Tags',
-          hash.map{ |k, v|
-            {'Key' => __attribute_key(k), 'Value' => v}
-          }
-        )
+             hash.map { |k, v|
+          {'Key' => __attribute_key(k), 'Value' => v}
+        })
       end
-      alias_method :tags!, :_tags
 
+      alias_method :tags!, :_tags
     end
-
   end
 end

data/lib/sparkle_formation/sparkle_attribute/azure.rb

@@ -14,7 +14,7 @@ class SparkleFormation
       # @param hash [Hash] template dump
       # @return [Hash]
       def self.resources_formatter(hash)
-        if(hash.key?('resources') && !hash['resources'].is_a?(Array))
+        if hash.key?('resources') && !hash['resources'].is_a?(Array)
           resources = hash.delete('resources')
           hash['resources'] = Array.new
           resources.each do |r_name, r_contents|
@@ -34,11 +34,12 @@ class SparkleFormation
         klass.class_eval do
           def _azure_dump
             result = _attribute_struct_dump
-            if(_parent.nil?)
+            if _parent.nil?
               result = ::SparkleFormation::SparkleAttribute::Azure.resources_formatter(result)
             end
             result
           end
+
           alias_method :_attribute_struct_dump, :_dump
           alias_method :_dump, :_azure_dump
           alias_method :dump!, :_azure_dump
@@ -73,7 +74,7 @@ class SparkleFormation
         'providers',
         'reference',
         'resourceGroup',
-        'subscription'
+        'subscription',
       ]
 
       # NOTE: Alias implementation disabled due to Ruby 2.3 __callee__ bug
@@ -110,6 +111,7 @@ class SparkleFormation
         x._fn_context = self
         x
       end
+
       alias_method :variables!, :_variables
 
       # @overload _resource_id(resource_name)
@@ -119,14 +121,14 @@ class SparkleFormation
       #     @param [String, Symbol] name of resource
       # @return [FunctionStruct]
       def _resource_id(*args)
-        if(args.size > 1)
+        if args.size > 1
           ::SparkleFormation::FunctionStruct.new('resourceId', *args)
         else
           r_name = args.first
           resource = _root.resources.set!(r_name)
-          if(resource.nil?)
+          if resource.nil?
             ::Kernel.raise ::SparkleFormation::Error::NotFound::Resource.new(:name => r_name)
-          elsif(resource.type.nil?)
+          elsif resource.type.nil?
             ::Kernel.raise ::SparkleFormation::Error::InvalidResource.new(
               "Resource `#{r_name}` provides no type information."
             )
@@ -139,6 +141,7 @@ class SparkleFormation
           end
         end
       end
+
       alias_method :resource_id!, :_resource_id
 
       # Resource dependency generator
@@ -155,7 +158,7 @@ class SparkleFormation
           case item
           when ::Symbol
             resource = _root.resources.set!(item)
-            if(resource.nil?)
+            if resource.nil?
               ::Kernel.raise ::SparkleFormation::Error::NotFound::Resource.new(:name => item)
             else
               [resource.type, resource.resource_name!].join('/')
@@ -166,6 +169,7 @@ class SparkleFormation
         end
         set!(:depends_on, args)
       end
+
       alias_method :depends_on!, :_depends_on
 
       # Reference output value from nested stack
@@ -180,8 +184,8 @@ class SparkleFormation
         o_root.outputs.set!(output_name).value
         o_root
       end
-      alias_method :stack_output!, :_stack_output
 
+      alias_method :stack_output!, :_stack_output
     end
   end
 end

data/lib/sparkle_formation/sparkle_attribute/google.rb

@@ -6,7 +6,6 @@ class SparkleFormation
 
     # Google specific helper implementations
     module Google
-
       CHARACTER_COLLECTION = ('a'..'z').to_a
 
       def self.included(klass)
@@ -15,9 +14,9 @@ class SparkleFormation
         klass.class_eval do
           def _google_dump
             result = _non_google_attribute_struct_dump
-            if(_parent.nil?)
+            if _parent.nil?
               sparkle_root = {}
-              if(result.key?('resources') && result['resources'].is_a?(Hash))
+              if result.key?('resources') && result['resources'].is_a?(Hash)
                 resources = result.delete('resources') || {}
                 sparkle_root = (resources.delete(_self.name) || {}).fetch('properties', {})
                 result['resources'] = resources.map do |r_name, r_content|
@@ -27,21 +26,22 @@ class SparkleFormation
                 result['outputs'] = outputs.map do |o_name, o_content|
                   o_content.merge('name' => o_name)
                 end
-                if(_self.parent.nil?)
+                if _self.parent.nil?
                   result = {
                     'resources' => [{
                       'name' => _self.name,
                       'type' => _self.stack_resource_type,
                       'properties' => {
-                        'stack' => result
-                      }.merge(sparkle_root)
-                    }]
+                        'stack' => result,
+                      }.merge(sparkle_root),
+                    }],
                   }
                 end
               end
             end
             result
           end
+
           alias_method :_non_google_attribute_struct_dump, :_dump
           alias_method :_dump, :_google_dump
           alias_method :dump!, :_google_dump
@@ -56,17 +56,16 @@ class SparkleFormation
       # @see SparkleFormation::SparkleAttribute#dynamic!
       # @note generate unique names using the `:sparkle_unique` argument
       def _google_dynamic!(name, *args, &block)
-        if(args.delete(:sparkle_unique))
+        if args.delete(:sparkle_unique)
           seed = Zlib.crc32(_self.root_path.map(&:name).join('-'))
           gen = Random.new(seed)
           suffix = Array.new(10) do
             CHARACTER_COLLECTION.at(
-              gen.rand(CHARACTER_COLLECTION.size
-              )
+              gen.rand(CHARACTER_COLLECTION.size)
             )
           end.join
-          config_hash = args.detect{|a| a.is_a?(Hash)}
-          unless(config_hash)
+          config_hash = args.detect { |a| a.is_a?(Hash) }
+          unless config_hash
             config_hash = {}
             args.push(config_hash)
           end
@@ -83,12 +82,13 @@ class SparkleFormation
       # @return [SparkleFormation::GoogleStruct]
       def _ref(r_name)
         __t_stringish(r_name)
-        if(_root.resources.set!(r_name).nil?)
+        if _root.resources.set!(r_name).nil?
           ::Kernel.raise ::SparkleFormation::Error::NotFound::Resource.new(:name => r_name)
         else
           ::SparkleFormation::GoogleStruct.new('ref').set!(__attribute_key(r_name))
         end
       end
+
       alias_method :ref!, :_ref
 
       # Jinja function string wrapper
@@ -97,6 +97,7 @@ class SparkleFormation
       def _jinja
         ::SparkleFormation::JinjaExpressionStruct.new
       end
+
       alias_method :jinja!, :_jinja
       alias_method :fn!, :_jinja
 
@@ -108,6 +109,7 @@ class SparkleFormation
         __t_stringish(e_name)
         _jinja.env[__attribute_key(e_name)]
       end
+
       alias_method :env!, :_env
 
       # Access a property value supplied to template
@@ -119,6 +121,7 @@ class SparkleFormation
         __t_stringish(p_name)
         _jinja.properties[__attribute_key(p_name)]
       end
+
       alias_method :property!, :_property
       alias_method :properties!, :_property
 
@@ -129,6 +132,7 @@ class SparkleFormation
       def _statement(line)
         ::SparkleFormation::JinjaStatementStruct.new(line)
       end
+
       alias_method :statement!, :_statement
 
       # Reference output value from nested stack
@@ -141,9 +145,8 @@ class SparkleFormation
         __t_stringish(output_name)
         _ref(stack_name)._set(output_name)
       end
-      alias_method :stack_output!, :_stack_output
 
+      alias_method :stack_output!, :_stack_output
     end
-
   end
 end

data/lib/sparkle_formation/sparkle_attribute/heat.rb

@@ -10,7 +10,7 @@ class SparkleFormation
 
       # Set customized struct behavior
       def self.included(klass)
-        if(klass.const_defined?(:CAMEL_KEYS))
+        if klass.const_defined?(:CAMEL_KEYS)
           klass.send(:remove_const, :CAMEL_KEYS)
         end
         klass.const_set(:CAMEL_KEYS, false)
@@ -28,6 +28,7 @@ class SparkleFormation
         end
         {'get_attr' => args}
       end
+
       alias_method :_attr, :_get_attr
       alias_method :attr!, :_get_attr
 
@@ -39,13 +40,14 @@ class SparkleFormation
       #   @option options [String] :delimiter value used for joining items. Defaults to ''
       # @return [Hash]
       def _list_join(*args)
-        options = args.detect{|i| i.is_a?(::Hash) && i[:options]} || {:options => {}}
+        options = args.detect { |i| i.is_a?(::Hash) && i[:options] } || {:options => {}}
         args.delete(options)
-        unless(args.size == 1)
+        unless args.size == 1
           args = [args]
         end
         {'list_join' => [options[:options][:delimiter] || '', *args]}
       end
+
       alias_method :_join, :_list_join
       alias_method :join!, :_list_join
 
@@ -57,6 +59,7 @@ class SparkleFormation
         __t_stringish(loc)
         {'get_file' => loc}
       end
+
       alias_method :_file, :_get_file
       alias_method :file!, :_get_file
 
@@ -76,6 +79,7 @@ class SparkleFormation
         end
         {'get_param' => args.size == 1 ? args.first : args}
       end
+
       alias_method :_param, :_get_param
       alias_method :param!, :_get_param
 
@@ -87,6 +91,7 @@ class SparkleFormation
         __t_stringish(r_name)
         {'get_resource' => __attribute_key(r_name)}
       end
+
       alias_method :_resource, :_get_resource
       alias_method :resource!, :_get_resource
 
@@ -94,10 +99,11 @@ class SparkleFormation
       #
       # @param value [String, Hash] thing to be hashed
       # @param algorithm [String] algorithm to use (defaults to 'sha512')
-      def _digest(value, algorithm='sha512')
+      def _digest(value, algorithm = 'sha512')
         __t_stringish(algorithm)
         {'digest' => [algorithm, value]}
       end
+
       alias_method :digest!, :_digest
 
       # resource_facade generator
@@ -108,6 +114,7 @@ class SparkleFormation
         __t_stringish(type)
         {'resource_facade' => type}
       end
+
       alias_method :_facade, :_resource_facade
       alias_method :facade!, :_resource_facade
       alias_method :resource_facade!, :_resource_facade
@@ -122,6 +129,7 @@ class SparkleFormation
         __t_hashish(params)
         {'str_replace' => {'template' => template, 'params' => params}}
       end
+
       alias_method :_replace, :_str_replace
       alias_method :replace!, :_str_replace
 
@@ -131,10 +139,11 @@ class SparkleFormation
       # @param string [Object]
       # @param idx [Numeric]
       # @return [Hash]
-      def _str_split(splitter, string, idx=nil)
+      def _str_split(splitter, string, idx = nil)
         __t_stringish(splitter) unless splitter.is_a?(Hash)
         {'str_split' => [splitter, string, idx].compact}
       end
+
       alias_method :_split, :_str_split
       alias_method :split!, :_str_split
 
@@ -146,24 +155,28 @@ class SparkleFormation
       def _map_merge(*args)
         {'map_merge' => args}
       end
+
       alias_method :map_merge!, :_map_merge
 
       # @return [Hash]
       def _stack_id
         _get_param('OS::stack_id')
       end
+
       alias_method :stack_id!, :_stack_id
 
       # @return [Hash]
       def _stack_name
         _get_param('OS::stack_name')
       end
+
       alias_method :stack_name!, :_stack_name
 
       # @return [Hash]
       def _project_id
         _get_param('OS::project_id')
       end
+
       alias_method :project_id!, :_project_id
 
       # Resource dependency generator
@@ -176,8 +189,9 @@ class SparkleFormation
       # @return [Array<String>]
       # @note this will directly modify the struct at its current context to inject depends on structure
       def _depends_on(*args)
-        _set('depends_on', [args].flatten.compact.map{|s| __attribute_key(s) })
+        _set('depends_on', [args].flatten.compact.map { |s| __attribute_key(s) })
       end
+
       alias_method :depends_on!, :_depends_on
 
       # Reference output value from nested stack
@@ -191,9 +205,10 @@ class SparkleFormation
           __attribute_key(output_name)
         )
       end
-      alias_method :stack_output!, :_stack_output
 
+      alias_method :stack_output!, :_stack_output
     end
+
     OpenStack = Heat
   end
 end

data/lib/sparkle_formation/sparkle_attribute/rackspace.rb

@@ -14,8 +14,6 @@ class SparkleFormation
       def self.included(klass)
         klass.include SparkleFormation::SparkleAttribute::Heat
       end
-
     end
-
   end
 end