attributor 2.6.1 → 3.0

data/spec/support/models.rb

@@ -40,11 +40,16 @@ class Turducken < Attributor::Model
   end
 end
 
-
 # http://en.wikipedia.org/wiki/Cormorant
 
 class Cormorant < Attributor::Model
   attributes do
+    attribute :name, String, :description => "Name of the Cormorant", :example => /[:name:]/
+    attribute :timestamps do
+      attribute :born_at, DateTime
+      attribute :died_at, DateTime, example: Proc.new {|timestamps| timestamps.born_at + 10}
+    end
+
     # This will be a collection of arbitrary Ruby Objects
     attribute :fish, Attributor::Collection, :description => "All kinds of fish for feeding the babies"
 
@@ -53,7 +58,7 @@ class Cormorant < Attributor::Model
 
     # This will be a collection of instances of an anonymous Struct class, each having two well-defined attributes
 
-    attribute :babies, Attributor::Collection.of(Attributor::Struct), :description => "All the babies", :member_options => {:identity => 'name'} do
+    attribute :babies, Attributor::Collection.of(Attributor::Struct), :description => "All the babies", :member_options => {:identity => :name} do
       attribute :name, Attributor::String, :example => /[:name]/, :description => "The name of the baby cormorant"
       attribute :months, Attributor::Integer, :default => 0, :min => 0, :description => "The age in months of the baby cormorant"
       attribute :weight, Attributor::Float, :example => /\d{1,2}\.\d{3}/, :description => "The weight in kg of the baby cormorant"

data/spec/type_spec.rb

@@ -3,7 +3,7 @@ require File.join(File.dirname(__FILE__), 'spec_helper.rb')
 
 describe Attributor::Type do
 
-  subject(:test_type) do 
+  subject(:test_type) do
     Class.new do
       include Attributor::Type
       def self.native_type
@@ -42,7 +42,7 @@ describe Attributor::Type do
         test_type.load(value).should be(value)
       end
     end
-    
+
     context "when given a value that is of native_type" do
       let(:value) { "one" }
       it 'returns the value' do
@@ -53,7 +53,7 @@ describe Attributor::Type do
     context "when given a value that is not of native_type" do
       let(:value) { 1 }
       let(:context) { ['top','sub'] }
-      
+
       it 'raises an exception' do
         expect { test_type.load(value,context) }.to raise_error( Attributor::IncompatibleTypeError, /cannot load values of type Fixnum.*while loading top.sub/)
       end
@@ -149,6 +149,7 @@ describe Attributor::Type do
   end
 
   context 'describe' do
+    let(:example){ "Foo" }
     subject(:description) { test_type.describe }
     it 'outputs the type name' do
       description[:name].should eq(test_type.name)
@@ -156,6 +157,15 @@ describe Attributor::Type do
     it 'outputs the type id' do
       description[:id].should eq(test_type.name)
     end
+
+    context 'with an example' do
+      subject(:description) { test_type.describe(example: example) }
+      it 'includes it in the :example key' do
+        description.should have_key(:example)
+        description[:example].should be(example)
+      end
+    end
+
   end
 
 end

data/spec/types/collection_spec.rb

@@ -59,7 +59,7 @@ describe Attributor::Collection do
 
   context '.native_type' do
     it "returns Array" do
-      type.native_type.should be(::Array)
+      type.native_type.should be(type)
     end
   end
 
@@ -79,7 +79,6 @@ describe Attributor::Collection do
 
     context 'for invalid JSON strings' do
       [
-        '{}',
         'foobar',
         '2',
         '',
@@ -107,15 +106,21 @@ describe Attributor::Collection do
     end
 
     context 'with unspecified element type' do
+      context 'for nil values' do
+        it 'returns nil' do
+          type.load(nil).should be nil
+        end
+      end
+
       context 'for valid values' do
         [
-          nil,
           [],
           [1,2,3],
           [Object.new, [1,2], nil, true]
         ].each do |value|
           it "returns value when incoming value is #{value.inspect}" do
-            type.load(value).should == value
+
+            type.load(value).should =~ value
           end
         end
       end
@@ -141,7 +146,7 @@ describe Attributor::Collection do
         }.each do |member_type, value|
           it "returns loaded value when member_type is #{member_type} and value is #{value.inspect}" do
             expected_result = value.map {|v| member_type.load(v)}
