sparkle_formation 1.1.14 → 1.2.0

data/lib/sparkle_formation/sparkle_attribute.rb

@@ -5,276 +5,29 @@ class SparkleFormation
   # Provides template helper methods
   module SparkleAttribute
 
-    # Fn::Join generator
-    #
-    # @param args [Object]
-    # @return [Hash]
-    def _cf_join(*args)
-      options = args.detect{|i| i.is_a?(Hash) && i[:options]} || {:options => {}}
-      args.delete(options)
-      unless(args.size == 1)
-        args = [args]
-      end
-      {'Fn::Join' => [options[:options][:delimiter] || '', *args]}
-    end
-    alias_method :join!, :_cf_join
-
-    # Ref generator
-    #
-    # @param thing [String, Symbol] reference name
-    # @return [Hash]
-    # @note Symbol value will force key processing
-    def _cf_ref(thing)
-      thing = _process_key(thing, :force) if thing.is_a?(Symbol)
-      {'Ref' => thing}
-    end
-    alias_method :_ref, :_cf_ref
-    alias_method :ref!, :_cf_ref
+    autoload :Aws, 'sparkle_formation/sparkle_attribute/aws'
 
-    # Fn::FindInMap generator
+    # Return current resource name
     #
-    # @param thing [String, Symbol] thing to find
-    # @param key [String, Symbol] thing to search
-    # @param suffix [Object] additional args
-    # @return [Hash]
-    def _cf_map(thing, key, *suffix)
-      suffix = suffix.map do |item|
-        if(item.is_a?(Symbol))
-          _process_key(item, :force)
+    # @return [String]
+    def _resource_name
+      result = nil
+      if(_parent)
+        if(_parent._parent == _root)
+          result = _parent._data.detect do |r_name, r_value|
+            r_value == self
+          end
+          result = result.first if result
         else
-          item
+          result = _parent._resource_name
         end
       end
