praxis-blueprints 1.2.0 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cc026836ebcbda29b7cba8d4a0bfae53b450969b
-  data.tar.gz: 42b68fb6981428da9acaf054507b16ce00606633
+  metadata.gz: 48fb0aab37d8848325be498e9e89221ce803cdfe
+  data.tar.gz: 3bb509c2daadb670527d0cf43e9b919573273059
 SHA512:
-  metadata.gz: 11162b7589b516b84585df4d074123065ba5017ee712993c9bea8c17e2d19d598059a00c54a6dd01e7c0eab4f097041d9753f6da37d96368986d72c346431c26
-  data.tar.gz: 96cb3ccf1238acec2e3b0a41456fe9cd0e965e4103000920d1b2486b8aa762bfd3cf6058678c8058eaa9e488eb0be39208d29c17e8a670737469225b9f21e47e
+  metadata.gz: 83cfc54c0609a7586f4961ebb698b87018c3e1f0a191de3e9f0db4b2bed0eac9cea58a828dd7b2c151448ec3e5fb7f224fe76810107969685d6314d8b657f2d7
+  data.tar.gz: f18a5b85e4b17b104912910725a647ce9886c2cede2c617e313a1eb185de73c785af265bc2ce5ef9d805889fbdfa911d7887b335a9778dbf34ea938e3e8a95fd

data/CHANGELOG.md

@@ -1,6 +1,14 @@
 # praxis-blueprints changelog
 
-## next
+## next 
+
+## 1.3.0
+
+* Added `include_nil` option to `View` for refining the rendering of nil values. 
+  * This can be set when defining the view with `Blueprint.view`, and defaults to false. For example: `view :default, include_nil: true { ... }`.
+* Fixed `Blueprint.describe` to output the proper `:id`. That is: the 'id` from the Class name, rather than the internal Struct attribute.
+* Fixed `Blueprint.dump(nil)` raising a `NoMethodError`
+* Fixed `Blueprint.load(nil)` to properly support the `recurse` option.
 
 ## 1.2.0
 

data/lib/praxis-blueprints/blueprint.rb

@@ -3,6 +3,7 @@ require 'ostruct'
 # Blueprint ==
 #   - part implementation definition for attributes
 #   - part container for views
+
 module Praxis
   class Blueprint
     include Attributor::Type
@@ -56,14 +57,14 @@ module Praxis
     def self.describe(shallow=false)
       type_name = self.ancestors.find { |k| k.name && !k.name.empty? }.name
 
-      description = self.attribute.type.describe(shallow).merge!(name: type_name)
+      description = self.attribute.type.describe(shallow).merge!(id: self.id, name: type_name)
 
       unless shallow
         description[:views] = self.views.each_with_object({}) do |(view_name, view), hash|
           hash[view_name] = view.describe
         end
       end
-      
+
       description
     end
 
@@ -110,11 +111,14 @@ module Praxis
 
     def self.load(value,context=Attributor::DEFAULT_ROOT_CONTEXT, **options)
       case value
-      when nil, self
+      when self
         value
-      when Hash, String
+      when nil, Hash, String
         # Need to parse/deserialize first
-        self.new(self.attribute.load(value,context, **options))
+        # or apply default/recursive loading options if necessary
+        if (value = self.attribute.load(value,context, **options))
+          self.new(value)
+        end
       else
         # Just wrap whatever value
         self.new(value)
@@ -171,59 +175,19 @@ module Praxis
     end
 
 
-    def self.view(name, &block)
+    def self.view(name, **options, &block)
       if block_given?
-        return self.views[name] = View.new(name, self, &block)
+        return self.views[name] = View.new(name, self, **options, &block)
       end
 
       self.views[name]
     end
 
     def self.dump(object, view: :default, context: Attributor::DEFAULT_ROOT_CONTEXT, **opts)
