cloud-templates 0.2.0 → 0.3.0

data/lib/aws/templates/utils/contextualized/filter/proxy.rb

@@ -0,0 +1,29 @@
+require 'aws/templates/utils'
+
+module Aws
+  module Templates
+    module Utils
+      module Contextualized
+        class Filter
+          ##
+          # Proc proxy
+          #
+          # Just passes opts to the proc the filter was initialized with. It is used internaly.
+          class Proxy < self
+            using Contextualized::Refinements
+
+            attr_reader :proc
+
+            def initialize(prc, &blk)
+              @proc = prc || blk
+            end
+
+            def filter(opts, memo, instance)
+              instance.instance_exec(opts, memo, &proc)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/aws/templates/utils/contextualized/filter/recursive_schema_filter.rb

@@ -0,0 +1,46 @@
+require 'aws/templates/utils'
+
+module Aws
+  module Templates
+    module Utils
+      module Contextualized
+        class Filter
+          ##
+          # Base class for recursive operations
+          #
+          # Internally used by Add and Remove filters.
+          class RecursiveSchemaFilter < self
+            using Contextualized::Refinements
+
+            attr_reader :scheme
+
+            def initialize(*args)
+              schm = if args.last.respond_to?(:to_hash)
+                args.each_with_object(args.pop) do |field, hsh|
+                  hsh[field] = nil
+                  hsh
+                end
+              else
+                args
+              end
+
+              @scheme = _check_scheme(schm)
+            end
+
+            private
+
+            def _check_scheme(schm)
+              if schm.respond_to?(:to_hash)
+                schm.to_hash.each_pair { |_, sub| _check_scheme(sub) unless sub.nil? }
+              elsif !schm.respond_to?(:to_a)
+                raise "#{schm.inspect} is not appropriate branch in the scheme"
+              end
+
+              schm
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/aws/templates/utils/contextualized/filter/remove.rb

@@ -0,0 +1,66 @@
+require 'aws/templates/utils'
+
+module Aws
+  module Templates
+    module Utils
+      module Contextualized
+        class Filter
+          ##
+          # Remove specified keys from hash
+          #
+          # The filter performs removal of values from options hash
+          # according to specified schema represented by combination of
+          # nested hashes and arrays. User can specify removal of values
+          # at arbitrary depth in options hash hierarchy with arbitrary
+          # granularity.
+          #
+          # === Example
+          #
+          #    class Piece
+          #      include Aws::Templates::Utils::Contextualized
+          #
+          #      contextualize filter(:copy) & filter(:remove, :a, :b, c: [:d])
+          #    end
+          #
+          #    i = Piece.new()
+          #    opts = Options.new(a: { q: 1 }, b: 2, c: { d: { r: 5 }, e: 1 })
+          #    opts.filter(i.filter) # => { c: { e: 1 } }
+          class Remove < RecursiveSchemaFilter
+            using Contextualized::Refinements
+
+            def filter(_, memo, _)
+              _recurse_remove(memo, scheme)
+              memo
+            end
+
+            private
+
+            def _recurse_remove(opts, schm)
+              return unless Utils.recursive?(opts)
+
+              if Utils.hashable?(schm)
+                _scheme_remove(opts, schm.to_hash)
+              elsif Utils.list?(schm)
+                _list_remove(opts, schm.to_ary)
+              end
+            end
+
+            def _list_remove(opts, list)
+              list.each { |field| opts.delete(field) }
+            end
+
+            def _scheme_remove(opts, schm)
+              schm.each_pair do |field, sub_scheme|
+                if sub_scheme.nil?
+                  opts.delete(field)
+                elsif opts.include?(field)
+                  _recurse_remove(opts[field], sub_scheme)
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/aws/templates/utils/contextualized/filter/scoped.rb

