cloud-templates 0.1.0

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

@@ -0,0 +1,131 @@
+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
+    module Render
+      module Utils
+        ##
+        # Utility views
+        #
+        # A collection of handful utility views which know how to flexibly render values into
+        # specific types.
+        module BaseTypeViews
+          include Render
+
+          ##
+          # Pass-through render
+          class AsIs < BasicView
+            def to_rendered
+              instance.object
+            end
+          end
+
+          ##
+          # Convert to string
+          class ToString < BasicView
+            def to_rendered
+              instance.to_s
+            end
+          end
+
+          ##
+          # Convert to array
+          #
+          # Converts value to array and iteratively renders every element in it.
+          class ToArray < BasicView
+            def to_rendered
+              instance
+                .to_a
+                .map { |element| render.view_for(element, parameters).to_rendered }
+            end
+          end
+
+          ##
+          # Convert to hash
+          #
+          # Converts value to hash and iteratively renders each key and value in it.
+          class ToHash < BasicView
+            def to_rendered
+              _from(instance).map { |k, v| [_to_rendered(k), _to_rendered(v)] }.to_h
+            end
+
+            private
+
+            def _from(obj)
+              if obj.respond_to?(:to_h)
+                instance.to_h
+              else
+                instance.to_hash
+              end
+            end
+
+            def _to_rendered(obj)
+              render.view_for(obj, parameters).to_rendered
+            end
+          end
+
+          ##
+          # Convert to float
+          class ToFloat < BasicView
+            def to_rendered
+              instance.to_f
+            end
+          end
+
+          ##
+          # Convert to integer
+          class ToInteger < BasicView
+            def to_rendered
+              instance.to_i
+            end
+          end
+
+          ##
+          # Convert to boolean
+          class ToBoolean < BasicView
+            def to_rendered
+              !instance.to_s.casecmp('false').zero?
+            end
+          end
+
+          DEFAULT_RENDERING_MAP = {
+            ::String => AsIs,
+            ::Float => AsIs,
+            ::Integer => AsIs,
+            ::TrueClass => AsIs,
+            ::FalseClass => AsIs,
+            ::NilClass => AsIs,
+            ::Symbol => AsIs,
+            Templates::Utils::Dependency => AsIs,
+            ::Array => ToArray,
+            ::Hash => ToHash,
+            Templates::Utils::Options => ToHash
+          }.freeze
+
+          ##
+          # Set all default views
+          #
+          # Set all default views for defined types. Views module class definitions are used
+          def initialize_base_type_views
+            DEFAULT_RENDERING_MAP.each_pair { |klass, view| define_view(klass, view) }
+          end
+
+          ##
+          # Set default views for specific classes
+          #
+          # Set default views only for passed types.
+          def initialize_base_type_views_for(*classes)
+            classes.each do |k|
+              raise "Can't find default view for class #{k}" unless DEFAULT_RENDERING_MAP.key?(k)
+              define_view(k, DEFAULT_RENDERING_MAP[k])
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,127 @@
+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)
+          render.view_for(obj, parameters).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
+        ##
+        # Render the instance of the artifact
+        #
+        # The method renders value returned by prepare
+        def to_rendered
+          rendered_for(prepare)
+        end
+
+        ##
+        # Prepare value for rendering
+        #
+        # Should be overriden. Should return a value which is to be passed for final rendering.
+        def prepare
+          raise NotImplementedError.new('The method should be overriden')
+        end
+      end
+    end
+  end
+end

data/lib/aws/templates/render.rb

