HornsAndHooves-flat_map 0.2.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 1f3b82b7ae0f88b1c76017b5ac2410dee62efeed
-  data.tar.gz: 5f72a1ca80df379ddfd7dfeb22b8b8d1530c8b0f
+SHA256:
+  metadata.gz: 7902561902733c34e2f37b66ae25ed17fded33ff38f6f0f013630137a87eacb6
+  data.tar.gz: ba3167200d89dad368a42d23dbe4bebcfc147f15879ef8a78835a609127aa20c
 SHA512:
-  metadata.gz: 62115ee9279c68f7ed109ed43b769fb28669d9f6a3c884d69fb8680e41cc20b2139f2993578b73a9b79a924de5d790bde331755190d6f6fbd77467c3ad40f511
-  data.tar.gz: 50f70f29acdc63ba0de90725f79694e877ca983dcd84bea897e9defa9c7463fcff6dd62ee48233e7981d55eae9e50735ec4ad23905c071f7d2a5f69ec29e558c
+  metadata.gz: 44f53062529bafb8ae96504dbaa6576e6e44c453749a01012c37a723726aa459a31f1f097e3e364a47ad1453d1609e1da7e87099d4cd27d0f2a2d8f365463bff
+  data.tar.gz: 5d8861f359ea9c460e0cbac177726143cf87b4d18299f43052a845fb0c74faf2aef483e828bbd7be06160a5d9c7719c6cd55c64c505f0a9d99fede9bf142feaa

data/.ruby-version

@@ -1 +1 @@
-2.1.2
+2.6.6

data/Gemfile

@@ -3,19 +3,16 @@ source "https://rubygems.org"
 # Specify your gem's dependencies in flat_map.gemspec
 gemspec
 
-group :development do
-  gem 'redcarpet'
-  gem 'yard'
-end
+gem "activerecord"
+gem "activesupport"
 
-group :development, :test do
-  # code metrics:
-  gem "metric_fu"
-  gem "pry"
-end
+gem 'redcarpet'
+gem 'yard'
 
-group :test do
-  gem 'colorize'           , :require => false
-  gem 'simplecov'          , :require => false
-  gem 'simplecov-rcov-text', :require => false
-end
+# code metrics:
+gem "metric_fu"
+gem "pry"
+
+gem 'colorize'           , :require => false
+gem 'simplecov'          , :require => false
+gem 'simplecov-rcov-text', :require => false

data/HornsAndHooves-flat_map.gemspec

@@ -5,8 +5,8 @@ require "flat_map/version"
 Gem::Specification.new do |s|
   s.name        = "HornsAndHooves-flat_map"
   s.version     = FlatMap::VERSION
-  s.authors     = ["HornsAndHooves", "Artem Kuzko", "Zachary Belzer", "Sergey Potapov"]
-  s.email       = ["a.kuzko@gmail.com", "zbelzer@gmail.com", "blake131313@gmail.com"]
+  s.authors     = ["HornsAndHooves", "Artem Kuzko", "Zachary Belzer", "Sergey Potapov", "Bruce Burdick"]
+  s.email       = ["a.kuzko@gmail.com", "zbelzer@gmail.com", "blake131313@gmail.com", "rubygems.org@bruceburdick.com"]
   s.homepage    = "https://github.com/HornsAndHooves/flat_map"
   s.licenses    = ["LICENSE"]
   s.summary     = %q{Deep object graph to a plain properties mapper}
@@ -19,11 +19,11 @@ Gem::Specification.new do |s|
   s.require_paths = ["lib"]
 
   # specify any dependencies here; for example:
-  s.add_dependency(%q<activesupport>, ["~> 4.0.5"])
-  s.add_dependency(%q<activerecord>, ["~> 4.0.5"])
-  s.add_dependency(%q<yard>, [">= 0"])
+  s.add_dependency "activesupport", ">= 5", "< 7.0.0"
+  s.add_dependency "activerecord", ">= 5", "< 7.0.0"
+  s.add_dependency "yard"
 
-  s.add_development_dependency "rspec", "~> 3.0"
+  s.add_development_dependency "rspec", '~> 3.5'
   s.add_development_dependency "rspec-its"
   s.add_development_dependency "rake"
 end

data/lib/flat_map/model_mapper/persistence.rb

@@ -55,13 +55,6 @@ module FlatMap
       end
     end
 
-    # Return a 'mapper' string as a model_name. Used by Rails FormBuilder.
-    #
-    # @return [String]
-    def model_name
-      'mapper'
-    end
-
     # Delegate to the target's #to_key method.
     # @return [String]
     def to_key

data/lib/flat_map/open_mapper/persistence.rb

