praxis-blueprints 3.0 → 3.5

data/lib/praxis-blueprints/collection_view.rb

@@ -1,28 +1,33 @@
+# frozen_string_literal: true
 module Praxis
-
   class CollectionView < View
-    def initialize(name, schema, member_view=nil)
-      super(name,schema)
+    def initialize(name, schema, member_view = nil)
+      super(name, schema)
+
+      @_lazy_view = member_view if member_view
+    end
 
-      if member_view
-        @contents = member_view.contents.clone
+    def contents
+      if @_lazy_view
+        @contents = @_lazy_view.contents.clone
+        @_lazy_view = nil
       end
+      super
     end
 
-    def example(context=Attributor::DEFAULT_ROOT_CONTEXT)
-      collection = 3.times.collect do |i|
+    def example(context = Attributor::DEFAULT_ROOT_CONTEXT)
+      collection = Array.new(3) do |i|
         subcontext = context + ["at(#{i})"]
-        self.schema.example(subcontext)
+        schema.example(subcontext)
       end
       opts = {}
       opts[:context] = context if context
 
-      self.render(collection, **opts)
+      render(collection, **opts)
     end
 
     def describe
       super.merge(type: :collection)
     end
-
   end
 end

data/lib/praxis-blueprints/config_hash.rb

@@ -1,23 +1,27 @@
+# frozen_string_literal: true
 module Praxis
   class ConfigHash < BasicObject
-
     attr_reader :hash
 
-    def self.from(hash={},&block)
-      self.new(hash,&block)
+    def self.from(hash = {}, &block)
+      new(hash, &block)
     end
 
-    def initialize(hash={},&block)
+    def initialize(hash = {}, &block)
       @hash = hash
       @block = block
     end
 
     def to_hash
-      self.instance_eval(&@block)
+      instance_eval(&@block)
       @hash
     end
 
-    def method_missing(name, value, *rest, &block)
+    def respond_to_missing?(_method_name, _include_private = false)
+      true
+    end
+
+    def method_missing(name, value, *rest, &block) # rubocop:disable Style/MethodMissing
       if (existing = @hash[name])
         if block
           existing << [value, block]
@@ -28,13 +32,12 @@ module Praxis
           end
         end
       else
-        if rest.any?
-          @hash[name] = [value] + rest
-        else
-          @hash[name] = value
-        end
+        @hash[name] = if rest.any?
+                        [value] + rest
+                      else
+                        value
+                      end
       end
     end
-
   end
 end

data/lib/praxis-blueprints/field_expander.rb

@@ -1,15 +1,8 @@
+# frozen_string_literal: true
 module Praxis
   class FieldExpander
-    class CircularExpansionError < StandardError
-      attr_reader :stack
-      def initialize(message, stack=[])
-        super(message)
-        @stack = stack
-      end
-    end
-
-    def self.expand(object, fields=true)
-      self.new.expand(object,fields)
+    def self.expand(object, fields = true)
+      new.expand(object, fields)
     end
 
     attr_reader :stack
@@ -19,86 +12,105 @@ module Praxis
       @stack = Hash.new do |hash, key|
         hash[key] = Set.new
       end
-      @history = Hash.new do |hash,key|
-        hash[key] = Hash.new
+      @history = Hash.new do |hash, key|
+        hash[key] = {}
       end
     end
 
-    def expand(object, fields=true)
+    def expand(object, fields = true)
       if stack[object].include? fields
-        raise CircularExpansionError, "Circular expansion detected for object #{object.inspect} with fields #{fields.inspect}"
+        return history[object][fields] if history[object].include? fields
+        # We should probably never get here, since we should have a record
+        # of the history of an expansion if we're trying to redo it,
+        # but we should also be conservative and raise here just in case.
+        raise "Circular expansion detected for object #{object.inspect} with fields #{fields.inspect}"
       else
         stack[object] << fields
       end
 