@@ -0,0 +1,42 @@
+require 'aws/templates/utils'
+
+module Aws
+  module Templates
+    module Utils
+      module Contextualized
+        class Filter
+          ##
+          # Statically scoped filter
+          #
+          # Scoped filter wraps whatever Proc obejct passed to it into specified scope for
+          # execution. So whatever the scope the filter is called in, it will always be evaluated
+          # in the same scope specified at creation.
+          #
+          # The filter is used by the internal mechanics of the framework.
+          class Scoped < self
+            using Contextualized::Refinements
+
+            attr_reader :scoped_filter
+            attr_reader :scope
+
+            def initialize(fltr, scp)
+              @scoped_filter = _check_filter(fltr)
+              @scope = scp
+            end
+
+            def filter(options, memo, _)
+              scope.instance_exec(options, memo, &scoped_filter)
+            end
+
+            private
+
+            def _check_filter(fltr)
+              raise "#{fltr} is not a filter" unless fltr.respond_to?(:to_proc)
+              fltr
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+require 'aws/templates/utils'
+
+module Aws
+  module Templates
+    module Utils
+      module Contextualized
+        ##
+        # Filter transformation refinements
+        #
+        # Contains standard object refinements to transform their instances into scope filters.
+        module Refinements
+          ##
+          # Hash class patch
+          #
+          # Adds to_filter method converting a hash into an Override filter
+          refine ::Hash do
+            ##
+            # Convert to Override filter
+            def to_filter
+              Aws::Templates::Utils::Contextualized::Filter::Override.new(self)
+            end
+          end
+
+          ##
+          # NilClass class patch
+          #
+          # Adds to_filter method converting nil into the Identity filter
+          refine ::NilClass do
+            ##
+            # Convert nil to Identity filter
+            def to_filter
+              Aws::Templates::Utils::Contextualized::Filter::Identity.new
+            end
+          end
+
+          ##
+          # Proc class patch
+          #
+          # Adds to_filter method proxying a Proc through Filter interface object
+          refine ::Proc do
+            ##
+            # Proxy the Proc through Proxy filter object
+            def to_filter
+              Aws::Templates::Utils::Contextualized::Filter::Proxy.new(self)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/aws/templates/utils/default.rb

@@ -1,6 +1,4 @@
 require 'aws/templates/utils'
-require 'aws/templates/utils/options'
-require 'aws/templates/utils/inheritable'
 
 module Aws
   module Templates
@@ -16,24 +14,239 @@ module Aws
       # object which have common traits organized as an arbitrary graph
       # with many-to-many relationship.
       module Default
