sparkle_formation 2.1.8 → 3.0.0

data/lib/sparkle_formation/sparkle.rb

@@ -5,6 +5,123 @@ class SparkleFormation
   # Independent collection of SparkleFormation items
   class Sparkle
 
+    # Evaluation context wrapper for loading SparkleFormation files
+    class EvalWrapper < BasicObject
+
+      # @!visibility private
+      def require(*args)
+        ::Kernel.require(*args)
+      end
+
+      # @!visibility private
+      class SparkleFormation
+
+        attr_accessor :sparkle_path
+
+        class << self
+
+          def insert(*args, &block)
+            ::SparkleFormation.insert(*args, &block)
+          end
+
+          def part_data(data=nil)
+            if(data)
+              @data = data
+            else
+              @data
+            end
+          end
+
+          def dynamic(name, args={}, &block)
+            part_data[:dynamic].push(
+              ::Smash.new(
+                :name => name,
+                :block => block,
+                :args => ::Smash[
+                  args.map(&:to_a)
+                ],
+                :type => :dynamic
+              )
+            ).last
+          end
+
+          def build(&block)
+            part_data[:component].push(
+              ::Smash.new(
+                :block => block,
+                :type => :component
+              )
+            ).last
+          end
+
+          def component(name, args={}, &block)
+            part_data[:component].push(
+              ::Smash.new(
+                :name => name,
+                :block => block,
+                :args => ::Smash[
+                  args.map(&:to_a)
+                ],
+                :type => :component
+              )
+            ).last
+          end
+
+          def dynamic_info(*args)
+            ::Smash.new(:metadata => {}, :args => {})
+          end
+
+        end
+
+        def initialize(*args)
+          opts = args.detect{|a| a.is_a?(Hash)} || {}
+          SparkleFormation.part_data[:template].push(
+            ::Smash.new(
+              :name => args.first,
+              :args => opts
+            )
+          )
+          raise ::TypeError
+        end
+
+        # @!visibility private
+        class Registry
+
+          def self.register(name, args={}, &block)
+            SparkleFormation.part_data[:registry].push(
+              ::Smash.new(
+                :name => name,
+                :block => block,
+                :args => ::Smash[
+                  args.map(&:to_a)
+                ],
+                :type => :registry
+              )
+            ).last
+          end
+
+        end
+      end
+
+      # @!visibility private
+      SfnRegistry = SparkleFormation::Registry
+
+      # NOTE: Enable access to top level constants but do not
+      # include deprecated constants to prevent warning outputs
+      ::Object.constants.each do |const|
+        unless(self.const_defined?(const)) # rubocop:disable Style/RedundantSelf
+          next if const == :Config || const == :TimeoutError
+          self.const_set(const, ::Object.const_get(const)) # rubocop:disable Style/RedundantSelf
+        end
+      end
+
+      # @!visibility private
+      def part_data(arg)
+        SparkleFormation.part_data(arg)
+      end
+
+    end
+
     class << self
 
       @@_pack_registry = Smash.new
@@ -61,113 +178,9 @@ class SparkleFormation
     end
 
     # Wrapper for evaluating sfn files to store within sparkle
-    # container and remove global application
-    # rubocop:disable Metrics/MethodLength
+    # container
     def eval_wrapper
-      klass = Class.new(BasicObject)
-      klass.class_eval(<<-EOS
-        def require(*args)
-          ::Kernel.require *args
-        end
-
-        class SparkleFormation
-
-          attr_accessor :sparkle_path
-
-          class << self
-
-            def insert(*args, &block)
-              ::SparkleFormation.insert(*args, &block)
-            end
-
-            def part_data(data=nil)
-              if(data)
-                @data = data
-              else
-                @data
-              end
-            end
-
-            def dynamic(name, args={}, &block)
-              part_data[:dynamic].push(
-                ::Smash.new(
-                  :name => name,
-                  :block => block,
-                  :args => Smash[
-                    args.map(&:to_a)
-                  ],
-                  :type => :dynamic
-                )
-              ).last
-            end
-
-            def build(&block)
-              part_data[:component].push(
-                ::Smash.new(
-                  :block => block,
-                  :type => :component
-                )
-              ).last
-            end
-
-            def component(name, args={}, &block)
-              part_data[:component].push(
-                ::Smash.new(
-                  :name => name,
-                  :block => block,
-                  :args => Smash[
-                    args.map(&:to_a)
-                  ],
-                  :type => :component
-                )
-              ).last
-            end
-
-            def dynamic_info(*args)
-              Smash.new(:metadata => {}, :args => {})
-            end
-
-          end
-
-          def initialize(*args)
-            SparkleFormation.part_data[:template].push(
-              ::Smash.new(
-                :name => args.first
-              )
-            )
-            raise TypeError
-          end
-
-          class Registry
-
-            def self.register(name, &block)
-              SparkleFormation.part_data[:registry].push(
-                ::Smash.new(
-                  :name => name,
-                  :block => block,
-                  :type => :registry
-                )
-              ).last
-            end
-
-          end
-        end
-
-        SfnRegistry = SparkleFormation::Registry
-
-        ::Object.constants.each do |const|
-          unless(self.const_defined?(const))
-            next if const == :Config || const == :TimeoutError # prevent warning output
-            self.const_set(const, ::Object.const_get(const))
-          end
-        end
-
-        def part_data(arg)
-          SparkleFormation.part_data(arg)
-        end
-        EOS
-      )
-      klass
+      Class.new(EvalWrapper)
     end
 
     include Bogo::Memoization