-      if object.kind_of?(Praxis::View)
-        self.expand_view(object, fields)
-      elsif object.kind_of? Attributor::Attribute
-        self.expand_type(object.type, fields)
-      else
-        self.expand_type(object,fields)
-      end
-    rescue CircularExpansionError => e
-      e.stack.unshift [object,fields]
-      raise
+      result = if object.is_a?(Praxis::View)
+                 expand_view(object, fields)
+               elsif object.is_a? Attributor::Attribute
+                 expand_type(object.type, fields)
+               else
+                 expand_type(object, fields)
+               end
+
+      result
     ensure
       stack[object].delete fields
     end
 
     def expand_fields(attributes, fields)
-      raise ArgumentError, "expand_fields must be given a block" unless block_given?
+      raise ArgumentError, 'expand_fields must be given a block' unless block_given?
 
       unless fields == true
-        attributes = attributes.select do |k,v|
+        attributes = attributes.select do |k, _v|
           fields.key?(k)
         end
       end
 
       attributes.each_with_object({}) do |(name, dumpable), hash|
         sub_fields = case fields
-          when true
-            true
-          when Hash
-            fields[name] || true
-          end
-        hash[name] = yield(dumpable,sub_fields)
+                     when true
+                       true
+                     when Hash
+                       fields[name] || true
+                     end
+        hash[name] = yield(dumpable, sub_fields)
       end
     end
 
+    def expand_view(object, fields = true)
+      history[object][fields] = if object.is_a?(Praxis::CollectionView)
+                                  []
+                                else
+                                  {}
+                                end
 
-    def expand_view(object,fields=true)
       result = expand_fields(object.contents, fields) do |dumpable, sub_fields|
-        self.expand(dumpable, sub_fields)
+        expand(dumpable, sub_fields)
       end
 
-      return [result] if object.kind_of?(Praxis::CollectionView)
-      result
+      if object.is_a?(Praxis::CollectionView)
+        history[object][fields] << result
+      else
+        history[object][fields].merge!(result)
+      end
+      history[object][fields]
     end
 
-
-    def expand_type(object,fields=true)
+    def expand_type(object, fields = true)
       unless object.respond_to?(:attributes)
         if object.respond_to?(:member_attribute)
-          fields = fields[0] if fields.kind_of? Array
-          return [self.expand(object.member_attribute.type, fields)]
+          return expand_with_member_attribute(object, fields)
         else
           return true
         end
       end
 
       # just include the full thing if it has no attributes
-      if object.attributes.empty?
-        return true
-      end
+      return true if object.attributes.empty?
 
-      if history[object].include? fields
-        return history[object][fields]
-      end
+      return history[object][fields] if history[object].include? fields
 
-      history[object][fields] = expand_fields(object.attributes, fields) do |dumpable, sub_fields|
-        self.expand(dumpable.type, sub_fields)
+      history[object][fields] = {}
+      result = expand_fields(object.attributes, fields) do |dumpable, sub_fields|
+        expand(dumpable.type, sub_fields)
       end
+      history[object][fields].merge!(result)
     end
 
+    def expand_with_member_attribute(object, fields = true)
+      return history[object][fields] if history[object].include? fields
+      history[object][fields] = []
+
+      new_fields = fields.is_a?(Array) ? fields[0] : fields
+
+      result = [expand(object.member_attribute.type, new_fields)]
+      history[object][fields].concat(result)
+
+      result
+    end
   end
 end

data/lib/praxis-blueprints/finalizable.rb

@@ -1,7 +1,6 @@
+# frozen_string_literal: true
 module Praxis
   module Finalizable
-
-
     def self.extended(klass)
       klass.module_eval do
         @finalizable = Set.new
@@ -26,13 +25,10 @@ module Praxis
       @finalized = true
     end
 
-    def finalize! 
-      self.finalizable.reject(&:finalized?).each do |klass|
-        klass._finalize!
-      end
+    def finalize!
+      finalizable.reject(&:finalized?).each(&:_finalize!)
 
-      self.finalize! unless self.finalizable.all?(&:finalized?)
+      finalize! unless finalizable.all?(&:finalized?)
     end
-
   end
 end

