cloud-templates 0.2.0 → 0.3.0

data/lib/aws/templates/render/utils/base_type_views.rb

@@ -1,8 +1,4 @@
-require 'aws/templates/render'
-require 'aws/templates/render/view'
 require 'aws/templates/utils'
-require 'aws/templates/utils/dependency'
-require 'aws/templates/utils/options'
 
 module Aws
   module Templates
@@ -15,10 +11,11 @@ module Aws
         # specific types.
         module BaseTypeViews
           include Render
+          using Templates::Utils::Dependency::Refinements
 
           ##
           # Pass-through render
-          class AsIs < BasicView
+          class AsIs < Render::BasicView
             def to_rendered
               instance.object
             end
@@ -26,7 +23,7 @@ module Aws
 
           ##
           # Convert to string
-          class ToString < BasicView
+          class ToString < Render::BasicView
             def to_rendered
               instance.to_s
             end
@@ -36,11 +33,11 @@ module Aws
           # Convert to array
           #
           # Converts value to array and iteratively renders every element in it.
-          class ToArray < BasicView
+          class ToArray < Render::BasicView
             def to_rendered
               instance
                 .to_a
-                .map { |element| render.view_for(element, parameters).to_rendered }
+                .map { |element| processed_for(element) }
             end
           end
 
@@ -48,9 +45,9 @@ module Aws
           # Convert to hash
           #
           # Converts value to hash and iteratively renders each key and value in it.
-          class ToHash < BasicView
+          class ToHash < Render::BasicView
             def to_rendered
-              _from(instance).map { |k, v| [_to_rendered(k), _to_rendered(v)] }.to_h
+              _from(instance).map { |k, v| [processed_for(k), processed_for(v)] }.to_h
             end
 
             private
@@ -62,15 +59,11 @@ module Aws
                 instance.to_hash
               end
             end
-
-            def _to_rendered(obj)
-              render.view_for(obj, parameters).to_rendered
-            end
           end
 
           ##
           # Convert to float
-          class ToFloat < BasicView
+          class ToFloat < Render::BasicView
             def to_rendered
               instance.to_f
             end
@@ -78,7 +71,7 @@ module Aws
 
           ##
           # Convert to integer
-          class ToInteger < BasicView
+          class ToInteger < Render::BasicView
             def to_rendered
               instance.to_i
             end
@@ -86,7 +79,7 @@ module Aws
 
           ##
           # Convert to boolean
-          class ToBoolean < BasicView
+          class ToBoolean < Render::BasicView
             def to_rendered
               !instance.to_s.casecmp('false').zero?
             end
@@ -100,10 +93,10 @@ module Aws
             ::FalseClass => AsIs,
             ::NilClass => AsIs,
             ::Symbol => AsIs,
-            Templates::Utils::Dependency => AsIs,
+            Aws::Templates::Utils::Dependency => AsIs,
             ::Array => ToArray,
             ::Hash => ToHash,
-            Templates::Utils::Options => ToHash
+            Aws::Templates::Utils::Options => ToHash
           }.freeze
 
           ##

data/lib/aws/templates/render/utils/inspect.rb

@@ -1,6 +1,4 @@
-require 'aws/templates/render'
-require 'aws/templates/utils/parametrized'
-require 'aws/templates/utils/dependency'
+require 'aws/templates/utils'
 
 module Aws
   module Templates
@@ -29,7 +27,7 @@ module Aws
           #
           # Defines "depth" property which is used to control recursion depth during object
           # introspection.
-          class InspectView < BasicView
+          class InspectView < Render::BasicView
             def depth
               (parameters.nil? ? Inspect.recursion_depth : Integer(parameters)) - 1
             end

data/lib/aws/templates/render/utils/stringify.rb

@@ -1,7 +1,4 @@
-require 'aws/templates/render'
-require 'aws/templates/artifact'
-require 'aws/templates/utils/parametrized/nested'
-require 'aws/templates/utils/dependency'
+require 'aws/templates/utils'
 
 module Aws
   module Templates
@@ -17,7 +14,7 @@ module Aws
 
           define_view(::Object) do
             def to_rendered
-              instance.to_s
+              instance.class.name
             end
           end
 

data/lib/aws/templates/render/view.rb

@@ -1,112 +1,15 @@
+require 'aws/templates/utils'
+
 module Aws
   module Templates
     module Render
