sparkle_formation 0.1.4 → 0.1.6

data/lib/sparkle_formation/sparkle_attribute.rb

@@ -16,87 +16,95 @@
 # limitations under the License.
 #
 
-require 'attribute_struct'
+require 'sparkle_formation'
 
-module SparkleAttribute
+class SparkleFormation
+  module SparkleAttribute
 
-  def _cf_join(*args)
-    options = args.detect{|i| i.is_a?(Hash) && i[:options]} || {:options => {}}
-    args.delete(options)
-    unless(args.size == 1)
-      args = [args]
+    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
-    {'Fn::Join' => [options[:options][:delimiter] || '', *args]}
-  end
 
-  def _cf_ref(thing)
-    thing = _process_key(thing, :force) if thing.is_a?(Symbol)
-    {'Ref' => thing}
-  end
-  alias_method :_ref, :_cf_ref
-
-  def _cf_map(thing, key, *suffix)
-    suffix = suffix.map do |item|
-      if(item.is_a?(Symbol))
-        _process_key(item, :force)
-      else
-        item
+    def _cf_ref(thing)
+      thing = _process_key(thing, :force) if thing.is_a?(Symbol)
+      {'Ref' => thing}
+    end
+    alias_method :_ref, :_cf_ref
+
+    def _cf_map(thing, key, *suffix)
+      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)
+      key = _process_key(key, :force) if key.is_a?(Symbol)
+      {'Fn::FindInMap' => [_process_key(thing), {'Ref' => _process_key(key)}, *suffix]}
     end
-    thing = _process_key(thing, :force) if thing.is_a?(Symbol)
-    key = _process_key(key, :force) if key.is_a?(Symbol)
-    {'Fn::FindInMap' => [_process_key(thing), {'Ref' => _process_key(key)}, *suffix]}
-  end
-  alias_method :_cf_find_in_map, :_cf_map
-
-  def _cf_attr(*args)
-    args = args.map do |thing|
-      if(thing.is_a?(Symbol))
-        _process_key(thing, :force)
-      else
-        thing
+    alias_method :_cf_find_in_map, :_cf_map
+
+    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
 
+    def _cf_base64(arg)
+      {'Fn::Base64' => arg}
     end
-    {'Fn::GetAtt' => args}
-  end
-  alias_method :_cf_get_att, :_cf_attr
 
-  def _cf_base64(arg)
-    {'Fn::Base64' => arg}
-  end
+    def _cf_get_azs(region=nil)
+      region = case region
+               when Symbol
+                 _cf_ref(region)
+               when NilClass
+                 ''
+               else
+                 region
+               end
+      {'Fn::GetAZs' => region}
+    end
 
-  def _cf_get_azs(region=nil)
-    region = case region
-             when Symbol
-               _cf_ref(region)
-             when NilClass
-               ''
-             else
-               region
-             end
-    {'Fn::GetAZs' => region}
-  end
+    def _cf_select(index, item)
+      item = _cf_ref(item) if item.is_a?(Symbol)
+      {'Fn::Select' => [index.to_i.to_s, item]}
+    end
 
-  def _cf_select(index, item)
-    item = _cf_ref(item) if item.is_a?(Symbol)
-    {'Fn::Select' => [index.to_i.to_s, item]}
-  end
+    def rhel?
+      !!@platform[:rhel]
+    end
 
-  def rhel?
-    !!@platform[:rhel]
-  end
+    def debian?
+      !!@platform[:debian]
+    end
 
-  def debian?
-    !!@platform[:debian]
-  end
+    def _platform=(plat)
+      @platform || __hashish
+      @platform.clear
+      @platform[plat.to_sym] = true
+    end
 
-  def _platform=(plat)
-    @platform || __hashish
-    @platform.clear
-    @platform[plat.to_sym] = true
-  end
+    def dynamic!(name, *args, &block)
+      SparkleFormation.insert(name, self, *args, &block)
+    end
 
-end
+    def registry!(name, *args)
+      SfnRegistry.insert(name, self, *args)
+    end
 
-AttributeStruct.send(:include, SparkleAttribute)
+  end
+end

data/lib/sparkle_formation/sparkle_formation.rb

@@ -16,11 +16,9 @@
 # limitations under the License.
 #
 
-require 'attribute_struct'
-require 'sparkle_formation/sparkle_attribute'
-require 'sparkle_formation/utils'
+require 'sparkle_formation'
 
-AttributeStruct.camel_keys = true
+SparkleFormation::SparkleStruct.camel_keys = true
 
 class SparkleFormation
 
