cloud-templates 0.2.0 → 0.3.0

data/lib/aws/templates/utils/parametrized/getter/one_of.rb

@@ -0,0 +1,48 @@
+require 'aws/templates/utils'
+
+module Aws
+  module Templates
+    module Utils
+      module Parametrized
+        class Getter
+          ##
+          # Pick one of non-nil values returned by nested getters
+          #
+          # In general it plays the same role as || operator in Ruby. It
+          # just picks first non-nil value returned by a list of getters
+          #
+          # === Example
+          #
+          #    class Piece
+          #      include Aws::Templates::Utils::Parametrized
+          #
+          #      parameter :param1, :getter => one_of(
+          #        path(:a, :b),
+          #        path(:b, :c)
+          #      )
+          #    end
+          #
+          #    i = Piece.new( :a => { :b => 3 } )
+          #    i.param1 # => 3
+          #    i = Piece.new( :b => { :c => 4 } )
+          #    i.param1 # => 4
+          class OneOf < self
+            attr_reader :getters
+
+            def initialize(getters)
+              @getters = getters
+            end
+
+            protected
+
+            def get(parameter, instance)
+              getters.lazy
+                     .map { |g| instance.instance_exec(parameter, &g) }
+                     .find { |v| !v.nil? }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/aws/templates/utils/parametrized/getter/path.rb

@@ -0,0 +1,53 @@
+require 'aws/templates/utils'
+
+module Aws
+  module Templates
+    module Utils
+      module Parametrized
+        class Getter
+          ##
+          # Lookup value in options by path
+          #
+          # Looks up value from options attribute by specified path. The path
+          # can be either statically specified or a block can be provided.
+          # The block shouldn't have parameters and should return an array
+          # containing path. The block will be executed in the instance context.
+          #
+          # === Example
+          #
+          #    class Piece
+          #      include Aws::Templates::Utils::Parametrized
+          #
+          #      parameter :param1, :getter => path(:a, :b)
+          #    end
+          #
+          #    i = Piece.new(:a => { :b => 3 })
+          #    i.param1 # => 3
+          class Path < self
+            attr_reader :path
+
+            def initialize(path)
+              unless path.respond_to?(:to_proc) || path.respond_to?(:to_a)
+                raise ArgumentError.new(
+                  "Path can be either array or Proc: #{path.inspect}"
+                )
+              end
+
+              @path = path
+            end
+
+            protected
+
+            def get(_, instance)
+              if path.respond_to?(:to_proc)
+                instance.options[*instance.instance_eval(&path)]
+              elsif path.respond_to?(:to_a)
+                instance.options[*path]
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/aws/templates/utils/parametrized/getter/value.rb

@@ -0,0 +1,50 @@
+require 'aws/templates/utils'
+
+module Aws
+  module Templates
+    module Utils
+      module Parametrized
+        class Getter
+          ##
+          # Calculate value
+          #
+          # If a block is specified, it will be executed in the instance
+          # context and return will be used as parameter value. If a value
+          # specified then it will be used as parameter value instead.
+          #
+          # === Example
+          #
+          #    class Piece
+          #      include Aws::Templates::Utils::Parametrized
+          #
+          #      parameter :param1, :getter => value(1)
+          #      parameter :param2, :getter => value { options[:z] + 1 }
+          #    end
+          #
+          #    i = Piece.new(:z => 3)
+          #    i.param2 # => 4
+          #    i.param1 # => 1
+          class Value < self
+            attr_reader :calculation
+
+            def initialize(calculation)
+              @calculation = calculation
+            end
+
+            protected
+
+            def get(_, instance)
+              if calculation.respond_to?(:to_hash)
+                calculation
+              elsif calculation.respond_to?(:to_proc)
+                instance.instance_eval(&calculation)
+              else
+                calculation
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/aws/templates/utils/parametrized/nested.rb

