sparkle_formation 2.1.8 → 3.0.0

data/lib/sparkle_formation/sparkle_attribute/aws.rb

@@ -8,9 +8,12 @@ class SparkleFormation
     # AWS specific helper implementations
     module Aws
 
-      # Fn::Join generator
-      #
-      # @param args [Object]
+      # @overload _cf_join(*args, opts={})
+      #   Fn::Join generator
+      #   @param args [String, Hash] list of items to join
+      #   @param opts [Hash]
+      #   @option opts [Hash] :options options for join function
+      #   @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 => {}}
@@ -34,11 +37,11 @@ class SparkleFormation
       alias_method :_ref, :_cf_ref
       alias_method :ref!, :_cf_ref
 
-      # Fn::FindInMap generator
-      #
-      # @param thing [String, Symbol] thing to find
-      # @param key [String, Symbol] thing to search
-      # @param suffix [Object] additional args
+      # @overload _cf_map(map_name, top_level_key, second_level_key)
+      #   Fn::FindInMap generator
+      #   @param map_name [String, Symbol] name of map
+      #   @param top_level_key [String, Symbol, Hash] top level key name
+      #   @param second_level_key [String, Symbol, Hash] second level key name
       # @return [Hash]
       def _cf_map(thing, key, *suffix)
         __t_stringish(thing)
@@ -59,9 +62,10 @@ class SparkleFormation
       alias_method :find_in_map!, :_cf_map
       alias_method :map!, :_cf_map
 
-      # Fn::GetAtt generator
-      #
-      # @param [Object] pass through arguments
+      # @overload _cf_attr(logical_id, attribute_name)
+      #   Fn::GetAtt generator
+      #   @param logical_id [String, Symbol] logical resource name
+      #   @param attribute_name [String, Symbol] name of desired resource attribute
       # @return [Hash]
       def _cf_attr(*args)
         r_name = args.first
@@ -82,7 +86,7 @@ class SparkleFormation
 
       # Fn::Base64 generator
       #
-      # @param arg [Object] pass through
+      # @param arg [Object] argument to be encoded
       # @return [Hash]
       def _cf_base64(arg)
         {'Fn::Base64' => arg}
@@ -143,8 +147,8 @@ class SparkleFormation
       # Fn::If generator
       #
       # @param cond [String, Symbol] symbol will be case processed
-      # @param true_value [Object]
-      # @param false_value [Object]
+      # @param true_value [Object] item to be used when true
+      # @param false_value [Object] item to be used when false
       # @return [Hash]
       def _if(cond, true_value, false_value)
         {'Fn::If' => _array(__attribute_key(cond), true_value, false_value)}
@@ -153,7 +157,7 @@ class SparkleFormation
 
       # Fn::And generator
       #
-      # @param args [Object]
+      # @param args [Object] items to be AND'ed together
       # @return [Hash]
       # @note symbols will be processed and set as condition. strings
       #   will be set as condition directly. procs will be evaluated
@@ -218,7 +222,7 @@ class SparkleFormation
 
       # No value generator
       #
-      # @return [String]
+      # @return [Hash]
       def _no_value
         _ref('AWS::NoValue')
       end
@@ -265,9 +269,14 @@ class SparkleFormation
       alias_method :stack_name!, :_stack_name
 
       # Resource dependency generator
-      #
-      # @param [Symbol, String, Array<Symbol, String>] resource names
+      # @overload _depends_on(resource_name)
+      #   @param resource_name [String, Symbol] logical resource name
+      # @overload _depends_on(resource_names)
+      #   @param resource_names [Array<String, Symbol>] list of logical resource names
+      # @overload _depends_on(*resource_names)
+      #   @param resource_names [Array<String, Symbol>] list of logical resource names
       # @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)})
       end

data/lib/sparkle_formation/sparkle_attribute/azure.rb

@@ -77,6 +77,9 @@ class SparkleFormation
         'subscription'
       ]
 
+      # NOTE: Alias implementation disabled due to Ruby 2.3 __callee__ bug
+      #   see: https://bugs.ruby-lang.org/issues/12176
+
       # Generate a builtin azure function
       #
       # @return [SparkleFormation::FunctionStruct]
@@ -89,15 +92,22 @@ class SparkleFormation
       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
+        # alias_method "_#{f_name}".to_sym, :_fn_format
+        # alias_method "#{f_name}!".to_sym, :_fn_format
+
+        define_method("_#{f_name}".to_sym) do |*args|
+          src = ::Kernel.__callee__.to_s
+          src = ::Bogo::Utility.camel(src.sub(/(^_|\!$)/, ''), false)
+          ::SparkleFormation::FunctionStruct.new(src, *args)
+        end
+        alias_method "#{f_name}!".to_sym, "_#{f_name}".to_sym
       end
 
-      # Customized resourceId generator that will perform automatic
-      # lookup on defined resources for building the function if Symbol
-      # type is provided
-      #
-      # @param args [Object]
+      # @overload _resource_id(resource_name)
+      #   Customized resourceId generator that will perform automatic
+      #   lookup on defined resources for building the function if Symbol
+      #   type is provided
+      #     @param [String, Symbol] name of resource
       # @return [FunctionStruct]
       def _resource_id(*args)
         if(args.size > 1)
@@ -118,12 +128,15 @@ class SparkleFormation
       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]
+      # Resource dependency generator
+      # @overload _depends_on(resource_name)
+      #   @param resource_name [String, Symbol] logical resource name
+      # @overload _depends_on(resource_names)
+      #   @param resource_names [Array<String, Symbol>] list of logical resource names
+      # @overload _depends_on(*resource_names)
+      #   @param resource_names [Array<String, Symbol>] list of logical resource names
       # @return [Array<String>]
+      # @note this will directly modify the struct at its current context to inject depends on structure
       def _depends_on(*args)
         args = args.map do |item|
           case item

data/lib/sparkle_formation/sparkle_attribute/google.rb