-        include Inheritable
+        include Aws::Templates::Utils::Inheritable
+
+        ##
+        # Functionality-specific refinements
+        module Refinements
+          refine ::Object do
+            ##
+            # If the object can be considered a defaults override
+            #
+            # It is the one which can't be merged with existing defaults layers
+            def override?
+              respond_to?(:to_sym) || !(respond_to?(:to_proc) || Utils.recursive?(self))
+            end
+
+            ##
+            # Transform object to defaults definition.
+            def to_definition
+              Definition.from(self)
+            end
+          end
+        end
+
+        using Refinements
+
+        ##
+        # Abstract defaults definition
+        #
+        # Defaults definition is an object wrapper which enables definition merging. It also
+        # contains factory method to transform arbitrary objects into Definition object and defines
+        # basic functionality.
+        class Definition
+          ##
+          # Empty definition
+          #
+          # Doesn't mutate definition in any way. Tries to elliminate itself from the chain
+          # of merges.
+          class Empty < Definition
+            include ::Singleton
+
+            def for(_)
+              {}
+            end
+
+            def merge(b)
+              b.to_definition
+            end
+          end
+
+          ##
+          # Scalar definition
+          #
+          # Scalar definition overrides everything before it and can be overriden by anything
+          # after it.
+          class Scalar < Definition
+            attr_reader :value
+
+            def initialize(value)
+              @value = value
+            end
+
+            def for(_)
+              value
+            end
+
+            def merge(b)
+              b.to_definition
+            end
+
+            def override?
+              true
+            end
+          end
+
+          ##
+          # Definition with scheme
+          #
+          # Scheme definition can be merged without stacking layers with any other scheme
+          # definition. Internal schemes will be merged together producing aggregated scheme.
+          # Otherwise, the definition is wither overriden with Scalar or stacked together with
+          # Calculable.
+          class Scheme < Definition
+            attr_reader :scheme
+
+            def initialize(scheme)
+              @scheme = scheme
+            end
+
+            def merge(b)
+              if b.is_a? self.class
+                merge(b.scheme)
+              elsif Utils.recursive?(b)
+                self.class.new(Utils.merge(scheme, b) { |left, right| _merge(left, right) })
+              else
+                super(b)
+              end
+            end
+
+            def for(_)
+              scheme
+            end
+
+            private
+
+            def _merge(a, b)
+              a.override? || b.override? ? b : a.to_definition.merge(b)
+            end
+          end
+
+          ##
+          # Lazy-calculated definition
+          #
+          # Contains functor object which will be evaluated only during actual value look-up
+          class Calculable < Definition
+            include Utils::Guarded
+
+            attr_reader :block
+
+            def initialize(block)
+              @block = block
+            end
+
+            def for(instance)
+              guarded_for(instance, block) { _process_value(block, instance) }
+            end
+
+            private
+
+            def _process_value(value, instance)
+              return value if value.override? || Utils.recursive?(value)
+              _process_value(instance.instance_eval(&value), instance)
+            end
+          end
+
+          ##
+          # Definition composition
+          #
+          # Pair of definitions which act like one.
+          class Pair < Definition
+            class << self
+              def [](a, b)
+                return b if b.override? || a.override? || a == Definition.empty
+                return a if b.nil? || b == Definition.empty
+                _unite(a, b)
+              end
+
+              private
+
+              def _unite(a, b)
+                if a.is_a?(self)
+                  new(a.a, a.b.merge(b))
+                elsif b.is_a?(self)
+                  new(a.merge(b.a), b.b)
+                else
+                  new(a, b)
+                end
+              end
+            end
+
+            attr_reader :a
+            attr_reader :b
+
+            def initialize(a, b)
+              @a = a.to_definition
+              @b = b.to_definition
+            end
+
+            def for(instance)
+              eval_b = b.for(instance)
+              return eval_b if eval_b.override? && !eval_b.nil?
+              eval_a = a.for(instance)
+              return eval_b if eval_a.override?
+
+              eval_a.to_definition.merge(eval_b).for(instance)
+            end
+          end
+
+          class << self
+            def empty
+              Empty.instance
+            end
+
+            def from(obj)
+              return obj if obj.is_a? Definition
+              return Scalar.new(obj) if obj.override?
+              return Scheme.new(obj) if Utils.recursive?(obj)
+              return Calculable.new(obj) if obj.respond_to?(:to_proc)
+
+              raise "Invalid object #{obj}"
+            end
+          end
+
+          def merge(b)
+            return b if b.override?
+            return self if b == Definition.empty
+            Pair[self, b]
+          end
+
+          def for(_)
+            raise 'Must be overriden'
+          end
+
+          def to_definition
+            self
+          end
+
+          def override?
+            false
+          end
+        end
 
         ##
         # Hash wrapper
         #
         # The hash wrapper does intermediate calculations of nested lambdas in the specified
         # context as they are encountered
-        class Definition
+        class Instantiation
+          def value
+            return @value if @value
+            @value = @entry.to_definition.for(@context)
+            raise "#{@value.inspect} is not recursive" if @value.override?
+            @value
+          end
+
           ##
           # Defined hash keys
           def keys
-            @hash.keys
+            value.keys
           end
 
           ##
           # Transform to hash
           def to_hash
-            _recurse_into(@hash)
+            _recurse_into(value)
           end
 
           def dependency?
@@ -51,14 +264,14 @@ module Aws
           # returns it wrapping into Definition instance with the same context if needed
           # (if value is a map)
           def [](k)
-            result = _process_value(@hash[k])
-            result.respond_to?(:to_hash) ? self.class.new(result, @context) : result
+            result = _process_value(value[k])
+            Utils.recursive?(result) ? _new(result) : result
           end
 
           ##
           # Check if the key is present in the hash
           def include?(k)
-            @hash.include?(k)
+            value.include?(k)
           end
 
           # The class already supports recursive concept so return self
