cloud-templates 0.2.0 → 0.3.0

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

@@ -1,293 +0,0 @@
-require 'aws/templates/exceptions'
-require 'aws/templates/utils/parametrized'
-require 'singleton'
-
-module Aws
-  module Templates
-    module Utils
-      module Parametrized #:nodoc:
-        ##
-        # Getter functor class
-        #
-        # A getter is a Proc without parameters and it is expected to return
-        # a value. Since the proc is to be executed in instance context
-        # the value can be calculated based on other methods or extracted from
-        # options attrribute
-        #
-        # The class implements functor pattern through to_proc method and
-        # closure. Essentially, all getters can be used everywhere where
-        # a block is expected.
-        #
-        # It provides protected method get which should be overriden in
-        # all concrete getter classes.
-        class Getter
-          ##
-          # Get parameter from instance variables as is
-          #
-          # Gets value from instance variable by parameter's name without
-          # any other operations performed.
-          #
-          # === Example
-          #
-          #    class Piece
-          #      include Aws::Templates::Utils::Parametrized
-          #
-          #      parameter :param1, getter: as_instance_variable
-          #
-          #      def initialize(x)
-          #        @param1 = x
-          #      end
-          #    end
-          #
-          #    i = Piece.new(3)
-          #    i.param1 # => 3
-          class AsInstanceVariable < Getter
-            include Singleton
-
-            protected
-
-            def get(parameter, instance)
-              instance.instance_variable_get("@#{parameter.name}")
-            end
-          end
-
-          ##
-          # Get options value "as is"
-          #
-          # Gets value from options attribute by parameter's name without
-          # any other operations performed.
-          #
-          # === Example
-          #
-          #    class Piece
-          #      include Aws::Templates::Utils::Parametrized
-          #
-          #      parameter :param1, :getter => as_is
-          #    end
-          #
-          #    i = Piece.new(:param1 => 3)
-          #    i.param1 # => 3
-          class AsIs < Getter
-            include Singleton
-
-            protected
-
-            def get(parameter, instance)
-              instance.options[parameter.name]
-            end
-          end
-
-          ##
-          # 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 < Getter
-            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
-
-          ##
-          # 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 < Getter
-            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
-
-          ##
-          # 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 < Getter
-            attr_reader :getters
-
-            def initialize(getters)
-              @getters = getters
-            end
-
-            protected
-
-            def get(parameter, instance)
-              getters.inject(nil) do |value, g|
-                value = instance.instance_exec(parameter, &g)
-                break value unless value.nil?
-              end
-            end
-          end
-
-          ##
-          # Creates closure with getter invocation
-          #
-          # It's an interface method required for Getter to expose
-          # functor properties. It encloses invocation of Getter get_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 1 parameters
-          # * +parameter+ - the Parameter object which the getter is executed for
-          # ...where instance is assumed from self
-          def to_proc
-            getter = self
-
-            lambda do |parameter|
-              getter.get_wrapper(parameter, self)
-            end
-          end
-
-          ##
-          # Wraps getter-dependent method
-          #
-          # It wraps constraint-dependent "get" method into a rescue block
-          # to standardize exception type and information provided by failed
-          # value calculation
-          # * +parameter+ - the Parameter object which the getter is executed for
-          # * +instance+ - the instance value is taken from
-          def get_wrapper(parameter, instance)
-            get(parameter, instance)
-          rescue StandardError
-            raise NestedParameterException.new(parameter)
-          end
-
-          protected
-
-          ##
-          # Getter method
-          #
-          # * +parameter+ - the Parameter object which the getter is executed for
-          # * +instance+ - the instance value is taken from
-          def get(parameter, instance); end
-        end
-
-        ##
-        # Syntax sugar for getters definition
-        #
-        # It injects the methods as class-scope methods into mixing classes.
-        # The methods are factories to create particular type of getter
-        class_scope do
-          ##
-          # Get parameter from instance variables as is
-          #
-          # alias for AsInstanceVariable class
-          def as_instance_variable
-            Getter::AsInstanceVariable.instance
-          end
-
-          ##
-          # Get parameter from Options as is
-          #
-          # alias for AsIs class
-          def as_is
-            Getter::AsIs.instance
-          end
-
-          ##
-          # Calculate value of parameter
-          #
-          # alias for Value class
-          def value(v = nil, &blk)
-            Getter::Value.new(v.nil? ? blk : v)
-          end
-
-          ##
-          # Look up value of the parameter with path
-          #
-          # alias for Path class
-          def path(*v, &blk)
-            Getter::Path.new(
-              v.empty? ? blk : v
-            )
-          end
-
-          ##
-          # Choose one non-nil value from nested getters
-          #
-          # alias for OneOf class
-          def one_of(*getters)
-            Getter::OneOf.new(getters)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,32 +0,0 @@
-require 'set'
-
-module Aws
-  module Templates
-    module Utils
-      module Parametrized
-        ##
-        # Remember Alan Turing's halting problem and don't believe in miracles. The method will
-        # only work with parameters because they are supposed to be pure unmodifying functions.
-        # Hence we can terminate if a parameter method was invoked twice in the stack with the same
-        # context.
-        module Guarded
-          Call = Struct.new(:instance, :parameter)
-
-          def guarded_get(instance, parameter_object)
-            current_call = Call.new(instance, parameter_object)
-            return unless trace.add?(current_call)
-            ret = parameter_object.get(self)
-            trace.delete(current_call)
-            ret
-          end
-
-          private
-
-          def trace
-            Thread.current[Guarded.name] ||= Set.new
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,652 +0,0 @@
-require 'aws/templates/exceptions'
-require 'aws/templates/utils/parametrized'
-require 'aws/templates/utils/parametrized/nested'
-require 'singleton'
-
-module Aws
-  module Templates
-    module Utils
-      module Parametrized #:nodoc:
-        ##
-        # 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
-          ##
-          # 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 < Transformation
-            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
-
-          ##
-          # 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 < Transformation
-            attr_reader :klass
-
-            def initialize(scope, klass = nil, &definition)
-              @klass = if klass.nil?
-                Nested.create_class(scope)
-              elsif klass.is_a?(Class)
-                klass
-              elsif klass.is_a?(Module)
-                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
-
-          ##
-          # 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 < Transformation
-            attr_reader :sub_parameter
-
-            def initialize(klass = nil, options = nil)
-              return if options.nil?
-
-              @sub_parameter = 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
-
-          ##
-          # 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 < Transformation
-            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
-
-          ##
-          # 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 < Transformation
-            include Singleton
-
-            protected
-
-            def transform(_, value, _)
-              return if value.nil?
-              Integer(value)
-            end
-          end
-
-          ##
-          # 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 < Transformation
-            include Singleton
-
-            protected
-
-            def transform(_, value, _)
-              return if value.nil?
-              String(value)
-            end
-          end
-
-          ##
-          # 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 < Transformation
-            include Singleton
-
-            protected
-
-            def transform(_, value, _)
-              return if value.nil?
-              !value.to_s.casecmp('false').zero?
-            end
-          end
-
-          ##
-          # 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 < Transformation
-            include Parametrized.class_scope
-
-            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)
-              Parameter.new(
-                opts[:name],
-                @klass,
-                description: opts[:description],
-                transform: opts[:transform],
-                constraint: opts[:constraint]
-              )
-            end
-          end
-
-          ##
-          # 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 < Transformation
-            include Singleton
-
-            protected
-
-            def transform(_, value, _)
-              return if value.nil?
-              return value if value.is_a?(Module)
-              return _lookup(value.to_s) if value.respond_to?(:to_s)
-              raise "#{value} can't be transformed to a class"
-            end
-
-            private
-
-            PATH_REGEXP = Regexp.compile('::|[.]|/')
-
-            def _lookup(class_name)
-              target = class_name.split(PATH_REGEXP)
-                                 .inject(::Kernel) { |acc, elem| acc.const_get(elem) }
-
-              raise "#{class_name} == #{target} which is not a class" unless target.is_a?(Module)
-
-              target
-            end
-          end
-
-          ##
-          # 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 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
-
-        ##
-        # 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
-        class_scope do
-          ##
-          # Chain a few transformations into a single one
-          #
-          # alias for AsChain class
-          def as_chain(*components)
-            Transformation::AsChain.new(components)
-          end
-
-          ##
-          # Transform the value into an object
-          #
-          # alias for AsObject class
-          def as_object(klass = nil, &definition)
-            Transformation::AsObject.new(self, klass, &definition)
-          end
-
-          ##
-          # Transform the value into a list
-          #
-          # alias for AsList class
-          def as_list(parameters = nil)
-            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)
-            Transformation::AsRendered.new(render_type, params || params_block)
-          end
-
-          ##
-          # Convert input into integer
-          #
-          # alias for AsInteger class
-          def as_integer
-            Transformation::AsInteger.instance
-          end
-
-          ##
-          # Convert input into string
-          #
-          # alias for AsString class
-          def as_string
-            Transformation::AsString.instance
-          end
-
-          ##
-          # Convert input into boolean
-          #
-          # alias for AsBoolean class
-          def as_boolean
-            Transformation::AsBoolean.instance
-          end
-
-          ##
-          # Convert input into hash
-          #
-          # alias for AsHash class
-          def as_hash(&blk)
-            Transformation::AsHash.new(self, &blk)
-          end
-
-          ##
-          # Convert input into a class
-          #
-          # alias for AsModule class
-          def as_module
-            Transformation::AsModule.instance
-          end
-        end
-
-        class Nested #:nodoc:
-          include Parametrized
-        end
-      end
-    end
-  end
-end