praxis-blueprints 2.2 → 3.0

data/spec/praxis-blueprints/collection_view_spec.rb

@@ -2,50 +2,64 @@ require_relative '../spec_helper'
 
 describe Praxis::CollectionView do
 
-  let(:collection_schema) { double(:collection_schema) }
+  let(:root_context) { ['people'] }
 
-  let(:people) { [Person.example('p-1'), Person.example('p-2')] }
+  let(:people) do
+    3.times.collect do |i|
+      context = ["people", "at(#{i})"]
+      Person.example(context)
+    end
+  end
 
 
-  let(:member_view) do
-    Praxis::View.new(:tiny, Person) do
+  let(:contents_definition) do
+    proc do
       attribute :name
       attribute :address, view: :state
     end
   end
 
+  let(:member_view) do
+    Praxis::View.new(:tiny, Person, &contents_definition)
+  end
+
   let(:collection_view) do
-    Praxis::CollectionView.new(:collection_view, collection_schema, member_view)
+    Praxis::CollectionView.new(:collection_view, Person, member_view)
   end
 
-  let(:root_context) { ['people'] }
+  context 'creating from a member view' do
 
-  context '#dump' do
-    before do
-      people.each_with_index do |person, i|
-        subcontext = root_context + ["at(#{i})"]
-        expect(member_view).to(
-          receive(:dump).
-          with(person, context: subcontext).
-        and_call_original)
-      end
+    it 'gets the proper contents' do
+      collection_view.contents.should eq member_view.contents
     end
+  end
+
+  context 'creating with a set of attributes defined in a block' do
+    let(:collection_view) do
+      Praxis::CollectionView.new(:collection_view, Person, &contents_definition)
+    end
+
+    it 'gets the proper contents' do
+      collection_view.contents.should eq member_view.contents
+    end
+  end
 
-    subject(:output) { collection_view.dump(people, context: root_context) }
+  context '#render' do
+    subject(:output) { collection_view.render(people, context: root_context) }
 
     it { should be_kind_of(Array) }
+    it { should eq people.collect {|person| member_view.render(person)} }
   end
 
   context '#example' do
     it 'generates an example from the schema and renders it' do
-      expect(collection_schema).to(
-        receive(:example).
-        with(root_context).
-        and_return(people)
-      )
-      expect(collection_view).to receive(:dump).and_call_original
-
-      collection_view.example(root_context)
+      # because we set the context throughout, we know +people+ will
+      # will generate with identical contents across all runs.
+      expected = people.collect do |person|
+        { name: person.name, address: person.address.render(view: :state) }
+      end
+
+      collection_view.example(root_context).should eq expected
     end
   end
 

data/spec/praxis-blueprints/field_expander_spec.rb