-      ##
-      # Basic render view
-      #
-      # Views are classes encapsulating functionality of transforming
-      # artifacts into domain-specific output. For instance, the same
-      # LDAP record can be transformed into JSON description or LDIF definition.
-      # Views can be attached to ancestors of an artifact and it expected
-      # that the library will look-up the closest ancestor having view attached
-      # if the render is invoked on a child.
-      #
-      # Each view is attached to a registry object which stores correspondence
-      # between artifact classes and their views, and optionally to an artifact.
-      # A view is registered in a registry only when it is attached to an artifact.
-      # Views depend on artifacts but artifacts are not aware of views.
-      # As the extreme case, a sole view can be attached to Artifact
-      # if you have universal way to render your domain objects.
-      #
-      # Views are regular Ruby classes and all assumptions made about
-      # polymorphism, inheritance and incapsulation are true for them.
-      #
-      # View class itself is an abstract class which can't be instantiated
-      # directly.
-      class BasicView
-        ##
-        # Render accessor
-        #
-        # Returns either render of this view class or render of any ancestor.
-        def self.render
-          @render || superclass.render
-        end
-
-        ##
-        # Register the view class in a render
-        #
-        # Registers the view class in the render
-        # * +r+ - render registrar
-        def self.register_in(r)
-          @render = r
-          self
-        end
-
-        ##
-        # Link the view class to the artifact class
-        #
-        # Registers the link in the render object of the view class.
-        def self.artifact(artifact_class)
-          render.register(artifact_class, self)
-          self
-        end
-
-        ##
-        # Artifact instance view object is attached to
-        attr_reader :instance
-
-        ##
-        # Assigned view parameters
-        attr_reader :parameters
-
-        ##
-        # Execute in the instance context
-        #
-        # Executed passed block in the context of the instance being rendered. It helps against
-        # putting too much instance method accesses in long blocks. Returns the value returned by
-        # the block.
-        def in_instance(*args, &blk)
-          instance.instance_exec(*args, &blk)
-        end
-
-        ##
-        # Create view instance and link it to the artifact instance
-        def initialize(obj, params = nil)
-          @instance = obj
-          @parameters = params
-        end
-
-        ##
-        # Alias for class method render
-        def render
-          self.class.render
-        end
-
-        ##
-        # Render the object
-        #
-        # Renders passed object with the view default render
-        def rendered_for(obj, parameters_override = nil)
-          render.view_for(obj, parameters_override.nil? ? parameters : parameters_override)
-                .to_rendered
-        end
-
-        ##
-        # Render the instance of the artifact
-        #
-        # The method should be overriden and return rendered form of the attached instance
-        def to_rendered
-          raise NotImplementedError.new('The method should be overriden')
-        end
-      end
-
       ##
       # Render view
       #
       # The class introduces additional stage called "prepare" where you can put prepared view
       # which will be additionally recursively rendered. Useful for complex views containing values
       # needed additional rendering so you don't need to invoke rendered_for.
-      class View < BasicView
+      class View < Render::BasicView
         ##
         # Render the instance of the artifact
         #

data/lib/aws/templates/utils.rb

@@ -1,18 +1,25 @@
-require 'aws/templates/exceptions'
+require 'aws/templates/utils/autoload'
+require 'facets/string/modulize'
 
 ##
-# Hash implements resursive concept
-class Hash
-  def to_recursive
-    self
+# Utility methods for Module class
+class Module
+  ##
+  # Get all ancestors which have "base" module as one of its' own ancestors
+  def ancestors_with(base)
+    ancestors.reverse_each.select { |mod| mod < base }
   end
 end
 
 module Aws
   module Templates
     ##
-    # Variable utility functions used through the code
+    # Variable utility functions used through the code.
+    #
+    # Defines auxiliary functions set and serves as the namespace for the framework modules.
     module Utils
+      include Templates::Exception
+
       RECURSIVE_METHODS = %i[keys [] include?].freeze
 
       ##
@@ -95,19 +102,24 @@ module Aws
       ##
       # Recursively merge two "recursive" objects
       # PS: Yes I know that there is "merge" method for *hashes*.
-      def self.merge(a, b)
-        return hashify(b) unless Utils.recursive?(a) && Utils.recursive?(b)
-        _merge_back(_merge_forward(a, b), b)
+      def self.merge(a, b, &blk)
+        unless Utils.recursive?(a) && Utils.recursive?(b)
+          return hashify(blk.nil? ? b : blk.call(a, b))
+        end
+
+        _merge_back(_merge_forward(a, b, blk), b)
       end
 
-      def self._merge_forward(a, b)
+      def self._merge_forward(a, b, blk)
         a.keys.each_with_object({}) do |k, hsh|
