sparkle_formation 1.1.14 → 1.2.0

data/lib/sparkle_formation/resources.rb

@@ -0,0 +1,114 @@
+require 'sparkle_formation'
+
+class SparkleFormation
+  # Resources helper
+  class Resources
+
+    autoload :Aws, 'sparkle_formation/resources/aws'
+
+    class << self
+
+      include SparkleFormation::Utils::AnimalStrings
+      # @!parse include SparkleFormation::Utils::AnimalStrings
+
+      # Register resource
+      #
+      # @param type [String] Orchestration resource type
+      # @param hash [Hash] metadata information
+      # @return [TrueClass]
+      def register(type, hash)
+        unless(class_variable_defined?(:@@registry))
+          @@registry = AttributeStruct.hashish.new
+        end
+        @@registry[type] = hash
+        true
+      end
+
+      # Resource information
+      #
+      # @param identifier [String, Symbol] resource identifier
+      # @param key [String, Symbol] specific data
+      # @return [Hashish]
+      def resource(identifier, key=nil)
+        res = lookup(identifier)
+        if(key && res)
+          res[key.to_sym]
+        else
+          res
+        end
+      end
+
+      # Register all discovered resources
+      #
+      # @param json_path_or_hash [String, Hashish] path to files or hash
+      # @return [TrueClass]
+      def load(json_path_or_hash)
+        if(json_path_or_hash.is_a?(String))
+          content = AttributeStruct.hashish.new(MultiJson.load(File.read(json_path_or_hash)))
+        else
+          content = json_path_or_hash
+        end
+        content.each do |type, hash|
+          register(type, hash)
+        end
+        true
+      end
+
+      # Load the builtin AWS resources
+      #
+      # @return [TrueClass]
+      def load!
+        true
+      end
+
+      # Discover registry key via part searching
+      #
+      # @param key [String, Symbol]
+      # @return [String, NilClass]
+      def registry_key(key)
+        o_key = key
+        key = key.to_s.tr('_', '')
+        snake_parts = nil
+        result = @@registry.keys.detect do |ref|
+          ref = ref.downcase
+          snake_parts = ref.split('::')
+          until(snake_parts.empty?)
+            break if snake_parts.join('') == key
+            snake_parts.shift
+          end
+          !snake_parts.empty?
+        end
+        if(result)
+          collisions = @@registry.keys.find_all do |ref|
+            split_ref = ref.downcase.split('::')
+            ref = split_ref.slice(split_ref.size - snake_parts.size, split_ref.size).join('')
+            key == ref
+          end
+          if(collisions.size > 1)
+            raise ArgumentError.new 'Ambiguous dynamic name returned multiple matches! ' \
+              "`#{o_key.inspect}` -> #{collisions.sort.join(', ')}"
+          end
+        end
+        result
+      end
+
+      # Registry information for given type
+      #
+      # @param key [String, Symbol]
+      # @return [Hashish, NilClass]
+      def lookup(key)
+        @@registry[registry_key(key)]
+      end
+
+      # @return [Hashish] currently loaded AWS registry
+      def registry
+        if(class_variable_defined?(:@@registry))
+          @@registry
+        else
+          @@registry = AttributeStruct.hashish.new
+        end
+      end
+
+    end
+  end
+end

data/lib/sparkle_formation/sparkle.rb

@@ -1,6 +1,8 @@
 require 'sparkle_formation'
 
+# Unicorns and rainbows
 class SparkleFormation
+  # Independent collection of SparkleFormation items
   class Sparkle
 
     class << self
@@ -17,16 +19,15 @@ class SparkleFormation
           idx = caller.index do |item|
             item.end_with?("`register!'")
           end
-          if(idx)
-            file = caller[idx.next].split(':', 2).first
-            path = File.join(File.dirname(file), 'sparkleformation')
-            unless(File.directory?(path))
-              path = nil
-            end
-            unless(name)
-              name = File.basename(caller[idx.next].split(':', 2).first)
-              name.sub!(File.extname(name), '')
-            end
+          idx = idx ? idx.next : 0
+          file = caller[idx].split(':', 2).first
+          path = File.join(File.dirname(file), 'sparkleformation')
+          unless(File.directory?(path))
+            path = nil
+          end
+          unless(name)
+            name = File.basename(caller[idx].split(':', 2).first)
+            name.sub!(File.extname(name), '')
           end
         end
         unless(name)
@@ -61,6 +62,7 @@ class SparkleFormation
 
     # Wrapper for evaluating sfn files to store within sparkle
     # container and remove global application