@@ -0,0 +1,169 @@
+require 'spec_helper'
+
+describe Praxis::FieldExpander do
+
+  let(:field_expander) { Praxis::FieldExpander.new }
+
+  let(:view) do
+    Praxis::View.new(:testing, Person) do
+      attribute :name
+      attribute :full_name
+      attribute :parents do
+        attribute :father
+        attribute :mother
+      end
+      attribute :address, view: :extended
+      attribute :prior_addresses, view: :state
+      attribute :tags
+    end
+  end
+
+  let(:full_expected) do
+    {
+      name: true,
+      full_name: {first: true, last: true},
+      parents: {mother: true, father: true},
+      address: {
+        state: true,
+        street: true,
+        resident: {
+          name: true,
+          full_name: {first: true, last: true},
+          address: {street:true, state:true},
+          prior_addresses: [{street:true, state:true}]
+        }
+      },
+      prior_addresses: [{state: true}],
+      tags: [true]
+    }
+  end
+
+  context 'expanding a view' do
+    it 'expands all fields on the view, subviews, and related attributes' do
+      field_expander.expand(view,true).should eq(full_expected)
+    end
+
+    it 'expands for a subset of the direct fields' do
+      field_expander.expand(view,name: true).should eq({name:true})
+    end
+
+    it 'expands for a subview' do
+      field_expander.expand(view,parents: true).should eq({parents:{mother: true, father: true}})
+    end
+
+    it 'expands for a related attribute' do
+      field_expander.expand(view,address: true).should eq({address: full_expected[:address]})
+    end
+
+    it 'expands for a subset of a related attribute' do
+      field_expander.expand(view,address: {resident: true}).should eq({address: {resident: full_expected[:address][:resident]}})
+    end
+
+    it 'expands for a subset of a subview' do
+      field_expander.expand(view,parents: {mother: true}).should eq({parents:{mother: true}})
+    end
+
+    it 'ignores fields not defined in the view' do
+      field_expander.expand(view,name: true, age: true).should eq({name:true})
+    end
+
+    it 'expands a specific subattribute of a struct' do
+      field_expander.expand(view,full_name: {first: true}).should eq({full_name: {first: true}})
+    end
+
+    it 'wraps expanded collections in arrays' do
+      field_expander.expand(view,prior_addresses: {state: true}).should eq({prior_addresses: [{state: true}]})
+    end
+
+    it 'wraps expanded collections in arrays' do
+      field_expander.expand(view, prior_addresses: true).should eq({prior_addresses: [{state: true}]})
+    end
+  end
+
+  it 'expands for an Attributor::Model' do
+    field_expander.expand(FullName).should eq({first: true, last: true})
+  end
+
+
+  it 'expands for a Blueprint' do
+    field_expander.expand(Person, parents: true).should eq({parents:{father: true, mother: true}})
+  end
+
+  it 'expands for an Attributor::Collection of an Attrbutor::Model' do
+    expected = [{first: true, last: true}]
+    field_expander.expand(Attributor::Collection.of(FullName)).should eq expected
+  end
+
+  it 'expands for an Attributor::Collection of a Blueprint' do
+    expected = [{name: true, resident: {full_name: {first: true, last: true}}}]
+
+    field_expander.expand(Attributor::Collection.of(Address), name: true, resident:{full_name: true}).should eq expected
+  end
+
+  it 'also expands array-wrapped field hashes for collections' do
+    expected = [{name: true, resident: {full_name: {first: true, last: true}}}]
+    field_expander.expand(Attributor::Collection.of(Address), [name: true, resident:{full_name: true}]).should eq expected
+  end
+
+  it 'expands for an Attributor::Collection of a primitive type' do
+   field_expander.expand(Attributor::Collection.of(String)).should eq([true])
+  end
+
+  it 'expands for for a primitive type' do
+   field_expander.expand(String).should eq(true)
+  end
+
+  context 'expanding a two-dimensional collection' do
+    let(:matrix_type) do
+      Attributor::Collection.of(Attributor::Collection.of(FullName))
+    end
+
+    it 'expands the fields with proper nesting' do
+      field_expander.expand(matrix_type).should eq([[first: true, last: true]])
+    end
+
+  end
+
+  context 'circular expansions' do
+    it 'throws a CircularExpansionError' do
+      expect { field_expander.expand(Address,true) }.to raise_error(Praxis::FieldExpander::CircularExpansionError)
+    end
+  end
+
+  it 'optimizes duplicate field expansions' do
+    expect(field_expander.expand(FullName,true)).to be(field_expander.expand(FullName,true))
+  end
+
+  context 'expanding hash attributes' do
+    let(:type) do
+      Class.new(Attributor::Model) do
+        attributes do
+          attribute :name, String
+          attribute :simple_hash, Hash
+          attribute :keyed_hash, Hash do
+            key :foo, String
+            key :bar, String
+          end
+          attribute :some_struct do
+            attribute :something, String
+          end
+        end
+      end
+    end
+
+    it 'expands' do
+      expected = {
+        name: true,
+        simple_hash: true,
+        keyed_hash: {foo: true, bar: true},
+        some_struct: {something: true}
+      }
+      field_expander.expand(type, true).should eq(expected)
+    end
+
+
+
+  end
+
+
+end

data/spec/praxis-blueprints/renderer_spec.rb

