sparkle_formation 1.2.0 → 2.0.0

data/lib/sparkle_formation/sparkle_attribute.rb

@@ -6,6 +6,9 @@ class SparkleFormation
   module SparkleAttribute
 
     autoload :Aws, 'sparkle_formation/sparkle_attribute/aws'
+    autoload :Azure, 'sparkle_formation/sparkle_attribute/azure'
+    autoload :Heat, 'sparkle_formation/sparkle_attribute/heat'
+    autoload :Rackspace, 'sparkle_formation/sparkle_attribute/rackspace'
 
     # Return current resource name
     #
@@ -88,26 +91,18 @@ class SparkleFormation
       SparkleFormation.nest(template, self, *args, &block)
     end
 
-    # TODO: Deprecate or re-imagine
-
-    # @return [TrueClass, FalseClass]
-    def rhel?
-      !!@platform[:rhel]
-    end
-
-    # @return [TrueClass, FalseClass]
-    def debian?
-      !!@platform[:debian]
-    end
-
-    # Set the destination platform
+    # Format the provided key. If symbol type is provided
+    # formatting is forced. Otherwise the default formatting
+    # is applied
     #
-    # @param plat [String, Symbol] one of :rhel or :debian
-    # @return [TrueClass]
-    def _platform=(plat)
-      @platform || __hashish
-      @platform.clear
-      @platform[plat.to_sym] = true
+    # @param key [String, Symbol] given key
+    # @return [String] formatted key
+    def __attribute_key(key)
+      if(key.is_a?(::Symbol) || key.is_a?(::String))
+        _process_key(key, key.is_a?(::Symbol) ? :force : nil)
+      else
+        key
+      end
     end
 
   end

data/lib/sparkle_formation/sparkle_attribute/aws.rb

@@ -29,8 +29,7 @@ class SparkleFormation
       # @note Symbol value will force key processing
       def _cf_ref(thing)
         __t_stringish(thing)
-        thing = _process_key(thing, :force) if thing.is_a?(Symbol)
-        {'Ref' => thing}
+        {'Ref' => __attribute_key(thing)}
       end
       alias_method :_ref, :_cf_ref
       alias_method :ref!, :_cf_ref
@@ -50,7 +49,7 @@ class SparkleFormation
             item
           end
         end
-        thing = _process_key(thing, :force) if thing.is_a?(Symbol)
+        thing = __attribute_key(thing)
         if(key.is_a?(Symbol))
           key = ref!(key)
         end
@@ -65,7 +64,9 @@ class SparkleFormation
       # @param [Object] pass through arguments
       # @return [Hash]
       def _cf_attr(*args)
-        __t_stringish(args.first)
+        r_name = args.first
+        args = args.slice(1, args.size)
+        __t_stringish(r_name)
         args = args.map do |thing|
           if(thing.is_a?(Symbol))
             _process_key(thing, :force)
@@ -73,7 +74,7 @@ class SparkleFormation
             thing
           end
         end
-        {'Fn::GetAtt' => args}
+        {'Fn::GetAtt' => [__attribute_key(r_name), *args]}
       end
       alias_method :_cf_get_att, :_cf_attr
       alias_method :get_att!, :_cf_attr
@@ -124,7 +125,7 @@ class SparkleFormation
       # @return [Hash]
       def _condition(name)
         __t_stringish(name)
-        {'Condition' => name.is_a?(Symbol) ? _process_key(name, :force) : name}
+        {'Condition' => __attribute_key(name)}
       end
       alias_method :condition!, :_condition
 
@@ -146,8 +147,7 @@ class SparkleFormation
       # @param false_value [Object]
       # @return [Hash]
       def _if(cond, true_value, false_value)
-        cond = cond.is_a?(Symbol) ? _process_key(cond) : cond
-        {'Fn::If' => _array(cond, true_value, false_value)}
+        {'Fn::If' => _array(__attribute_key(cond), true_value, false_value)}
       end
       alias_method :if!, :_if
 
@@ -269,7 +269,7 @@ class SparkleFormation
       # @param [Symbol, String, Array<Symbol, String>] resource names
       # @return [Array<String>]
       def _depends_on(*args)
-        _set('DependsOn', [args].flatten.compact.map{|s| _process_key(s)})
+        _set('DependsOn', [args].flatten.compact.map{|s| __attribute_key(s)})
       end
       alias_method :depends_on!, :_depends_on
 
@@ -278,7 +278,7 @@ class SparkleFormation
       # @param stack_name [String, Symbol] logical resource name of stack
       # @apram output_name [String, Symbol] stack output name
       def _stack_output(stack_name, output_name)
-        _cf_attr(_process_key(stack_name), "Outputs.#{_process_key(output_name)}")
+        _cf_attr(_process_key(stack_name), "Outputs.#{__attribute_key(output_name)}")
       end
       alias_method :stack_output!, :_stack_output
 