@@ -28,38 +26,85 @@ class SparkleFormation
 
   class << self
 
+    include SparkleFormation::Utils::AnimalStrings
+
     attr_reader :dynamics
-    attr_reader :components_path
-    attr_reader :dynamics_path
 
+    # Return custom paths
     def custom_paths
       @_paths ||= {}
       @_paths
     end
 
-    def components_path=(path)
-      custom_paths[:sparkle_path] = path
+    # path:: Path
+    # Path to sparkle directory
+    def sparkle_path=(path=nil)
+      if(path)
+        custom_paths[:sparkle_path] = path
+        custom_paths[:components_directory] ||= File.join(path, 'components')
+        custom_paths[:dynamics_directory] ||= File.join(path, 'dynamics')
+        custom_paths[:registry_directory] ||= File.join(path, 'registry')
+      end
+      custom_paths[:sparkle_path]
+    end
+    alias_method(:sparkle_path, :sparkle_path=)
+
+    # path:: Path
+    # Set path to component files
+    def components_path=(path=nil)
+      if(path)
+        custom_paths[:components_directory] = path
+      end
+      custom_paths[:components_directory]
+    end
+    alias_method(:components_path, :components_path=)
+
+    # path:: Path
+    # Set path to dynamic files
+    def dynamics_path=(path=nil)
+      if(path)
+        custom_paths[:dynamics_directory] = path
+      end
+      custom_paths[:dynamics_directory]
     end
+    alias_method(:dynamics_path, :dynamics_path=)
 
-    def dynamics_path=(path)
-      custom_paths[:dynamics_directory] = path
+    # path:: Path
+    # Set path to registry files
+    def registry_path=(path=nil)
+      if(path)
+        custom_paths[:registry_directory] = path
+      end
+      custom_paths[:registry_directory]
     end
+    alias_method(:registry_path, :registry_path=)
 
+    # path:: Path
+    # args:: Option symbols
+    #   - :sparkle:: Return formation instead of Hash
+    # Compile file at given path and return Hash
     def compile(path, *args)
       formation = self.instance_eval(IO.read(path), path, 1)
       args.include?(:sparkle) ? formation : formation.compile._dump
     end
 
+    # base:: Base SparkleStruct
+    # Execute given block within base
     def build(base=nil, &block)
-      struct = base || AttributeStruct.new
+      struct = base || SparkleStruct.new
       struct.instance_exec(&block)
-      struct
+      @_struct = struct
     end
 
+    # path:: Path
+    # Load component at given path
     def load_component(path)
       self.instance_eval(IO.read(path), path, 1)
+      @_struct
     end
 
+    # directory:: Path
+    # Load all dynamics within given directory
     def load_dynamics!(directory)
       @loaded_dynamics ||= []
       Dir.glob(File.join(directory, '*.rb')).each do |dyn|
@@ -72,22 +117,90 @@ class SparkleFormation
       true
     end
 
-    def dynamic(name, &block)
-      @dynamics ||= Mash.new
-      @dynamics[name] = block
+    # directory:: Path
+    # Load all registry entries within given directory
+    def load_registry!(directory)
+      Dir.glob(File.join(directory, '*.rb')).each do |reg|
+        reg = File.expand_path(reg)
+        require reg
+      end
+      true
+    end
+
+    # name:: Name of dynamic
+    # args:: Optional dynamic metadata
+    # Define a new dynamic and store associated block
+    def dynamic(name, args={}, &block)
+      @dynamics ||= SparkleStruct.hashish.new
+      @dynamics[name] = SparkleStruct.hashish[
+        :block, block, :args, SparkleStruct.hashish[args.map(&:to_a)]
+      ]
+    end
+
+    # name:: Name of dynamic
+    # Return metadata about dynamic
+    def dynamic_info(name)
+      if(@dynamics[name])
+        @dynamics[name][:args]
+      else
+        raise KeyError.new("No dynamic registered with provided name (#{name})")
+      end
     end
+    alias_method :dynamic_information, :dynamic_info
 
-    def insert(dynamic_name, struct, *args)
+    # dynamic_name:: Name of dynamic
+    # struct:: SparkleStruct instances
+    # args:: Args to pass to dynamic
+    # Inserts a dynamic into the given SparkleStruct instance
+    def insert(dynamic_name, struct, *args, &block)
+      result = false
       if(@dynamics && @dynamics[dynamic_name])
-        struct.instance_exec(*args, &@dynamics[dynamic_name])
-        struct
+        struct.instance_exec(*args, &@dynamics[dynamic_name][:block])
+        result = struct
       else