-            type.of(member_type).load(value).should == expected_result
+            type.of(member_type).load(value).should =~ expected_result
           end
         end
       end
@@ -221,7 +226,7 @@ describe Attributor::Collection do
           ].each do |value|
             it "returns value when incoming value is #{value.inspect}" do
               expected_value = value.map {|v| simple_struct.load(v.clone)}
-              type.of(simple_struct).load(value).should == expected_value
+              type.of(simple_struct).load(value).should =~ expected_value
             end
           end
         end
@@ -244,27 +249,37 @@ describe Attributor::Collection do
   end
 
   context '.validate' do
-    let(:collection_members) { [1, 2, 'three'] }
-    let(:expected_errors) { ["error 1", "error 2", "error 3"]}
-
-    before do
-      collection_members.zip(expected_errors).each do |member, expected_error|
-        type.member_attribute.should_receive(:validate).
-          with(member,an_instance_of(Array)). # we don't care about the exact context here
-          and_return([expected_error])
+    context 'compatible type values' do
+      let(:collection_members) { [1, 2, 'three'] }
+      let(:expected_errors) { ["error 1", "error 2", "error 3"]}
+
+      before do
+        collection_members.zip(expected_errors).each do |member, expected_error|
+          type.member_attribute.should_receive(:validate).
+            with(member,an_instance_of(Array)). # we don't care about the exact context here
+            and_return([expected_error])
+        end
       end
-    end
 
-    it 'validates members' do
-      type.validate(collection_members).should =~ expected_errors
+      it 'validates members' do
+        type.validate(collection_members).should =~ expected_errors
+      end
+    end
+    context 'invalid incoming types' do
+      subject(:type) { Attributor::Collection.of(Integer) }
+      it 'raise an exception' do
+        expect {
+          type.validate('invalid_value')
+        }.to raise_error(Attributor::IncompatibleTypeError, /cannot load values of type String/)
+      end
     end
   end
 
 
   context '.example' do
-    it "returns an Array" do
+    it "returns an instance of the type" do
       value = type.example
-      value.should be_a(::Array)
+      value.should be_a(type)
     end
 
     [
@@ -277,6 +292,7 @@ describe Attributor::Collection do
     ].each do |member_type|
       it "returns an Array of native types of #{member_type}" do
         value = Attributor::Collection.of(member_type).example
+        value.should_not be_empty
         value.all? { |element| member_type.valid_type?(element) }.should be_true
       end
     end
@@ -300,4 +316,35 @@ describe Attributor::Collection do
     end
 
   end
+
+  context '.describe' do
+    let(:type){ Attributor::Collection.of(Attributor::String)}
+    let(:example){ nil }
+    subject(:described){ type.describe(example: example)}
+    it 'includes the member_attribute' do
+      described.should have_key(:member_attribute)
+      described[:member_attribute].should_not have_key(:example)
+    end
+
+    context 'with an example' do
+      let(:example){ type.example }
+      it 'includes the member_attribute with an example from the first member' do
+        described.should have_key(:member_attribute)
+        described[:member_attribute].should have_key(:example)
+        described[:member_attribute].should eq( type.member_attribute.describe(example: example.first ) )
+      end
+    end
+  end
+
+  context 'dumping' do
+    let(:type) { Attributor::Collection.of(Cormorant) }
+
+    subject(:example) { type.example }
+    it 'dumps' do
+      expect {
+        example.dump
+      }.to_not raise_error
+    end
+  end
+
 end

data/spec/types/csv_spec.rb