-      object = self.load(object, context)
-      object.render(view, context: context)
-    end
-
-
-    def initialize(object, decorators=nil)
-      # TODO: decide what sort of type checking (if any) we want to perform here.
-      @object = object
-      @decorators = if decorators.kind_of?(Hash) && decorators.any?
-        OpenStruct.new(decorators)
-      else
-        decorators
-      end
-      @rendered_views = {}
-      @validating = false
-
-      # OPTIMIZE: revisit the circular rendering tracking.
-      #           removing this results in a significant performance
-      #           and memory use savings.
-      @active_renders = []
-    end
-
-
-    # Render the wrapped data with the given view
-    def render(view_name=:default, context: Attributor::DEFAULT_ROOT_CONTEXT)
-      unless (view = self.class.views[view_name])
-        raise "view with name '#{view_name.inspect}' is not defined in #{self.class}"
-      end
+      object = self.load(object, context, **opts)
+      return nil if object.nil?
 
-      return @rendered_views[view_name] if @rendered_views.has_key? view_name
-      return CIRCULAR_REFERENCE_MARKER if @active_renders.include?(view_name)
-      @active_renders << view_name
-
-      @rendered_views[view_name] = view.dump(self, context: context)
-    ensure
-      @active_renders.delete view_name
-    end
-
-
-    alias_method :to_hash, :render
-
-
-    def dump(view: :default, context: Attributor::DEFAULT_ROOT_CONTEXT)
-      self.render(view, context: context)
+      object.render(view, context: context)
     end
 
     # Internal finalize! logic
@@ -256,46 +220,23 @@ module Praxis
 
 
     def self.define_reader!(name)
-      attribute = self.attributes[name]
-      if attribute.type < Praxis::Blueprint
-        define_blueprint_reader!(name)
-      else
-        define_direct_reader!(name)
-      end
-    end
-
-    def self.define_blueprint_reader!(name)
-      # it's faster to use define_method in this case than module_eval
-      # because we save the attribute lookup on every access.
-      attribute = self.attributes[name]
-      define_method(name) do
-       if @decorators && @decorators.respond_to?(name)
-         @decorators.send(name)
-       else
-         value = @object.send(name)
-         return value if value.nil? || value.kind_of?(attribute.type)
-         attribute.type.load(value)
-       end
-      end
-    end
-
-    def self.define_direct_reader!(name)
       attribute = self.attributes[name]
       # TODO: profile and optimize
-      # because we use the attribute in the reader, 
-      # it's likely faster to use define_method here 
+      # because we use the attribute in the reader,
+      # it's likely faster to use define_method here
       # than module_eval, but we should make sure.
       define_method(name) do
-       if @decorators && @decorators.respond_to?(name)
-         @decorators.send(name)
-       else
-         value = @object.__send__(name)
-         return value if value.nil? || value.kind_of?(attribute.type)
-         attribute.load(value)
-       end
+        if @decorators && @decorators.respond_to?(name)
+          @decorators.send(name)
+        else
+          value = @object.__send__(name)
+          return value if value.nil? || value.kind_of?(attribute.type)
+          attribute.load(value)
+        end
       end
     end
 
+
     def self.generate_master_view!
       attributes = self.attributes
       view :master do
@@ -308,6 +249,46 @@ module Praxis
     end
 
 
+    def initialize(object, decorators=nil)
+      # TODO: decide what sort of type checking (if any) we want to perform here.
+      @object = object
+      @decorators = if decorators.kind_of?(Hash) && decorators.any?
+        OpenStruct.new(decorators)
+      else
+        decorators
+      end
+      @rendered_views = {}
+      @validating = false
+
+      # OPTIMIZE: revisit the circular rendering tracking.
+      #           removing this results in a significant performance
+      #           and memory use savings.
+      @active_renders = []
+    end
+
+
+    # Render the wrapped data with the given view
+    def render(view_name=:default, context: Attributor::DEFAULT_ROOT_CONTEXT)
+      unless (view = self.class.views[view_name])
+        raise "view with name '#{view_name.inspect}' is not defined in #{self.class}"
+      end
+
+      return @rendered_views[view_name] if @rendered_views.has_key? view_name
+      return CIRCULAR_REFERENCE_MARKER if @active_renders.include?(view_name)
+      @active_renders << view_name
+
+      @rendered_views[view_name] = view.dump(self, context: context)
+    ensure
+      @active_renders.delete view_name
+    end
+    alias_method :to_hash, :render
+
+
+    def dump(view: :default, context: Attributor::DEFAULT_ROOT_CONTEXT)
+      self.render(view, context: context)
+    end
+
+
     def validate(context=Attributor::DEFAULT_ROOT_CONTEXT)
       raise ArgumentError, "Invalid context received (nil) while validating value of type #{self.name}" if context == nil
       context = [context] if context.is_a? ::String
