praxis-blueprints 2.0.1 → 2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 66f44c7da0a75ef693bbe9ef10b3b592a700090d
-  data.tar.gz: 282cad83972b06bb4b185daf03407dffc7f086ac
+  metadata.gz: 14169dd33330be68f4e42c2db5ed8884e243b893
+  data.tar.gz: c4fb566937d470785645d7899ba7351dfa174289
 SHA512:
-  metadata.gz: 7a5256f895d130ff7c7fdc49e41f35899c775b118c226b44b559f7102a64564b87415760ce5f73531a82d275eb6b4cc2cada56e2fdadeea343a7ec4f76f009a2
-  data.tar.gz: f1bf843427801470ca5539614fd75ef18172109e73689f945e45e6761cd414a026b0cb34bb6bda6dec10de8f53c3fa9d952e748926bf019f621b3777836ad6ca
+  metadata.gz: 23dbe2797e5ce3575608d619f56908e21fad55baa53934c2a78dccf594231def06d18b28dc24110b8f09b79a290284eae7cf68d313129925eb8ffd8b32a91c0a
+  data.tar.gz: 4dc85caab7023389dcda2a6974328e815850c07adfbc17ce32ffed83423c58803462bbf5cedb3e799d3fe8b72ecf7d7f46451c1d805f56686e8fa6d7baa8dbcb

data/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 ## next
 
+
+## 2.1
+
+* Fixed handling of objects passed in to `Blueprint.example`.
+* Bumped attributor dependnecy to >= 4.0.1
+
+
 ## 2.0.1 
 
 * relaxed attributor dependency to >= 3.0

data/lib/praxis-blueprints/blueprint.rb

@@ -64,10 +64,14 @@ module Praxis
       'hash'
     end
 
-    def self.describe(shallow=false,**opts)
+    def self.describe(shallow=false,example: nil, **opts)
       type_name = self.ancestors.find { |k| k.name && !k.name.empty? }.name
 
-      description = self.attribute.type.describe(shallow,**opts).merge!(id: self.id, name: type_name)
+      if example
+        example = example.object
+      end
+
+      description = self.attribute.type.describe(shallow,example: example, **opts).merge!(id: self.id, name: type_name)
 
       unless shallow
         description[:views] = self.views.each_with_object({}) do |(view_name, view), hash|

data/lib/praxis-blueprints/version.rb

@@ -1,3 +1,3 @@
 module Praxis
-  BLUEPRINTS_VERSION = "2.0.1"
+  BLUEPRINTS_VERSION = "2.1"
 end

data/praxis-blueprints.gemspec

@@ -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>, [">= 3.0"])
+  spec.add_runtime_dependency(%q<attributor>, [">= 4.0.1"])
   spec.add_runtime_dependency(%q<activesupport>, [">= 3"])
 
   spec.add_development_dependency "bundler", "~> 1.6"

data/spec/praxis-blueprints/blueprint_spec.rb

@@ -171,16 +171,18 @@ describe Praxis::Blueprint do
   end
 
   context '.describe' do
+    let(:shallow ) { false }
+    let(:example_object) { nil }
+
     before do
-      expect(blueprint_class.attribute.type).to receive(:describe).and_return(type_describe)
+      expect(blueprint_class.attribute.type).to receive(:describe).with(shallow, example: example_object).and_call_original #.and_return(type_describe)
     end
-    let(:type_describe){ {name: "Fake", id: "From Struct attr", other: "type attribute"} }
 
     context 'for non-shallow descriptions' do
       subject(:output){ blueprint_class.describe }
+
       its([:name]){ should eq(blueprint_class.name)}
       its([:id]){ should eq(blueprint_class.id)}
-      its([:other]){ should eq("type attribute")}
       its([:views]){ should be_kind_of(Hash)}
       it 'should contain the an entry for each view' do
         subject[:views].keys.should include(:default, :current, :extended, :master)
@@ -188,11 +190,34 @@ describe Praxis::Blueprint do
     end
 
     context 'for shallow descriptions' do