data/lib/praxis-blueprints/renderer.rb

@@ -1,11 +1,27 @@
+# frozen_string_literal: true
 module Praxis
   class Renderer
     attr_reader :include_nil
     attr_reader :cache
 
+    class CircularRenderingError < StandardError
+      attr_reader :object
+      attr_reader :context
+
+      def initialize(object, context)
+        @object = object
+        @context = context
+
+        first = Attributor.humanize_context(context[0..10])
+        last = Attributor.humanize_context(context[-5..-1])
+        pretty_context = "#{first}...#{last}"
+        super("SystemStackError in rendering #{object.class} with context: #{pretty_context}")
+      end
+    end
+
     def initialize(include_nil: false)
-      @cache = Hash.new do |hash,key|
-        hash[key] = Hash.new
+      @cache = Hash.new do |hash, key|
+        hash[key] = {}
       end
 
       @include_nil = include_nil
@@ -15,30 +31,39 @@ module Praxis
     #
     # @param [Object] object the object to render
     # @param [Hash] fields the set of fields, as from FieldExpander, to apply to each member of the collection.
-    def render_collection(collection, member_fields, view=nil, context: Attributor::DEFAULT_ROOT_CONTEXT)
-      render(collection,[member_fields], view, context: context)
+    def render_collection(collection, member_fields, view = nil, context: Attributor::DEFAULT_ROOT_CONTEXT)
+      render(collection, [member_fields], view, context: context)
     end
 
     # Renders an object using a given list of fields.
     #
     # @param [Object] object the object to render
     # @param [Hash] fields the correct set of fields, as from FieldExpander
-    def render(object, fields, view=nil, context: Attributor::DEFAULT_ROOT_CONTEXT)
-      if fields.kind_of? Array
+    def render(object, fields, view = nil, context: Attributor::DEFAULT_ROOT_CONTEXT)
+      if fields.is_a? Array
         sub_fields = fields[0]
         object.each_with_index.collect do |sub_object, i|
           sub_context = context + ["at(#{i})"]
           render(sub_object, sub_fields, view, context: sub_context)
         end
-      elsif object.kind_of? Praxis::Blueprint
-        @cache[object.object_id][fields.object_id] ||= _render(object,fields, view, context: context)
+      elsif object.is_a? Praxis::Blueprint
+        @cache[object._cache_key][fields] ||= _render(object, fields, view, context: context)
       else
-        _render(object,fields, view, context: context)
+        _render(object, fields, view, context: context)
       end
+    rescue SystemStackError
+      raise CircularRenderingError.new(object, context)
     end
 
-    def _render(object, fields, view=nil, context: Attributor::DEFAULT_ROOT_CONTEXT)
-      return object if fields == true
+    def _render(object, fields, view = nil, context: Attributor::DEFAULT_ROOT_CONTEXT)
+      if fields == true
+        return case object
+               when Attributor::Dumpable
+                 object.dump
+               else
+                 object
+               end
+      end
 
       notification_payload = {
         blueprint: object,
@@ -46,26 +71,32 @@ module Praxis
         view: view
       }
 
-      ActiveSupport::Notifications.instrument 'praxis.blueprint.render'.freeze,  notification_payload do
-        fields.each_with_object(Hash.new) do |(key, subfields), hash|
+      ActiveSupport::Notifications.instrument 'praxis.blueprint.render', notification_payload do
+        fields.each_with_object({}) do |(key, subfields), hash|
           begin
             value = object._get_attr(key)
           rescue => e
-            raise Attributor::DumpError, context: context, name: key, type: object.class, original_exception: e
+            raise Attributor::DumpError.new(context: context, name: key, type: object.class, original_exception: e)
           end
 
-          next if value.nil? && !self.include_nil
+          if value.nil?
+            hash[key] = nil if self.include_nil
+            next
+          end
 
           if subfields == true
-            hash[key] = value
+            hash[key] = case value
+                        when Attributor::Dumpable
+                          value.dump
+                        else
+                          value
+                        end
           else
             new_context = context + [key]
