HornsAndHooves-flat_map 0.2.1 → 0.3.0

data/spec/flat_map/mapper/mapping_spec.rb

@@ -31,13 +31,13 @@ module FlatMap
   describe 'Mapping' do
     context 'defining mappings' do
       it "should use Factory for defining mappings" do
-        MappingSpec::EmptyMapper.should_receive(:define_mappings).once.
+        expect(MappingSpec::EmptyMapper).to receive(:define_mappings).once.
           with({:attr_a => :attr_a, :mapped_attr_b => :attr_b}, {:writer => false}).
           and_call_original
-        Mapping::Factory.should_receive(:new).
+        expect(Mapping::Factory).to receive(:new).
                          with(:attr_a, :attr_a, :writer => false).
                          and_call_original
-        Mapping::Factory.should_receive(:new).
+        expect(Mapping::Factory).to receive(:new).
                          with(:mapped_attr_b, :attr_b, :writer => false).
                          and_call_original
 
@@ -48,36 +48,36 @@ module FlatMap
     end
 
     specify 'mapper class should have defined mappings' do
-      MappingSpec::SpecMapper.mappings.size.should == 4
-      MappingSpec::SpecMapper.mappings.all?{ |m| m.is_a?(Mapping::Factory) }.should be true
+      expect(MappingSpec::SpecMapper.mappings.size).to eq 4
+      expect(MappingSpec::SpecMapper.mappings.all?{ |m| m.is_a?(Mapping::Factory) }).to be true
     end
 
     context "for initialized mapper" do
-      let(:target){ MappingSpec::SpecTarget.new('a', 'b', 'c', 'd') }
-      let(:mapper){ MappingSpec::SpecMapper.new(target) }
+      let(:target) { MappingSpec::SpecTarget.new('a', 'b', 'c', 'd') }
+      let(:mapper) { MappingSpec::SpecMapper.new(target) }
 
       it "should be able to access mapping by its name" do
-        mapper.mapping(:mapped_attr_a).should be_a(FlatMap::Mapping)
-        mapper.mapping(:not_defined).should be_nil
+        expect(mapper.mapping(:mapped_attr_a)).to be_a(FlatMap::Mapping)
+        expect(mapper.mapping(:not_defined  )).to be_nil
       end
 
       describe 'reading and writing' do
         it "should be able to read from target via brackets" do
-          mapper[:mapped_attr_a].should == 'a'
+          expect(mapper[:mapped_attr_a]).to eq 'a'
         end
 
         it 'should be able to write to target via brackets' do
           mapper[:attr_b] = 'B'
-          target.attr_b.should == 'B'
+          expect(target.attr_b).to eq 'B'
         end
 
         it '#read should read all mappings to a hash' do
-          mapper.read.should == {
+          expect(mapper.read).to eq({
             :mapped_attr_a => 'a',
             :attr_b        => 'b',
             :attr_c        => 'attr_c-c',
             :mapped_attr_d => 'mapped_attr_d-d'
-          }
+          })
         end
 
         it '#write should assign values using mappings, ignoring invalid ones' do
@@ -87,10 +87,10 @@ module FlatMap
             :attr_c        => 'new-c',
             :mapped_attr_d => 'new-d'
 
-          target.attr_a.should == 'A'
-          target.attr_b.should == 'B'
-          target.attr_c.should == 'NEW-C'
-          target.attr_d.should == 'NEW-D'
+          expect(target.attr_a).to eq 'A'
+          expect(target.attr_b).to eq 'B'
+          expect(target.attr_c).to eq 'NEW-C'
+          expect(target.attr_d).to eq 'NEW-D'
         end
       end
     end

data/spec/flat_map/mapper/mounting_spec.rb

@@ -75,7 +75,7 @@ module FlatMap
 
     context 'defining mountings' do
       it "should use Factory for defining mappings" do