@@ -70,27 +283,26 @@ module Aws
           # Create wrapper object
           #
           # Creates wrapper object with attached hash and context to evaluate lambdas in
-          def initialize(hsh, ctx)
-            @hash = hsh
+          def initialize(ent, ctx)
+            raise "#{ent.inspect} is not recursive" if ent.override?
+            @entry = ent
             @context = ctx
           end
 
           private
 
           def _process_value(value)
-            if value.respond_to?(:to_hash)
-              value
-            elsif value.respond_to?(:to_proc)
-              @context.instance_eval(&value)
-            else
-              value
-            end
+            value.override? || Utils.recursive?(value) ? value : value.to_definition.for(@context)
+          end
+
+          def _new(ent)
+            self.class.new(ent, @context)
           end
 
           def _recurse_into(value)
-            value.each_with_object({}) do |(k, v), memo|
-              processed = _process_value(v)
-              processed = _recurse_into(processed.to_hash) if Utils.hashable?(processed)
+            value.keys.each_with_object({}) do |k, memo|
+              processed = _process_value(value[k])
+              processed = _recurse_into(processed) if Utils.recursive?(processed)
               memo[k] = processed
             end
           end
@@ -109,22 +321,7 @@ module Aws
           # is working correctly with both parent classes and all Default
           # mixins used in between.
           def defaults
-            # iterating through all ancestors with defaults
-            ancestors_with_defaults.inject(Options.new) do |opts, mod|
-              mod.defaults.inject(opts) do |acc, defaults_definition|
-                acc.merge!(Definition.new(defaults_definition, self))
-              end
-            end
-          end
-
-          private
-
-          def ancestors_with_defaults
-            self
-              .class
-              .ancestors
-              .select { |mod| (mod != Default) && mod.ancestors.include?(Default) }
-              .reverse!
+            Instantiation.new(self.class.defaults_definition, self)
           end
         end
 
@@ -139,17 +336,28 @@ module Aws
             Aws::Templates::Utils::DELETED_MARKER
           end
 
+          ##
+          # Module's specific defaults
+          #
+          # The defaults defined in this module and not its' ancestors.
+          def module_defaults_definition
+            @module_defaults_definition || Definition.empty
+          end
+
           ##
           # Defaults for the input hash
           #
-          # Class-level accessor of a hash which will be merged into input
-          # parameters hash. The hash can't be changed directly or set to
-          # another value. Only incremental changes are allowed with
-          # default method which is a part of the framework DSL. The method
-          # returns only defaults for the current class without
-          # consideration of the class hierarchy.
-          def defaults
-            @defaults ||= []
+          # Class-level accessor of a definition of defaults which will be merged into input
+          # parameters hash. The definition can't be changed directly or set to another value.
+          # Only incremental changes are allowed with default method which is a part of the
+          # framework DSL. The method returns accumulated defaults of all ancestors of the module
+          # in one single definition object
+          def defaults_definition
+            return @defaults if @defaults
+            @defaults = ancestors_with(Default)
+                        .inject(Definition.empty) do |acc, elem|
+                          acc.merge(elem.module_defaults_definition)
+                        end
           end
 
           ##
@@ -169,11 +377,11 @@ module Aws
           #
           # If the parameter you passed is neither a hash nor callable or
           # no parameters are passed at all, ArgumentError will be thrown.
-          def default(defaults_hash = nil)
-            raise_defaults_is_nil unless defaults_hash
-            raise_default_type_mismatch(defaults_hash) unless defaults_hash.respond_to?(:to_hash)
+          def default(param)
+            raise_defaults_is_nil unless param
+            raise_default_type_mismatch(param) if param.override?
 
-            defaults << defaults_hash.to_hash
+            @module_defaults_definition = module_defaults_definition.to_definition.merge(param)
           end
 
           def raise_defaults_is_nil
@@ -181,7 +389,7 @@ module Aws
           end
 
           def raise_default_type_mismatch(defaults_hash)
-            raise ArgumentError.new("#{defaults_hash.inspect} is not a hash")
+            raise ArgumentError.new("#{defaults_hash.inspect} is not recursive or proc")
           end
         end
       end