@@ -200,12 +213,15 @@ class SparkleFormation
     attr_reader :root
     # @return [Smash] raw part data
     attr_reader :raw_data
+    # @return [Symbol] provider
+    attr_accessor :provider
 
     # Create new sparkle instance
     #
     # @param args [Hash]
     # @option args [String] :root path to sparkle directories
     # @option args [String, Symbol] :name registered pack name
+    # @option args [String, Symbol] :provider name of default provider
     # @return [self]
     def initialize(args={})
       if(args[:name])
@@ -213,7 +229,7 @@ class SparkleFormation
       else
         @root = args.fetch(:root, locate_root)
       end
-      unless(File.directory?(@root))
+      if(@root != :none && !File.directory?(@root))
         raise Errno::ENOENT.new("No such directory - #{@root}")
       end
       @raw_data = Smash.new(
@@ -222,9 +238,10 @@ class SparkleFormation
         :registry => [],
         :template => []
       )
+      @provider = Bogo::Utility.snake(args.fetch(:provider, 'aws').to_s).to_sym
       @wrapper = eval_wrapper.new
       wrapper.part_data(raw_data)
-      load_parts!
+      load_parts! unless @root == :none
     end
 
     # @return [Smash<name:block>]
@@ -259,16 +276,20 @@ 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)
       unless(TYPES.keys.include?(type.to_s))
         raise NameError.new "Invalid type requested (#{type})! Valid types: #{TYPES.keys.join(', ')}"
       end
