HornsAndHooves-flat_map 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1f3b82b7ae0f88b1c76017b5ac2410dee62efeed
-  data.tar.gz: 5f72a1ca80df379ddfd7dfeb22b8b8d1530c8b0f
+  metadata.gz: ae437e1e699d72bc1e9a7edae6fe93d2a4ef2074
+  data.tar.gz: e3dc282d44fb77ba18df155e4386372cba68941d
 SHA512:
-  metadata.gz: 62115ee9279c68f7ed109ed43b769fb28669d9f6a3c884d69fb8680e41cc20b2139f2993578b73a9b79a924de5d790bde331755190d6f6fbd77467c3ad40f511
-  data.tar.gz: 50f70f29acdc63ba0de90725f79694e877ca983dcd84bea897e9defa9c7463fcff6dd62ee48233e7981d55eae9e50735ec4ad23905c071f7d2a5f69ec29e558c
+  metadata.gz: adb627f3d5401014b077d9efbdcfb7bb9ad9dc516e960288a372e575f20bfab1ba3f03fa6706d6a1c26fe53328a79ff849cd6e815211452b5c7f5253ec3dbffb
+  data.tar.gz: 2bc1e394f9fef5e755ddc5c2fef79e6c42fb9fd3c18d4d21db7a2f992c32b82e1c44841d4fe4e29cceeade7739caa1ceb9190b8fe6e9e9d15599294c5e3d3175

data/HornsAndHooves-flat_map.gemspec

@@ -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<activesupport>, ["> 4.0", "< 4.2"])
+  s.add_dependency(%q<activerecord>, ["> 4.0", "< 4.2"])
   s.add_dependency(%q<yard>, [">= 0"])
 
-  s.add_development_dependency "rspec", "~> 3.0"
+  s.add_development_dependency "rspec"
   s.add_development_dependency "rspec-its"
   s.add_development_dependency "rake"
 end

data/lib/flat_map/version.rb

@@ -1,3 +1,3 @@
 module FlatMap # :nodoc:
-  VERSION = "0.2.1" # :nodoc:
+  VERSION = "0.3.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