-            hash[key] = self.render(value, subfields, context: new_context)
+            hash[key] = render(value, subfields, context: new_context)
           end
-
         end
       end
     end
-
   end
 end

data/lib/praxis-blueprints/version.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Praxis
-  BLUEPRINTS_VERSION = "3.0"
+  BLUEPRINTS_VERSION = '3.5'
 end

data/lib/praxis-blueprints/view.rb

@@ -1,5 +1,5 @@
+# frozen_string_literal: true
 module Praxis
-
   class View
     attr_reader :schema
     attr_reader :contents
@@ -17,7 +17,7 @@ module Praxis
 
     def contents
       if @block
-        self.instance_eval(&@block)
+        instance_eval(&@block)
         @block = nil
       end
 
@@ -26,32 +26,29 @@ module Praxis
 
     def expanded_fields
       @expanded_fields ||= begin
-        self.contents # force evaluation of the contents
+        contents # force evaluation of the contents
         FieldExpander.expand(self)
       end
     end
 
     def render(object, context: Attributor::DEFAULT_ROOT_CONTEXT, renderer: Renderer.new)
-      renderer.render(object, self.expanded_fields, context: context)
+      renderer.render(object, expanded_fields, context: context)
     end
 
-    alias_method :to_hash, :render # Why did we need this again?
-
-
     def attribute(name, **opts, &block)
-      raise AttributorException, "Attribute names must be symbols, got: #{name.inspect}" unless name.kind_of? ::Symbol
+      raise AttributorException, "Attribute names must be symbols, got: #{name.inspect}" unless name.is_a? ::Symbol
 
-      attribute = self.schema.attributes.fetch(name) do
-        raise "Displaying :#{name} is not allowed in view :#{self.name} of #{self.schema}. This attribute does not exist in the mediatype"
+      attribute = schema.attributes.fetch(name) do
+        raise "Displaying :#{name} is not allowed in view :#{self.name} of #{schema}. This attribute does not exist in the mediatype"
       end
 
       if block_given?
         type = attribute.type
         @contents[name] = if type < Attributor::Collection
-          CollectionView.new(name, type.member_attribute.type, &block)
-        else
-          View.new(name, attribute, &block)
-        end
+                            CollectionView.new(name, type.member_attribute.type, &block)
+                          else
+                            View.new(name, attribute, &block)
+                          end
       else
         type = attribute.type
         if type < Attributor::Collection
@@ -59,38 +56,36 @@ module Praxis
           type = type.member_attribute.type
         end
 
-
         if type < Praxis::Blueprint
           view_name = opts[:view] || :default
           view = type.views.fetch(view_name) do
             raise "view with name '#{view_name.inspect}' is not defined in #{type}"
           end
-          if is_collection
-            @contents[name] = Praxis::CollectionView.new(view_name, type, view)
-          else
-            @contents[name] = view
-          end
+          @contents[name] = if is_collection
+                              Praxis::CollectionView.new(view_name, type, view)
+                            else
+                              view
+                            end
         else
-          @contents[name] = attribute #, opts]
+          @contents[name] = attribute # , opts]
         end
       end
-
     end
 
-    def example(context=Attributor::DEFAULT_ROOT_CONTEXT)
-      object = self.schema.example(context)
+    def example(context = Attributor::DEFAULT_ROOT_CONTEXT)
+      object = schema.example(context)
       opts = {}
       opts[:context] = context if context
-      self.render(object, opts)
+      render(object, **opts)
     end
 
     def describe
       # TODO: for now we are just return the first level keys
       view_attributes = {}
 
-      self.contents.each do |k,dumpable|
+      contents.each do |k, dumpable|
         inner_desc = {}
-        if dumpable.kind_of?(Praxis::View)
+        if dumpable.is_a?(Praxis::View)
           inner_desc[:view] = dumpable.name if dumpable.name
         end
         view_attributes[k] = inner_desc
@@ -98,7 +93,5 @@ module Praxis
 
       { attributes: view_attributes, type: :standard }
     end
-
-
   end
 end