@@ -133,7 +133,7 @@ module FlatMap
     # @return [Array<ActiveModel::Errors>]
     def consolidate_errors!
       mountings.map(&:errors).each do |errs|
-        errors.messages.merge!(errs.to_hash){ |key, old, new| old.concat(new) }
+        errors.merge!(errs)
       end
     end
     private :consolidate_errors!

data/lib/flat_map/version.rb

@@ -1,3 +1,3 @@
 module FlatMap # :nodoc:
-  VERSION = "0.2.1" # :nodoc:
+  VERSION = "0.5.0" # :nodoc:
 end

data/spec/flat_map/errors_spec.rb

@@ -11,13 +11,13 @@ describe FlatMap::Errors do
 
   it "preserved errors should appear on #empty? call exactly once" do
     errors.preserve :base, 'an error'
-    errors.should_not be_empty
-    errors[:base].should == ['an error']
+    expect(errors).not_to be_empty
+    expect(errors[:base]).to eq ['an error']
     expect{ errors.empty? }.not_to change{ errors[:base].length }
   end
 
   it "should add error to mapper with suffix" do
     errors.add(:attr, 'an error')
-    errors[:attr_foo].should == ['an error']
+    expect(errors[:attr_foo]).to eq ['an error']
   end
 end

data/spec/flat_map/mapper/attribute_methods_spec.rb

@@ -8,8 +8,8 @@ module FlatMap
   end
 
   describe 'Attribute Methods' do
-    let(:target){ OpenStruct.new }
-    let(:mapper){ AttributeMethodsSpec::SpecMapper.new(target) }
+    let(:target) { OpenStruct.new }
+    let(:mapper) { AttributeMethodsSpec::SpecMapper.new(target) }
 
     before do
       target.attr_a = 'a'
@@ -17,27 +17,27 @@ module FlatMap
     end
 
     it 'correctly responds to dynamic methods' do
-      mapper.respond_to?(:attr_a=).should be true
-      mapper.method(:attr_a=).should_not be nil
+      expect(mapper).to respond_to(:attr_a=)
+      expect(mapper.method(:attr_a=)).not_to be_nil
 
-      mapper.respond_to?(:attr_b=).should be true
-      mapper.method(:attr_b=).should_not be nil
+      expect(mapper).to respond_to(:attr_b=)
+      expect(mapper.method(:attr_b=)).not_to be_nil
     end
 
     it 'should be able to read values via method calls' do
-      mapper.attr_a.should == 'a'
-      mapper.attr_b.should == 'b'
+      expect(mapper.attr_a).to eq 'a'
+      expect(mapper.attr_b).to eq 'b'
     end
 
     it 'should be able to write values via method calls' do
       mapper.attr_a = 'A'
       mapper.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
 
     it 'should still raise for unknown or private method calls' do
-      expect{ mapper.undefined_method }.to raise_error(NoMethodError)
+      expect{ mapper.undefined_method  }.to raise_error(NoMethodError)
       expect{ mapper.attribute_methods }.to raise_error(NoMethodError)
     end
   end

data/spec/flat_map/mapper/callbacks_spec.rb

@@ -49,27 +49,27 @@ module FlatMap
     end
 
     it 'should call callbacks once' do
-      mapper.should_receive(:set_a).once
+      expect(mapper).to receive(:set_a).once
       mapper.save
     end
 
     specify 'validation callbacks' do
       mapper.valid?
-      mapper.attr_a.should be_nil
-      mapper.attr_b.should == 'before validate'
-      mapper.attr_c.should == 'mounted before validate'
+      expect(mapper.attr_a).to be_nil
+      expect(mapper.attr_b).to eq 'before validate'
+      expect(mapper.attr_c).to eq 'mounted before validate'
     end
 
     specify 'save callbacks' do
       mapper.save
-      mapper.attr_a.should == 'before save'
+      expect(mapper.attr_a).to eq 'before save'
     end
 
     context 'extension trait and named traits' do
       it 'should process extension first' do
-        mapper.extension.should_receive(:extension_set_b).once.and_call_original
+        expect(mapper.extension).to receive(:extension_set_b).once.and_call_original
         mapper.valid?
-        mapper.attr_b.should == 'before validate'
+        expect(mapper.attr_b).to eq 'before validate'
       end
     end
   end

data/spec/flat_map/mapper/factory_spec.rb

@@ -2,40 +2,40 @@ require 'spec_helper'
 
 module FlatMap
   describe OpenMapper::Factory do
-    let(:trait_class){ Class.new(FlatMap::OpenMapper) }
-    let(:mapper){ OpenMapper.build }
+    let(:trait_class) { Class.new(FlatMap::OpenMapper) }
+    let(:mapper)      { OpenMapper.build }
 
