praxis-blueprints 3.2 → 3.3

data/spec/praxis-blueprints/field_expander_spec.rb

@@ -1,7 +1,7 @@
+# frozen_string_literal: true
 require 'spec_helper'
 
 describe Praxis::FieldExpander do
-
   let(:field_expander) { Praxis::FieldExpander.new }
 
   let(:view) do
@@ -21,96 +21,95 @@ describe Praxis::FieldExpander do
   let(:full_expected) do
     {
       name: true,
-      full_name: {first: true, last: true},
-      parents: {mother: true, father: 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}]
+          full_name: { first: true, last: true },
+          address: { street: true, state: true },
+          prior_addresses: [{ street: true, state: true }]
         }
       },
-      prior_addresses: [{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)
+      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})
+      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}})
+      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]})
+      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]}})
+      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}})
+      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})
+      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}})
+      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}]})
+      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}]})
+      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})
+    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}})
+    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}]
+    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}}}]
+    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
+    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
+    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])
+    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)
+    field_expander.expand(String).should eq(true)
   end
 
   context 'expanding a two-dimensional collection' do
@@ -121,12 +120,11 @@ describe Praxis::FieldExpander do
     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 'preserve field object identity for circular references' do
-      result = field_expander.expand(Address,true)
+      result = field_expander.expand(Address, true)
       result.should be result[:resident][:address]
     end
 
@@ -143,11 +141,10 @@ describe Praxis::FieldExpander do
         result[:address][:resident].should be result
       end
     end
-
   end
 
   it 'optimizes duplicate field expansions' do
-    expect(field_expander.expand(FullName,true)).to be(field_expander.expand(FullName,true))
+    expect(field_expander.expand(FullName, true)).to be(field_expander.expand(FullName, true))
   end
 
   context 'expanding hash attributes' do
@@ -171,15 +168,10 @@ describe Praxis::FieldExpander do
       expected = {
         name: true,
         simple_hash: true,
-        keyed_hash: {foo: true, bar: true},
-        some_struct: {something: 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

@@ -1,17 +1,17 @@
+# frozen_string_literal: true
 require_relative '../spec_helper'
 
 describe Praxis::Renderer do
-
   let(:address) { Address.example }
-  let(:prior_addresses) { 2.times.collect { Address.example } }
+  let(:prior_addresses) { Array.new(2) { Address.example } }
   let(:alias_one) { FullName.example }
   let(:alias_two) { FullName.example }
   let(:aliases) { [alias_one, alias_two] }
   let(:metadata_hash) { { something: 'here' } }
-  let(:metadata) { Attributor::Hash.load( metadata_hash ) }
+  let(:metadata) { Attributor::Hash.load(metadata_hash) }
 
   let(:person) do
-     Person.example(
+    Person.example(
       address: address,
       email: nil,
       prior_addresses: prior_addresses,
@@ -22,18 +22,17 @@ describe Praxis::Renderer do
     )
   end
 
-
   let(:fields) do
     {
-      name:true,
-      email:true,
-      full_name: {first:true, last:true},
+      name: true,
+      email: true,
+      full_name: { first: true, last: true },
       address: {
-        state:true,
-        street:true,
-        resident:  {name:true}
+        state: true,
+        street: true,
+        resident:  { name: true }
       },
-      prior_addresses: [{name: true}],
+      prior_addresses: [{ name: true }],
       work_address: true,
       alive: true,
       metadata: true,
@@ -49,45 +48,41 @@ describe Praxis::Renderer do
     output.keys.should match_array([:name, :full_name, :alive, :address, :prior_addresses, :metadata, :aliases])
 
     output[:name].should eq person.name
-    output[:full_name].should eq({first: person.full_name.first, last: person.full_name.last})
+    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}
-    })
+    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} }
+    expected_prior_addresses = prior_addresses.collect { |addr| { name: addr.name } }
     output[:prior_addresses].should match_array(expected_prior_addresses)
 
-    expected_aliases = aliases.collect { |the_alias| the_alias.dump }
-    output[:aliases].should match_array( expected_aliases )
+    expected_aliases = aliases.collect(&:dump)
+    output[:aliases].should match_array(expected_aliases)
 
-    output[:metadata].should eq( metadata.dump )
+    output[:metadata].should eq(metadata.dump)
   end
 
   context 'calls dump for non-Blueprint, but still Dumpable instances' do
     it 'when rendering them in full as array members' do
       alias_one.should_receive(:dump).and_call_original
-      output[:aliases].first.should eq( first: alias_one.first, last: alias_one.last )
+      output[:aliases].first.should eq(first: alias_one.first, last: alias_one.last)
     end
     it 'when rendering them in full as leaf object' do
       metadata.should_receive(:dump).and_call_original
-      output[:metadata].should eq( metadata_hash )
+      output[:metadata].should eq(metadata_hash)
     end
-
   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
+      name: true,
+      email: true
     }
 
     notification_payload = {
@@ -96,16 +91,16 @@ describe Praxis::Renderer do
       fields: fields
     }
 
-    ActiveSupport::Notifications.should_receive(:instrument).
-      with('praxis.blueprint.render',notification_payload).
-      and_call_original
+    ActiveSupport::Notifications.should_receive(:instrument)
+                                .with('praxis.blueprint.render', notification_payload)
+                                .and_call_original
 
     renderer.render(person, fields)
-   end
-
+  end
 
   context 'with include_nil: true' do
     let(:renderer) { Praxis::Renderer.new(include_nil: true) }
+    let(:address) { nil }
 
     it 'renders attributes with nil values' do
       output.should have_key :email
@@ -114,38 +109,42 @@ describe Praxis::Renderer do
       output.should have_key :work_address
       output[:work_address].should be nil
     end
+
+    it 'renders nil directly for nil subobjects' do
+      output.should have_key :address
+      output[:address].should be nil
+    end
   end
 
   context '#render_collection' do
-    let(:people) { 10.times.collect { Person.example(address: address, email: nil) } }
+    let(:people) { Array.new(10) { 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))
+      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(:names) { Array.new(9) { |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(:matrix) { matrix_type.load(names.each_slice(3).collect { |slice| slice }) }
 
-    let(:fields) { [[{name: true}]] }
+    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))
+      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))
+      rendered = renderer.render(matrix, fields)
+      rendered.flatten.collect { |r| r[:name] }.should eq((0..8).collect(&:to_s))
     end
   end
 
@@ -164,18 +163,16 @@ describe Praxis::Renderer do
       render_2 = renderer.render(person, fields)
       expect(render_1).to be(render_2)
     end
-
   end
 
   context 'circular rendering' do
     it do
       field_expander = Praxis::FieldExpander.new
-      fields = field_expander.expand(Person,true)
+      fields = field_expander.expand(Person, true)
 
       person.object.address.object.resident = person
       expect { renderer.render(person, fields) }.to raise_error(Praxis::Renderer::CircularRenderingError)
     end
-
   end
 
   context 'rendering hashes' do
@@ -186,8 +183,8 @@ describe Praxis::Renderer do
       }
     end
 
-    let(:data) { {id: 10, hash: {foo: 'bar'}} }
-    let(:object) { SimpleHash.load(data)}
+    let(:data) { { id: 10, hash: { foo: 'bar' } } }
+    let(:object) { SimpleHash.load(data) }
     let(:renderer) { Praxis::Renderer.new }
 
     subject(:output) { renderer.render(object, fields) }
@@ -205,8 +202,8 @@ describe Praxis::Renderer do
       }
     end
 
-    let(:data) { {id: 10, hash_collection: [{foo: 'bar'}]} }
-    let(:object) { SimpleHashCollection.load(data)}
+    let(:data) { { id: 10, hash_collection: [{ foo: 'bar' }] } }
+    let(:object) { SimpleHashCollection.load(data) }
     let(:renderer) { Praxis::Renderer.new }
 
     subject(:output) { renderer.render(object, fields) }
@@ -220,4 +217,14 @@ describe Praxis::Renderer do
     end
   end
 
+  context 'rendering a Blueprint with fields true' do
+    let(:fields) do
+      {
+        name: true,
+        address: true
+      }
+    end
+
+    its([:address]) { should eq person.address.dump }
+  end
 end

data/spec/praxis-blueprints/view_spec.rb

@@ -1,7 +1,7 @@
+# frozen_string_literal: true
 require_relative '../spec_helper'
 
 describe Praxis::View do
-
   let(:person) { Person.example(['person']) }
   let(:address) { person.address }
 
@@ -34,7 +34,7 @@ describe Praxis::View 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|
+      [:name, :email, :full_name].each do |attr|
         contents[attr].should be Person.attributes[attr]
       end
     end
@@ -49,7 +49,6 @@ describe Praxis::View do
       contents[:prior_addresses].contents.should eq Address.views[:state].contents
     end
 
-
     context 'creating subviews' do
       it 'creates subviews when a block is used' do
         contents[:parents].should be_kind_of(Praxis::View)
@@ -85,33 +84,30 @@ describe Praxis::View do
           it 'creates the sub-CollectionViews with a member view with the same contents of the parent' do
             contents[:friends].should be_kind_of(Praxis::CollectionView)
             contents[:friends].contents.should eq(view.contents)
-            contents[:friends].contents.keys.should match_array([:myself,:friends])
+            contents[:friends].contents.keys.should match_array([:myself, :friends])
           end
         end
-
       end
     end
-
   end
 
   context '#describe' do
-    subject(:description) { view.describe}
-    its(:keys){ should =~ [:attributes, :type] }
+    subject(:description) { view.describe }
+    its(:keys) { should =~ [:attributes, :type] }
     its([:type]) { should eq(:standard) }
     context 'returns attributes' do
       subject { description[:attributes] }
 
-      its(:keys){ should match_array view.contents.keys }
+      its(:keys) { should match_array view.contents.keys }
 
       it 'should return empty hashes for attributes with no specially defined view' do
         subject[:name].should eq({})
         subject[:email].should eq({})
       end
       it 'should return the view name if specified' do
-        subject[:address].should eq({view: :extended})
-        subject[:prior_addresses].should eq({view: :state})
+        subject[:address].should eq(view: :extended)
+        subject[:prior_addresses].should eq(view: :state)
       end
     end
   end
-
 end