-        Mapper::Factory.should_receive(:new).
+        expect(Mapper::Factory).to receive(:new).
                         with(:foo, :mapper_class_name => 'FooMapper').
                         and_call_original
 
@@ -85,75 +85,75 @@ module FlatMap
     end
 
     describe 'properties' do
-      it{ mapper.hosted?.should be false }
-      it{ mounting.hosted?.should be true }
-      it{ mounting.host.should == mapper }
+      it{ expect(mapper.hosted?  ).to be false }
+      it{ expect(mounting.hosted?).to be true }
+      it{ expect(mounting.host   ).to eq mapper }
     end
 
     it 'should be able to access mapping by name' do
-      mapper.mounting(:spec_mount).should be_a(FlatMap::Mapper)
-      mapper.mounting(:undefined_mount).should be_nil
+      expect(mapper.mounting(:spec_mount     )).to be_a(FlatMap::Mapper)
+      expect(mapper.mounting(:undefined_mount)).to be_nil
     end
 
     describe "#read" do
       it 'should add mounted mappers to a result' do
-        mapper.read.should == {
+        expect(mapper.read).to eq({
           :host_attr     => 'attr',
           :attr_a        => 'a',
           :mapped_attr_b => 'b'
-        }
+        })
       end
 
       it 'should define dynamic writer methods' do
-        mapper.respond_to?(:attr_a).should be true
-        mapper.method(:attr_a).should_not  be nil
+        expect(mapper.respond_to?(:attr_a)).to     be true
+        expect(mapper.method(:attr_a     )).not_to be nil
 
-        mapper.respond_to?(:mapped_attr_b).should be true
-        mapper.method(:mapped_attr_b).should_not  be nil
+        expect(mapper.respond_to?(:mapped_attr_b)).to     be true
+        expect(mapper.method(:mapped_attr_b     )).not_to be nil
       end
     end
 
     describe "#write" do
       it 'should define dynamic writer methods' do
-        mapper.respond_to?(:attr_a=).should be true
-        mapper.method(:attr_a=).should_not  be nil
+        expect(mapper.respond_to?(:attr_a=)).to     be true
+        expect(mapper.method(:attr_a=     )).not_to be nil
 
-        mapper.respond_to?(:mapped_attr_b=).should be true
-        mapper.method(:mapped_attr_b=).should_not  be nil
+        expect(mapper.respond_to?(:mapped_attr_b=)).to     be true
+        expect(mapper.method(:mapped_attr_b=     )).not_to be nil
       end
 
       it 'should pass values to mounted mappers' do
         target = MountingSpec.mount_target
         mapper.write :attr_a => 'A', :mapped_attr_b => 'B'
-        target.attr_a.should == 'A'
-        target.attr_b.should == 'B'
+        expect(target.attr_a).to eq 'A'
+        expect(target.attr_b).to eq 'B'
       end
     end
 
     it 'should delegate missing methods to mounted mappers' do
-      expect{ mapper.a_method.should == 'a value' }.not_to raise_error
+      expect{ expect(mapper.a_method).to eq 'a value' }.not_to raise_error
     end
 
     specify '#before_save_mountings' do
-      mapper.before_save_mountings.should == [mapper.mounting(:spec_mount_before)]
+      expect(mapper.before_save_mountings).to eq [mapper.mounting(:spec_mount_before)]
     end
 
     specify '#after_save_mountings' do
-      mapper.after_save_mountings.should == [mapper.mounting(:spec_mount)]
+      expect(mapper.after_save_mountings).to eq [mapper.mounting(:spec_mount)]
     end
 
     context 'with suffix' do
       let(:mapper){ MountingSuffixSpec::SpecMapper.new(OpenStruct.new) }
       let(:mounting){ mapper.mounting(:mount_foo) }
 
-      it{ mapper.should_not be_suffixed }
-      it{ mounting.should be_suffixed }
+      it{ expect(mapper  ).not_to be_suffixed }
+      it{ expect(mounting).to be_suffixed }
 
       it 'should cascade to nested mappings' do
         mapper.attr_mount_foo  = 'foo'
         mapper.attr_nested_foo = 'bar'
 