@@ -299,10 +299,10 @@ class SparkleFormation
       # @param hash [Hash] Key/value pair tags
       # @return [SparkleStruct]
       def _tags(hash)
+        __t_hashish(hash)
         _set('Tags',
           hash.map{ |k, v|
-            key = k.is_a?(Symbol) ? _process_key(k, :force) : k
-            {'Key' => key, 'Value' => v}
+            {'Key' => __attribute_key(k), 'Value' => v}
           }
         )
       end

data/lib/sparkle_formation/sparkle_attribute/azure.rb

@@ -0,0 +1,161 @@
+require 'sparkle_formation'
+
+class SparkleFormation
+
+  # Provides template helper methods
+  module SparkleAttribute
+
+    # Azure specific helper implementations
+    module Azure
+
+      # Extract resources Hash from template dump and transform to
+      # Array type expected by the ARM API
+      #
+      # @param hash [Hash] template dump
+      # @return [Hash]
+      def self.resources_formatter(hash)
+        if(hash.key?('resources') && !hash['resources'].is_a?(Array))
+          resources = hash.delete('resources')
+          hash['resources'] = Array.new
+          resources.each do |r_name, r_contents|
+            hash['resources'].push(
+              r_contents.merge('name' => r_name)
+            )
+          end
+        end
+        hash
+      end
+
+      # Inject camel style on module inclusion
+      # Add custom dump functionality to properly set resources
+      def self.included(klass)
+        klass.const_set(:CAMEL_STYLE, :no_leading)
+
+        klass.class_eval do
+          def _azure_dump
+            result = _attribute_struct_dump
+            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
+        end
+      end
+
+      # Valid azure builtin functions
+      AZURE_FUNCTIONS = [
+        'add',
+        'copyIndex',
+        'div',
+        'int',
+        'length',
+        'mod',
+        'mul',
+        'sub',
+        'base64',
+        'concat',
+        'padLeft',
+        'replace',
+        'split',
+        'string',
+        'substring',
+        'toLower',
+        'toUpper',
+        'trim',
+        'uniqueString',
+        'uri',
+        'deployment',
+        'parameters',
+        'variables',
+        'listKeys',
+        'providers',
+        'reference',
+        'resourceGroup',
+        'subscription'
+      ]
+
+      # Generate a builtin azure function
+      #
+      # @return [SparkleFormation::FunctionStruct]
+      def _fn_format(*args)
+        src = ::Kernel.__callee__.to_s
+        src = ::Bogo::Utility.camel(src.sub(/(^_|\!$)/, ''), false)
+        ::SparkleFormation::FunctionStruct.new(src, *args)
+      end
+
+      AZURE_FUNCTIONS.map do |f_name|
+        ::Bogo::Utility.snake(f_name)
+      end.each do |f_name|
+        alias_method "_#{f_name}".to_sym, :_fn_format
+        alias_method "#{f_name}!".to_sym, :_fn_format
+      end
+
+      # Customized resourceId generator that will perform automatic
+      # lookup on defined resources for building the function if Symbol
+      # type is provided
+      #
+      # @param args [Object]
+      # @return [FunctionStruct]
+      def _resource_id(*args)
+        if(args.size > 1)
+          ::SparkleFormation::FunctionStruct.new('resourceId', *args)
+        else
+          r_name = args.first
+          resource = _root.resources.set!(r_name)
+          if(resource.nil?)
+            ::Kernel.raise ::SparkleFormation::Error::NotFound::Resource.new(:name => r_name)
+          else
+            ::SparkleFormation::FunctionStruct.new(
+              'resourceId',
+              resource.type,
+              resource.resource_name!
+            )
+          end
+        end
+      end
+      alias_method :resource_id!, :_resource_id
+
+      # Customized dependsOn generator. Will automatically build resource
+      # reference value using defined resources for Symbol type values. Sets
+      # directly into current context.
+      #
+      # @param args [Object]
+      # @return [Array<String>]
+      def _depends_on(*args)
+        args = args.map do |item|
+          case item
+          when ::Symbol
+            resource = _root.resources.set!(item)
+            if(resource.nil?)
+              ::Kernel.raise ::SparkleFormation::Error::NotFound::Resource.new(:name => item)
+            else
+              [resource.type, resource.resource_name!].join('/')
+            end
+          else
+            item
+          end
+        end
+        set!(:depends_on, args)
+      end
+      alias_method :depends_on!, :_depends_on
+
+      # Reference output value from nested stack
+      #
+      # @param stack_name [String, Symbol] logical resource name of stack
+      # @param output_name [String, Symbol] stack output name
+      # @return [Hash]
+      def _stack_output(stack_name, output_name)
+        stack_name = __attribute_key(stack_name)
+        output_name = __attribute_key(output_name)
+        o_root = _reference(stack_name)
+        o_root.outputs.set!(output_name).value
+        o_root
+      end
+      alias_method :stack_output!, :_stack_output
+
+    end
+  end
+end

