praxis-blueprints 3.0 → 3.5

data/spec/praxis-blueprints/config_hash_spec.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Praxis::ConfigHash do
+  subject(:instance) { Praxis::ConfigHash.new(hash, &block) }
+  let(:hash) { { one: ['existing'], two: 'dos' } }
+  let(:block) do
+    proc { 'abc' }
+  end
+
+  context 'initialization' do
+    it 'saves the passed hash' do
+      expect(subject.hash).to be(hash)
+    end
+  end
+
+  context '.from' do
+    subject(:instance) { Praxis::ConfigHash.from(hash, &block) }
+    it 'returns an instance' do
+      expect(subject).to be_kind_of(Praxis::ConfigHash)
+      expect(subject.hash).to be(hash)
+    end
+  end
+
+  context '#to_hash' do
+    let(:block) do
+      proc { hash['i_was'] = 'here' }
+    end
+    it 'evaluates the block and returns the resulting hash' do
+      expect(subject.to_hash).to eq(subject.hash)
+      expect(subject.hash['i_was']).to eq('here')
+    end
+  end
+
+  context '#method_missing' do
+    context 'when keys do not exist in the hash key' do
+      it 'sets a single value to the hash' do
+        subject.some_name 'someval'
+        expect(subject.hash[:some_name]).to eq('someval')
+      end
+      it 'sets a multiple values to the hash key' do
+        subject.some_name 'someval', 'other1', 'other2'
+        expect(subject.hash[:some_name]).to include('someval', 'other1', 'other2')
+      end
+    end
+    context 'when keys already exist in the hash key' do
+      it 'adds one value to the hash' do
+        subject.one'newval'
+        expect(subject.hash[:one]).to match_array(%w(existing newval))
+      end
+      it 'adds multiple values to the hash key' do
+        subject.one 'newval', 'other1', 'other2'
+        expect(subject.hash[:one]).to match_array(%w(existing newval other1 other2))
+      end
+      context 'when passing a value and a block' do
+        let(:my_block) { proc {} }
+        it 'adds the tuple to the hash key' do
+          subject.one 'val', &my_block
+          expect(subject.hash[:one]).to include(['val', my_block])
+        end
+      end
+    end
+  end
+end

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,17 +120,31 @@ 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 'throws a CircularExpansionError' do
-      expect { field_expander.expand(Address,true) }.to raise_error(Praxis::FieldExpander::CircularExpansionError)
+    it 'preserve field object identity for circular references' do
+      result = field_expander.expand(Address, true)
+      result.should be result[:resident][:address]
+    end
+
+    context 'with collections of Blueprints' do
+      it 'still preserves object identity' do
+        result = field_expander.expand(Person, prior_addresses: true)[:prior_addresses][0]
+        result.should be result[:resident][:prior_addresses][0]
+      end
+    end
+
+    context 'for views' do
+      it 'still preserves object identity' do
+        result = field_expander.expand(Person.views[:circular], true)
+        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
@@ -155,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,33 +1,42 @@
+# 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(:person) do
-     Person.example(
+    Person.example(
       address: address,
       email: nil,
       prior_addresses: prior_addresses,
       alive: false,
-      work_address: nil
+      work_address: nil,
+      aliases: aliases,
+      metadata: metadata
     )
   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
+      alive: true,
+      metadata: true,
+      aliases: [true]
     }
   end
 
@@ -36,31 +45,44 @@ describe Praxis::Renderer do
   subject(:output) { renderer.render(person, fields) }
 
   it 'renders existing attributes' do
-    output.keys.should match_array([:name, :full_name, :alive, :address, :prior_addresses])
+    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(&:dump)
+    output[:aliases].should match_array(expected_aliases)
+
+    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)
+    end
+    it 'when rendering them in full as leaf object' do
+      metadata.should_receive(:dump).and_call_original
+      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 = {
@@ -69,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
@@ -87,44 +109,48 @@ 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
 
   context 'rendering stuff that breaks badly' do
     it 'does not break badly' do
-      renderer.render(person, tags: [true])
+      renderer.render(person, {tags: [true]})
     end
   end
 
@@ -137,6 +163,68 @@ 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)
+
+      person.object.address.object.resident = person
+      expect { renderer.render(person, fields) }.to raise_error(Praxis::Renderer::CircularRenderingError)
+    end
+  end
+
+  context 'rendering hashes' do
+    let(:fields) do
+      {
+        id: true,
+        hash: true
+      }
+    end
+
+    let(:data) { { id: 10, hash: { foo: 'bar' } } }
+    let(:object) { SimpleHash.load(data) }
+    let(:renderer) { Praxis::Renderer.new }
+
+    subject(:output) { renderer.render(object, fields) }
+
+    its([:id]) { should eq data[:id] }
+    its([:hash]) { should eq data[:hash] }
+    its([:hash]) { should be_kind_of(Hash) }
+  end
+
+  context 'rendering collections of hashes' do
+    let(:fields) do
+      {
+        id: true,
+        hash_collection: [true]
+      }
+    end
+
+    let(:data) { { id: 10, hash_collection: [{ foo: 'bar' }] } }
+    let(:object) { SimpleHashCollection.load(data) }
+    let(:renderer) { Praxis::Renderer.new }
+
+    subject(:output) { renderer.render(object, fields) }
+
+    its([:id]) { should eq data[:id] }
+    its([:hash_collection]) { should eq data[:hash_collection] }
+    its([:hash_collection]) { should be_kind_of(Array) }
+
+    it 'renders the hashes' do
+      expect(output[:hash_collection].first).to be_kind_of(Hash)
+    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