attributor 5.0.2 → 5.1.0

data/spec/types/container_spec.rb

@@ -1,49 +1,45 @@
 require File.join(File.dirname(__FILE__), '../spec_helper.rb')
 
-
 describe Attributor::Container do
-
   context '.decode_json' do
-
     let(:mock_type) do
       Class.new do
         include Attributor::Container
         def self.native_type
-          ::Hash   
+          ::Hash
         end
       end
-    end       
+    end
     context 'for valid JSON strings' do
-      it "parses JSON string into the native type" do
-        a_hash = {"a" => 1, "b" => 2}
-        json_hash =  JSON.dump( a_hash )
-        mock_type.decode_json(json_hash).should == a_hash
+      it 'parses JSON string into the native type' do
+        a_hash = { 'a' => 1, 'b' => 2 }
+        json_hash = JSON.dump(a_hash)
+        expect(mock_type.decode_json(json_hash)).to eq a_hash
       end
       it 'complains when trying to decode a non-String value' do
-        expect{ 
+        expect do
           mock_type.decode_json(Object.new)
-        }.to raise_error(Attributor::DeserializationError, /Error deserializing a Object using JSON/)
+        end.to raise_error(Attributor::DeserializationError, /Error deserializing a Object using JSON/)
       end
-      
+
       it 'complains when the deserialized value is not of the native_type' do
-        expect{ 
-          mock_type.decode_json("[1,2,3]")
-        }.to raise_error(Attributor::CoercionError, /Error coercing from Array/)
+        expect do
+          mock_type.decode_json('[1,2,3]')
+        end.to raise_error(Attributor::CoercionError, /Error coercing from Array/)
       end
-      
+
       it 'complains if there is a error deserializing the string' do
-        expect{ 
-          mock_type.decode_json("{invalid_json}")
-        }.to raise_error(Attributor::DeserializationError, /Error deserializing a String using JSON/)
+        expect do
+          mock_type.decode_json('{invalid_json}')
+        end.to raise_error(Attributor::DeserializationError, /Error deserializing a String using JSON/)
       end
-      
+
       it 'uses the passed context in the output error' do
-        expect{ 
-          mock_type.decode_json("{invalid_json}",["my_context","attribute_name"])
-        }.to raise_error(Attributor::DeserializationError, /Error deserializing a String using JSON.* while loading my_context.attribute_name/)
+        expect do
+          mock_type.decode_json('{invalid_json}', %w(my_context attribute_name))
+        end.to raise_error(Attributor::DeserializationError,
+                           /Error deserializing a String using JSON.* while loading my_context.attribute_name/)
       end
-
     end
   end
-  
-end
+end

data/spec/types/csv_spec.rb

@@ -1,7 +1,6 @@
 require File.join(File.dirname(__FILE__), '..', 'spec_helper.rb')
 
 describe Attributor::CSV do
-
   subject!(:csv) { Attributor::CSV.of(Integer) }
 
   context '.load' do
@@ -9,7 +8,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 =~ array
+      expect(csv.load(value)).to match_array array
     end
   end
 
@@ -18,46 +17,46 @@ describe Attributor::CSV do
     let!(:loaded_example) { csv.load(example) }
 
     it 'generates a String example' do
-      example.should be_a(String)
+      expect(example).to be_a(String)
     end
 
     it 'generates a comma-separated list of Integer values' do
-      loaded_example.should be_a(csv)
-      loaded_example.size.should be > 1
-      loaded_example.each { |e| e.should be_a(Integer) }
+      expect(loaded_example).to be_a(csv)
+      expect(loaded_example.size).to be > 1
+      loaded_example.each { |e| expect(e).to be_a(Integer) }
     end
   end
 
   context '.dump' do
     let!(:int_vals) { [1, 2, 3] }
-    let!(:str_vals)  { (0..2).collect { /\w+/.gen} }
+    let!(:str_vals) { (0..2).collect { /\w+/.gen } }
 
     it 'dumps a String value' do
-      csv.dump(int_vals).should be_a(String)
+      expect(csv.dump(int_vals)).to be_a(String)
     end
 
     it 'dumps a comma-separated list of Integers' do
-      csv.dump(int_vals).should eq(int_vals.join(','))
+      expect(csv.dump(int_vals)).to eq(int_vals.join(','))
     end
 
     it 'dumps non-Integer values also' do
-      csv.dump(str_vals).should eq(str_vals.join(','))
+      expect(csv.dump(str_vals)).to eq(str_vals.join(','))
     end
 
     it 'dumps nil values as nil' do
-      csv.dump(nil).should eq(nil)
+      expect(csv.dump(nil)).to eq(nil)
     end
   end
 
   context '.describe' do
-    let(:example){ csv.example }
-    subject(:described){ csv.describe(example: example)}
+    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))
+      expect(described).to have_key(:example)
+      expect(described[:example]).to eq(csv.dump(example))
     end
     it 'ensures no member_attribute key exists from underlying Collection' do
-      described.should_not have_key(:member_attribute)
+      expect(described).not_to have_key(:member_attribute)
     end
   end
 end

data/spec/types/date_spec.rb

@@ -1,11 +1,10 @@
 require File.join(File.dirname(__FILE__), '..', 'spec_helper.rb')
 
 describe Attributor::Date do
-
   subject(:type) { Attributor::Date }
 
   it 'it is not Dumpable' do
-    type.new.is_a?(Attributor::Dumpable).should_not be(true)
+    expect(type.new.is_a?(Attributor::Dumpable)).not_to be(true)
   end
 
   context '.native_type' do
@@ -17,45 +16,40 @@ describe Attributor::Date do
   end
 
   context '.dump' do
-    let(:example) { type.example}
+    let(:example) { type.example }
     subject(:value) { type.dump(example) }
     it 'is formatted correctly' do
-      value.should match(/\d{4}-\d{2}-\d{2}T00:00:00\+00:00/)
+      expect(value).to match(/\d{4}-\d{2}-\d{2}T00:00:00\+00:00/)
     end
     context 'nil values' do
       it 'should be nil' do
-        type.dump(nil).should be_nil
+        expect(type.dump(nil)).to be_nil
       end
     end
   end
 
-
   context '.load' do
-
     it 'returns nil for nil' do
-      type.load(nil).should be(nil)
+      expect(type.load(nil)).to be(nil)
     end
 
     context 'for incoming objects' do
-
-      it "returns correct Date for Time objects" do
+      it 'returns correct Date for Time objects' do
         object = Time.now
         loaded = type.load(object)
-        loaded.should be_a(::Date)
-        loaded.to_date.should == object.to_date
+        expect(loaded).to be_a(::Date)
+        expect(loaded.to_date).to eq object.to_date
       end
 
-      it "returns correct Date for DateTime objects" do
+      it 'returns correct Date for DateTime objects' do
         object = DateTime.now
         loaded = type.load(object)
-        loaded.should be_a(::Date)
-        loaded.should be(object)
+        expect(loaded).to be_a(::Date)
+        expect(loaded).to be(object)
       end
-
     end
 
     context 'for incoming strings' do
-
       [
         '2001-02-03T04:05:06+07:00',
         'Sat, 03 Feb 2001 04:05:06 GMT',
@@ -67,11 +61,9 @@ describe Attributor::Date do
         '2007-10-19T04:11:33Z',
         '2001-02-03T04:05:06+07:00.123456', # custom format with microseconds
       ].each do |value|
-
         it "returns correct Date for #{value.inspect}" do
-          type.load(value).should == Date.parse(value)
+          expect(type.load(value)).to eq Date.parse(value)
         end
-
       end
 
       [
@@ -80,13 +72,11 @@ describe Attributor::Date do
         '2007-10-33T04:11:33Z',
         '2001-02-33T04:05:06+07:00.123456', # custom format with microseconds
       ].each do |value|
-
         it "raises Attributor::AttributorException for #{value.inspect}" do
-          expect {
+          expect do
             type.load(value)
-          }.to raise_error(Attributor::DeserializationError, /Error deserializing a String using Date/)
+          end.to raise_error(Attributor::DeserializationError, /Error deserializing a String using Date/)
         end
-
       end
 
       [
@@ -94,19 +84,12 @@ describe Attributor::Date do
         'foobar',
         'Sat, 30 Feb 2001 04:05:06 FOOBAR', # No such date format exists
       ].each do |value|
-
         it "raises Attributor::AttributorException for #{value.inspect}" do
-          expect {
+          expect do
             type.load(value)
-          }.to raise_error(Attributor::DeserializationError, /Error deserializing a String using Date/)
+          end.to raise_error(Attributor::DeserializationError, /Error deserializing a String using Date/)
         end
-
       end
-
     end
-
   end
-
 end
-
-

data/spec/types/date_time_spec.rb

@@ -1,11 +1,10 @@
 require File.join(File.dirname(__FILE__), '..', 'spec_helper.rb')
 
 describe Attributor::DateTime do
-
   subject(:type) { Attributor::DateTime }
 
   it 'it is not Dumpable' do
-    type.new.is_a?(Attributor::Dumpable).should_not be(true)
+    expect(type.new.is_a?(Attributor::Dumpable)).not_to be(true)
   end
 
   context '.native_type' do
@@ -17,45 +16,40 @@ describe Attributor::DateTime do
   end
 
   context '.dump' do
-    let(:example) { type.example}
+    let(:example) { type.example }
     subject(:value) { type.dump(example) }
     it 'is formatted correctly' do
-      value.should match(/\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}[\+-]\d{2}:\d{2}/)
+      expect(value).to match(/\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}[\+-]\d{2}:\d{2}/)
     end
     context 'nil values' do
       it 'should be nil' do
-        type.dump(nil).should be_nil
+        expect(type.dump(nil)).to be_nil
       end
     end
   end
 
-
   context '.load' do
-
     it 'returns nil for nil' do
-      type.load(nil).should be(nil)
+      expect(type.load(nil)).to be(nil)
     end
 
     context 'for incoming objects' do
-
-      it "returns correct DateTime for Time objects" do
+      it 'returns correct DateTime for Time objects' do
         object = Time.now
         loaded = type.load(object)