@@ -1,9 +1,4 @@
-require 'set'
-require 'aws/templates/utils/default'
-require 'aws/templates/utils/parametrized'
-require 'aws/templates/utils/parametrized/getters'
-require 'aws/templates/utils/dependent'
-require 'aws/templates/utils/options'
+require 'aws/templates/utils'
 
 module Aws
   module Templates
@@ -14,14 +9,17 @@ module Aws
         #
         # Wraps hash or object into "parametrized" instance. Used for nested parameter definitions.
         class Nested
+          using Utils::Recursive
+          using Utils::Dependency::Refinements
+
           include Parametrized
-          include Default
-          include Dependent
+          include Utils::Default
+          include Utils::Dependent
 
           attr_reader :options
 
           def self.getter
-            as_is
+            Parametrized::Getter::AsIs.instance
           end
 
           def self.create_class(scope)
@@ -58,20 +56,15 @@ module Aws
           attr_reader :parent
 
           def dependencies
-            @dependencies ||= Set.new
+            @dependencies ||= ::Set.new
           end
 
           protected
 
           def initialize(parent, obj)
-            unless obj.respond_to?(:to_recursive)
-              raise "Value #{obj} can't be transformed " \
-                    'into a recursive container'
-            end
-
             @parent = parent
             depends_on(obj) if obj.dependency?
-            @options = Options.new(defaults, obj.to_recursive)
+            @options = Utils::Options.new(defaults, obj.to_recursive)
           end
         end
       end

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