@@ -0,0 +1,142 @@
+require_relative '../spec_helper'
+
+describe Praxis::Renderer do
+
+  let(:address) { Address.example }
+  let(:prior_addresses) { 2.times.collect { Address.example } }
+  let(:person) do
+     Person.example(
+      address: address,
+      email: nil,
+      prior_addresses: prior_addresses,
+      alive: false,
+      work_address: nil
+    )
+  end
+
+
+  let(:fields) do
+    {
+      name:true,
+      email:true,
+      full_name: {first:true, last:true},
+      address: {
+        state:true,
+        street:true,
+        resident:  {name:true}
+      },
+      prior_addresses: [{name: true}],
+      work_address: true,
+      alive: true
+    }
+  end
+
+  let(:renderer) { Praxis::Renderer.new }
+
+  subject(:output) { renderer.render(person, fields) }
+
+  it 'renders existing attributes' do
+    output.keys.should match_array([:name, :full_name, :alive, :address, :prior_addresses])
+
+    output[:name].should eq person.name
+    output[:full_name].should eq({first: person.full_name.first, last: person.full_name.last})
+    output[:alive].should be false
+
+    output[:address].should eq({
+      state: person.address.state,
+      street: person.address.street,
+      resident: {name: person.address.resident.name}
+    })
+
+    expected_prior_addresses = prior_addresses.collect { |addr| {name: addr.name} }
+    output[:prior_addresses].should match_array(expected_prior_addresses)
+  end
+
+  it 'does not render attributes with nil values' do
+    output.should_not have_key(:email)
+  end
+
+
+  it 'sends the correct ActiveSupport::Notification' do
+    fields = {
+      name:true,
+      email:true
+    }
+
+    notification_payload = {
+      blueprint: person,
+      view: nil,
+      fields: fields
+    }
+
+    ActiveSupport::Notifications.should_receive(:instrument).
+      with('praxis.blueprint.render',notification_payload).
+      and_call_original
+
+    renderer.render(person, fields)
+   end
+
+
+  context 'with include_nil: true' do
+    let(:renderer) { Praxis::Renderer.new(include_nil: true) }
+
+    it 'renders attributes with nil values' do
+      output.should have_key :email
+      output[:email].should be nil
+
+      output.should have_key :work_address
+      output[:work_address].should be nil
+    end
+  end
+
+  context '#render_collection' do
+    let(:people) { 10.times.collect { Person.example(address: address, email: nil) } }
+    subject(:output) { renderer.render_collection(people, fields) }
+
+    it { should have(10).items }
+
+    it 'renders the collection' do
+      output.first.should eq(renderer.render(people.first,fields))
+    end
+
+  end
+
+  context 'rendering a two-dimmensional collection' do
+    let(:names) { 9.times.collect { |i| Address.example(i.to_s, name: i.to_s) } }
+    let(:matrix_type) do
+      Attributor::Collection.of(Attributor::Collection.of(Address))
+    end
+
+    let(:matrix) { matrix_type.load(names.each_slice(3).collect { |slice| slice })  }
+
+    let(:fields) { [[{name: true}]] }
+
+    it 'renders with render_collection and per-element field spec' do
+      rendered = renderer.render_collection(matrix,fields.first)
+      rendered.flatten.collect {|r| r[:name] }.should eq((0..8).collect(&:to_s))
+    end
+
+    it 'renders with render and proper field spec' do
+      rendered =  renderer.render(matrix,fields)
+      rendered.flatten.collect {|r| r[:name] }.should eq((0..8).collect(&:to_s))
+    end
+  end
+
+  context 'rendering stuff that breaks badly' do
+    it 'does not break badly' do
+      renderer.render(person, tags: [true])
+    end
+  end
+
+  context 'caching rendered objects' do
+    let(:fields) { Praxis::FieldExpander.expand(Person, full_name: true) }
+    it 'caches and returns identical results for the same field objects' do
+      expect(person).to receive(:full_name).once.and_call_original
+
+      render_1 = renderer.render(person, fields)
+      render_2 = renderer.render(person, fields)
+      expect(render_1).to be(render_2)
+    end
+
+  end
+end

data/spec/praxis-blueprints/view_spec.rb

@@ -6,347 +6,76 @@ describe Praxis::View do
   let(:address) { person.address }
 
   let(:view) do
-    Praxis::View.new(:tiny, Person) do
+    Praxis::View.new(:testing, Person) do
       attribute :name
-      attribute :alive
-      attribute :address, view: :state
+      attribute :email
+      attribute :full_name
+      attribute :parents do
+        attribute :father
+        attribute :mother
+      end
+      attribute :address, view: :extended
+      attribute :prior_addresses, view: :state
+      attribute :work_address
     end
   end
-  let(:dumping_options){ {} }
-  subject(:output) { view.to_hash(person, dumping_options ) }
-
 
   it 'can generate examples' do
     view.example.should have_key(:name)
   end
 