+      let(:shallow) { true }
+
       it 'should not include views' do
         blueprint_class.describe(true).key?(:views).should be(false)
       end
     end
+
+    context 'with an example' do
+      let(:example) { blueprint_class.example }
+      let(:example_object) { example.object }
+      let(:shallow) { false }
+
+      subject(:output) { blueprint_class.describe(false, example: example) }
+
+      it 'outputs examples for leaf values using the provided example' do
+        output[:attributes][:name][:example].should eq example.name
+        output[:attributes][:age][:example].should eq example.age
+
+        output[:attributes][:full_name].should_not have_key(:example)
+        output[:attributes][:aliases].should_not have_key(:example)
+
+        parents_attributes = output[:attributes][:parents][:type][:attributes]
+        parents_attributes[:father][:example].should eq example.parents.father
+        parents_attributes[:mother][:example].should eq example.parents.mother
+      end
+    end
   end
+  
   context '.validate' do
     let(:hash) { {name: 'bob'} }
     let(:person) { Person.load(hash) }
@@ -207,217 +232,217 @@ describe Praxis::Blueprint do
 
       it { should have(1).item }
       its(:first) { should =~ /Attribute \$.address.state/ }
-    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
-
-  end
-
-
-  context 'decorators' do
-    let(:name) { 'Soren II' }
-
-    let(:object) { Person.example.object }
-    subject(:person) { Person.new(object, decorators) }
-
-
-    context 'as a hash' do
-      let(:decorators) { {name: name} }
-      it do
-        pers = person
-        # binding.pry
-        pers.name.should eq('Soren II')
-      end
-
-      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 'an additional instance with the same hash object' do
-        subject(:additional_person) { Person.new(object, decorators) }
-        it { should_not be person }
-      end
-
-      context 'an instance of the same object without decorators' do
-        subject(:additional_person) { Person.new(object) }
-        it { should_not be person }
-      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
+          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 '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 'decorators' do
+            let(:name) { 'Soren II' }
 
-    end
-  end
+            let(:object) { Person.example.object }
+            subject(:person) { Person.new(object, decorators) }
 
 
-  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
+            context 'as a hash' do
+              let(:decorators) { {name: name} }
+              it do
+                pers = person
+                # binding.pry
+                pers.name.should eq('Soren II')
+              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
+              its(:name) { should be(name) }
 
-  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
+              context 'an additional instance with the equivalent hash' do
+                subject(:additional_person) { Person.new(object, {name: name}) }
+                it { should_not be person }
+              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 'an additional instance with the same hash object' do
+                subject(:additional_person) { Person.new(object, decorators) }
+                it { should_not be person }
+              end
 
-      context 'even when :fields are specified' do
-        let(:render_opts) { {fields: {email: nil, age: nil, address: {street: nil, state: nil}}} }
+              context 'an instance of the same object without decorators' do
+                subject(:additional_person) { Person.new(object) }
+                it { should_not be person }
+              end
+            end
 
-        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
+            context 'as an object' do
+              let(:decorators) { double("decorators", name: name) }
+              its(:name) { should be(name) }
 
-        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
+              context 'an additional instance with the same object' do
+                subject(:additional_person) { Person.new(object, decorators) }
+                it { should_not be person }
+              end
+            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)
+          end
 
-          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
+          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
 
-    context 'with a sub-attribute that is a blueprint' do
+              it 'should raise an error' do
+                expect {
+                  mismatched_reference.attributes
+                }.to raise_error
+              end
 
-      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
+            end
+          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 '.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
 
-    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 '.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 '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 '#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
 
-end
+          end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: praxis-blueprints
 version: !ruby/object:Gem::Version
-  version: 2.0.1
+  version: '2.1'
 platform: ruby
 authors:
 - Josep M. Blanquer
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-08 00:00:00.000000000 Z
+date: 2015-08-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: randexp
@@ -31,14 +31,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: 4.0.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: 4.0.1
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement