cloud-templates 0.2.0 → 0.3.0

data/lib/aws/templates/utils/parametrized/transformation/as_integer.rb

@@ -0,0 +1,39 @@
+require 'aws/templates/utils'
+
+module Aws
+  module Templates
+    module Utils
+      module Parametrized
+        class Transformation
+          ##
+          # Convert input into integer
+          #
+          # Input value can be anything implementing :to_i method.
+          #
+          # === Example
+          #
+          #    class Piece
+          #      include Aws::Templates::Utils::Parametrized
+          #
+          #      parameter :param, :transform => as_integer
+          #    end
+          #
+          #    i = Piece.new
+          #    i.param # => nil
+          #    i = Piece.new(:param => '23')
+          #    i.param # => 23
+          class AsInteger < self
+            include ::Singleton
+
+            protected
+
+            def transform(_, value, _)
+              return if value.nil?
+              Integer(value)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/aws/templates/utils/parametrized/transformation/as_list.rb

@@ -0,0 +1,97 @@
+require 'aws/templates/utils'
+
+module Aws
+  module Templates
+    module Utils
+      module Parametrized
+        class Transformation
+          ##
+          # Transform input value into a list
+          #
+          # Input value can be either an array or something which implements
+          # to_a method standard semantics. Each list entry is evaluated
+          # with specified constraints and transformations.
+          #
+          # With as_list transformation you can have as many nested levels
+          # as it's needed in terms of nested lists or nested objects.
+          #
+          # === Example
+          #
+          #    class Piece
+          #      include Aws::Templates::Utils::Parametrized
+          #
+          #      parameter :param1, :transform => as_list(
+          #        # alias for all elements. Plays a role during introspection
+          #        :name => :element,
+          #        # description of what the element represents
+          #        :description => 'List element',
+          #        # constraint for list element
+          #        :constraint => not_nil
+          #      )
+          #      parameter :param2, :transform => as_list(
+          #        :name => :element,
+          #        :description => 'List element',
+          #        :transform => as_list( # nested list
+          #          :name => :sub_element,
+          #          :description => 'Sub-list element',
+          #          :constraint => not_nil
+          #        )
+          #      )
+          #      parameter :param3, :transform => as_list(
+          #          :name => :particle,
+          #          :description => 'Small particle',
+          #          :transform => as_object( # nested object
+          #            Aws::Templates::Utils::AsNamed
+          #          )
+          #        )
+          #    end
+          #
+          #    i = Piece.new(:param1 => [1,2,3])
+          #    i.param1 # => [1,2,3]
+          #    i = Piece.new(:param1 => [1,nil,3])
+          #    i.param1 # throws exception
+          #    i = Piece.new(:param2 => [[1],[2],[3]])
+          #    i.param2 # => [[1],[2],[3]]
+          #    i = Piece.new(:param2 => [1,[2],[3]])
+          #    i.param2 # throws exception
+          #    i = Piece.new(:param2 => [[1],[nil],[3]])
+          #    i.param2 # throws exception
+          #    i = Piece.new(:param3 => [{:name => 'Zed'}])
+          #    i.param3.first.name # => 'Zed'
+          class AsList < self
+            attr_reader :sub_parameter
+
+            def initialize(klass = nil, options = nil)
+              return if options.nil?
+
+              @sub_parameter = Parametrized::Parameter.new(
+                options[:name],
+                klass,
+                description: options[:description],
+                transform: options[:transform],
+                constraint: options[:constraint]
+              )
+            end
+
+            protected
+
+            def transform(parameter, value, instance)
+              return if value.nil?
+
+              unless value.respond_to?(:to_a)
+                raise "#{parameter.name} is assigned to " \
+                  "#{value.inspect} which is not a list"
+              end
+
+              if sub_parameter
+                value.to_a.map { |el| sub_parameter.process_value(instance, el) }
+              else
+                value.to_a
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/aws/templates/utils/parametrized/transformation/as_module.rb

@@ -0,0 +1,42 @@
+require 'aws/templates/utils'
+
+module Aws
+  module Templates
+    module Utils
+      module Parametrized
+        class Transformation
+          ##
+          # Convert to a Ruby class
+          #
+          # The transformation allows to use elements of metaprogramming in the framework. It
+          # tries to transform passed value to a Ruby class.
+          #
+          # === Example
+          #
+          #    class Piece
+          #      include Aws::Templates::Utils::Parametrized
+          #
+          #      parameter :param, :transform => as_module
+          #    end
+          #
+          #    i = Piece.new
+          #    i.param # => nil
+          #    i = Piece.new(:param => 'Object')
+          #    i.param # => Object
+          class AsModule < self
+            include ::Singleton
+
+            protected
+
+            def transform(_, value, _)
+              return if value.nil?
+              return value if value.is_a?(Module)
+              return Utils.lookup_module(value.to_s) if value.respond_to?(:to_s)
+              raise "#{value} can't be transformed to a class"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/aws/templates/utils/parametrized/transformation/as_object.rb

@@ -0,0 +1,76 @@
+require 'aws/templates/utils'
+
+module Aws
+  module Templates
+    module Utils
+      module Parametrized
+        class Transformation
+          ##
+          # Transform input value into the object
+          #
+          # Input value can be either hash or object. The transformation performs
+          # nested object evaluation recusrsively as the input were Parametrized
+          # instance. As a parameter for the transformation you can
+          # specify either Module which mixes in Parametrized or to use
+          # a block which is to be evaluated as a part of Parametrized definition
+          # or both.
+          #
+          # With as_object transformation you can have as many nested levels
+          # as it's needed.
+          #
+          # === Example
+          #
+          #    class Piece
+          #      include Aws::Templates::Utils::Parametrized
+          #
+          #      parameter :param1,
+          #        :transform => as_object(Aws::Templates::Utils::AsNamed)
+          #      parameter :param2, :transform => as_object {
+          #        parameter :id, :description => 'Just ID',
+          #          :constraint => not_nil
+          #      }
+          #      parameter :param3,
+          #        :transform => as_object(Aws::Templates::Utils::AsNamed) {
+          #          parameter :path, :description => 'Just path',
+          #            :constraint => not_nil
+          #        }
+          #    end
+          #
+          #    i = Piece.new
+          #    i.param1 # => nil
+          #    i = Piece.new(:param1 => {:name => 'Zed'})
+          #    i.param1.name # => 'Zed'
+          #    i = Piece.new(:param2 => {:id => 123})
+          #    i.param2.id # => 123
+          #    i = Piece.new(:param3 => {:path => 'a/b', :name => 'Rex'})
+          #    i.param3.path # => 'a/b'
+          #    i.param3.name # => 123
+          class AsObject < self
+            attr_reader :klass
+
+            def initialize(scope, klass = nil, &definition)
+              @klass = if klass.nil?
+                Parametrized::Nested.create_class(scope)
+              elsif klass.is_a?(Class)
+                klass
+              elsif klass.is_a?(Module)
+                Parametrized::Nested.create_class(scope).with(klass)
+              else
+                raise "#{klass} is neither a class nor a module"
+              end
+
+              @klass.class_eval(&definition) unless definition.nil?
+            end
+
+            protected
+
+            def transform(_, value, instance)
+              return if value.nil?
+              klass.new(instance, value)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/aws/templates/utils/parametrized/transformation/as_rendered.rb