-          hsh[k] = b[k].nil? ? hashify(a[k]) : merge(a[k], b[k])
+          hsh[k] = b[k].nil? ? hashify(a[k]) : merge(a[k], b[k], &blk)
         end
       end
 
       def self._merge_back(result, b)
-        b.keys.reject { |k| result.include?(k) }.each_with_object(result) { |k, res| res[k] = b[k] }
+        b.keys
+         .reject { |k| result.include?(k) }
+         .each_with_object(result) { |k, res| res[k] = hashify(b[k]) }
       end
 
       def self.hashify(v)
@@ -157,11 +169,11 @@ module Aws
         # we stop lookup and return nil if nil is encountered
         return if value.nil?
         # value was deleted in this layer
-        raise OptionValueDeleted.new(path) if value == DELETED_MARKER
+        raise Exception::OptionValueDeleted.new(path) if value == DELETED_MARKER
         # we reached our target! returning it
         return value if path.nil? || path.empty?
         # we still have some part of path to traverse but scalar was found
-        raise OptionScalarOnTheWay.new(value, path) if Utils.scalar?(value)
+        raise Exception::OptionScalarOnTheWay.new(value, path) if Utils.scalar?(value)
 
         _lookup_recursively(value, path.dup)
       end
@@ -194,7 +206,7 @@ module Aws
         last_key = path.pop
 
         last_branch = path.inject(container) do |obj, current_key|
-          raise OptionScalarOnTheWay.new(obj, path) unless Utils.recursive?(obj)
+          raise Exception::OptionScalarOnTheWay.new(obj, path) unless Utils.recursive?(obj)
           if obj.include?(current_key)
             obj[current_key]
           else
@@ -222,6 +234,18 @@ module Aws
           end
         end
       end
+
+      PATH_REGEXP = Regexp.compile('::|[.]|/')
+
+      def self.lookup_module(str)
+        target = str.split(PATH_REGEXP)
+                    .inject(::Object.lazy) { |acc, elem| acc.const_get(elem.modulize) }
+                    .reduce
+
+        raise "#{str} == #{target} which is not a module" unless target.is_a?(Module)
+
+        target
+      end
     end
   end
 end

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

@@ -1,5 +1,4 @@
-require 'aws/templates/artifact'
-require 'set'
+require 'aws/templates/utils'
 
 module Aws
   module Templates
@@ -100,7 +99,7 @@ module Aws
 
         def initialize
           @map = {}
-          @set = Set.new
+          @set = ::Set.new
         end
 
         private

data/lib/aws/templates/utils/{named.rb → as_named.rb}

@@ -1,5 +1,4 @@
-require 'aws/templates/utils/parametrized'
-require 'aws/templates/utils/parametrized/constraints'
+require 'aws/templates/utils'
 
 module Aws
   module Templates
@@ -10,7 +9,7 @@ module Aws
       # Provides a simple utility to define artifacts/objects which have
       # "name" parameter which should be present as :name in the input hash
       module AsNamed
-        include Parametrized
+        include Aws::Templates::Utils::Parametrized
 
         parameter :name, description: 'Name of the object', constraint: not_nil
       end

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