@@ -0,0 +1,72 @@
+require 'aws/templates/exceptions'
+require 'aws/templates/render/registry'
+require 'aws/templates/render/view'
+
+module Aws
+  module Templates
+    ##
+    # View layer of the MVC pattern
+    #
+    # View layer provides means of defining "views" of your artifacts
+    # to define different ways of rendering the object hierarchies you
+    # create to end representation.
+    #
+    # The module also contains a few mixin methods to simplify creation
+    # of "renders" - collections of views defining the same domain
+    # representation. For instance JSON, LDIF, Wiki could be such
+    # final destinations.
+    #
+    # Renders could be classes or modules. Modules work best if no
+    # customization is needed and you want a singleton.
+    #
+    # === Example
+    #
+    #    class Wiki
+    #      include Aws::Templates::Render
+    #    end
+    #
+    #    module JSON
+    #      extend Aws::Templates::Render
+    #    end
+    module Render
+      ##
+      # Registry accessor
+      #
+      # All views and corresponding artifacts in a render are stored
+      # in a registry.
+      def registry
+        @registry ||= Registry.new
+      end
+
+      ##
+      # Proxy for Registry register method
+      def register(*args)
+        registry.register(*args)
+      end
+
+      ##
+      # Proxy for Registry can_render? method
+      def can_render?(*args)
+        registry.can_render?(*args)
+      end
+
+      ##
+      # Proxy for Registry view_for method
+      def view_for(*args)
+        registry.view_for(*args)
+      end
+
+      ##
+      # Define view for artifact
+      #
+      # Another way to define views for artifacts. Creates anonymous class and attaches as the view
+      # to the specified artifact
+      def define_view(artifact_class, view = nil, &blk)
+        Class
+          .new(view || Aws::Templates::Render::BasicView, &blk)
+          .register_in(self)
+          .artifact(artifact_class)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,141 @@
+require 'aws/templates/artifact'
+require 'set'
+
+module Aws
+  module Templates
+    module Utils
+      ##
+      # Arifact storage
+      #
+      # It mimics behavior of Hash providing additional ability to search
+      # through elements checking for different types of matches:
+      # * labels
+      # * classes
+      # * parameters
+      # It is also able to perform recursive deep search and de-duplication of artifact objects
+      class ArtifactStorage < Hash
+        include Enumerable
+
+        ##
+        # Find artifacts by criteria
+        #
+        # The method allows flexible introspection of the artifacts
+        # enclosed into the storage.
+        #
+        # * +search_params+ - map of search parameters:
+        # ** +recursive+ - if true, search will be performed recusrsively
+        #                  in nested composites
+        # ** +label+ - search for artifacts which have the label
+        # ** +parameters+ - search for artifacts which have specified
+        #                   parameters values; it's a multi-level map so
+        #                   you can check for nested values also
+        def search(search_params = {})
+          found = filter_artifacts(search_params)
+
+          if search_params[:recursive]
+            values
+              .select { |object| object.respond_to?(:search) }
+              .each { |object| found.concat(object.search(search_params)) }
+          end
+
+          found
+        end
+
+        ##
+        # Artifacts list
+        def artifacts
+          @set.to_a
+        end
+
+        ##
+        # Artifacts' labels list
+        def labels
+          @map.keys
+        end
+
+        ##
+        # If the label is present
+        def label?(l)
+          @map.key?(l)
+        end
+
+        ##
+        # Extract object by label
+        def [](k)
+          @map[k]
+        end
+
+        ##
+        # Associate label to the object
+        def []=(k, v)
+          raise 'nil artifacts are not supported' if v.nil?
+          @set << v unless @set.include?(v)
+          @map[k] = v
+        end
+
+        alias values artifacts
+        alias keys labels
+        alias key? label?
+        alias include? label?
+
+        def each(&blk)
+          @map.each(&blk)
+        end
+
+        def each_pair(&blk)
+          @map.each_pair(&blk)
+        end
+
+        def map(&blk)
+          @map.map(&blk)
+        end
+
+        def select(&blk)
+          @map.select(&blk)
+        end
+
+        def reject(&blk)
+          @map.reject(&blk)
+        end
+
+        def initialize
+          @map = {}
+          @set = Set.new
+        end
+
+        private
+
+        def filter_artifacts(search_params)
+          found = filter_by_label(search_params[:label])
+
+          klass = search_params[:klass]
+          params_match = search_params[:parameters]
+
+          found = found.select { |object| object.is_a?(klass) } if klass
+          found = found.select { |object| check_parameters(object, params_match) } if params_match
+
+          found
+        end
+
+        def filter_by_label(label)
+          return values if label.nil?
+          return [] unless key?(label)
+
+          [self[label]]
+        end
+
+        def check_parameters(object, params)
+          params.all? do |name, value|
+            if object.respond_to?(name)
+              if value.respond_to?(:to_hash)
+                check_parameters(object.send(name), value.to_hash)
+              else
+                object.send(name) == value
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end