-  context 'swanky rendering options' do
-    let(:view) do
-      Praxis::View.new(:info, Person) do
-        attribute :name
-        attribute :email
-        attribute :age
-        attribute :address
-      end
-    end
-
-    let(:data) { {name: 'Bob', email: nil, address: nil } }
-
-    let(:person) { Person.load(data) }
-
-    context 'with default rendering options' do
-      it 'attributor works right' do
-        person.object.key?(:name).should be(true)
-        person.object.key?(:email).should be(true)
-        person.object.key?(:age).should be(false)
-        person.object.key?(:address).should be(true)
-
-        person.name.should eq('Bob')
-        person.email.should eq(nil)
-        person.age.should eq(nil)
-        person.address.should eq(nil)
-      end
-
-      it 'renders existing, non-nil, attributes' do
-        output.key?(:name).should be(true)
-        output.key?(:email).should_not be(true)
-        output.key?(:age).should_not be(true)
-        output.key?(:address).should_not be(true)
-      end
-
-      context 'and custom field rendering' do
-        let(:data) { {name: 'Bob', email: 'bob@acme.org', age: 50 } }
-
-        context 'renders only the specified fields that have values' do
-          let(:dumping_options){ { fields: {name: nil, email: nil} } }
-          its(:keys){ should == [:name, :email] }
-        end
-
-        context 'renders only the specified fields excluding nil valued ones' do
-          let(:dumping_options){ { fields: {name: nil, address: nil} } }
-          its(:keys){ should == [:name] }
-        end
-      end
-    end
-
-
-    context 'with include_nil: true' do
-      let(:view) do
-        Praxis::View.new(:info, Person, include_nil: true) do
-          attribute :name
-          attribute :email
-          attribute :age
-          attribute :address
-        end
-      end
-
-      it 'includes attributes with nil values' do
-        output.key?(:email).should be(true)
-        output[:email].should be(nil)
-
-        output.key?(:address).should be(true)
-        output[:address].should be(nil)
-
-        output.key?(:age).should be(true)
-        output[:age].should be(nil)
-      end
-
-      context 'and custom field rendering' do
-        let(:data) { {name: 'Bob', email: 'bob@acme.org', age: 50 } }
-
-        context 'renders only the specified fields including nil valued' do
-          let(:dumping_options){ { fields: {name: nil, address: nil}} }
-          its(:keys){ should == [:name,:address] }
-        end
-      end
-    end
-
-  end
-
-
-
-  context 'direct attributes' do
-
-    let(:person) { Person.load(person_data) }
-    context 'with undisputably existing values' do
-
-      let(:person_data) { {name:'somename', alive:true} }
-
-      let(:expected_output) do
-        {
-          :name => 'somename',
-          :alive => true
-        }
-      end
-      it 'should show up' do
-        subject.should == expected_output
-      end
-    end
-    context 'with nil values' do
-      let(:person_data) { {name:'alive_is_nil', alive: nil} }
-      let(:expected_output) do
-        {
-          name: 'alive_is_nil',
-          alive: true
-        }
-      end
-      it 'are skipped completely' do
-        subject.should == expected_output
-      end
-    end
-
-    context 'with false values' do
-      let(:person_data) { {name:'alive_is_false', alive:false} }
-      let(:expected_output) do
-        {
-          :name => 'alive_is_false',
-          :alive => false
-        }
-      end
-      it 'should still show up, since "false" is really a valid value' do
-        subject.should == expected_output
-      end
-    end
-
+  it 'delegates to Renderer with its expanded_fields' do
+    renderer = Praxis::Renderer.new
+    renderer.should_receive(:render).with(person, view.expanded_fields, context: 'foo')
+    view.render(person, context: 'foo', renderer: renderer)
   end
 
-  context 'nested attributes' do
-
-    context 'without block' do
-      let(:view) do
-        Praxis::View.new(:parents, Person) do
-          attribute :name
-          attribute :parents
-        end
+  context 'defining views' do
+    subject(:contents) { view.contents }
+    its(:keys) { should match_array([:name, :email, :full_name, :parents, :address, :prior_addresses, :work_address]) }
+    it 'saves attributes defined on the Blueprint' do
+      [:name, :email, :full_name ].each do |attr|
+        contents[attr].should be Person.attributes[attr]
       end
-
-      let(:expected_output) do
-        {
-          :name => person.name,
-          :parents => {
-            :father => person.parents.father,
-            :mother => person.parents.mother
-          }
-        }
-      end
-
-      it { should eq expected_output }
-
     end
 
-    context 'with block' do
-      let(:view) do
-        Praxis::View.new(:paternal, Person) do
-          attribute :name
-          attribute :parents do
-            attribute :father
-          end
-        end
-      end
-      let(:expected_output) do
-        {
-          :name => person.name,
-          :parents => {
-            :father => person.parents.father
-          }
-        }
-      end
-
-      it { should eq expected_output }
+    it 'saves views for attributes for Blueprints' do
+      contents[:address].should be Address.views[:extended]
+      contents[:work_address].should be Address.views[:default]
     end
 