@@ -0,0 +1,224 @@
+require 'facets/string/pathize'
+require 'facets/module/pathize'
+require 'set'
+require 'concurrent/map'
+
+module Aws
+  module Templates
+    module Utils
+      ##
+      # Lazy load implementation
+      #
+      # It allows to skip 'require' definitions and load all classes and modules by convention.
+      module Autoload
+        REQUIRE_LOCKER = Concurrent::Map.new
+        MODULE_LOCKER = Concurrent::Map.new
+
+        Trace = TracePoint.new(:class) { |tp| Autoload.autoload!(tp.self) }
+
+        def self._try_to_require(path, mutex)
+          require path
+        rescue ScriptError, NoMemoryError, StandardError => e
+          REQUIRE_LOCKER.get_and_set(path, e)
+          raise e
+        ensure
+          mutex.unlock
+        end
+
+        def self._check_if_required(path, obj)
+          raise(obj) if obj.is_a?(::Exception)
+          return if obj.owned?
+
+          obj.lock.unlock
+          locker_obj = REQUIRE_LOCKER[path]
+          raise locker_obj if locker_obj.is_a?(Exception)
+        end
+
+        def self.atomic_require(path)
+          mutex = Mutex.new.lock
+
+          obj = REQUIRE_LOCKER.put_if_absent(path, mutex)
+
+          if obj.nil?
+            _try_to_require(path, mutex)
+          else
+            _check_if_required(path, obj)
+          end
+
+          true
+        end
+
+        def self.autoload!(mod)
+          return if mod.name.nil?
+
+          MODULE_LOCKER.compute_if_absent(mod) do
+            path = mod.pathize
+
+            begin
+              atomic_require path
+            rescue LoadError => e
+              sanitize_load_exception(e, path)
+            end
+
+            true
+          end
+        end
+
+        def self.const_path_for(mod, const_name)
+          raise ScriptError.new("Autoload is not supported for #{mod}") if mod.name.nil?
+
+          path = const_name.to_s.pathize
+
+          path = "#{mod.pathize}/#{path}" unless mod.root_namespace?
+
+          path
+        end
+
+        def self.sanitize_load_exception(e, path)
+          raise e unless e.path == path
+        end
+
+        def self.const_is_loaded?(mod, const_name)
+          const_path = Autoload.const_path_for(mod, const_name)
+
+          begin
+            atomic_require const_path
+            true
+          rescue LoadError => e
+            Autoload.sanitize_load_exception(e, const_path)
+            false
+          end
+        end
+
+        def const_missing(const_name)
+          super(const_name) unless Autoload.const_is_loaded?(self, const_name)
+
+          unless const_defined?(const_name)
+            raise NameError.new(
+              "::#{self}::#{const_name} is loaded but the constant is missing"
+            )
+          end
+
+          const_get(const_name)
+        end
+
+        def lazy
+          Lazy.new(self)
+        end
+
+        def reduce(_ = false)
+          self
+        end
+
+        def root_namespace?
+          (self == ::Kernel) || (self == ::Object)
+        end
+      end
+
+      ##
+      # Lazy module wrapper
+      #
+      # Allows to traverse non-existent modules up to the point when constant can be
+      # auto-discovered.
+      class Lazy < Module
+        def self.fail_on_method(method_name)
+          define_method(method_name) { |*params, &blk| raise_error(method_name, params, blk) }
+        end
+
+        def raise_error(method_name, params, blk)
+          raise NoMethodError.new(
+            "Lazy namespace #{self} doesn't support #{method_name}\n" \
+            "  Parameters: #{params}\n" \
+            "  Block: #{blk}"
+          )
+        end
+
+        fail_on_method :alias_method
+        fail_on_method :append_features
+        fail_on_method :attr
+        fail_on_method :attr_accessor
+        fail_on_method :attr_reader
+        fail_on_method :attr_writer
+        fail_on_method :autoload
+        fail_on_method :autoload?
+        fail_on_method :define_method
+        fail_on_method :extend_object
+        fail_on_method :extended
+        fail_on_method :include
+        fail_on_method :included
+        fail_on_method :method_added
+        fail_on_method :method_removed
+        fail_on_method :method_undefined
+        fail_on_method :prepend
+        fail_on_method :prepend_features
+        fail_on_method :prepended
+        fail_on_method :refine
+        fail_on_method :remove_method
+        fail_on_method :undef_method
+        fail_on_method :using
+
+        def method_missing(method_name, *params, &blk)
+          raise_error(method_name, params, blk)
+          super
+        end
+
+        def respond_to_missing?(*)
+          super
+        end
+
+        def const_missing(const_name)
+          Lazy.new(self, const_name)
+        end
+
+        def reduce(is_loaded = false)
+          return @parent.reduce if @short_name.nil?
+
+          @parent.reduce(is_loaded || Autoload.const_is_loaded?(@parent, @short_name))
+                 .const_get(@short_name)
+        end
+
+        def to_s
+          name
+        end
+
+        def inspect
+          "#{name}(Lazy)"
+        end
+
+        def lazy
+          self
+        end
+
+        def name
+          return @parent.name if @short_name.nil?
+
+          if @parent.root_namespace?
+            @short_name.to_s
+          else
+            "#{@parent.name}::#{@short_name}"
+          end
+        end
+
+        def root_namespace?
+          @parent.root_namespace? && @short_name.nil?
+        end
+
+        def initialize(parent, short_name = nil)
+          raise ScriptError.new("#{parent} is not a module") unless parent.is_a?(Module)
+          @parent = parent
+          @short_name = short_name
+        end
+      end
+    end
+  end
+end
+
+##
+# Lazy load
+#
+# It allows to skip 'require' definitions and load all classes and modules by convention.
+class Module
+  prepend Aws::Templates::Utils::Autoload
+end
+
+Aws::Templates::Utils::Autoload::Trace.enable