-        mapper.read.should include({
+        expect(mapper.read).to include({
           :attr_mount_foo  => 'foo',
           :attr_nested_foo => 'bar' })
       end

data/spec/flat_map/mapper/persistence_spec.rb

@@ -29,21 +29,24 @@ module FlatMap
   describe Mapper::Persistence do
     describe '#target_class' do
       it 'should detect target_class from mapper class name' do
-        PersistenceSpec::TargetClassMapper.target_class.should == PersistenceSpec::TargetClass
+        expect(PersistenceSpec::TargetClassMapper.target_class.ancestors).
+          to include PersistenceSpec::TargetClass
       end
 
       it 'should detect target_class from nearest ancestor when inherited' do
-        PersistenceSpec::InheritedClassMapper.target_class.should == PersistenceSpec::TargetClass
+        expect(PersistenceSpec::InheritedClassMapper.target_class.ancestors).
+          to include PersistenceSpec::TargetClass
       end
 
       it 'should use explicit class name if specified' do
-        PersistenceSpec::ExplicitNameMapper.target_class.should == PersistenceSpec::OtherTargetClass
+        expect(PersistenceSpec::ExplicitNameMapper.target_class.ancestors).
+          to include PersistenceSpec::OtherTargetClass
       end
     end
 
     describe '.build' do
       it 'should use target class to build a new object for mapper' do
-        PersistenceSpec::TargetClassMapper.should_receive(:new).with(kind_of(PersistenceSpec::TargetClass), :used_trait)
+        expect(PersistenceSpec::TargetClassMapper).to receive(:new).with(kind_of(PersistenceSpec::TargetClass), :used_trait)
         PersistenceSpec::TargetClassMapper.build(:used_trait)
       end
     end
@@ -52,8 +55,8 @@ module FlatMap
       let(:target){ PersistenceSpec::TargetClass.new('a', 'b') }
 
       it 'should delegate to target class to find object for mapper' do
-        PersistenceSpec::TargetClass.should_receive(:find).with(1).and_return(target)
-        PersistenceSpec::TargetClassMapper.should_receive(:new).with(target, :used_trait)
+        expect(PersistenceSpec::TargetClass).to receive(:find).with(1).and_return(target)
+        expect(PersistenceSpec::TargetClassMapper).to receive(:new).with(target, :used_trait)
         PersistenceSpec::TargetClassMapper.find(1, :used_trait)
       end
     end
@@ -63,35 +66,35 @@ module FlatMap
       let(:mapper){ PersistenceSpec::TargetClassMapper.new(target){} }
 
       specify '#model_name' do
-        mapper.model_name.should == 'mapper'
+        expect(mapper.model_name).to eq 'mapper'
       end
 
       specify '#to_key should delegate to target' do
-        target.should_receive(:to_key).and_return(1)
-        mapper.to_key.should == 1
+        expect(target).to receive(:to_key).and_return(1)
+        expect(mapper.to_key).to eq 1
       end
 
       specify '#persisted? when target does not respond to :persised?' do
-        mapper.should_not be_persisted
+        expect(mapper).not_to be_persisted
       end
 
       specify '#persisted? when target responds to :persisted?' do
-        target.stub(:persisted?).and_return(true)
-        mapper.should be_persisted
+        expect(target).to receive(:persisted?).and_return(true)
+        expect(mapper).to be_persisted
       end
 
       specify '#id when target does not respond to :id' do
-        mapper.id.should be_nil
+        expect(mapper.id).to be_nil
       end
 
       specify '#id when target responds to :id' do
-        target.stub(:id).and_return(1)
-        mapper.id.should == 1
+        expect(target).to receive(:id).and_return(1)
+        expect(mapper.id).to eq 1
       end
 
       describe '#write with multiparams' do
         let(:params) {{
-          'attr_a'     => 'A',
+          'attr_a'  => 'A',
           'dob(0i)' => '1999',
           'dob(1i)' => '01',
           'dob(2i)' => '02'
@@ -99,23 +102,23 @@ module FlatMap
 
         it 'should assign values properly' do
           mapper.write(params)
-          target.attr_a.should == 'A'
-          target.attr_b.should == Date.new(1999, 1, 2)
+          expect(target.attr_a).to eq 'A'
+          expect(target.attr_b).to eq Date.new(1999, 1, 2)
         end
       end
 
       describe '#save_target' do
         it 'should return true for owned mappers' do
-          mapper.extension.save_target.should be true
+          expect(mapper.extension.save_target).to eq true
         end
 
         it 'should return true if target does not respond to #save' do
-          mapper.save_target.should be true
+          expect(mapper.save_target).to eq true
         end
 
         it 'should save with no validation if target responds to #save' do
-          target.should_receive(:save).with(:validate => false).and_return(true)
-          mapper.save_target.should be true
+          expect(target).to receive(:save).with(:validate => false).and_return(true)
+          expect(mapper.save_target).to eq true
         end
       end
 
@@ -123,28 +126,28 @@ module FlatMap
         let(:params){{ :attr_a => 'A' }}
 
         it 'should write params first' do
-          mapper.should_receive(:write).with(params)
-          ActiveRecord::Base.should_receive(:transaction).and_yield
+          expect(mapper).to receive(:write).with(params)
+          expect(ActiveRecord::Base).to receive(:transaction).and_yield
           mapper.apply(params)
         end
 
         it 'should not save if not valid' do
-          mapper.stub(:valid?).and_return(false)
-          mapper.should_not_receive(:save)
+          expect(mapper).to receive(:valid?).and_return(false)
+          expect(mapper).not_to receive(:save)
           mapper.apply(params)
         end
 
         it 'should save if valid' do
-          mapper.stub(:valid?).and_return(true)
-          ActiveRecord::Base.should_receive(:transaction).and_yield
-          mapper.should_receive(:save)
+          expect(mapper).to receive(:valid?).and_return(true)
+          expect(ActiveRecord::Base).to receive(:transaction).and_yield
+          expect(mapper).to receive(:save)
           mapper.apply(params)
         end
       end
 
       specify '#shallow_save saves target in a save callbacks' do
-        mapper.should_receive(:run_callbacks).with(:save).and_yield
-        mapper.should_receive(:save_target)
+        expect(mapper).to receive(:run_callbacks).with(:save).and_yield
+        expect(mapper).to receive(:save_target)
         mapper.shallow_save
       end
     end

data/spec/flat_map/mapper/skipping_spec.rb

@@ -28,22 +28,22 @@ module FlatMap
     before{ mapper.trait(:with_trait).skip! }
 
     it 'should completely ignore skipped mounting' do
-      mapper.should be_valid
-      mapper.save.should be true
-      mapper.attr_a.should be_nil
-      mapper.attr_b.should be_nil
+      expect(mapper       ).to be_valid
+      expect(mapper.save  ).to be true
+      expect(mapper.attr_a).to be_nil
+      expect(mapper.attr_b).to be_nil
     end
 
     it '#use! should enable skipped mounting' do
       mapper.trait(:with_trait).use!
 
-      mapper.should_not be_valid
-      mapper.attr_a.should == 'a'
-      mapper.errors[:attr_a].should be_present
+      expect(mapper).not_to be_valid
+      expect(mapper.attr_a).to eq 'a'
+      expect(mapper.errors[:attr_a]).to be_present
 
       mapper.attr_a = 5
       mapper.save
-      mapper.attr_b.should == 'b'
+      expect(mapper.attr_b).to eq 'b'
     end
   end
 
@@ -51,39 +51,40 @@ module FlatMap
     let(:target){ OpenStruct.new }
     let(:mapper){ SkippingSpec::SpecMapper.new(target, :with_trait) }
 
-    before{ target.stub(:is_a?).with(ActiveRecord::Base).and_return(true) }
+    before{ expect(target).
+        to receive(:is_a?).at_least(1).times.with(ActiveRecord::Base).and_return(true) }
 
     context 'for new record' do
       before do
-        target.stub(:new_record?).and_return(true)
+        expect(target).to receive(:new_record?).at_least(1).times.and_return(true)
         mapper.trait(:with_trait).skip!
       end
 
       specify '#skip! should set ivar @destroyed to true' do
-        target.instance_variable_get('@destroyed').should be true
+        expect(target.instance_variable_get('@destroyed')).to be true
       end
 
       specify '#use! should set ivar @destroyed to true' do
         mapper.trait(:with_trait).use!
-        target.instance_variable_get('@destroyed').should be false
+        expect(target.instance_variable_get('@destroyed')).to be false
       end
     end
 
     context 'for persisted record' do
       before do
-        target.stub(:new_record?).and_return(false)
+        expect(target).to receive(:new_record?).at_least(1).times.and_return(false)
       end
 
       specify '#skip! should reload persisted record' do
-        target.should_receive(:reload)
+        expect(target).to receive(:reload)
         mapper.trait(:with_trait).skip!
       end
 
       specify '#use! should use all nested mountings' do
         mapper.trait(:with_trait).skip!
         mock = double('mounting')
-        mock.should_receive(:use!)
-        mapper.trait(:with_trait).stub(:all_nested_mountings).and_return([mock])
+        expect(mock).to receive(:use!)
+        expect(mapper.trait(:with_trait)).to receive(:all_nested_mountings).and_return([mock])
         mapper.trait(:with_trait).use!
       end
     end

data/spec/flat_map/mapper/targeting_spec.rb

@@ -29,24 +29,23 @@ module FlatMap
   describe 'Working with Target' do
     describe '#target_class' do
       it 'should detect target_class from mapper class name' do
-        ModelMethodsSpec::TargetClassMapper.target_class.should == ModelMethodsSpec::TargetClass
+        expect(ModelMethodsSpec::TargetClassMapper.target_class).to eq ModelMethodsSpec::TargetClass
       end
 
       it 'should detect target_class from nearest ancestor when inherited' do
-        ModelMethodsSpec::InheritedClassMapper.target_class.
-                                               should == ModelMethodsSpec::TargetClass
+        expect(ModelMethodsSpec::InheritedClassMapper.target_class.ancestors).
+          to include ModelMethodsSpec::TargetClass
       end
 
       it 'should use explicit class name if specified' do
-        ModelMethodsSpec::ExplicitNameMapper.target_class.
-                                             should == ModelMethodsSpec::OtherTargetClass
+        expect(ModelMethodsSpec::ExplicitNameMapper.target_class.ancestors).
+          to include ModelMethodsSpec::OtherTargetClass
       end
     end
 
     describe '.build' do
       it 'should use target class to build a new object for mapper' do
-        ModelMethodsSpec::TargetClassMapper.
-          should_receive(:new).
+        expect(ModelMethodsSpec::TargetClassMapper).to receive(:new).
           with(kind_of(ModelMethodsSpec::TargetClass), :used_trait)
         ModelMethodsSpec::TargetClassMapper.build(:used_trait)
       end
@@ -56,8 +55,8 @@ module FlatMap
       let(:target){ ModelMethodsSpec::TargetClass.new('a', 'b') }
 
       it 'should delegate to target class to find object for mapper' do
-        ModelMethodsSpec::TargetClass.should_receive(:find).with(1).and_return(target)
-        ModelMethodsSpec::TargetClassMapper.should_receive(:new).with(target, :used_trait)
+        expect(ModelMethodsSpec::TargetClass).to receive(:find).with(1).and_return(target)
+        expect(ModelMethodsSpec::TargetClassMapper).to receive(:new).with(target, :used_trait)
         ModelMethodsSpec::TargetClassMapper.find(1, :used_trait)
       end
     end
@@ -67,30 +66,30 @@ module FlatMap
       let(:mapper){ ModelMethodsSpec::TargetClassMapper.new(target){} }
 
       specify '#model_name' do
-        mapper.model_name.should == 'mapper'
+        expect(mapper.model_name).to eq 'mapper'
       end
 
       specify '#to_key should delegate to target' do
-        target.should_receive(:to_key).and_return(1)
-        mapper.to_key.should == 1
+        expect(target).to receive(:to_key).and_return(1)
+        expect(mapper.to_key).to eq 1
       end
 
       specify '#persisted? when target does not respond to :persised?' do
-        mapper.should_not be_persisted
+        expect(mapper).not_to be_persisted
       end
 
       specify '#persisted? when target responds to :persisted?' do
-        target.stub(:persisted?).and_return(true)
-        mapper.should be_persisted
+        expect(target).to receive(:persisted?).and_return(true)
+        expect(mapper).to be_persisted
       end
 
       specify '#id when target does not respond to :id' do
-        mapper.id.should be_nil
+        expect(mapper.id).to be_nil
       end
 
       specify '#id when target responds to :id' do
-        target.stub(:id).and_return(1)
-        mapper.id.should == 1
+        expect(target).to receive(:id).and_return(1)
+        expect(mapper.id).to eq 1
       end
 
       describe '#write with multiparams' do
@@ -103,23 +102,23 @@ module FlatMap
 
         it 'should assign values properly' do
           mapper.write(params)
-          target.attr_a.should == 'A'
-          target.attr_b.should == Date.new(1999, 1, 2)
+          expect(target.attr_a).to eq 'A'
+          expect(target.attr_b).to eq Date.new(1999, 1, 2)
         end
       end
 
       describe '#save_target' do
         it 'should return true for owned mappers' do
-          mapper.extension.save_target.should be true
+          expect(mapper.extension.save_target).to be true
         end
 
         it 'should return true if target does not respond to #save' do
-          mapper.save_target.should be true
+          expect(mapper.save_target).to be true
         end
 
         it 'should save with no validation if target responds to #save' do
-          target.should_receive(:save).with(:validate => false).and_return(true)
-          mapper.save_target.should be true
+          expect(target).to receive(:save).with(:validate => false).and_return(true)
+          expect(mapper.save_target).to be true
         end
       end
 
@@ -127,28 +126,28 @@ module FlatMap
         let(:params){{ :attr_a => 'A' }}
 
         it 'should write params first' do
-          mapper.should_receive(:write).with(params)
-          ActiveRecord::Base.should_receive(:transaction).and_yield
+          expect(mapper).to receive(:write).with(params)
+          expect(ActiveRecord::Base).to receive(:transaction).and_yield
           mapper.apply(params)
         end
 
         it 'should not save if not valid' do
-          mapper.stub(:valid?).and_return(false)
-          mapper.should_not_receive(:save)
+          expect(mapper).to     receive(:valid?).and_return(false)
+          expect(mapper).not_to receive(:save)
           mapper.apply(params)
         end
 
         it 'should save if valid' do
-          mapper.stub(:valid?).and_return(true)
-          ActiveRecord::Base.should_receive(:transaction).and_yield
-          mapper.should_receive(:save)
+          expect(mapper).to receive(:valid?).and_return(true)
+          expect(ActiveRecord::Base).to receive(:transaction).and_yield
+          expect(mapper).to receive(:save)
           mapper.apply(params)
         end
       end
 
       specify '#shallow_save saves target in a save callbacks' do
-        mapper.should_receive(:run_callbacks).with(:save).and_yield
-        mapper.should_receive(:save_target)
+        expect(mapper).to receive(:run_callbacks).with(:save).and_yield
+        expect(mapper).to receive(:save_target)
         mapper.shallow_save
       end
     end