@@ -0,0 +1,100 @@
+require 'aws/templates/utils'
+
+module Aws
+  module Templates
+    module Utils
+      module Parametrized
+        class Transformation
+          ##
+          # Transform value with the specified render
+          #
+          # Input value can be anything which could be rendered by the
+          # specified render type. Returned value is rendered input.
+          #
+          # The transformation is useful when you have a document of some
+          # format embedded into a document of another format. An example
+          # could be Bash scripts embedded into AWS CFN template.
+          #
+          # === Example
+          #
+          #    class Brush
+          #      attr_reader :color
+          #      attr_reader :thickness
+          #      attr_reader :type
+          #
+          #      def initialize(c, thick, t)
+          #        @c = c
+          #        @thick = thick
+          #        @t = t
+          #      end
+          #    end
+          #
+          #    class Circle
+          #      attr_reader :radius
+          #      attr_reader :brush
+          #
+          #      def initialize(r, b)
+          #        @radius = r
+          #        @brush = b
+          #      end
+          #    end
+          #
+          #    class Piece
+          #      include Aws::Templates::Utils::Parametrized
+          #
+          #      parameter :picture, :transform => as_rendered(
+          #        # Render Type
+          #        Graphics::Renders::JPEG,
+          #        # parameter section for the render
+          #        format: :base64
+          #      )
+          #    end
+          #
+          #    i = Piece.new(picture: Circle.new(10, Brush.new(:red, 2, :dots)))
+          #    i.picture # => <rendered representation>
+          class AsRendered < self
+            attr_reader :type
+            attr_reader :parameters
+
+            def initialize(render_type, params)
+              @type = _check_render_type(render_type)
+              @parameters = params
+            end
+
+            protected
+
+            def transform(_, value, instance)
+              return if value.nil?
+              type.view_for(value, _compute_render_parameters(instance)).to_rendered
+            end
+
+            private
+
+            def _check_render_type(render_type)
+              unless render_type.respond_to?(:view_for)
+                raise(
+                  "Wrong render type object #{params}. " \
+                  'The instance should have #view_for method.'
+                )
+              end
+
+              render_type
+            end
+
+            def _compute_render_parameters(instance)
+              return if parameters.nil?
+
+              if parameters.respond_to?(:to_hash)
+                parameters
+              elsif parameters.respond_to?(:to_proc)
+                instance.instance_exec(&parameters)
+              else
+                parameters
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/aws/templates/utils/parametrized/transformation/as_string.rb

@@ -0,0 +1,39 @@
+require 'aws/templates/utils'
+
+module Aws
+  module Templates
+    module Utils
+      module Parametrized
+        class Transformation
+          ##
+          # Convert input into string
+          #
+          # Input value can be anything implementing :to_s method.
+          #
+          # === Example
+          #
+          #    class Piece
+          #      include Aws::Templates::Utils::Parametrized
+          #
+          #      parameter :param, :transform => as_string
+          #    end
+          #
+          #    i = Piece.new
+          #    i.param # => nil
+          #    i = Piece.new(:param => 23)
+          #    i.param # => '23'
+          class AsString < self
+            include ::Singleton
+
+            protected
+
+            def transform(_, value, _)
+              return if value.nil?
+              String(value)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/aws/templates/utils/parametrized/transformation/dsl.rb

@@ -0,0 +1,94 @@
+require 'aws/templates/utils'
+
+module Aws
+  module Templates
+    module Utils
+      module Parametrized
+        class Transformation
+          ##
+          # Syntax sugar for transformations definition
+          #
+          # It injects the methods as class-scope methods into mixing classes.
+          # The methods are factories to create particular type of transformation
+          module Dsl
+            include Utils::Inheritable
+
+            class_scope do
+              ##
+              # Chain a few transformations into a single one
+              #
+              # alias for AsChain class
+              def as_chain(*components)
+                Parametrized::Transformation::AsChain.new(components)
+              end
+
+              ##
+              # Transform the value into an object
+              #
+              # alias for AsObject class
+              def as_object(klass = nil, &definition)
+                Parametrized::Transformation::AsObject.new(self, klass, &definition)
+              end
+
+              ##
+              # Transform the value into a list
+              #
+              # alias for AsList class
+              def as_list(parameters = nil)
+                Parametrized::Transformation::AsList.new(self, parameters)
+              end
+
+              ##
+              # Transform value with the specified render
+              #
+              # alias for AsRendered class
+              def as_rendered(render_type, params = nil, &params_block)
+                Parametrized::Transformation::AsRendered.new(render_type, params || params_block)
+              end
+
+              ##
+              # Convert input into integer
+              #
+              # alias for AsInteger class
+              def as_integer
+                Parametrized::Transformation::AsInteger.instance
+              end
+
+              ##
+              # Convert input into string
+              #
+              # alias for AsString class
+              def as_string
+                Parametrized::Transformation::AsString.instance
+              end
+
+              ##
+              # Convert input into boolean
+              #
+              # alias for AsBoolean class
+              def as_boolean
+                Parametrized::Transformation::AsBoolean.instance
+              end
+
+              ##
+              # Convert input into hash
+              #
+              # alias for AsHash class
+              def as_hash(&blk)
+                Parametrized::Transformation::AsHash.new(self, &blk)
+              end
+
+              ##
+              # Convert input into a class
+              #
+              # alias for AsModule class
+              def as_module
+                Parametrized::Transformation::AsModule.instance
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end