@@ -0,0 +1,149 @@
+require 'zlib'
+require 'sparkle_formation'
+
+class SparkleFormation
+  module SparkleAttribute
+
+    # Google specific helper implementations
+    module Google
+
+      CHARACTER_COLLECTION = ('a'..'z').to_a
+
+      def self.included(klass)
+        klass.const_set(:CAMEL_STYLE, :no_leading)
+
+        klass.class_eval do
+          def _google_dump
+            result = _non_google_attribute_struct_dump
+            if(_parent.nil?)
+              sparkle_root = {}
+              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|
+                  r_content.merge('name' => r_name)
+                end
+                outputs = result.delete('outputs') || {}
+                result['outputs'] = outputs.map do |o_name, o_content|
+                  o_content.merge('name' => o_name)
+                end
+                if(_self.parent.nil?)
+                  result = {
+                    'resources' => [{
+                      'name' => _self.name,
+                      'type' => _self.stack_resource_type,
+                      'properties' => {
+                        '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
+          alias_method :_non_google_dynamic!, :dynamic!
+          alias_method :dynamic!, :_google_dynamic!
+        end
+      end
+
+      # Customized dynamic to provide automatic unique name generation for
+      # built in resources
+      #
+      # @see SparkleFormation::SparkleAttribute#dynamic!
+      # @note generate unique names using the `:sparkle_unique` argument
+      def _google_dynamic!(name, *args, &block)
+        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
+              )
+            )
+          end.join
+          config_hash = args.detect{|a| a.is_a?(Hash)}
+          unless(config_hash)
+            config_hash = {}
+            args.push(config_hash)
+          end
+          config_hash[:resource_name_suffix] = "-#{suffix}"
+          args[0] = args.first.to_s.tr('_', '-').downcase
+        end
+        _non_google_dynamic!(name, *args, &block)
+      end
+
+      # Reference generator. Will lookup defined resource name
+      # to validate exist.
+      #
+      # @param r_name [String, Symbol] resource name
+      # @return [SparkleFormation::GoogleStruct]
+      def _ref(r_name)
+        __t_stringish(r_name)
+        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
+      #
+      # @return [SparkleFormation::JinjaExpressionStruct]
+      def _jinja
+        ::SparkleFormation::JinjaExpressionStruct.new
+      end
+      alias_method :jinja!, :_jinja
+      alias_method :fn!, :_jinja
+
+      # Request deployment manager environment variable
+      #
+      # @param e_name [String, Symbol] environment variable name
+      # @return [SparkleFormation::JinjaExpressionStruct]
+      def _env(e_name)
+        __t_stringish(e_name)
+        _jinja.env[__attribute_key(e_name)]
+      end
+      alias_method :env!, :_env
+
+      # Access a property value supplied to template
+      #
+      # @param p_name [String, Symbol] parameter name
+      # @return [SparkleFormation::JinjaExpressionStruct]
+      # @todo Provide lookup validation that defined p_name is valid
+      def _property(p_name)
+        __t_stringish(p_name)
+        _jinja.properties[__attribute_key(p_name)]
+      end
+      alias_method :property!, :_property
+      alias_method :properties!, :_property
+
+      # Generate a statement
+      #
+      # @param line [String]
+      # @return [SparkleFormation::JinjaStatementStruct]
+      def _statement(line)
+        ::SparkleFormation::JinjaStatementStruct.new(line)
+      end
+      alias_method :statement!, :_statement
+
+      # 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 [SparkleFormation::JinjaExpressionStruct]
+      def _stack_output(stack_name, output_name)
+        __t_stringish(stack_name)
+        __t_stringish(output_name)
+        _ref(stack_name)._set(output_name)
+      end
+      alias_method :stack_output!, :_stack_output
+
+    end
+
+  end
+end

data/lib/sparkle_formation/sparkle_attribute/heat.rb

@@ -13,9 +13,10 @@ class SparkleFormation
         klass.const_set(:CAMEL_KEYS, false)
       end
 
-      # get_attr generator
-      #
-      # @param [Object] pass through arguments
+      # @overload _get_attr(logical_id, attribute_name)
+      #   get_attr generator
+      #   @param logical_id [String, Symbol] logical resource name
+      #   @param attribute_name [String, Symbol] name of desired resource attribute
       # @return [Hash]
       def _get_attr(*args)
         __t_stringish(args.first)
@@ -27,9 +28,12 @@ class SparkleFormation
       alias_method :_attr, :_get_attr
       alias_method :attr!, :_get_attr
 
-      # list_join generator
-      #
-      # @param args [Object]
+      # @overload _list_join(*args, opts={})
+      #   list_join generator
+      #   @param args [String, Hash] list of items to join
+      #   @param opts [Hash]
+      #   @option opts [Hash] :options options for join function
+      #   @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 => {}}
@@ -53,9 +57,14 @@ class SparkleFormation
       alias_method :_file, :_get_file
       alias_method :file!, :_get_file
 
-      # get_param generator
-      #
-      # @param args [Object]
+      # @overload _get_param(name)
+      #   get_param generator
+      #   @param name [String, Symbol] name of parameter
+      # @overload _get_param(name, index1, index2, ...)
+      #   get_param generator accessing complex data
+      #   @param name [String, Symbol] name of parameter
+      #   @param index1 [Object] value for key/index
+      #   @param index2 [Object] value for key/index
       # @return [Hash]
       def _get_param(*args)
         __t_stringish(args.first)
@@ -78,6 +87,10 @@ class SparkleFormation
       alias_method :_resource, :_get_resource
       alias_method :resource!, :_get_resource
 
+      # digest generator
+      #
+      # @param value [String, Hash] thing to be hashed
+      # @param algorithm [String] algorithm to use (defaults to 'sha512')
       def _digest(value, algorithm='sha512')
         __t_string(algorithm)
         {'digest' => [algorithm, value]}
@@ -122,9 +135,10 @@ class SparkleFormation
       alias_method :_split, :_str_split
       alias_method :split!, :_str_split
 
-      # map_merge generator
-      #
-      # @param args [Object]
+      # @overload _map_merge(hash1, hash2, ...)
+      #   map_merge generator
+      #   @param hash1 [Hash] item to merge
+      #   @param hash2 [Hash] item to merge
       # @return [Hash]
       def _map_merge(*args)
         {'map_merge' => args}
@@ -150,9 +164,14 @@ class SparkleFormation
       alias_method :project_id!, :_project_id
 
       # Resource dependency generator
-      #
-      # @param [Symbol, String, Array<Symbol, String>] resource names
+      # @overload _depends_on(resource_name)
+      #   @param resource_name [String, Symbol] logical resource name
+      # @overload _depends_on(resource_names)
+      #   @param resource_names [Array<String, Symbol>] list of logical resource names
+      # @overload _depends_on(*resource_names)
+      #   @param resource_names [Array<String, Symbol>] list of logical resource names
       # @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) })
       end

data/lib/sparkle_formation/sparkle_collection.rb

@@ -8,10 +8,16 @@ class SparkleFormation
 
     autoload :Rainbow, 'sparkle_formation/sparkle_collection/rainbow'
 
+    # @return [Symbol] provider
+    attr_accessor :provider
+
     # Create a new collection of sparkles
     #
+    # @param args [Hash]
+    # @option args [Symbol, String] :provider name of default provider
     # @return [self]
-    def initialize(*_)
+    def initialize(args={})
+      @provider = Bogo::Utility.snake(args.to_smash.fetch(:provider, 'aws')).to_sym
       @root = nil
       @sparkles = []
     end
@@ -81,9 +87,13 @@ class SparkleFormation
       memoize("components_#{checksum}") do
         Smash.new.tap do |hsh|
           sparkles.each do |sprkl|
-            sprkl.components.each_pair do |c_name, c_value|
-              hsh[c_name] ||= Rainbow.new(c_name, :component)
-              hsh[c_name].add_layer(c_value)
+            sprkl.components.each_pair do |c_provider, c_info|
+              c_info.each_pair do |c_name, c_value|
+                unless(hsh.get(c_provider, c_name))
+                  hsh.set(c_provider, c_name, Rainbow.new(c_name, :component))
+                end
+                hsh.get(c_provider, c_name).add_layer(c_value)
+              end
             end
           end
         end
@@ -95,9 +105,13 @@ class SparkleFormation
       memoize("dynamics_#{checksum}") do
         Smash.new.tap do |hsh|
           sparkles.each do |sprkl|
-            sprkl.dynamics.each_pair do |c_name, c_value|
-              hsh[c_name] ||= Rainbow.new(c_name, :dynamic)
-              hsh[c_name].add_layer(c_value)
+            sprkl.dynamics.each_pair do |c_provider, c_info|
+              c_info.each_pair do |c_name, c_value|
+                unless(hsh.get(c_provider, c_name))
+                  hsh.set(c_provider, c_name, Rainbow.new(c_name, :dynamic))
+                end
+                hsh.get(c_provider, c_name).add_layer(c_value)
+              end
             end
           end
         end
@@ -109,7 +123,7 @@ class SparkleFormation
       memoize("registries_#{checksum}") do
         Smash.new.tap do |hsh|
           sparkles.each do |sprkl|
-            hsh.merge!(sprkl.registries)
+            hsh.deep_merge!(sprkl.registries)
           end
         end
       end
@@ -120,9 +134,13 @@ class SparkleFormation
       memoize("templates_#{checksum}") do
         Smash.new.tap do |hsh|
           sparkles.each do |sprkl|
-            sprkl.templates.each_pair do |c_name, c_value|
-              hsh[c_name] ||= Rainbow.new(c_name, :template)
-              hsh[c_name].add_layer(c_value)
+            sprkl.templates.each_pair do |c_provider, c_info|
+              c_info.each_pair do |c_name, c_value|
+                unless(hsh.get(c_provider, c_name))
+                  hsh.set(c_provider, c_name, Rainbow.new(c_name, :template))
+                end
+                hsh.get(c_provider, c_name).add_layer(c_value)
+              end
             end
           end
         end
@@ -133,25 +151,29 @@ class SparkleFormation
     #
     # @param type [String, Symbol] item type (see: TYPES)
     # @param name [String, Symbol] name of item
+    # @param target_provider [String, Symbol] restrict to provider
     # @return [Smash] requested item
     # @raises [NameError, Error::NotFound]
-    def get(type, name)
+    def get(type, name, target_provider=nil)
       type_name = Sparkle::TYPES[type.to_s]
       unless(type_name)
         raise ArgumentError.new "Unknown file type requested from collection `#{type}`"
       end
       result = nil
       error = nil
-      result = send(type_name)[name]
+      unless(target_provider)
+        target_provider = provider
+      end
+      result = send(type_name).get(target_provider, name)
       if(result.nil? && type_name == 'templates')
         t_direct = sparkles.map do |pack|
           begin
-            pack.get(:template, name)
+            pack.get(:template, name, target_provider)
           rescue Error::NotFound
           end
         end.compact.last
         if(t_direct)
-          result = send(type_name)[t_direct[:name]]
+          result = send(type_name).get(target_provider, t_direct[:name])
         end
       end
       unless(result)