+    # rubocop:disable Metrics/MethodLength
     def eval_wrapper
       klass = Class.new(BasicObject)
       klass.class_eval(<<-EOS
@@ -214,7 +216,8 @@ class SparkleFormation
       @raw_data = Smash.new(
         :dynamic => [],
         :component => [],
-        :registry => []
+        :registry => [],
+        :template => []
       )
       @wrapper = eval_wrapper.new
       wrapper.part_data(raw_data)
@@ -245,35 +248,7 @@ class SparkleFormation
     # @return [Smash<name:path>]
     def templates
       memoize(:templates) do
-        Smash.new.tap do |hash|
-          Dir.glob(File.join(root, '**', '**', '*.{json,rb}')) do |path|
-            slim_path = path.sub("#{root}/", '')
-            next if DIRS.include?(slim_path.split('/').first)
-            data = Smash.new(:template => [])
-            t_wrap = eval_wrapper.new
-            t_wrap.part_data(data)
-            if(slim_path.end_with?('.rb'))
-              begin
-                t_wrap.instance_eval(IO.read(path), path, 1)
-              rescue TypeError
-              end
-            end
-            data = data[:template].first || Smash.new
-            unless(data[:name])
-              data[:name] = slim_path.tr('/', '__').sub(/\.(rb|json)$/, '')
-            end
-            if(hash[data[:name]])
-              raise KeyError.new "Template name is already in use within pack! (`#{data[:name]}`)"
-            end
-            hash[data[:name]] = data.merge(
-              Smash.new(
-                :type => :template,
-                :path => path,
-                :serialized => !path.end_with?('.rb')
-              )
-            )
-          end
-        end
+        Smash.new
       end
     end
 
@@ -290,9 +265,9 @@ class SparkleFormation
       result = send(TYPES[type])[name]
       if(result.nil? && TYPES[type] == 'templates')
         result = (
-          send(TYPES[type]).detect{|k,v|
+          send(TYPES[type]).detect{|_, v|
             name = name.to_s
-            short_name = v[:path].sub(/#{Regexp.escape(root)}\/?/, '')
+            short_name = v[:path].sub(%r{#{Regexp.escape(root)}/?}, '')
             v[:path] == name ||
             short_name == name ||
             short_name.sub('.rb', '').gsub(File::SEPARATOR, '__').tr('-', '_') == name ||
@@ -323,7 +298,7 @@ class SparkleFormation
     def locate_root
       VALID_ROOT_DIRS.map do |part|
         path = File.expand_path(File.join(Dir.pwd, part))
-        if(File.exists?(path))
+        if(File.exist?(path))
           path
         end
       end.compact.first
@@ -332,8 +307,28 @@ class SparkleFormation
     # Load all sparkle parts
     def load_parts!
       memoize(:load_parts) do
-        Dir.glob(File.join(root, "{#{DIRS.join(',')}}", '**', '**', '*.rb')).each do |file|
-          wrapper.instance_eval(IO.read(file), file, 1)
+        Dir.glob(File.join(root, '**', '**', '*.{json,rb}')).each do |file|
+          slim_path = file.sub("#{root}/", '')
+          if(file.end_with?('.rb'))
+            begin
+              wrapper.instance_eval(IO.read(file), file, 1)
+            rescue TypeError
+            end
+          end
+          if(file.end_with?('.json') || raw_data[:template].first)
+            data = raw_data[:template].pop || Smash.new
+            unless(data[:name])
+              data[:name] = slim_path.tr('/', '__').sub(/\.(rb|json)$/, '')
+            end
+            if(templates[data[:name]])
+              raise KeyError.new "Template name is already in use within pack! (`#{data[:name]}`)"
+            end
+            templates[data[:name]] = data.merge(
+              :type => :template,
+              :path => file,
+              :serialized => !file.end_with?('.rb')
+            )
+          end
         end
         raw_data.each do |key, items|
           items.each do |item|

data/lib/sparkle_formation/sparkle_attribute/aws.rb

@@ -0,0 +1,314 @@
+require 'sparkle_formation'
+
+class SparkleFormation
+
+  # Provides template helper methods
+  module SparkleAttribute
+
+    # AWS specific helper implementations
+    module Aws
+
+      # 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)
+        __t_stringish(thing)
+        thing = _process_key(thing, :force) if thing.is_a?(Symbol)
+        {'Ref' => thing}
+      end
+      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
+      # @return [Hash]
+      def _cf_map(thing, key, *suffix)
+        __t_stringish(thing)
+        suffix = suffix.map do |item|
+          if(item.is_a?(Symbol))
+            _process_key(item, :force)
+          else
+            item
+          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)
+        __t_stringish(args.first)
+        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)
+        __t_stringish(name)
+        {'Condition' => name.is_a?(Symbol) ? _process_key(name, :force) : 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
+        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')
+      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
+
+      # @return [TrueClass, FalseClass] resource can be tagged
+      def taggable?
+        if(self[:type])
+          resource = _self.lookup(self[:type].gsub('::', '_').downcase)
+          resource && resource[:properties].include?('Tags')
+        else
+          if(_parent)
+            _parent.taggable?
+          end
+        end
+      end
+
+      # Set tags on a resource
+      #
+      # @param hash [Hash] Key/value pair tags
+      # @return [SparkleStruct]
+      def _tags(hash)
+        _set('Tags',
+          hash.map{ |k, v|
+            key = k.is_a?(Symbol) ? _process_key(k, :force) : k
+            {'Key' => key, 'Value' => v}
+          }
+        )
+      end
+      alias_method :tags!, :_tags
+
+    end
+
+  end
+end