@@ -328,7 +309,6 @@ module Praxis
       @validating = false
     end
 
-
   end
 
 end

data/lib/praxis-blueprints/version.rb

@@ -1,3 +1,3 @@
 module Praxis
-  BLUEPRINTS_VERSION = "1.2.0"
+  BLUEPRINTS_VERSION = "1.3.0"
 end

data/lib/praxis-blueprints/view.rb

@@ -1,16 +1,24 @@
 module Praxis
 
   class View
-    attr_reader :schema, :contents, :name
+    attr_reader :schema
+    attr_reader :contents
+    attr_reader :name
+    attr_reader :options
 
+    attr_reader :include_nil
 
-    def initialize(name, schema, &block)
+    def initialize(name, schema, **options, &block)
       @name = name
       @schema = schema
       @contents = ::Hash.new
       @block = block
-    end
 
+      @include_nil = options.fetch(:include_nil, false)
+
+      @options = options
+
+    end
 
     def contents
       if @block
@@ -23,15 +31,22 @@ module Praxis
 
 
     def dump(object, context: Attributor::DEFAULT_ROOT_CONTEXT,**opts)
+
       self.contents.each_with_object({}) do |(name, (dumpable, dumpable_opts)), hash|
-        next unless object.respond_to?(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
-        next if value.nil?
+
+        if value.nil?
+          next unless @include_nil
+        end
         
         # FIXME: this is such an ugly way to do this. Need attributor#67.
         if dumpable.kind_of?(View) || dumpable.kind_of?(CollectionView)

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

data/spec/praxis-blueprints/blueprint_spec.rb

@@ -117,21 +117,25 @@ describe Praxis::Blueprint do
 
     context 'wrapping an object' do
 
-      let(:resource) do
-        double("resource",
-               name: 'Bob',
-               full_name: FullName.example,
-               address: Address.example,
-               email: "bob@example.com",
-               aliases: [],
-               prior_addresses: [],
-               parents: double('parents', father: /[:first_name:]/.gen, mother: /[:first_name:]/.gen),
-               href: "www.example.com",
-               alive: true)
+      let(:data) do
+        {
+          name: 'Bob',
+          full_name: FullName.example,
+          address: Address.example,
+          email: "bob@example.com",
+          aliases: [],
+          prior_addresses: [],
+          parents: { father: /[:first_name:]/.gen, mother: /[:first_name:]/.gen},
+          href: "www.example.com",
+          alive: true
+        }
       end
 
+      let(:resource) { blueprint_class.load(data).object }
+
       subject(:blueprint_instance) { blueprint_class.new(resource) }
 
+
       it_behaves_like 'a blueprint instance'
 
       context 'creating additional blueprint instances from that object' do
@@ -153,7 +157,7 @@ describe Praxis::Blueprint do
             blueprint_class.cache[resource].should be(blueprint_instance)
           end
         end
-      
+
         context 'with caching disabled' do
           it { should_not be blueprint_instance }
         end
@@ -164,7 +168,29 @@ describe Praxis::Blueprint do
 
   end
 
+  context '.describe' do
+    before do
+      expect(blueprint_class.attribute.type).to receive(:describe).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)
+      end
+    end
 
+    context 'for shallow descriptions' do
+      it 'should not include views' do
+        blueprint_class.describe(true).key?(:views).should be(false)
+      end
+    end
+  end
   context '.validate' do
     let(:hash) { {name: 'bob'} }
     let(:person) { Person.load(hash) }