@@ -9,7 +9,7 @@ describe Attributor::CSV do
     let!(:value) { array.join(',') }
 
     it 'parses the value and returns an array with the right types' do
-      csv.load(value).should eq(array)
+      csv.load(value).should =~ array
     end
   end
 
@@ -22,7 +22,7 @@ describe Attributor::CSV do
     end
 
     it 'generates a comma-separated list of Integer values' do
-      loaded_example.should be_a(Array)
+      loaded_example.should be_a(csv)
       loaded_example.size.should be > 1
       loaded_example.each { |e| e.should be_a(Integer) }
     end
@@ -43,10 +43,21 @@ describe Attributor::CSV do
     it 'dumps non-Integer values also' do
       csv.dump(str_vals).should eq(str_vals.join(','))
     end
-    
+
     it 'dumps nil values as nil' do
       csv.dump(nil).should eq(nil)
     end
   end
 
+  context '.describe' do
+    let(:example){ csv.example }
+    subject(:described){ csv.describe(example: example)}
+    it 'adds a string example if an example is passed' do
+      described.should have_key(:example)
+      described[:example].should eq(csv.dump(example))
+    end
+    it 'ensures no member_attribute key exists from underlying Collection' do
+      described.should_not have_key(:member_attribute)
+    end
+  end
 end

data/spec/types/hash_spec.rb

@@ -9,6 +9,43 @@ describe Attributor::Hash do
   its(:key_type) { should be(Attributor::Object) }
   its(:value_type) { should be(Attributor::Object) }
 
+context 'attributes' do
+    context 'with an exception from the definition block' do
+      subject(:broken_model) do
+        Class.new(Attributor::Model) do
+          attributes do
+            raise 'sorry :('
+            attribute :name, String
+          end
+        end
+      end
+
+      it 'throws original exception upon first run' do
+        lambda {
+          broken_model.attributes
+        }.should raise_error(RuntimeError, 'sorry :(')
+      end
+
+      it 'throws InvalidDefinition for subsequent access' do
+        broken_model.attributes rescue nil
+
+        lambda {
+          broken_model.attributes
+        }.should raise_error(Attributor::InvalidDefinition)
+      end
+
+      it 'throws for any attempts at using of an instance of it' do
+        broken_model.attributes rescue nil
+
+        instance = broken_model.new
+        lambda {
+          instance.name
+        }.should raise_error(Attributor::InvalidDefinition)
+      end
+
+    end
+  end
+
   context 'default options' do
     subject(:options) { type.options }
     it 'has allow_extra false' do
@@ -478,14 +515,15 @@ describe Attributor::Hash do
       let(:example_hash) { {:key => "value"} }
       let(:options) { { example: proc { example_hash } } }
       it 'uses the hash' do
-        attribute.example.should be(example_hash)
+        attribute.example.should eq(example_hash)
       end
     end
 
   end
 
   context '.describe' do
-    subject(:description) { type.describe }
+    let(:example){ nil }
+    subject(:description) { type.describe(example: example) }
     context 'for hashes with key and value types' do
       it 'describes the type correctly' do
         description[:name].should eq('Hash')
@@ -511,12 +549,25 @@ describe Attributor::Hash do
         description[:key].should eq(type:{name: 'String', id: 'Attributor-String', family: 'string'})
         description.should_not have_key(:value)
 
-        keys = description[:keys]
+        attrs = description[:attributes]
+
+        attrs['a string'].should eq(type: {name: 'String', id: 'Attributor-String', family: 'string'} )
+        attrs['1'].should eq(type: {name: 'Integer', id: 'Attributor-Integer', family: 'numeric'}, options: {min: 1, max: 20}  )
+        attrs['some_date'].should eq(type: {name: 'DateTime', id: 'Attributor-DateTime', family: 'temporal'})
+        attrs['defaulted'].should eq(type: {name: 'String', id: 'Attributor-String', family: 'string'}, default: 'default value')
+      end
+
+      context 'with an example' do
+        let(:example){ type.example }
 
-        keys['a string'].should eq(type: {name: 'String', id: 'Attributor-String', family: 'string'} )
-        keys['1'].should eq(type: {name: 'Integer', id: 'Attributor-Integer', family: 'numeric'}, options: {min: 1, max: 20}  )
-        keys['some_date'].should eq(type: {name: 'DateTime', id: 'Attributor-DateTime', family: 'temporal'})
-        keys['defaulted'].should eq(type: {name: 'String', id: 'Attributor-String', family: 'string'}, default: 'default value')
+        it 'should have the matching example for each leaf key' do
+          description[:attributes].keys.should =~ type.keys.keys
+          description[:attributes].each do |name,sub_description|
+            sub_description.should have_key(:example)
+            val = type.attributes[name].dump( example[name] ).to_s
+            sub_description[:example].should eq( val )
+          end
+        end
       end
     end
   end
@@ -613,6 +664,79 @@ describe Attributor::Hash do
     end
   end
 
+  context '.from_hash' do
+
+    context 'without allowing extra keys' do
+      let(:type) do
+        Class.new(Attributor::Hash) do
+          self.value_type = String
+
+          keys do
+            key :one, String
+            key :two, String, default: 'two'
+          end
+        end
+      end
+      subject(:input){ {} }
+      subject(:output) { type.load(input) }
+
+      its(:class){ should be(type) }
+
+      let(:load_context) { "$.some_root" }
+      it 'complains about the extra, with the right context' do
+        expect{
+          type.load( {one: 'one', three: 3} , load_context )
+        }.to raise_error(Attributor::AttributorException,/Unknown key received: :three while loading \$\.some_root.key\(:three\)/)
+      end
+      context 'properly sets them (and loads them) in the created instance' do
+        let(:input){ {one: 'one', two: 2 } }
+
+        its(:keys){ should eq([:one, :two])}
+        its([:one]){ should eq('one') }
+        its([:two]){ should eq('2') } #loaded as a string
+      end
+      context 'properly sets the default values when not passed in' do
+        let(:input){ {one: 'one'} }
+
+        its([:one]){ should eq('one') }
+        its([:two]){ should eq('two') }
+      end
+    end
+
+    context ' allowing extra keys' do
+      context 'at the top level' do
+        let(:type) do
+          Class.new(Attributor::Hash) do
+            keys allow_extra: true do
+              key :one, String
+            end
+          end
+        end
+        let(:input){ {one: 'one', three: 'tres' } }
+        subject(:output) { type.load(input) }
+
+        its(:keys){ should eq([:one,:three])}
+      end
+      context 'inside an :other subkey' do
+        let(:type) do
+          Class.new(Attributor::Hash) do
+            keys allow_extra: true do
+              key :one, String
+              extra :other
+            end
+          end
+        end
+        let(:input){ {one: 'one', three: 'tres' } }
+        subject(:output) { type.load(input) }
+
+        its(:keys){ should =~ [:one,:other] }
+        it 'has the key inside the :other hash' do
+          expect(output[:other]).to eq({three: 'tres'})
+        end
+      end
+    end
+  end
+
   context 'case_insensitive_load option' do
     let(:case_insensitive) { true }
     let(:type) { Attributor::Hash.of(key: String).construct(block, case_insensitive_load: case_insensitive) }
@@ -634,17 +758,17 @@ describe Attributor::Hash do
         output['CamelCase'].should eq(3)
       end
       it 'has loaded the (internal) insensitive_map upon building the definition' do
-        type.definition 
+        type.definition
         type.insensitive_map.should be_kind_of(::Hash)
         type.insensitive_map.keys.should =~ ["downcase","upcase","camelcase"]
       end
     end
-  
+
     context 'when not defined' do
       let(:case_insensitive) { false }
 
       it 'skips the loading of the (internal) insensitive_map' do
-        type.definition 
+        type.definition
         type.insensitive_map.should be_nil
       end
     end