@@ -0,0 +1,74 @@
+require 'aws/templates/utils'
+
+module Aws
+  module Templates
+    module Utils
+      module Parametrized
+        ##
+        # Transformation functor class
+        #
+        # A transformation is a Proc accepting input value and providing output
+        # value which is expected to be a transformation of the input.
+        # The proc is executed in instance context so instance methods can
+        # be used for calculation.
+        #
+        # The class implements functor pattern through to_proc method and
+        # closure. Essentially, all transformations can be used everywhere where
+        # a block is expected.
+        #
+        # It provides protected method transform which should be overriden in
+        # all concrete transformation classes.
+        class Transformation
+          ##
+          # Creates closure with transformation invocation
+          #
+          # It's an interface method required for Transformation to expose
+          # functor properties. It encloses invocation of Transformation
+          # transform_wrapper method into a closure. The closure itself is
+          # executed in the context of Parametrized instance which provides
+          # proper set "self" variable.
+          #
+          # The closure itself accepts 2 parameters:
+          # * +parameter+ - the Parameter object which the transformation
+          #                 will be performed for
+          # * +value+ - parameter value to be transformed
+          # ...where instance is assumed from self
+          def to_proc
+            transform = self
+
+            lambda do |parameter, value|
+              transform.transform_wrapper(parameter, value, self)
+            end
+          end
+
+          ##
+          # Wraps transformation-dependent method
+          #
+          # It wraps constraint-dependent "transform" method into a rescue block
+          # to standardize exception type and information provided by failed
+          # transformation calculation
+          # * +parameter+ - the Parameter object which the transformation will
+          #                 be performed for
+          # * +value+ - parameter value to be transformed
+          # * +instance+ - the instance value is transform
+          def transform_wrapper(parameter, value, instance)
+            transform(parameter, value, instance)
+          rescue StandardError
+            raise Templates::Exception::NestedParameterException.new(parameter)
+          end
+
+          protected
+
+          ##
+          # Transform method
+          #
+          # * +parameter+ - the Parameter object which the transformation is
+          #                 performed for
+          # * +value+ - parameter value to be transformed
+          # * +instance+ - the instance value is transform
+          def transform(parameter, value, instance); end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+require 'aws/templates/utils'
+
+module Aws
+  module Templates
+    module Utils
+      module Parametrized
+        class Transformation
+          ##
+          # Convert input into boolean
+          #
+          # Input value can be anything implementing :to_s method. Value considered false if it is:
+          # * +'false' as a string+
+          # * +FalseClass+
+          # Otherwise, value is true. If value is nil, it won't be replaced by "false"
+          #
+          # === Example
+          #
+          #    class Piece
+          #      include Aws::Templates::Utils::Parametrized
+          #
+          #      parameter :param, :transform => as_boolean
+          #    end
+          #
+          #    i = Piece.new
+          #    i.param # => false
+          #    i = Piece.new(:param => 0)
+          #    i.param # => true
+          class AsBoolean < self
+            include ::Singleton
+
+            protected
+
+            def transform(_, value, _)
+              return if value.nil?
+              !value.to_s.casecmp('false').zero?
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+require 'aws/templates/utils'
+
+module Aws
+  module Templates
+    module Utils
+      module Parametrized
+        class Transformation
+          ##
+          # Apply several transformation sequentially
+          #
+          # Useful when a few transformations need to be applied to a single value to get
+          # the final result
+          #
+          # === Example
+          #
+          #    class Piece
+          #      include Aws::Templates::Utils::Parametrized
+          #
+          #      parameter :param,
+          #        transform: as_chain(
+          #                     as_hash,
+          #                     as_object(Aws::Templates::Utils::AsNamed)
+          #                   )
+          #    end
+          #
+          #    i = Piece.new(param: [:name, 'Rex'])
+          #    i.param.name # => 'Rex'
+          class AsChain < self
+            attr_reader :components
+
+            def initialize(components)
+              @components = _check_components(components)
+            end
+
+            protected
+
+            def transform(parameter, value, instance)
+              return if value.nil?
+              components.inject(value) { |acc, elem| instance.instance_exec(parameter, acc, &elem) }
+            end
+
+            private
+
+            def _check_components(components)
+              result = components.to_a
+
+              invalid_components = result.reject { |component| component.respond_to?(:to_proc) }
+              raise "Invalid components: #{invalid_components}" unless invalid_components.empty?
+
+              result
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,89 @@
+require 'aws/templates/utils'
+
+module Aws
+  module Templates
+    module Utils
+      module Parametrized
+        class Transformation
+          ##
+          # Convert input into hash
+          #
+          # Input value can be anything implementing :to_hash method.
+          #
+          # === Example
+          #
+          #    class Piece
+          #      include Aws::Templates::Utils::Parametrized
+          #
+          #      parameter :param, :transform => as_hash
+          #      parameter :param2,
+          #        transform: as_hash {
+          #          value name: :number,
+          #            description: 'Number',
+          #            constraint: not_nil,
+          #            transform: as_integer
+          #        }
+          #    end
+          #
+          #    i = Piece.new
+          #    i.param # => nil
+          #    i = Piece.new(:param => [[1,2]])
+          #    i.param # => {1=>2}
+          #    i = Piece.new(:param2 => [[1,'3']])
+          #    i.param # => {1=>3}
+          class AsHash < self
+            include Parametrized::ClassScope
+
+            attr_reader :key_parameter
+            attr_reader :value_parameter
+
+            def key(opts)
+              @key_parameter = _create_parameter(opts)
+            end
+
+            def value(opts)
+              @value_parameter = _create_parameter(opts)
+            end
+
+            def initialize(klass = nil, &blk)
+              @klass = klass
+              instance_eval(&blk) if blk
+            end
+
+            protected
+
+            def transform(_, value, instance)
+              return if value.nil?
+
+              Hash[
+                Hash[value].map do |k, v|
+                  [
+                    _process_value(@key_parameter, instance, k),
+                    _process_value(@value_parameter, instance, v)
+                  ]
+                end
+              ]
+            end
+
+            def _process_value(parameter, instance, value)
+              return value if parameter.nil?
+              parameter.process_value(instance, value)
+            end
+
+            private
+
+            def _create_parameter(opts)
+              Parametrized::Parameter.new(
+                opts[:name],
+                @klass,
+                description: opts[:description],
+                transform: opts[:transform],
+                constraint: opts[:constraint]
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end