-      result = send(TYPES[type])[name]
+      unless(target_provider)
+        target_provider = provider
+      end
+      result = send(TYPES[type]).get(target_provider, name)
       if(result.nil? && TYPES[type] == 'templates')
         result = (
-          send(TYPES[type]).detect{|_, v|
+          send(TYPES[type]).fetch(target_provider, Smash.new).detect{|_, v|
             name = name.to_s
             short_name = v[:path].sub(%r{#{Regexp.escape(root)}/?}, '')
             v[:path] == name ||
@@ -323,13 +344,16 @@ class SparkleFormation
             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]}`)"
+            t_provider = data.fetch(:args, :provider, :aws)
+            if(templates.get(t_provider, data[:name]))
+              raise KeyError.new "Template name is already in use within pack! (`#{data[:name]}` -> `#{t_provider}`)"
             end
-            templates[data[:name]] = data.merge(
-              :type => :template,
-              :path => file,
-              :serialized => !file.end_with?('.rb')
+            templates.set(t_provider, data[:name],
+              data.merge(
+                :type => :template,
+                :path => file,
+                :serialized => !file.end_with?('.rb')
+              )
             )
           end
         end
@@ -343,10 +367,11 @@ class SparkleFormation
               type, name = path.slice(path.size - 2, 2)
               collection = send(type)
             end
-            if(collection[name])
-              raise KeyError.new "#{key.capitalize} name is already in use within pack! (`#{name}`)"
+            i_provider = item.fetch(:args, :provider, :aws)
+            if(collection.get(i_provider, name))
+              raise KeyError.new "#{key.capitalize} name is already in use within pack! (`#{name}` -> #{i_provider})"
             end
-            collection[name] = item
+            collection.set(i_provider, name, item)
           end
         end
       end

data/lib/sparkle_formation/sparkle_attribute.rb

@@ -7,6 +7,7 @@ class SparkleFormation
 
     autoload :Aws, 'sparkle_formation/sparkle_attribute/aws'
     autoload :Azure, 'sparkle_formation/sparkle_attribute/azure'
+    autoload :Google, 'sparkle_formation/sparkle_attribute/google'
     autoload :Heat, 'sparkle_formation/sparkle_attribute/heat'
     autoload :Rackspace, 'sparkle_formation/sparkle_attribute/rackspace'
 
@@ -41,9 +42,10 @@ class SparkleFormation
     end
     alias_method :system!, :_system
 
-    # Print to stdout
-    #
-    # @param args
+    # @overload _puts(obj, ...)
+    #   Print to stdout
+    #   @param obj [Object] object to print
+    # @see Kernel.puts
     # @return [NilClass]
     def _puts(*args)
       $stdout.puts(*args)
@@ -51,45 +53,82 @@ class SparkleFormation
     alias_method :puts!, :_puts
 
     # Raise an exception
+    # @see Kernel.raise
     def _raise(*args)
       ::Kernel.raise(*args)
     end
     alias_method :raise!, :_raise
 
-    # Lookup a method definition on self
-    # usually used as `puts! method!(:foo).source_location`
+    # @overload _method(sym)
+    #   Lookup a method definition on self
+    #   @param sym [Symbol] name of method
+    # @note usually used as `puts! method!(:foo).source_location`
+    # @see Object#method
     # @return [Method]
     def _method(*args)
       ::Kernel.instance_method(:method).bind(self).call(*args)
     end
     alias_method :method!, :_method
 
-    # Dynamic insertion helper method
-    #
-    # @param name [String, Symbol] dynamic name
-    # @param args [Object] argument list for dynamic
+    # @overload _dynamic(resource_type, custom_name, options={})
+    #   Insert builtin resource
+    #   @param resource_type [String, Symbol] provider resource type
+    #   @param custom_name [String, Symbol] custom name used for resource name generation
+    #   @param options [Hash]
+    #   @option options [String, NilClass] :resource_name_suffix custom suffix to use for
+    #     name generation (defaults to resource_type)
+    #   @note All other options are set into the new resource's properties
+    # @overload _dynamic(dynamic_name, custom_name, options={})
+    #   Call custom dynamic from available sparkle packs
+    #   @param dynamic_name [Symbol] name of registered dynamic
+    #   @param custom_name [Symbol, String] unique name passed directly to registered dynamic
+    #   @param options [Hash]
+    #   @option options [String, Symbol] :provider override provider restriction when fetching dynamic
+    #   @note All options are passed to dynamic with custom_name
+    # @yieldblock [new_struct] Provides newly inserted structure
+    # @yieldparam new_struct [SparkleStruct] newly inserted structure which can be modified
+    # @yieldreturn [Object] discarded
     # @return [self]
-    def dynamic!(name, *args, &block)
+    def _dynamic(name, *args, &block)
       SparkleFormation.insert(name, self, *args, &block)
     end
+    alias_method :dynamic!, :_dynamic
 
-    # Registry insertion helper method
-    #
-    # @param name [String, Symbol] name of registry item
-    # @param args [Object] argument list for registry
-    # @return [self]
-    def registry!(name, *args)
+    # @overload _registry(name)
+    #   Return value from registry item with given name
+    #   @param name [String, Symbol] registry item name
+    # @overload _registry(name, *args, options={})
+    #   Pass given parameters to registry item with given name and
+    #   return the value
+    #   @param name [String, Symbol] registry item name
+    #   @param options [Hash]
+    #   @param options [Hash] :provider override provider restriction when fetching registry item
+    #   @param args [Object] argument list
+    #   @note args and options will be passed directly to registry item when called
+    # @return [Object] return value of registry item
+    def _registry(name, *args)
       SparkleFormation.registry(name, self, *args)
     end
+    alias_method :registry!, :_registry
 
-    # Stack nesting helper method
-    #
-    # @param template [String, Symbol] template to nest
-    # @param args [String, Symbol] stringified and underscore joined for name
+    # @overload _nest(template, *names, options={})
+    #   Nest a stack resource
+    #   @param template [String, Symbol] name of desired template
+    #   @param names [String, Symbol] list of optional string/symbol values for resource name generation
+    #   @param options [Hash]
+    #   @option options [String, Symbol] :provider override provider restriction when
+    #     fetching template
+    #   @option options [Truthy, Falsey] :overwrite_name when set to true, will not include
+    #     template name in resource name
+    #   @option options [Hash] :parameters compile time parameter values to pass to nested template
+    # @yieldblock [new_struct] Provides newly inserted structure
+    # @yieldparam new_struct [SparkleStruct] newly inserted structure which can be modified
+    # @yieldreturn [Object] discarded
     # @return [self]
-    def nest!(template, *args, &block)
+    def _nest(template, *args, &block)
       SparkleFormation.nest(template, self, *args, &block)
     end
+    alias_method :nest!, :_nest
 
     # Format the provided key. If symbol type is provided
     # formatting is forced. Otherwise the default formatting