data/lib/sparkle_formation/sparkle_attribute/heat.rb

@@ -0,0 +1,177 @@
+require 'sparkle_formation'
+
+class SparkleFormation
+
+  # Provides template helper methods
+  module SparkleAttribute
+
+    # Heat specific helper implementations
+    module Heat
+
+      # Set customized struct behavior
+      def self.included(klass)
+        klass.const_set(:CAMEL_KEYS, false)
+      end
+
+      # get_attr generator
+      #
+      # @param [Object] pass through arguments
+      # @return [Hash]
+      def _get_attr(*args)
+        __t_stringish(args.first)
+        args = args.map do |thing|
+          __attribute_key(thing)
+        end
+        {'get_attr' => args}
+      end
+      alias_method :_attr, :_get_attr
+      alias_method :attr!, :_get_attr
+
+      # list_join generator
+      #
+      # @param args [Object]
+      # @return [Hash]
+      def _list_join(*args)
+        options = args.detect{|i| i.is_a?(::Hash) && i[:options]} || {:options => {}}
+        args.delete(options)
+        unless(args.size == 1)
+          args = [args]
+        end
+        {'list_join' => [options[:options][:delimiter] || '', *args]}
+      end
+      alias_method :_join, :_list_join
+      alias_method :join!, :_list_join
+
+      # get_file generator
+      #
+      # @param loc [String]
+      # @return [Hash]
+      def _get_file(loc)
+        __t_string(loc)
+        {'get_file' => loc}
+      end
+      alias_method :_file, :_get_file
+      alias_method :file!, :_get_file
+
+      # get_param generator
+      #
+      # @param args [Object]
+      # @return [Hash]
+      def _get_param(*args)
+        __t_stringish(args.first)
+        args = args.map do |thing|
+          __attribute_key(thing)
+        end
+        {'get_param' => args.size == 1 ? args.first : args}
+      end
+      alias_method :_param, :_get_param
+      alias_method :param!, :_get_param
+
+      # get_resource generator
+      #
+      # @param r_name [String, Symbol]
+      # @return [Hash]
+      def _get_resource(r_name)
+        __t_stringish(r_name)
+        {'get_resource' => __attribute_key(r_name)}
+      end
+      alias_method :_resource, :_get_resource
+      alias_method :resource!, :_get_resource
+
+      def _digest(value, algorithm='sha512')
+        __t_string(algorithm)
+        {'digest' => [algorithm, value]}
+      end
+      alias_method :digest!, :_digest
+
+      # resource_facade generator
+      #
+      # @param type [String, Symbol]
+      # @return [Hash]
+      def _resource_facade(type)
+        __t_stringish(type)
+        {'resource_facade' => type}
+      end
+      alias_method :_facade, :_resource_facade
+      alias_method :facade!, :_resource_facade
+      alias_method :resource_facade!, :_resource_facade
+
+      # str_replace generator
+      #
+      # @param template [String]
+      # @param params [Hash]
+      # @return [Hash]
+      def _str_replace(template, params)
+        __t_stringish(template)
+        __t_hashish(params)
+        {'str_replace' => {'template' => template, 'params' => params}}
+      end
+      alias_method :_replace, :_str_replace
+      alias_method :replace!, :_str_replace
+
+      # str_split generator
+      #
+      # @param splitter [String]
+      # @param string [Object]
+      # @param idx [Numeric]
+      # @return [Hash]
+      def _str_split(splitter, string, idx=nil)
+        __t_string(splitter)
+        {'str_split' => [splitter, string, idx].compact}
+      end
+      alias_method :_split, :_str_split
+      alias_method :split!, :_str_split
+
+      # map_merge generator
+      #
+      # @param args [Object]
+      # @return [Hash]
+      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
+      #
+      # @param [Symbol, String, Array<Symbol, String>] resource names
+      # @return [Array<String>]
+      def _depends_on(*args)
+        _set('depends_on', [args].flatten.compact.map{|s| __attribute_key(s) })
+      end
+      alias_method :depends_on!, :_depends_on
+
+      # Reference output value from nested stack
+      #
+      # @param stack_name [String, Symbol] logical resource name of stack
+      # @param output_name [String, Symbol] stack output name
+      # @return [Hash]
+      def _stack_output(stack_name, output_name)
+        _attr(
+          __attribute_key(stack_name),
+          __attribute_key(output_name)
+        )
+      end
+      alias_method :stack_output!, :_stack_output
+
+    end
+
+  end
+end