cloud-templates 0.2.0 → 0.3.0

data/lib/aws/templates/utils/contextualized/hash.rb

@@ -1,13 +0,0 @@
-require 'aws/templates/utils/contextualized'
-
-##
-# Hash class patch
-#
-# Adds to_filter method converting a hash into an Override filter
-class Hash
-  ##
-  # Convert to Override filter
-  def to_filter
-    Aws::Templates::Utils::Contextualized::Filter::Override.new(self)
-  end
-end

data/lib/aws/templates/utils/contextualized/nil.rb

@@ -1,13 +0,0 @@
-require 'aws/templates/utils/contextualized'
-
-##
-# NilClass class patch
-#
-# Adds to_filter method converting nil into the Identity filter
-class NilClass
-  ##
-  # Convert nil to Identity filter
-  def to_filter
-    Aws::Templates::Utils::Contextualized::Filter::Identity.new
-  end
-end

data/lib/aws/templates/utils/contextualized/proc.rb

@@ -1,13 +0,0 @@
-require 'aws/templates/utils/contextualized'
-
-##
-# Proc class patch
-#
-# Adds to_filter method proxying a Proc through Filter interface object
-class Proc
-  ##
-  # Proxy the Proc through Proxy filter object
-  def to_filter
-    Aws::Templates::Utils::Contextualized::Filter::Proxy.new(self)
-  end
-end

data/lib/aws/templates/utils/dependency/enumerable.rb

@@ -1,13 +0,0 @@
-require 'set'
-
-##
-# Dependencies methods definitions for all collections
-module Enumerable
-  def dependencies
-    find_all(&:dependency?).inject(Set.new) { |acc, elem| acc.merge(elem.dependencies) }
-  end
-
-  def dependency?
-    true
-  end
-end

data/lib/aws/templates/utils/dependency/object.rb

@@ -1,46 +0,0 @@
-require 'set'
-require 'aws/templates/utils/dependency'
-
-##
-# Dependency method stubs
-#
-# To avoid checking classes directly to filter out dependencies and non-dependencies, we're
-# monkey-patching Object class with stubs for Dependency class.
-#
-# TODO: Devise a better approach and remove the extension
-class Object
-  EMPTY_SET = Set.new.freeze
-
-  # By default an object is not a dependency
-  def dependency?
-    false
-  end
-
-  # It returns self
-  def object
-    self
-  end
-
-  ##
-  # Object root
-  #
-  # It is used to gracefully process dependencies
-  def root; end
-
-  alias not_a_dependency object
-
-  # it returns a set containing a single dependency on itself
-  def dependencies
-    EMPTY_SET
-  end
-
-  # mark the object as dependency
-  def as_a_dependency
-    Aws::Templates::Utils::Dependency.new(object)
-  end
-
-  # mark the object as dependency of itself
-  def as_a_self_dependency
-    as_a_dependency.to_self
-  end
-end

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