-  end
-
-
-  context 'using a related object as an attribute' do
-
-    context 'using default view' do
-      let(:view) do
-        Praxis::View.new(:default, Person) do
-          attribute :name
-          attribute :address
-        end
-      end
-      let(:expected_output) do
-        {
-          :name => person.name,
-          :address => {
-            :street => address.street,
-            :state => address.state
-          }
-        }
-      end
-
-
-      it { should eq expected_output }
-
-      context 'using the fields option' do
-        let(:dumping_options){ { fields: {name: nil, address: {state: nil} } } }
-
-        let(:expected_output) do
-          {
-            :name => person.name,
-            :address => {
-              :state => address.state
-            }
-          }
-        end
-
-        it { should eq expected_output }
-      end
-
+    it 'does something with collections of Blueprints' do
+      contents[:prior_addresses].should be_kind_of(Praxis::CollectionView)
+      contents[:prior_addresses].contents.should eq Address.views[:state].contents
     end
 
 
-    context 'specifying a view' do
-      let(:view) do
-        Praxis::View.new(:default, Person) do
-          attribute :name
-          attribute :address, :view => :state
-        end
-      end
-
-
-
-      let(:expected_output) do
-        {
-          :name => person.name,
-          :address => {
-            :state => address.state
-          }
-        }
+    context 'creating subviews' do
+      it 'creates subviews when a block is used' do
+        contents[:parents].should be_kind_of(Praxis::View)
       end
 
-      it { should eq expected_output }
-    end
-
-
-    context 'with some sort of "in-lined" view' do
-      let(:view) do
-        Praxis::View.new(:default, Person) do
-          attribute :name
-          attribute :address do
-            attribute :state
+      context 'for collections' do
+        let(:view) do
+          Praxis::View.new(:testing, Person) do
+            attribute :name
+            attribute :prior_addresses do
+              attribute :name
+              attribute :street
+            end
           end
         end
-      end
-
-      let(:expected_output) do
-        {
-          :name => person.name,
-          :address => {
-            :state => address.state
-          }
-        }
-      end
-
-
-
-      it { should eq expected_output }
-    end
-
-    context 'when the related object is nil (does not respond to the related method)' do
-      let(:person) { Person.load(name: 'Bob') }
-
-      let(:view) do
-        Praxis::View.new(:default, Person) do
-          attribute :name
-          attribute :address
-        end
-      end
-      let(:expected_output) do
-        {
-          :name => person.name
-        }
-      end
-
-      it { should eq expected_output }
-    end
 
-  end
-
-
-  context 'using a related collection as an attribute' do
-    context 'with the default view' do
-      let(:view) do
-        Praxis::View.new(:default, Person) do
-          attribute :name
-          attribute :prior_addresses
-        end
-      end
-
-      let(:expected_output) do
-        {
-          :name => person.name,
-          :prior_addresses => person.prior_addresses.collect { |a| a.to_hash(view: :default)}
-        }
-      end
-
-      it { should eq expected_output }
-    end
-
-
-    context 'with a specified view' do
-      let(:view) do
-        Praxis::View.new(:default, Person) do
-          attribute :name
-          attribute :prior_addresses, :view => :state
+        it 'creates sub-CollectionViews from a block' do
+          contents[:prior_addresses].should be_kind_of(Praxis::CollectionView)
+          contents[:prior_addresses].contents.keys.should match_array([:name, :street])
         end
       end
 
-      let(:expected_output) do
-        {
-          :name => person.name,
-          :prior_addresses => person.prior_addresses.collect { |a| a.to_hash(view: :state)}
-        }
-      end
-
-      it { should eq expected_output }
     end
 
   end
 
-
   context '#describe' do
     subject(:description) { view.describe}
     its(:keys){ should =~ [:attributes, :type] }
@@ -354,14 +83,15 @@ describe Praxis::View do
     context 'returns attributes' do
       subject { description[:attributes] }
 
-      its(:keys){ should == [:name,:alive,:address]  }
+      its(:keys){ should match_array view.contents.keys }
 
       it 'should return empty hashes for attributes with no specially defined view' do
-        subject[:name].should == {}
-        subject[:alive].should == {}
+        subject[:name].should eq({})
+        subject[:email].should eq({})
       end
       it 'should return the view name if specified' do
-        subject[:address].should == {view: :state}
+        subject[:address].should eq({view: :extended})
+        subject[:prior_addresses].should eq({view: :state})
       end
     end
   end