@@ -179,150 +205,149 @@ 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
-
-
- context 'with a provided :reference option on attributes' do
-   context 'that does not match the value set on the class' do
-
-     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
-
-   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 '#render' do
-  let(:person) { Person.example }
-  let(:view_name) { :default }
-  subject(:output) { person.render(view_name) }
-
-  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_name, context: ['special_root'])
-      }.to raise_error(/Error while dumping attribute state of type Address for context special_root.address. Reason: .*Kaboom/)
+    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 '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)
+    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
 
- 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
+
+
+  context 'with a provided :reference option on attributes' do
+    context 'that does not match the value set on the class' do
+
+      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
+
+    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 '#render' do
+    let(:person) { Person.example }
+    let(:view_name) { :default }
+    subject(:output) { person.render(view_name) }
+
+    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_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
+
+  end
 
 end

data/spec/praxis-blueprints/view_spec.rb

@@ -15,14 +15,83 @@ describe Praxis::View do
 
   subject(:output) { view.to_hash(person) }
 
-  
+
   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
+    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
+
+      subject(:output) { view.to_hash(person) }
+
+      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
+
+    end
+
+  
+  end
+
+
+
   context 'direct attributes' do
+
+    let(:person) { Person.load(person_data) }
     context 'with undisputably existing values' do
-      let(:person) { OpenStruct.new(:name=>'somename', :alive=>true)}
+
+      let(:person_data) { {name:'somename', alive:true} }
+
       let(:expected_output) do
         {
           :name => 'somename',
@@ -34,10 +103,11 @@ describe Praxis::View do
       end
     end
     context 'with nil values' do
-      let(:person) { OpenStruct.new(:name=>'alive_is_nil', :alive=>nil)}
+      let(:person_data) { {name:'alive_is_nil', alive: nil} }
       let(:expected_output) do
         {
-          :name => 'alive_is_nil'
+          name: 'alive_is_nil',
+          alive: true
         }
       end
       it 'are skipped completely' do
@@ -46,7 +116,7 @@ describe Praxis::View do
     end
 
     context 'with false values' do
-      let(:person) { OpenStruct.new(:name=>'alive_is_false', :alive=>false)}
+      let(:person_data) { {name:'alive_is_false', alive:false} }
       let(:expected_output) do
         {
           :name => 'alive_is_false',
@@ -181,10 +251,8 @@ describe Praxis::View do
     end
 
     context 'when the related object is nil (does not respond to the related method)' do
-      let(:resource) { OpenStruct.new(name: "Bob") }
-      let(:person) { Person.new(resource) }
+      let(:person) { Person.load(name: 'Bob') }
 
-      
       let(:view) do
         Praxis::View.new(:default, Person) do
           attribute :name
@@ -242,7 +310,7 @@ describe Praxis::View do
     end
 
   end
- 
+
 
   context '#describe' do
     subject(:description) { view.describe}
@@ -250,7 +318,7 @@ describe Praxis::View do
     its([:type]) { should eq(:standard) }
     context 'returns attributes' do
       subject { description[:attributes] }
-      
+
       its(:keys){ should == [:name,:alive,:address]  }
 
       it 'should return empty hashes for attributes with no specially defined view' do
@@ -263,4 +331,4 @@ describe Praxis::View do
     end
   end
 
-end
+end

data/spec/support/spec_blueprints.rb

@@ -3,7 +3,9 @@ class Person < Praxis::Blueprint
   attributes do
     attribute :name, String, example: /[:first_name:]/
     attribute :email, String, example: proc { |person| "#{person.name}@example.com" }
-    
+
+    attribute :age, Integer
+
     attribute :full_name, FullName
     attribute :aliases, Attributor::Collection.of(FullName)
 
@@ -36,10 +38,17 @@ class Person < Praxis::Blueprint
   view :extended do
     attribute :name
     attribute :full_name
+    attribute :age
     attribute :address
     attribute :alive
   end
 
+  view :with_unset, include_unset: true  do
+    attribute :name
+    attribute :email
+    attribute :age
+  end
+
 end
 
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: praxis-blueprints
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.3.0
 platform: ruby
 authors:
 - Josep M. Blanquer
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-11 00:00:00.000000000 Z
+date: 2015-03-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: randexp
@@ -31,14 +31,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2'
+        version: '2.6'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2'
+        version: '2.6'
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement