praxis-blueprints 2.2 → 3.0

data/lib/praxis-blueprints/renderer.rb

@@ -0,0 +1,71 @@
+module Praxis
+  class Renderer
+    attr_reader :include_nil
+    attr_reader :cache
+
+    def initialize(include_nil: false)
+      @cache = Hash.new do |hash,key|
+        hash[key] = Hash.new
+      end
+
+      @include_nil = include_nil
+    end
+
+    # Renders an a collection using a given list of per-member fields.
+    #
+    # @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)
+    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
+        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)
+      else
+        _render(object,fields, view, context: context)
+      end
+    end
+
+    def _render(object, fields, view=nil, context: Attributor::DEFAULT_ROOT_CONTEXT)
+      return object if fields == true
+
+      notification_payload = {
+        blueprint: object,
+        fields: fields,
+        view: view
+      }
+
+      ActiveSupport::Notifications.instrument 'praxis.blueprint.render'.freeze,  notification_payload do
+        fields.each_with_object(Hash.new) 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
+          end
+
+          next if value.nil? && !self.include_nil
+
+          if subfields == true
+            hash[key] = value
+          else
+            new_context = context + [key]
+            hash[key] = self.render(value, subfields, context: new_context)
+          end
+
+        end
+      end
+    end
+
+  end
+end

data/lib/praxis-blueprints/version.rb

@@ -1,3 +1,3 @@
 module Praxis
-  BLUEPRINTS_VERSION = "2.2"
+  BLUEPRINTS_VERSION = "3.0"
 end

data/lib/praxis-blueprints/view.rb

@@ -6,18 +6,13 @@ module Praxis
     attr_reader :name
     attr_reader :options
 
-    attr_reader :include_nil
-
     def initialize(name, schema, **options, &block)
       @name = name
       @schema = schema
       @contents = ::Hash.new
       @block = block
 
-      @include_nil = options.fetch(:include_nil, false)
-
       @options = options
-
     end
 
     def contents
@@ -29,52 +24,21 @@ module Praxis
       @contents
     end
 
-    def dump(object, context: Attributor::DEFAULT_ROOT_CONTEXT,**opts)
-      fields = opts[:fields]
-      # Restrict which attributes to output if we receive a fields parameter
-      # Note: should we complain if any of the names in "fields" do not match an existing attribute name?
-      attributes_to_render = self.contents.keys
-      attributes_to_render &= fields.keys if fields
-
-      attributes_to_render.each_with_object({}) do |name, hash|
-        dumpable, dumpable_opts = self.contents[name]
-        unless object.respond_to?(name)
-          warn "#{object} does not respond to #{name} during rendering???"
-          next
-        end
-
-        begin
-          value = object.send(name)
-        rescue => e
-          raise Attributor::DumpError, context: context, name: name, type: object.class, original_exception: e
-        end
+    def expanded_fields
+      @expanded_fields ||= begin
+        self.contents # force evaluation of the contents
+        FieldExpander.expand(self)
+      end
+    end
 
-        if value.nil?
-          next unless @include_nil
-        end
+    def render(object, context: Attributor::DEFAULT_ROOT_CONTEXT, renderer: Renderer.new)
+      renderer.render(object, self.expanded_fields, context: context)
+    end
 
-        # FIXME: this is such an ugly way to do this. Need attributor#67.
-        if dumpable.kind_of?(View) || dumpable.kind_of?(CollectionView)
-          new_context = context + [name]
+    alias_method :to_hash, :render # Why did we need this again?
 
-          sub_opts = add_subfield_options( fields, name, dumpable_opts )
-          hash[name] = dumpable.dump(value, context: new_context ,**sub_opts)
-        else
 
-          type = dumpable.type
-          if type.respond_to?(:attributes) || type.respond_to?(:member_attribute)
-            new_context = context + [name]
-            sub_opts = add_subfield_options( fields, name, dumpable_opts )
-            hash[name] = dumpable.dump(value, context: new_context ,**sub_opts)
-          else
-            hash[name] = value
-          end
-        end
-      end
-    end
-    alias_method :to_hash, :dump
-
-    def attribute(name, opts={}, &block)
+    def attribute(name, **opts, &block)
       raise AttributorException, "Attribute names must be symbols, got: #{name.inspect}" unless name.kind_of? ::Symbol
 
       attribute = self.schema.attributes.fetch(name) do
@@ -82,42 +46,59 @@ module Praxis
       end
 
       if block_given?
-        view = View.new(name, attribute, &block)
-        @contents[name] = view
+        type = attribute.type
+        @contents[name] = if type < Attributor::Collection
+          CollectionView.new(name, type.member_attribute.type, &block)
+        else
+          View.new(name, attribute, &block)
+        end
       else
-        raise "Invalid options (#{opts.inspect}) for #{name} while defining view #{@name}" unless opts.is_a?(Hash)
-        @contents[name] = [attribute, opts]
+        type = attribute.type
+        if type < Attributor::Collection
+          is_collection = true
+          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
+        else
+          @contents[name] = attribute #, opts]
+        end
       end
 
     end
 
-    def example(context=nil)
+    def example(context=Attributor::DEFAULT_ROOT_CONTEXT)
       object = self.schema.example(context)
       opts = {}
       opts[:context] = context if context
-      self.dump(object, opts)
+      self.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,dumpable_opts)|
+      self.contents.each do |k,dumpable|
         inner_desc = {}
-        inner_desc[:view] = dumpable_opts[:view] if dumpable_opts && dumpable_opts[:view]
+        if dumpable.kind_of?(Praxis::View)
+          inner_desc[:view] = dumpable.name if dumpable.name
+        end
         view_attributes[k] = inner_desc
       end
 
       { attributes: view_attributes, type: :standard }
     end
 
-    private
-    def add_subfield_options(fields, name, existing_options)
-      sub_opts = if fields && fields[name]
-        {fields: fields[name] }
-      else
-        {}
-      end.merge(existing_options || {})
-    end
+
   end
 end

data/praxis-blueprints.gemspec

@@ -10,7 +10,7 @@ Gem::Specification.new do |spec|
   spec.description = "Praxis Blueprints is a library that allows for defining a reusable class structures that has a set of typed attributes and a set of views with which to render them. Instantiations of Blueprints resemble ruby Structs which respond to methods of the attribute names. Rendering is format-agnostic in that
 it results in a structured hash instead of an encoded string. Blueprints can automatically generate object structures that follow the attribute definitions."
   spec.email = ["blanquer@gmail.com","dane.jensen@gmail.com"]
-  
+
   spec.homepage = "https://github.com/rightscale/praxis-blueprints"
   spec.license = "MIT"
   spec.required_ruby_version = ">=2.1"
@@ -20,7 +20,7 @@ it results in a structured hash instead of an encoded string. Blueprints can aut
   spec.require_paths = ["lib"]
 
   spec.add_runtime_dependency(%q<randexp>, ["~> 0"])
-  spec.add_runtime_dependency(%q<attributor>, [">= 4.0.1"])
+  spec.add_runtime_dependency(%q<attributor>, [">= 4.1"])
   spec.add_runtime_dependency(%q<activesupport>, [">= 3"])
 
   spec.add_development_dependency "bundler", "~> 1.6"

data/spec/praxis-blueprints/blueprint_spec.rb

@@ -25,14 +25,15 @@ describe Praxis::Blueprint do
     end
 
     it 'uses :master view for rendering blueprint sub-attributes' do
-      dumpable, dumpable_opts = master_view.contents[:address]
-      dumpable_opts[:view].should == :master
+      subview = master_view.contents[:address]
+      subview.should be Address.views[:default]
     end
   end
 
   context 'creating a new Blueprint class' do
     subject!(:blueprint_class) do
       Class.new(Praxis::Blueprint) do
+        domain_model Hash
         attributes do
           attribute :id, Integer
         end
@@ -40,6 +41,7 @@ describe Praxis::Blueprint do
     end
 
     its(:finalized?) { should be(false) }
+    its(:domain_model) { should be(Hash) }
 
     context '.finalize on Praxis::Blueprint' do
       before do
@@ -101,19 +103,6 @@ describe Praxis::Blueprint do
         it 'has the right values' do
           subject[:name].should eq(expected_name)
         end
-
-        it 'sends the correct ActiveSupport::Notification' do
-          notification_payload = {
-            blueprint: blueprint_instance,
-            view: blueprint_class.views[:name_only],
-            fields: nil
-          }
-          ActiveSupport::Notifications.should_receive(:instrument).
-            with('praxis.blueprint.render',notification_payload).
-            and_call_original
-
-            blueprint_instance.render(view: :name_only)
-        end
       end
 
       context 'validation' do
@@ -140,7 +129,7 @@ describe Praxis::Blueprint do
           email: "bob@example.com",
           aliases: [],
           prior_addresses: [],
-          parents: { father: /[:first_name:]/.gen, mother: /[:first_name:]/.gen},
+          parents: { father: Randgen.first_name, mother: Randgen.first_name},
           href: "www.example.com",
           alive: true
         }
@@ -245,217 +234,178 @@ describe Praxis::Blueprint do
 
       it { should have(1).item }
       its(:first) { should =~ /Attribute \$.address.state/ }
-          end
+    end
 
-          context 'for objects of the wrong type' do
-            it 'raises an error' do
-              expect {
-                Person.validate(Object.new)
-              }.to raise_error(ArgumentError, /Error validating .* as Person for an object of type Object/)
-            end
-          end
-          end
+    context 'for objects of the wrong type' do
+      it 'raises an error' do
+        expect {
+          Person.validate(Object.new)
+        }.to raise_error(ArgumentError, /Error validating .* as Person for an object of type Object/)
+      end
+    end
+  end
 
-          context '.load' do
-            let(:hash) do
-              {
-                :name => 'Bob',
-                :full_name => {:first => 'Robert', :last => 'Robertson'},
-                :address => {:street => 'main', :state => 'OR'}
-              }
-            end
-            subject(:person) { Person.load(hash) }
-
-            it { should be_kind_of(Person) }
-
-            context 'recursively loading sub-attributes' do
-              context 'for a Blueprint' do
-                subject(:address) { person.address }
-                it { should be_kind_of(Address) }
-              end
-              context 'for an Attributor::Model' do
-                subject(:full_name) { person.full_name }
-                it { should be_kind_of(FullName) }
-              end
-            end
+  context '.load' do
+    let(:hash) do
+      {
+        :name => 'Bob',
+        :full_name => {:first => 'Robert', :last => 'Robertson'},
+        :address => {:street => 'main', :state => 'OR'}
+      }
+    end
+    subject(:person) { Person.load(hash) }
 
-          end
+    it { should be_kind_of(Person) }
 
+    context 'recursively loading sub-attributes' do
+      context 'for a Blueprint' do
+        subject(:address) { person.address }
+        it { should be_kind_of(Address) }
+      end
+      context 'for an Attributor::Model' do
+        subject(:full_name) { person.full_name }
+        it { should be_kind_of(FullName) }
+      end
+    end
 
-          context 'decorators' do
-            let(:name) { 'Soren II' }
+  end
 
-            let(:object) { Person.example.object }
-            subject(:person) { Person.new(object, decorators) }
 
+  context 'decorators' do
+    let(:name) { 'Soren II' }
 
-            context 'as a hash' do
-              let(:decorators) { {name: name} }
-              it do
-                pers = person
-                # binding.pry
-                pers.name.should eq('Soren II')
-              end
+    let(:object) { Person.example.object }
+    subject(:person) { Person.new(object, decorators) }
 
-              its(:name) { should be(name) }
 
-              context 'an additional instance with the equivalent hash' do
-                subject(:additional_person) { Person.new(object, {name: name}) }
-                it { should_not be person }
-              end
+    context 'as a hash' do
+      let(:decorators) { {name: name} }
+      it do
+        person.name.should eq('Soren II')
+      end
 
-              context 'an additional instance with the same hash object' do
-                subject(:additional_person) { Person.new(object, decorators) }
-                it { should_not be person }
-              end
+      its(:name) { should be(name) }
 
-              context 'an instance of the same object without decorators' do
-                subject(:additional_person) { Person.new(object) }
-                it { should_not be person }
-              end
-            end
+      context 'an additional instance with the equivalent hash' do
+        subject(:additional_person) { Person.new(object, {name: name}) }
+        it { should_not be person }
+      end
 
-            context 'as an object' do
-              let(:decorators) { double("decorators", name: name) }
-              its(:name) { should be(name) }
+      context 'an additional instance with the same hash object' do
+        subject(:additional_person) { Person.new(object, decorators) }
+        it { should_not be person }
+      end
 
-              context 'an additional instance with the same object' do
-                subject(:additional_person) { Person.new(object, decorators) }
-                it { should_not be person }
-              end
-            end
+      context 'an instance of the same object without decorators' do
+        subject(:additional_person) { Person.new(object) }
+        it { should_not be person }
+      end
+    end
 
-          end
+    context 'as an object' do
+      let(:decorators) { double("decorators", name: name) }
+      its(:name) { should be(name) }
 
+      context 'an additional instance with the same object' do
+        subject(:additional_person) { Person.new(object, decorators) }
+        it { should_not be person }
+      end
+    end
 
-          context 'with a provided :reference option on attributes' do
-            context 'that does not match the value set on the class' do
+  end
 
-              subject(:mismatched_reference) do
-                Class.new(Praxis::Blueprint) do
-                  self.reference = Class.new(Praxis::Blueprint)
-                  attributes(reference: Class.new(Praxis::Blueprint)) {}
-                end
-              end
 
-              it 'should raise an error' do
-                expect {
-                  mismatched_reference.attributes
-                }.to raise_error
-              end
+  context 'with a provided :reference option on attributes' do
+    context 'that does not match the value set on the class' do
 
-            end
-          end
+      subject(:mismatched_reference) do
+        Class.new(Praxis::Blueprint) do
+          self.reference = Class.new(Praxis::Blueprint)
+          attributes(reference: Class.new(Praxis::Blueprint)) {}
+        end
+      end
 
+      it 'should raise an error' do
+        expect {
+          mismatched_reference.attributes
+        }.to raise_error
+      end
 
-          context '.example' do
-            context 'with some attribute values provided' do
-              let(:name) { 'Sir Bobbert' }
-              subject(:person) { Person.example(name: name) }
-              its(:name) { should eq(name) }
-            end
-          end
+    end
+  end
 
-          context '.render' do
-            let(:person) { Person.example }
-            it 'is an alias to dump' do
-              rendered = Person.render(person, view: :default)
-              dumped = Person.dump(person, view: :default)
-              expect(rendered).to eq(dumped)
-            end
-          end
 