+        result = builtin_insert(dynamic_name, struct, *args, &block)
+      end
+      unless(result)
         raise "Failed to locate requested dynamic block for insertion: #{dynamic_name} (valid: #{@dynamics.keys.sort.join(', ')})"
       end
+      result
+    end
+
+    # dynamic_name:: Name of dynamic
+    # struct:: SparkleStruct instances
+    # args:: Args to pass to dynamic
+    # Inserts a builtin dynamic into the given SparkleStruct instance
+    def builtin_insert(dynamic_name, struct, *args, &block)
+      if(defined?(SfnAws) && lookup_key = SfnAws.registry_key(dynamic_name))
+        _name, _config = *args
+        _config ||= {}
+        return unless _name
+        new_resource = struct.resources.__send__("#{_name}_#{dynamic_name}".to_sym)
+        new_resource.type lookup_key
+        properties = new_resource.properties
+        SfnAws.resource(dynamic_name, :properties).each do |prop_name|
+          value = [prop_name, snake(prop_name)].map do |key|
+            _config[key] || _config[key.to_sym]
+          end.compact.first
+          if(value)
+            if(value.is_a?(Proc))
+              properties.__send__(prop_name).instance_exec(&value)
+            else
+              properties.__send__(prop_name, value)
+            end
+          end
+        end
+        new_resource.instance_exec(&block) if block
+        new_resource
+      end
     end
 
+    # hash:: Hash
+    # Attempts to load an SparkleStruct instance from and existing
+    # Hash instance
+    # NOTE: camel keys will do best effort at auto discovery
     def from_hash(hash)
-      struct = AttributeStruct.new
+      struct = SparkleStruct.new
       struct._camel_keys_set(:auto_discovery)
       struct._load(hash)
       struct._camel_keys_set(nil)
@@ -97,6 +210,9 @@ class SparkleFormation
 
   attr_reader :name
   attr_reader :sparkle_path
+  attr_reader :components_directory
+  attr_reader :dynamics_directory
+  attr_reader :registry_directory
   attr_reader :components
   attr_reader :load_order
 
@@ -104,27 +220,43 @@ class SparkleFormation
     @name = name
     @sparkle_path = options[:sparkle_path] ||
       self.class.custom_paths[:sparkle_path] ||
-      File.join(Dir.pwd, 'cloudformation/components')
+      File.join(Dir.pwd, 'cloudformation')
+    @components_directory = options[:components_directory] ||
+      self.class.custom_paths[:components_directory] ||
+      File.join(sparkle_path, 'components')
     @dynamics_directory = options[:dynamics_directory] ||
       self.class.custom_paths[:dynamics_directory] ||
-      File.join(File.dirname(@sparkle_path), 'dynamics')
+      File.join(sparkle_path, 'dynamics')
+    @registry_directory = options[:registry_directory] ||
+      self.class.custom_paths[:registry_directory] ||
+      File.join(sparkle_path, 'registry')
     self.class.load_dynamics!(@dynamics_directory)
-    @components = AttributeStruct.hashish.new
+    self.class.load_registry!(@registry_directory)
+    unless(options[:disable_aws_builtins])
+      require 'sparkle_formation/aws'
+      SfnAws.load!
+    end
+    @components = SparkleStruct.hashish.new
     @load_order = []
+    @overrides = []
     if(block)
       load_block(block)
     end
   end
 
+  # block:: block to execute
+  # Loads block
   def load_block(block)
     @components[:__base__] = self.class.build(&block)
     @load_order << :__base__
   end
 
+  # args:: symbols or paths for component loads
+  # Loads components into instance
   def load(*args)
     args.each do |thing|
       if(thing.is_a?(Symbol))
-        path = File.join(sparkle_path, "#{thing}.rb")
+        path = File.join(components_directory, "#{thing}.rb")
       else
         path = thing
       end
@@ -135,19 +267,23 @@ class SparkleFormation
     self
   end
 
-  def overrides(&block)
-    @overrides = block
+  # Registers block into overrides
+  def overrides(args={}, &block)
+    @overrides << {:args => args, :block => block}
     self
   end
 
   # Returns compiled Mash instance
   def compile
-    compiled = AttributeStruct.new
+    compiled = SparkleStruct.new
     @load_order.each do |key|
       compiled._merge!(components[key])
     end
-    if(@overrides)
-      self.class.build(compiled, &@overrides)
+    @overrides.each do |override|
+      if(override[:args] && !override[:args].empty?)
+        compiled._set_state(override[:args])
+      end
+      self.class.build(compiled, &override[:block])
     end
     compiled
   end