-    let(:mount_factory){ OpenMapper::Factory.new(:spec_mount, :traits => :used_traits) }
-    let(:trait_factory){ OpenMapper::Factory.new(trait_class, :trait_name => :a_trait) }
-    let(:open_factory){ OpenMapper::Factory.new(:some_mount, :open => true) }
+    let(:mount_factory) { OpenMapper::Factory.new(:spec_mount, :traits => :used_traits) }
+    let(:trait_factory) { OpenMapper::Factory.new(trait_class, :trait_name => :a_trait) }
+    let(:open_factory)  { OpenMapper::Factory.new(:some_mount, :open => true) }
 
     context 'when used for a trait' do
       subject{ trait_factory }
 
-      it{ should be_traited }
-      its(:name){ should be_nil }
-      its(:trait_name){ should == :a_trait }
-      its(:mapper_class){ should == trait_class }
+      it{ is_expected.to be_traited }
+      its(:name)         { is_expected.to be_nil }
+      its(:trait_name)   { is_expected.to eq :a_trait }
+      its(:mapper_class) { is_expected.to eq trait_class }
     end
 
     context 'when used for a mounted mapper' do
       subject{ mount_factory }
 
-      it{ should_not be_traited }
-      its(:name){ should == :spec_mount }
-      its(:trait_name){ should be_nil }
-      its(:traits){ should == [:used_traits] }
+      it{ is_expected.not_to be_traited }
+      its(:name)       { is_expected.to eq :spec_mount }
+      its(:trait_name) { is_expected.to be_nil }
+      its(:traits)     { is_expected.to eq [:used_traits] }
     end
 
     context 'when used for an open mapper' do
       it "should have descendant of OpenMapper as mapper_class" do
-        open_factory.mapper_class.should < OpenMapper
-        open_factory.mapper_class.name.should == 'SomeMountMapper'
+        expect(open_factory.mapper_class.ancestors).to include(OpenMapper)
+        expect(open_factory.mapper_class.name).to eq 'SomeMountMapper'
       end
 
       it "should create and instance of OpenMapper with open struct as a target" do
         mounted = open_factory.create(mapper)
-        mounted.target.should be_a(OpenStruct)
+        expect(mounted.target).to be_a(OpenStruct)
       end
     end
 
@@ -48,7 +48,7 @@ module FlatMap
         class OpenMapper::Factory::SpecMountMapper < FlatMap::OpenMapper; end
 
         it "should be able to fetch class name from name" do
-          mount_factory.mapper_class.should == ::SpecMountMapper
+          expect(mount_factory.mapper_class.ancestors).to include(::SpecMountMapper)
         end
 
         it "should be able to fetch class from mapper_class" do
@@ -56,7 +56,8 @@ module FlatMap
                       :spec_mount,
                       :mapper_class => FlatMap::OpenMapper::Factory::SpecMountMapper
                     )
-          factory.mapper_class.should == ::FlatMap::OpenMapper::Factory::SpecMountMapper
+          expect(factory.mapper_class.ancestors).
+            to include(::FlatMap::OpenMapper::Factory::SpecMountMapper)
         end
 
         it "should use options if specified" do
@@ -64,38 +65,39 @@ module FlatMap
                       :spec_mount,
                       :mapper_class_name => 'FlatMap::OpenMapper::Factory::SpecMountMapper'
                     )
-          factory.mapper_class.should == ::FlatMap::OpenMapper::Factory::SpecMountMapper
+          expect(factory.mapper_class.ancestors).
+            to include(::FlatMap::OpenMapper::Factory::SpecMountMapper)
         end
       end
 
       describe '#fetch_target_from' do
         it "should return owner's target for traited factory" do
-          trait_factory.fetch_target_from(mapper).should == target
+          expect(trait_factory.fetch_target_from(mapper)).to eq target
         end
 
         context 'explicit target' do
           it "should use explicitly specified if applicable" do
             factory = OpenMapper::Factory.new(:spec_mount, :target => other_target)
-            factory.fetch_target_from(mapper).should == other_target
+            expect(factory.fetch_target_from(mapper)).to eq other_target
           end
 
           it "should call Proc and pass owner target to it if Proc is specified as :target" do
             factory = OpenMapper::Factory.new(:spec_mount, :target => lambda{ |obj| obj.foo })
-            target.should_receive(:foo).and_return(other_target)
-            factory.fetch_target_from(mapper).should == other_target
+            expect(target).to receive(:foo).and_return(other_target)
+            expect(factory.fetch_target_from(mapper)).to eq other_target
           end
 
           it "should call a method if Symbol is used" do
             factory = OpenMapper::Factory.new(:spec_mount, :target => :foo)
-            mapper.should_receive(:foo).and_return(other_target)
-            factory.fetch_target_from(mapper).should == other_target
+            expect(mapper).to receive(:foo).and_return(other_target)
+            expect(factory.fetch_target_from(mapper)).to eq other_target
           end
         end
 
         context 'target from association' do
           before do
-            target.stub(:is_a?).and_call_original
-            target.stub(:is_a?).with(ActiveRecord::Base).and_return(true)
+            allow(target).to  receive(:is_a?).and_call_original
+            expect(target).to receive(:is_a?).with(ActiveRecord::Base).and_return(true)
           end
 
           let(:has_one_current_reflection) {
@@ -113,68 +115,68 @@ module FlatMap
 
           it "should refer to effective name for has_one_current association" do
             # Note: has_one_current is not part of Rails
-            mount_factory.should_receive(:reflection_from_target).
+            expect(mount_factory).to receive(:reflection_from_target).
                           with(target).
                           and_return(has_one_current_reflection)
-            target.should_receive(:effective_spec_mount).and_return(other_target)
-            mount_factory.fetch_target_from(mapper).should == other_target
+            expect(target).to receive(:effective_spec_mount).and_return(other_target)
+            expect(mount_factory.fetch_target_from(mapper)).to eq other_target
           end
 
           it "should refer to existing association object if possible, " \
              "and build it if it is absent for :has_one" do
-            mount_factory.should_receive(:reflection_from_target).
+            expect(mount_factory).to receive(:reflection_from_target).
                           with(target).
                           and_return(has_one_reflection)
-            target.should_receive(:spec_mount).and_return(nil)
-            target.should_receive(:build_spec_mount).and_return(other_target)
-            mount_factory.fetch_target_from(mapper).should == other_target
+            expect(target).to receive(:spec_mount).and_return(nil)
+            expect(target).to receive(:build_spec_mount).and_return(other_target)
+            expect(mount_factory.fetch_target_from(mapper)).to eq other_target
           end
 
           it "should refer to existing association object if possible, " \
              "and build it if it is absent for :belongs_to" do
-            mount_factory.should_receive(:reflection_from_target).
+            expect(mount_factory).to receive(:reflection_from_target).
                           with(target).
                           and_return(belongs_to_reflection)
-            target.should_receive(:spec_mount).and_return(nil)
-            target.should_receive(:build_spec_mount).and_return(other_target)
-            mount_factory.fetch_target_from(mapper).should == other_target
+            expect(target).to receive(:spec_mount).and_return(nil)
+            expect(target).to receive(:build_spec_mount).and_return(other_target)
+            expect(mount_factory.fetch_target_from(mapper)).to eq other_target
           end
 
           it "should always build a new record for :has_many association" do
-            mount_factory.should_receive(:reflection_from_target).
+            expect(mount_factory).to receive(:reflection_from_target).
                           with(target).
                           and_return(has_many_reflection)
-            target.should_receive(:association).with(:spec_mounts)
-            target.stub_chain(:association, :build).and_return(other_target)
-            mount_factory.fetch_target_from(mapper).should == other_target
+            expect(target).to receive(:association).with(:spec_mounts)
+            allow(target).to receive_message_chain(:association, :build).and_return(other_target)
+            expect(mount_factory.fetch_target_from(mapper)).to eq other_target
           end
 
           describe 'reflection_from_target' do
-            before{ target.stub(:is_a?).with(ActiveRecord::Base).and_return(true) }
+            before{ allow(target).to receive(:is_a?).with(ActiveRecord::Base).and_return(true) }
 
             it 'should first refer to singular association' do
-              target.stub_chain(:class, :reflect_on_association).
+              allow(target).to receive_message_chain(:class, :reflect_on_association).
                      with(:spec_mount).
                      and_return(has_one_reflection)
-              mount_factory.reflection_from_target(target).should == has_one_reflection
+              expect(mount_factory.reflection_from_target(target)).to eq has_one_reflection
             end
 
             it 'should use collection association if singular does not exist' do
-              target.stub_chain(:class, :reflect_on_association).
+              allow(target).to receive_message_chain(:class, :reflect_on_association).
                      with(:spec_mount).
                      and_return(nil)
-              target.stub_chain(:class, :reflect_on_association).
+              allow(target).to receive_message_chain(:class, :reflect_on_association).
                      with(:spec_mounts).
                      and_return(has_many_reflection)
-              mount_factory.reflection_from_target(target).should == has_many_reflection
+              expect(mount_factory.reflection_from_target(target)).to eq has_many_reflection
             end
           end
         end
 
         context 'target from name' do
           it 'should simply send method to owner target' do
-            target.should_receive(:spec_mount).and_return(other_target)
-            mount_factory.fetch_target_from(mapper).should == other_target
+            expect(target).to receive(:spec_mount).and_return(other_target)
+            expect(mount_factory.fetch_target_from(mapper)).to eq other_target
           end
         end
       end
@@ -182,7 +184,7 @@ module FlatMap
       describe '#create' do
         specify 'traited factory should create an owned mapper' do
           new_one = trait_factory.create(mapper)
-          new_one.owner.should == mapper
+          expect(new_one.owner).to eq mapper
         end
 
         context 'mounted mapper' do
@@ -190,12 +192,12 @@ module FlatMap
           let(:factory){ mount_factory }
 
           before do
-            factory.stub(:mapper_class).and_return(mount_class)
-            factory.stub(:fetch_target_from).and_return(other_target)
+            allow(factory).to receive(:mapper_class     ).and_return(mount_class)
+            allow(factory).to receive(:fetch_target_from).and_return(other_target)
           end
 
           it 'should combine traits' do
-            mount_class.should_receive(:new).
+            expect(mount_class).to receive(:new).
                         with(other_target, :used_traits, :another_trait).
                         and_call_original
             factory.create(mapper, :another_trait)
@@ -203,10 +205,10 @@ module FlatMap
 
           it 'should properly set properties' do
             new_one = factory.create(mapper)
-            new_one.host      .should == mapper
-            new_one.name      .should == :spec_mount
-            new_one.save_order.should == :after
-            new_one.suffix.should be_nil
+            expect(new_one.host      ).to eq mapper
+            expect(new_one.name      ).to eq :spec_mount
+            expect(new_one.save_order).to eq :after
+            expect(new_one.suffix    ).to be_nil
           end
 
           context 'when suffix is defined' do
@@ -214,8 +216,8 @@ module FlatMap
 
             it "should adjust properties with suffix" do
               new_one = factory.create(mapper)
-              new_one.name  .should == :spec_mount_foo
-              new_one.suffix.should == :foo
+              expect(new_one.name  ).to eq :spec_mount_foo
+              expect(new_one.suffix).to eq :foo
             end
           end
 
@@ -224,7 +226,7 @@ module FlatMap
             let(:factory){ OpenMapper::Factory.new(:spec_mount, &extension) }
 
             it "should pass it to mapper initialization" do
-              mount_class.should_receive(:new).
+              expect(mount_class).to receive(:new).
                           with(other_target, &extension).
                           and_call_original
               new_one = factory.create(mapper)
@@ -233,20 +235,20 @@ module FlatMap
 
           describe 'save order' do
             before do
-              mapper.stub(:is_a?).and_call_original
-              mapper.stub(:is_a?).with(ModelMapper).and_return(true)
+              allow(mapper).to receive(:is_a?).and_call_original
+              allow(mapper).to receive(:is_a?).with(ModelMapper).and_return(true)
             end
 
             it 'should be :before for belongs_to association' do
-              factory.stub(:reflection_from_target).
+              expect(factory).to receive(:reflection_from_target).
                       and_return(double('reflection', :macro => :belongs_to))
-              factory.fetch_save_order(mapper).should == :before
+              expect(factory.fetch_save_order(mapper)).to eq :before
             end
 
             it 'should be :after for other cases' do
-              factory.stub(:reflection_from_target).
+              expect(factory).to receive(:reflection_from_target).
                       and_return(double('reflection', :macro => :has_one))
-              factory.fetch_save_order(mapper).should == :after
+              expect(factory.fetch_save_order(mapper)).to eq :after
             end
 
             context 'when explicitly set' do
@@ -254,7 +256,7 @@ module FlatMap
 
               it 'should fetch from options, if possible' do
                 new_one = factory.create(mapper)
-                new_one.save_order.should == :before
+                expect(new_one.save_order).to eq :before
               end
             end
           end
@@ -273,11 +275,11 @@ module FlatMap
         let(:factory_for_b){ mapper_class.mountings.first.mapper_class.mountings.first }
 
         it "should be required for nested trait" do
-          factory_for_b.required_for_any_trait?([:trait_c]).should be true
+          expect(factory_for_b.required_for_any_trait?([:trait_c])).to be true
         end
 
         it "should not be required for top trait" do
-          factory_for_b.required_for_any_trait?([:trait_a]).should be false
+          expect(factory_for_b.required_for_any_trait?([:trait_a])).to be false
         end
       end
     end

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