-        loaded.should be_a(::DateTime)
-        loaded.to_time.should == object
+        expect(loaded).to be_a(::DateTime)
+        expect(loaded.to_time).to eq object
       end
 
-      it "returns correct DateTime for DateTime objects" do
+      it 'returns correct DateTime for DateTime objects' do
         object = DateTime.now
         loaded = type.load(object)
-        loaded.should be_a(::DateTime)
-        loaded.should be( object )
+        expect(loaded).to be_a(::DateTime)
+        expect(loaded).to be(object)
       end
-
     end
 
     context 'for incoming strings' do
-
       [
         '2001-02-03T04:05:06+07:00',
         'Sat, 03 Feb 2001 04:05:06 GMT',
@@ -67,11 +61,9 @@ describe Attributor::DateTime do
         '2007-10-19T04:11:33Z',
         '2001-02-03T04:05:06+07:00.123456', # custom format with microseconds
       ].each do |value|
-
         it "returns correct DateTime for #{value.inspect}" do
-          type.load(value).should == DateTime.parse(value)
+          expect(type.load(value)).to eq DateTime.parse(value)
         end
-
       end
 
       [
@@ -80,13 +72,11 @@ describe Attributor::DateTime do
         '2007-10-33T04:11:33Z',
         '2001-02-33T04:05:06+07:00.123456', # custom format with microseconds
       ].each do |value|
-
         it "raises Attributor::AttributorException for #{value.inspect}" do
-          expect {
+          expect do
             type.load(value)
-          }.to raise_error(Attributor::DeserializationError, /Error deserializing a String using DateTime/)
+          end.to raise_error(Attributor::DeserializationError, /Error deserializing a String using DateTime/)
         end
-
       end
 
       [
@@ -94,19 +84,12 @@ describe Attributor::DateTime do
         'foobar',
         'Sat, 30 Feb 2001 04:05:06 FOOBAR', # No such date format exists
       ].each do |value|
-
         it "raises Attributor::AttributorException for #{value.inspect}" do
-          expect {
+          expect do
             type.load(value)
-          }.to raise_error(Attributor::DeserializationError, /Error deserializing a String using DateTime/)
+          end.to raise_error(Attributor::DeserializationError, /Error deserializing a String using DateTime/)
         end
-
       end
-
     end
-
   end
-
 end
-
-

data/spec/types/file_upload_spec.rb

@@ -1,6 +1,5 @@
 require File.join(File.dirname(__FILE__), '..', 'spec_helper.rb')
 
-
 describe Attributor::FileUpload do
   it 'has specs'
-end
+end

data/spec/types/float_spec.rb

@@ -1,11 +1,10 @@
 require File.join(File.dirname(__FILE__), '..', 'spec_helper.rb')
 
 describe Attributor::Float do
-
   subject(:type) { Attributor::Float }
 
   it 'it is not Dumpable' do
-    type.new.is_a?(Attributor::Dumpable).should_not be(true)
+    expect(type.new.is_a?(Attributor::Dumpable)).not_to be(true)
   end
 
   context '.native_type' do
@@ -19,7 +18,7 @@ describe Attributor::Float do
       let(:min) { 1 }
       let(:max) { 2 }
 
-      subject(:examples) { (0..100).collect { type.example(options:{min:min, max:max})}}
+      subject(:examples) { (0..100).collect { type.example(options: { min: min, max: max }) } }
 
       its(:min) { should be > min }
       its(:max) { should be < max }
@@ -30,34 +29,31 @@ describe Attributor::Float do
     let(:value) { nil }
 
     it 'returns nil for nil' do
-      type.load(nil).should be(nil)
+      expect(type.load(nil)).to be(nil)
     end
 
     context 'for incoming Float values' do
-
       it 'returns the incoming value' do
         [0.0, -1.0, 1.0, 1e-10].each do |value|
-          type.load(value).should be(value)
+          expect(type.load(value)).to be(value)
         end
       end
     end
 
     context 'for incoming Integer values' do
-
       context 'with an integer value' do
         let(:value) { 1 }
         it 'decodes it if the Integer represents a Float' do
-          type.load(value).should == 1.0
+          expect(type.load(value)).to eq 1.0
         end
       end
     end
 
     context 'for incoming String values' do
-
       context 'that are valid Floats' do
         ['0.0', '-1.0', '1.0', '1e-10'].each do |value|
           it 'decodes it if the String represents a Float' do
-            type.load(value).should == Float(value)
+            expect(type.load(value)).to eq Float(value)
           end
         end
       end
@@ -65,12 +61,11 @@ describe Attributor::Float do
       context 'that are valid Integers' do
         let(:value) { '1' }
         it 'decodes it if the String represents an Integer' do
-          type.load(value).should == 1.0
+          expect(type.load(value)).to eq 1.0
         end
       end
 
       context 'that are not valid Floats' do
-
         context 'with simple alphanumeric text' do
           let(:value) { 'not a Float' }
 
@@ -78,9 +73,7 @@ describe Attributor::Float do
             expect { type.load(value) }.to raise_error(/invalid value/)
           end
         end
-
       end
-
     end
   end
 end