cloud-templates 0.2.0 → 0.3.0

data/lib/aws/templates/utils/parametrized/constraint/enum.rb

@@ -0,0 +1,45 @@
+require 'aws/templates/utils'
+
+module Aws
+  module Templates
+    module Utils
+      module Parametrized
+        class Constraint
+          ##
+          # 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 < self
+            attr_reader :set
+
+            def initialize(list)
+              @set = Set.new(list)
+            end
+
+            protected
+
+            def check(_, value, _)
+              return if set.include?(value)
+
+              raise(
+                "Value #{value.inspect} is not in the set of allowed " \
+                "values #{set.inspect}"
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/aws/templates/utils/parametrized/constraint/matches.rb

@@ -0,0 +1,44 @@
+require 'aws/templates/utils'
+
+module Aws
+  module Templates
+    module Utils
+      module Parametrized
+        class Constraint
+          ##
+          # 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 < self
+            attr_reader :expression
+
+            def initialize(rex)
+              @expression = Regexp.new(rex)
+            end
+
+            protected
+
+            def check(parameter, value, _)
+              return if expression =~ value.to_s
+              raise "#{value} doesn't match #{expression} for parameter #{parameter.name}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/aws/templates/utils/parametrized/constraint/not_nil.rb

@@ -0,0 +1,38 @@
+require 'aws/templates/utils'
+
+module Aws
+  module Templates
+    module Utils
+      module Parametrized
+        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 < self
+            def initialize
+              self.if(Constraint::Condition.any)
+            end
+
+            protected
+
+            def check(_, value, _)
+              raise('required but was not found in input hash') if value.nil?
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/aws/templates/utils/parametrized/constraint/requires.rb

@@ -0,0 +1,54 @@
+require 'aws/templates/utils'
+
+module Aws
+  module Templates
+    module Utils
+      module Parametrized
+        class Constraint
+          ##
+          # 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 < self
+            attr_reader :dependencies
+
+            def initialize(dependencies)
+              @dependencies = dependencies
+            end
+
+            protected
+
+            def check(parameter, value, instance)
+              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
+        end
+      end
+    end
+  end
+end

data/lib/aws/templates/utils/parametrized/constraint/satisfies_condition.rb

@@ -0,0 +1,55 @@
+require 'aws/templates/utils'
+
+module Aws
+  module Templates
+    module Utils
+      module Parametrized
+        class Constraint
+          ##
+          # 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 < self
+            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 instance.instance_exec(value, &condition)
+
+              raise(
+                "#{value.inspect} doesn't satisfy the condition " \
+                "#{description} for parameter #{parameter.name}"
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+require 'aws/templates/utils'
+
+module Aws
+  module Templates
+    module Utils
+      module Parametrized
+        ##
+        # 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
+          ##
+          # 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 Templates::Exception::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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+require 'aws/templates/utils'
+
+module Aws
+  module Templates
+    module Utils
+      module Parametrized
+        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 < self
+            include ::Singleton
+
+            protected
+
+            def get(parameter, instance)
+              instance.instance_variable_get("@#{parameter.name}")
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+require 'aws/templates/utils'
+
+module Aws
+  module Templates
+    module Utils
+      module Parametrized
+        class Getter
+          ##
+          # 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 < self
+            include ::Singleton
+
+            protected
+
+            def get(parameter, instance)
+              instance.options[parameter.name]
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+require 'aws/templates/utils'
+
+module Aws
+  module Templates
+    module Utils
+      module Parametrized
+        class Getter
+          ##
+          # 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
+          module Dsl
+            include Utils::Inheritable
+
+            class_scope do
+              ##
+              # Get parameter from instance variables as is
+              #
+              # alias for AsInstanceVariable class
+              def as_instance_variable
+                Parametrized::Getter::AsInstanceVariable.instance
+              end
+
+              ##
+              # Get parameter from Options as is
+              #
+              # alias for AsIs class
+              def as_is
+                Parametrized::Getter::AsIs.instance
+              end
+
+              ##
+              # Calculate value of parameter
+              #
+              # alias for Value class
+              def value(v = nil, &blk)
+                Parametrized::Getter::Value.new(v.nil? ? blk : v)
+              end
+
+              ##
+              # Look up value of the parameter with path
+              #
+              # alias for Path class
+              def path(*v, &blk)
+                Parametrized::Getter::Path.new(v.empty? ? blk : v)
+              end
+
+              ##
+              # Choose one non-nil value from nested getters
+              #
+              # alias for OneOf class
+              def one_of(*getters)
+                Parametrized::Getter::OneOf.new(getters)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end