-      thing = _process_key(thing, :force) if thing.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
-
-    # Fn::GetAtt generator
-    #
-    # @param [Object] pass through arguments
-    # @return [Hash]
-    def _cf_attr(*args)
-      args = args.map do |thing|
-        if(thing.is_a?(Symbol))
-          _process_key(thing, :force)
-        else
-          thing
-        end
-
-      end
-      {'Fn::GetAtt' => args}
-    end
-    alias_method :_cf_get_att, :_cf_attr
-    alias_method :get_att!, :_cf_attr
-    alias_method :attr!, :_cf_attr
-
-    # Fn::Base64 generator
-    #
-    # @param arg [Object] pass through
-    # @return [Hash]
-    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)
-      region = case region
-               when Symbol
-                 _cf_ref(region)
-               when NilClass
-                 ''
-               else
-                 region
-               end
-      {'Fn::GetAZs' => region}
-    end
-    alias_method :get_azs!, :_cf_get_azs
-    alias_method :azs!, :_cf_get_azs
-
-    # Fn::Select generator
-    #
-    # @param index [String, Symbol, Integer] Symbol will be converted to ref
-    # @param item [Object, Symbol] Symbol will be converted to ref
-    # @return [Hash]
-    def _cf_select(index, item)
-      index = index.is_a?(Symbol) ? _cf_ref(index) : index
-      item = _cf_ref(item) if item.is_a?(Symbol)
-      {'Fn::Select' => [index, item]}
-    end
-    alias_method :select!, :_cf_select
-
-    # Condition generator
-    #
-    # @param name [String, Symbol] symbol will be processed
-    # @return [Hash]
-    def _condition(name)
-      {'Condition' => name.is_a?(Symbol) ? _process_key(name) : name}
-    end
-    alias_method :condition!, :_condition
-
-    # Condition setter
-    #
-    # @param name [String, Symbol] condition name
-    # @return [SparkleStruct]
-    # @note this is used to set a {"Condition" => "Name"} into the
-    #   current context, generally the top level of a resource
-    def _on_condition(name)
-      _set(*_condition(name).to_a.flatten)
-    end
-    alias_method :on_condition!, :_on_condition
-
-    # Fn::If generator
-    #
-    # @param cond [String, Symbol] symbol will be case processed
-    # @param true_value [Object]
-    # @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)}
-    end
-    alias_method :if!, :_if
-
-    # Fn::And generator
-    #
-    # @param args [Object]
-    # @return [Hash]
-    # @note symbols will be processed and set as condition. strings
-    #   will be set as condition directly. procs will be evaluated
-    def _and(*args)
-      {
-        'Fn::And' => _array(
-          *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
-    #
-    # @param v1 [Object]
-    # @param v2 [Object]
-    # @return [Hash]
-    def _equals(v1, v2)
-      {'Fn::Equals' => _array(v1, v2)}
-    end
-    alias_method :equals!, :_equals
-
-    # Fn::Not generator
-    #
-    # @param arg [Object]
-    # @return [Hash]
-    def _not(arg)
-      if(arg.is_a?(String) || arg.is_a?(Symbol))
-        arg = _condition(arg)
-      else
-        arg = _array(arg).first
+      unless(result)
+        ::Kernel.raise NameError.new 'Failed to determine current resource name! (Check call location)'
       end
-      {'Fn::Not' => [arg]}
-    end
-    alias_method :not!, :_not
-
-    # Fn::Or generator
-    #
-    # @param v1 [Object]
-    # @param v2 [Object]
-    # @return [Hash]
-    def _or(*args)
-      {
-        'Fn::Or' => _array(
-          *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
-    #
-    # @return [String]
-    def _no_value
-      _ref('AWS::NoValue')
-    end
-    alias_method :no_value!, :_no_value
-
-    # Region generator
-    #
-    # @return [Hash]
-    def _region
-      _ref('AWS::Region')
-    end
-    alias_method :region!, :_region
-
-    # Notification ARNs generator
-    #
-    # @return [Hash]
-    def _notification_arns
-      _ref('AWS::NotificationARNs')
-    end
-    alias_method :notification_arns!, :_notification_arns
-
-    # Account ID generator
-    #
-    # @return [Hash]
-    def _account_id
-      _ref('AWS::AccountId')
-    end
-    alias_method :account_id!, :_account_id
-
-    # Stack ID generator
-    #
-    # @return [Hash]
-    def _stack_id
-      _ref('AWS::StackId')
+      result
     end
-    alias_method :stack_id!, :_stack_id
-
-    # Stack name generator
-    #
-    # @return [Hash]
-    def _stack_name
-      _ref('AWS::StackName')
-    end
-    alias_method :stack_name!, :_stack_name
-
-    # Resource dependency generator
-    #
-    # @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)})
-    end
-    alias_method :depends_on!, :_depends_on
-
-    # Reference output value from nested stack
-    #
-    # @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)}")
-    end
-    alias_method :stack_output!, :_stack_output
+    alias_method :resource_name!, :_resource_name
 
     # Execute system command
     #
@@ -300,39 +53,13 @@ class SparkleFormation
     end
     alias_method :raise!, :_raise
 
-    # @return [TrueClass, FalseClass] resource can be tagged
-    def taggable?
-      if(defined?(SfnAws))
-        if(self[:type])
-          resource = SfnAws.lookup(self[:type].gsub('::', '_').downcase)
-          resource && resource[:properties].include?('Tags')
-        else
-          if(self._parent)
-            self._parent.taggable?
-          end
-        end
-      end
-    end
-
-    # @return [TrueClass, FalseClass]
-    def rhel?
-      !!@platform[:rhel]
-    end
-
-    # @return [TrueClass, FalseClass]
-    def debian?
-      !!@platform[:debian]
-    end
-
-    # Set the destination platform
-    #
-    # @param plat [String, Symbol] one of :rhel or :debian
-    # @return [TrueClass]
-    def _platform=(plat)
-      @platform || __hashish
-      @platform.clear
-      @platform[plat.to_sym] = true
+    # Lookup a method definition on self
+    # usually used as `puts! method!(:foo).source_location`
+    # @return [Method]
+    def _method(*args)
+      ::Kernel.instance_method(:method).bind(self).call(*args)
     end
+    alias_method :method!, :_method
 
     # Dynamic insertion helper method
     #
@@ -361,5 +88,27 @@ 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
+    #
+    # @param plat [String, Symbol] one of :rhel or :debian
+    # @return [TrueClass]
+    def _platform=(plat)
+      @platform || __hashish
+      @platform.clear
+      @platform[plat.to_sym] = true
+    end
+
   end
 end

data/lib/sparkle_formation/sparkle_formation.rb

@@ -22,6 +22,8 @@ class SparkleFormation
 
   class << self
 
+    include SparkleFormation::Utils::TypeCheckers
+
     # @return [Hashish] loaded dynamics
     def dynamics
       @dynamics ||= SparkleStruct.hashish.new
@@ -96,7 +98,7 @@ class SparkleFormation
         container = Sparkle.new(:root => spath)
         path = container.get(:template, path)[:path]
       end
-      formation = self.instance_eval(IO.read(path), path, 1)
+      formation = instance_eval(IO.read(path), path, 1)
       if(args.delete(:sparkle))
         formation
       else
@@ -124,7 +126,7 @@ class SparkleFormation
     # @param path [String] path to component
     # @return [SparkleStruct] resulting struct
     def load_component(path)
-      self.instance_eval(IO.read(path), path, 1)
+      instance_eval(IO.read(path), path, 1)
       @_struct
     end
 
@@ -137,7 +139,7 @@ class SparkleFormation
       Dir.glob(File.join(directory, '*.rb')).each do |dyn|
         dyn = File.expand_path(dyn)
         next if @loaded_dynamics.include?(dyn)
-        self.instance_eval(IO.read(dyn), dyn, 1)
+        instance_eval(IO.read(dyn), dyn, 1)
         @loaded_dynamics << dyn
       end
       @loaded_dynamics.uniq!
@@ -194,7 +196,7 @@ class SparkleFormation
     # @param args [Object] parameters for dynamic
     # @return [SparkleStruct]
     def registry(registry_name, struct, *args)
-      result = false
+      __t_stringish(registry_name)
       reg = struct._self.sparkle.get(:registry, registry_name)
       struct.instance_exec(*args, &reg[:block])
     end
@@ -206,6 +208,7 @@ class SparkleFormation
     # @param args [Object] parameters for dynamic
     # @return [SparkleStruct]
     def insert(dynamic_name, struct, *args, &block)
+      __t_stringish(dynamic_name)
       result = false
       begin
         dyn = struct._self.sparkle.get(:dynamic, dynamic_name)
@@ -219,7 +222,13 @@ class SparkleFormation
         result = builtin_insert(dynamic_name, struct, *args, &block)
       end
       unless(result)
-        raise "Failed to locate requested dynamic block for insertion: #{dynamic_name} (valid: #{struct._self.sparkle.dynamics.keys.sort.join(', ')})"
+        message = "Failed to locate requested dynamic block for insertion: #{dynamic_name} " \
+          "(valid: #{struct._self.sparkle.dynamics.keys.sort.join(', ')})"
+        if(struct._self.provider_resources.registry.keys.size > 1)
+          t_name = struct._self.provider_resources.registry.keys.first
+          message << "\nBuiltin dynamics pattern `#{t_name}` -> `:#{Bogo::Utility.snake(t_name.gsub('::', '_'))}`"
+        end
+        raise message
       end
       result
     end
@@ -239,6 +248,9 @@ class SparkleFormation
       else
         options = {}
       end
+      [template, *args].compact.each do |item|
+        __t_stringish(item)
+      end
       to_nest = struct._self.sparkle.get(:template, template)
       resource_name = template.to_s.gsub('__', '_')
       unless(args.empty?)
@@ -247,7 +259,7 @@ class SparkleFormation
           args.map{|a| Bogo::Utility.snake(a)}.join('_')
         ].flatten.compact.join('_').to_sym
       end
-      nested_template = self.compile(to_nest[:path], :sparkle)
+      nested_template = compile(to_nest[:path], :sparkle)
       nested_template.parent = struct._self
       nested_template.name = Bogo::Utility.camel(resource_name)
       if(options[:parameters])
@@ -270,17 +282,17 @@ class SparkleFormation
     # @param args [Object] parameters for dynamic
     # @return [SparkleStruct]
     def builtin_insert(dynamic_name, struct, *args, &block)
-      if(defined?(SfnAws) && lookup_key = SfnAws.registry_key(dynamic_name))
+      if(struct._self.provider_resources && lookup_key = struct._self.provider_resources.registry_key(dynamic_name))
         _name, _config = *args
         _config ||= {}
-        return unless _name
+        __t_stringish(_name)
+        __t_hashish(_config)
         resource_name = "#{_name}_#{_config.delete(:resource_name_suffix) || dynamic_name}".to_sym
-        struct.resources.set!(resource_name)
-        new_resource = struct.resources[resource_name]
+        new_resource = struct.resources.set!(resource_name)
         new_resource.type lookup_key
         properties = new_resource.properties
         config_keys = _config.keys.zip(_config.keys.map{|k| snake(k).to_s.tr('_', '')})
-        SfnAws.resource(dynamic_name, :properties).each do |prop_name|
+        struct._self.provider_resources.resource(dynamic_name, :properties).each do |prop_name|
           key = (config_keys.detect{|k| k.last == snake(prop_name).to_s.tr('_', '')} || []).first
           value = _config[key] if key
           if(value)
@@ -336,6 +348,10 @@ class SparkleFormation
   attr_reader :stack_resource_types
   # @return [Hash] state hash for compile time parameters
   attr_accessor :compile_state
+  # @return [Symbol] target provider
+  attr_reader :provider
+  # @return [Class] Provider resources
+  attr_reader :provider_resources
 
   # Create new instance
   #
@@ -366,7 +382,6 @@ class SparkleFormation
     )
     unless(options[:disable_aws_builtins])
       require 'sparkle_formation/aws'
-      SfnAws.load!
     end
     @parameters = set_generation_parameters!(
       options.fetch(:compile_time_parameters,
@@ -381,12 +396,27 @@ class SparkleFormation
     @load_order = []
     @overrides = []
     @parent = options[:parent]
+    @provider = options.fetch(:provider, @parent ? @parent.provider : :aws)
     if(block)
       load_block(block)
     end
     @compiled = nil
   end
 
+  # Set remote API target for template to allow loading of
+  # provider specific helpers and data if available. Setting
+  # to a false-y value will disable helpers loading
+  #
+  # @param val [String, Symbol, NilClass, FalseClass] remote provider
+  # @return [Symbol, NilClass]
+  def provider=(val)
+    if(val)
+      @provider = Bogo::Utility.snake(val).to_sym
+    else
+      @provider = nil
+    end
+  end
+
   # Check if type is a registered stack type
   #
   # @param type [String]
@@ -508,14 +538,26 @@ class SparkleFormation
   # @option args [Hash] :state local state parameters
   # @return [SparkleStruct]
   def compile(args={})
-    if(args.has_key?(:state))
+    if(args.key?(:state))
       @compile_state = args[:state]
       unmemoize(:compile)
     end
     memoize(:compile) do
       set_compile_time_parameters!
-      compiled = SparkleStruct.new
+      if(provider && SparkleAttribute.const_defined?(camel(provider)))
+        const = SparkleAttribute.const_get(camel(provider))
+        struct_class = Class.new(SparkleStruct)
+        struct_class.include(const)
+      else
+        struct_class = SparkleStruct
+      end
+      if(Resources.const_defined?(camel(provider)))
+        @provider_resources = Resources.const_get(camel(provider))
+        provider_resources.load!
+      end
+      compiled = struct_class.new
       compiled._set_self(self)
+      compiled._struct_class = struct_class
       if(compile_state)
         compiled.set_state!(compile_state)
       end
@@ -562,7 +604,7 @@ class SparkleFormation
   # @return [TrueClass, FalseClass] includes nested stacks
   def nested?(stack_hash=nil)
     stack_hash = compile.dump! unless stack_hash
-    !!stack_hash.fetch('Resources', {}).detect do |r_name, resource|
+    !!stack_hash.fetch('Resources', {}).detect do |_r_name, resource|
       stack_resource_type?(resource['Type'])
     end
   end
@@ -570,7 +612,7 @@ class SparkleFormation
   # @return [TrueClass, FalseClass] includes _only_ nested stacks
   def isolated_nests?(stack_hash=nil)
     stack_hash = compile.dump! unless stack_hash
-    stack_hash.fetch('Resources', {}).all? do |name, resource|
+    stack_hash.fetch('Resources', {}).all? do |_name, resource|
       stack_resource_type?(resource['Type'])
     end
   end
@@ -578,8 +620,8 @@ class SparkleFormation
   # @return [TrueClass, FalseClass] policies defined
   def includes_policies?(stack_hash=nil)
     stack_hash = compile.dump! unless stack_hash
-    stack_hash.fetch('Resources', {}).any? do |name, resource|
-      resource.has_key?('Policy')
+    stack_hash.fetch('Resources', {}).any? do |_name, resource|
+      resource.key?('Policy')
     end
   end
 
@@ -678,7 +720,11 @@ class SparkleFormation
     drip_path = root_path - outputs[output_name].root_path
     bubble_path.each_slice(2) do |base_sparkle, ref_sparkle|
       next unless ref_sparkle
-      base_sparkle.compile.outputs.set!(output_name).set!(:value, base_sparkle.compile.attr!(ref_sparkle.name, "Outputs.#{output_name}"))
+      base_sparkle.compile.outputs.set!(output_name).set!(
+        :value, base_sparkle.compile.attr!(
+          ref_sparkle.name, "Outputs.#{output_name}"
+        )
+      )
     end
     if(bubble_path.empty?)
       if(drip_path.size == 1)
@@ -699,7 +745,7 @@ class SparkleFormation
       drip_path.each_slice(2) do |base_sparkle, ref_sparkle|
         next unless ref_sparkle
         base_sparkle.compile.resources[ref_sparkle.name].properties.parameters.set!(output_name, result)
-        ref_sparkle.compile.parameters.set!(output_name){ type 'String' } # TODO <<<<------ type check and prop
+        ref_sparkle.compile.parameters.set!(output_name){ type 'String' } # TODO: <<<<------ type check and prop
         result = compile.ref!(output_name)
       end
     end
@@ -741,7 +787,7 @@ class SparkleFormation
   def apply_shallow_nesting(*args, &block)
     parameters = compile[:parameters] ? compile[:parameters]._dump : {}
     output_map = {}
-    nested_stacks(:with_resource, :with_name).each do |stack, stack_resource, stack_name|
+    nested_stacks(:with_resource, :with_name).each do |_stack, stack_resource, stack_name|
       remap_nested_parameters(compile, parameters, stack_name, stack_resource, output_map)
     end
     extract_templates(&block)
@@ -835,7 +881,7 @@ class SparkleFormation
 
   # @return [Hash] dumped hash
   def dump
-    MultiJson.load(self.to_json)
+    MultiJson.load(to_json)
   end
 
   # @return [String] dumped hash JSON