@@ -1,423 +0,0 @@
-require 'aws/templates/exceptions'
-require 'aws/templates/utils/parametrized'
-require 'set'
-require 'singleton'
-
-module Aws
-  module Templates
-    module Utils
-      module Parametrized #:nodoc:
-        ##
-        # Constraint functor class
-        #
-        # A constraint is a Proc which accepts one parameter which is a value
-        # which needs to be checked and ir is expected to throw an exception
-        # if the value is not in compliance with the constraint
-        #
-        # The class implements functor pattern through to_proc method and
-        # closure. Essentially, all constraints can be used everywhere where
-        # a block is expected.
-        #
-        # It provides protected method check which should be overriden in
-        # all concrete constraint classes.
-        class Constraint
-          ##
-          # Check if passed value is not nil
-          #
-          # === Example
-          #
-          #    class Piece
-          #      include Aws::Templates::Utils::Parametrized
-          #
-          #      parameter :param1, :constraint => not_nil
-          #    end
-          #
-          #    i = Piece.new(:param1 => 3)
-          #    i.param1 # => 3
-          #    i = Piece.new
-          #    i.param1 # throws ParameterValueInvalid
-          class NotNil < Constraint
-            include Singleton
-
-            protected
-
-            def check(_, value, _)
-              raise('required but was not found in input hash') if value.nil?
-            end
-          end
-
-          ##
-          # Check if passed value is in the enumeration values.
-          #
-          # === Example
-          #
-          #    class Piece
-          #      include Aws::Templates::Utils::Parametrized
-          #
-          #      parameter :param1, :constraint => enum([1,'2',3])
-          #    end
-          #
-          #    i = Piece.new(:param1 => 3)
-          #    i.param1 # => 3
-          #    i = Piece.new(:param1 => 4)
-          #    i.param1 # throws ParameterValueInvalid
-          class Enum < Constraint
-            attr_reader :set
-
-            def initialize(list)
-              @set = Set.new(list)
-            end
-
-            protected
-
-            def check(_, value, _)
-              return if value.nil? || set.include?(value)
-
-              raise(
-                "Value #{value.inspect} is not in the set of allowed " \
-                "values #{set.inspect}"
-              )
-            end
-          end
-
-          ##
-          # Switch-like variant check
-          #
-          # Recursive check implementing switch-based semantics for defining
-          # checks need to be performed depending on parameter's value.
-          #
-          # === Example
-          #
-          #    class Piece
-          #      include Aws::Templates::Utils::Parametrized
-          #      parameter :param2
-          #      parameter :param1,
-          #        :constraint => depends_on_value(
-          #          1 => lambda { |v| raise 'Too big' if param2 > 3 },
-          #          2 => lambda { |v| raise 'Too small' if param2 < 2 }
-          #        )
-          #    end
-          #
-          #    i = Piece.new(:param1 => 1, :param2 => 1)
-          #    i.param1 # => 1
-          #    i = Piece.new(:param1 => 1, :param2 => 5)
-          #    i.param1 # raise ParameterValueInvalid
-          #    i = Piece.new(:param1 => 2, :param2 => 1)
-          #    i.param1 # raise ParameterValueInvalid
-          #    i = Piece.new(:param1 => 2, :param2 => 5)
-          #    i.param1 # => 2
-          class DependsOnValue < Constraint
-            ##
-            # Selector hash
-            attr_reader :selector
-
-            def initialize(selector)
-              @selector = selector
-            end
-
-            protected
-
-            def check(parameter, value, instance)
-              return unless selector.key?(value)
-
-              instance.instance_exec(
-                parameter,
-                value,
-                &selector[value]
-              )
-            end
-          end
-
-          ##
-          # Check presence of parameters if the condition is met
-          #
-          # Requires presence of the methods passed as dependencies in the
-          # current scope with non-nil returning values. Default condition
-          # for the value is not to be nil. The condition can be either
-          # a block or a value.
-          #
-          # === Example
-          #
-          #    class Piece
-          #      include Aws::Templates::Utils::Parametrized
-          #      parameter :param2
-          #      parameter :param1, :constraint => requires(:param2)
-          #    end
-          #
-          #    i = Piece.new(:param2 => 1)
-          #    i.param1 # => nil
-          #    i = Piece.new(:param1 => 1)
-          #    i.param1 # raise ParameterValueInvalid
-          #    i = Piece.new(:param1 => 2, :param2 => 1)
-          #    i.param1 # => 2
-          class Requires < Constraint
-            attr_reader :dependencies
-            attr_reader :condition
-
-            def initialize(dependencies)
-              @dependencies = dependencies
-              @condition = method(:not_nil?)
-            end
-
-            def if(*params, &blk)
-              if params.empty?
-                @condition = blk
-              else
-                test = params.first
-                @condition = ->(v) { v == test }
-              end
-
-              self
-            end
-
-            protected
-
-            def not_nil?(value)
-              !value.nil?
-            end
-
-            def check(parameter, value, instance)
-              return unless instance.instance_exec(value, &condition)
-
-              dependencies.each do |pname|
-                next unless instance.send(pname).nil?
-
-                raise(
-                  "#{pname} is required when #{parameter.name} value " \
-                  "is set to #{value.inspect}"
-                )
-              end
-            end
-          end
-
-          ##
-          # Check if value satisfies the condition
-          #
-          # Checks if value satisfies the condition defined in the block
-          # which should return true if the condition is met and false if it's
-          # not. If value fails the check, an exception will be thrown
-          # with attached condition description. The description is a part
-          # of constraint definition.
-          #
-          # The block is evaluated in the functor's invocation context.
-          #
-          # === Example
-          #
-          #    class Piece
-          #      include Aws::Templates::Utils::Parametrized
-          #      parameter :param1,
-          #        :constraint => satisfies('Mediocre value') { |v| v < 100 }
-          #    end
-          #
-          #    i = Piece.new(:param2 => 1)
-          #    i.param1 # => 1
-          #    i = Piece.new(:param1 => 101)
-          #    i.param1 # raise ParameterValueInvalid
-          class SatisfiesCondition < Constraint
-            attr_reader :condition
-            attr_reader :description
-
-            def initialize(description, &cond_block)
-              @condition = cond_block
-              @description = description
-            end
-
-            protected
-
-            def check(parameter, value, instance)
-              return if value.nil? || instance.instance_exec(value, &condition)
-
-              raise(
-                "#{value.inspect} doesn't satisfy the condition " \
-                "#{description} for parameter #{parameter.name}"
-              )
-            end
-          end
-
-          ##
-          # Check if value matches the regular expression
-          #
-          # Checks if value matches the regular expression. If value doesn't match, an exception
-          # will be thrown with attached description of regular expression and value converted to
-          # string.
-          #
-          # === Example
-          #
-          #    class Piece
-          #      include Aws::Templates::Utils::Parametrized
-          #      parameter :param1, constraint: matches('A+')
-          #    end
-          #
-          #    i = Piece.new(:param1 => 'Ask')
-          #    i.param1 # => 'Ask'
-          #    i = Piece.new(:param1 => 'Bar')
-          #    i.param1 # raise ParameterValueInvalid
-          class Matches < Constraint
-            attr_reader :expression
-
-            def initialize(rex)
-              @expression = Regexp.new(rex)
-            end
-
-            protected
-
-            def check(parameter, value, _)
-              return if value.nil? || (expression =~ value.to_s)
-              raise "#{value} doesn't match #{expression} for parameter #{parameter.name}"
-            end
-          end
-
-          ##
-          # Aggregate constraint
-          #
-          # It is used to perform checks against a list of constraints-functors
-          # or lambdas.
-          #
-          # === Example
-          #
-          #    class Piece
-          #      include Aws::Templates::Utils::Parametrized
-          #      parameter :param1,
-          #        :constraint => all_of(
-          #          not_nil,
-          #          satisfies("Should be moderate") { |v| v < 100 }
-          #        )
-          #    end
-          #
-          #    i = Piece.new(:param1 => nil)
-          #    i.param1 # raise ParameterValueInvalid
-          #    i = Piece.new(:param1 => 200)
-          #    i.param1 # raise ParameterValueInvalid with description
-          #    i = Piece.new(:param1 => 50)
-          #    i.param1 # => 50
-          class AllOf < Constraint
-            attr_reader :constraints
-
-            def initialize(constraints)
-              @constraints = constraints
-            end
-
-            protected
-
-            def check(parameter, value, instance)
-              constraints.each do |c|
-                instance.instance_exec(parameter, value, &c)
-              end
-            end
-          end
-
-          ##
-          # Creates closure with checker invocation
-          #
-          # It's an interface method required for Constraint to expose
-          # functor properties. It encloses invocation of Constraint check_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 constraint is evaluated
-          #                 against
-          # * +value+ - parameter value to be checked
-          # ...where instance is assumed from self
-          def to_proc
-            constraint = self
-
-            lambda do |parameter, value|
-              constraint.check_wrapper(parameter, value, self)
-            end
-          end
-
-          ##
-          # Wraps constraint-dependent method
-          #
-          # It wraps constraint-dependent "check" method into a rescue block
-          # to standardize exception type and information provided by failed
-          # constraint validation
-          # * +parameter+ - the Parameter object which the constraint is evaluated
-          #                 against
-          # * +value+ - parameter value to be checked
-          # * +instance+ - the instance value is checked for
-          def check_wrapper(parameter, value, instance)
-            check(parameter, value, instance)
-          rescue StandardError
-            raise ParameterValueInvalid.new(parameter, instance, value)
-          end
-
-          protected
-
-          ##
-          # Constraint-dependent check
-          #
-          # * +parameter+ - the Parameter object which the constraint is evaluated
-          #                 against
-          # * +value+ - parameter value to be checked
-          # * +instance+ - the instance value is checked for
-          def check(parameter, value, instance); end
-        end
-
-        ##
-        # Syntax sugar for constraints definition
-        #
-        # It injects the methods as class-scope methods into mixing classes.
-        # The methods are factories to create particular type of constraint
-        class_scope do
-          ##
-          # Parameter shouldn't be nil
-          #
-          # alias for NotNil class
-          def not_nil
-            Constraint::NotNil.instance
-          end
-
-          ##
-          # Parameter value should be in enumeration
-          #
-          # alias for Enum class
-          def enum(*items)
-            Constraint::Enum.new(items.flatten)
-          end
-
-          ##
-          # Parameter value should satisfy all specified constraints
-          #
-          # alias for AllOf class
-          def all_of(*constraints)
-            Constraint::AllOf.new(constraints)
-          end
-
-          ##
-          # Requires presence of the parameters if condition is satisfied
-          #
-          # alias for Requires class
-          def requires(*dependencies)
-            Constraint::Requires.new(dependencies)
-          end
-
-          ##
-          # Constraint depends on value
-          #
-          # alias for DependsOnValue class
-          def depends_on_value(selector)
-            Constraint::DependsOnValue.new(selector)
-          end
-
-          ##
-          # Constraint should satisfy the condition
-          #
-          # alias for SatisfiesCondition class
-          def satisfies(description, &cond_block)
-            Constraint::SatisfiesCondition.new(description, &cond_block)
-          end
-
-          ##
-          # Value should match the regular experession
-          #
-          # alias for Matches
-          def matches(rex)
-            Constraint::Matches.new(rex)
-          end
-        end
-      end
-    end
-  end
-end