-          context '#render' do
-            let(:person) { Person.example }
-            let(:view_name) { :default }
-            let(:render_opts) { {} }
-            subject(:output) { person.render(view: view_name, **render_opts) }
-
-            context 'caches rendered views' do
-              it 'in the instance, by view name'  do
-                person.instance_variable_get(:@rendered_views)[view_name].should be_nil
-                person.render(view: view_name)
-                cached = person.instance_variable_get(:@rendered_views)[view_name]
-                cached.should_not be_nil
-              end
-
-              it 'and does not re-render a view if one is already cached'  do
-                rendered1 = person.render(view: view_name)
-                rendered2 = person.render(view: view_name)
-                rendered1.should be(rendered2)
-              end
-
-              context 'even when :fields are specified' do
-                let(:render_opts) { {fields: {email: nil, age: nil, address: {street: nil, state: nil}}} }
-
-                it 'caches the output in a different key than just the view_name' do
-                  plain_view_render = person.render(view: view_name)
-                  fields_render = person.render(view: view_name, **render_opts)
-                  plain_view_render.should_not be(fields_render)
-                end
-
-                it 'it still caches the object if rendered for the same fields'  do
-                  rendered1 = person.render(view: view_name, **render_opts)
-                  rendered2 = person.render(view: view_name, **render_opts)
-                  rendered1.should be(rendered2)
-                end
-
-                it 'it still caches the object if rendered for the same fields (even from an "equivalent" hash)'  do
-                  rendered1 = person.render(view: view_name, **render_opts)
-
-                  equivalent_render_opts = { fields: {age: nil, address: {state: nil, street: nil}, email: nil} }
-                  rendered2 = person.render(view: view_name, **equivalent_render_opts)
-
-                  rendered1.should be(rendered2)
-                end
-              end
-
-            end
-
-            context 'with a sub-attribute that is a blueprint' do
-
-              it { should have_key(:name) }
-              it { should have_key(:address) }
-              it 'renders the sub-attribute correctly' do
-                output[:address].should have_key(:street)
-                output[:address].should have_key(:state)
-              end
-
-              it 'reports a dump error with the appropriate context' do
-                person.address.should_receive(:state).and_raise("Kaboom")
-                expect {
-                  person.render(view: view_name, context: ['special_root'])
-                }.to raise_error(/Error while dumping attribute state of type Address for context special_root.address. Reason: .*Kaboom/)
-              end
-            end
-
-
-            context 'with sub-attribute that is an Attributor::Model' do
-              it { should have_key(:full_name) }
-              it 'renders the model correctly' do
-                output[:full_name].should be_kind_of(Hash)
-                output[:full_name].should have_key(:first)
-                output[:full_name].should have_key(:last)
-              end
-            end
-
-            context 'using the `fields` option' do
-              context 'as a hash' do
-                subject(:output) { person.render(view: view_name, fields: {address: { state: nil} } ) }
-                it 'should only have the address rendered' do
-                  output.keys.should == [:address]
-                end
-                it 'address should only have state' do
-                  output[:address].keys.should == [:state]
-                end
-              end
-              context 'as a simple array' do
-                subject(:output) { person.render(view: view_name, fields: [:address] ) }
-                it 'accepts it as the list of top-level attributes to be rendered' do
-                  output.keys.should == [:address]
-                end
-              end
-            end
-          end
+  context '.example' do
+    context 'with some attribute values provided' do
+      let(:name) { 'Sir Bobbert' }
+      subject(:person) { Person.example(name: name) }
+      its(:name) { should eq(name) }
+    end
+  end
 
-          end
+  context '.render' do
+    let(:person) { Person.example('1') }
+    it 'is an alias to dump' do
+
+      person.object.contents
+      rendered = Person.render(person, view: :default)
+      dumped = Person.dump(person, view: :default)
+      expect(rendered).to eq(dumped)
+    end
+  end
+
+  context '#render' do
+    let(:person) { Person.example }
+    let(:view_name) { :default }
+    let(:render_opts) { {} }
+    subject(:output) { person.render(view: view_name, **render_opts) }
+
+
+
+    context 'with a sub-attribute that is a blueprint' do
+
+      it { should have_key(:name) }
+      it { should have_key(:address) }
+      it 'renders the sub-attribute correctly' do
+        output[:address].should have_key(:street)
+        output[:address].should have_key(:state)
+      end
+
+      it 'reports a dump error with the appropriate context' do
+        person.address.should_receive(:state).and_raise("Kaboom")
+        expect {
+          person.render(view: view_name, context: ['special_root'])
+        }.to raise_error(/Error while dumping attribute state of type Address for context special_root.address. Reason: .*Kaboom/)
+      end
+    end
+
+
+    context 'with sub-attribute that is an Attributor::Model' do
+      it { should have_key(:full_name) }
+      it 'renders the model correctly' do
+        output[:full_name].should be_kind_of(Hash)
+        output[:full_name].should have_key(:first)
+        output[:full_name].should have_key(:last)
+      end
+    end
+
+    context 'using the `fields` option' do
+      context 'as a hash' do
+        subject(:output) { person.render(fields: {address: {state: true}}) }
+        it 'should only have the address rendered' do
+          output.keys.should eq [:address]
+        end
+        it 'address should only have state' do
+          output[:address].keys.should eq [:state]
+        end
+      end
+      context 'as a simple array' do
+        subject(:output) { person.render(fields: [:full_name]) }
+        it 'accepts it as the list of top-level attributes to be rendered' do
+          output.keys.should == [:full_name]
+        end
+      end
+    end
+  end
+
+end