HornsAndHooves-flat_map 0.2.1 → 0.3.0

data/spec/flat_map/mapper/traits_spec.rb

@@ -51,14 +51,14 @@ module FlatMap
   describe 'Traits' do
     describe 'trait definition' do
       it "should add a traited mapper factory to a class" do
-        TraitsSpec::EmptyMapper.should_receive(:mount).
+        expect(TraitsSpec::EmptyMapper).to receive(:mount).
                                 with(kind_of(Class), :trait_name => :a_trait).
                                 and_call_original
         expect{ TraitsSpec::EmptyMapper.trait(:a_trait) }.
           to change{ TraitsSpec::EmptyMapper.mountings.length }.by(1)
         trait_mapper_class =
           TraitsSpec::EmptyMapper.mountings.first.instance_variable_get('@identifier')
-        trait_mapper_class.name.should == 'FlatMap::TraitsSpec::EmptyMapperATraitTrait'
+        expect(trait_mapper_class.name).to eq 'FlatMap::TraitsSpec::EmptyMapperATraitTrait'
       end
     end
 
@@ -79,25 +79,25 @@ module FlatMap
       end
 
       it 'should be able to access trait by name' do
-        mapper.trait(:trait_one).should be_a(Mapper)
-        mapper.trait(:undefined).should be_nil
+        expect(mapper.trait(:trait_one)).to be_a(Mapper)
+        expect(mapper.trait(:undefined)).to be_nil
       end
 
       it 'should not contain unused trait' do
-        mapper.trait(:trait_two).should be_nil
+        expect(mapper.trait(:trait_two)).to be_nil
       end
 
       it 'should have mountings of a trait' do
-        mapper.mounting(:spec_mount).should be_present
+        expect(mapper.mounting(:spec_mount)).to be_present
       end
 
       it '#read should read values with respect to trait' do
-        mapper.read.should == {
+        expect(mapper.read).to eq({
           :attr_a => 'a',
           :attr_b => 'b',
           :attr_c => 'c',
           :attr_d => 'd'
-        }
+        })
       end
 
       it '#write should properly distribute values' do
@@ -106,33 +106,33 @@ module FlatMap
           :attr_b => 'B',
           :attr_c => 'C',
           :attr_d => 'D'
-        target.attr_a.should == 'A'
-        target.attr_b.should == 'B'
-        mount_target.attr_c.should == 'C'
-        mount_target.attr_d.should == 'D'
+        expect(target.attr_a      ).to eq 'A'
+        expect(target.attr_b      ).to eq 'B'
+        expect(mount_target.attr_c).to eq 'C'
+        expect(mount_target.attr_d).to eq 'D'
       end
 
       specify 'mapper should be avle to call methods of enabled traits' do
         mapper = TraitsSpec::HostMapper.new(target, :trait_one)
-        mapper.method_one.should == 'one'
+        expect(mapper.method_one).to eq 'one'
         expect{ mapper.method_two }.to raise_error(NoMethodError)
       end
 
       specify 'traits should be able to call methods of each other' do
         mapper = TraitsSpec::HostMapper.new(target, :trait_one, :trait_two)
-        mapper.trait(:trait_two).method_two.should == 'one'
+        expect(mapper.trait(:trait_two).method_two).to eq 'one'
       end
 
       describe 'trait nesting' do
         let(:mapper){ TraitsSpec::HostMapper.new(target, :trait_one_nested) }
 
         it 'should still be able to have top-level trait definitions' do
-          mapper.mounting(:spec_mount).should be_present
-          mapper.method_one.should == 'one'
+          expect(mapper.mounting(:spec_mount)).to be_present
+          expect(mapper.method_one).to eq 'one'
         end
 
         it 'should have new definitions' do
-          mapper.method_one_nested.should == 'nested_one'
+          expect(mapper.method_one_nested).to eq 'nested_one'
         end
       end
 
@@ -150,21 +150,21 @@ module FlatMap
         end
 
         it 'should behave like a normal trait' do
-          mapper.trait(:extension).should be_present
-          mapper.read.should include :attr_b => 'b'
+          expect(mapper.trait(:extension)).to be_present
+          expect(mapper.read).to include :attr_b => 'b'
         end
 
         it 'should be accessible' do
-          mapper.extension.should be_present
+          expect(mapper.extension).to be_present
         end
 
         it 'should be_extension' do
-          mapper.extension.should be_extension
+          expect(mapper.extension).to be_extension
         end
 
         it "should be able to handle save exception of traits" do
           expect{ mapper.apply(:writing_error => 'foo') }.not_to raise_error
-          mapper.errors[:writing_error].should include 'cannot be foo'
+          expect(mapper.errors[:writing_error]).to include 'cannot be foo'
         end
       end
     end

data/spec/flat_map/mapper/validations_spec.rb

@@ -52,21 +52,21 @@ module FlatMap
     end
 
     it 'should not be valid' do
-      mapper.should_not be_valid
+      expect(mapper).not_to be_valid
     end
 
     it 'should call callbacks' do
-      mapper.trait(:with_trait).should_receive(:set_default_attr_b).and_call_original
+      expect(mapper.trait(:with_trait)).to receive(:set_default_attr_b).and_call_original
       mapper.valid?
-      mapper.attr_b.should == 'foo'
+      expect(mapper.attr_b).to eq 'foo'
     end
 
     it 'should have all the errors' do
       mapper.valid?
-      mapper.errors[:attr_a].should == ["can't be blank"]
-      mapper.errors[:attr_b].should == ["can't be foo"]
-      mapper.errors[:attr_c].should == ["can't be blank"]
-      mapper.errors[:attr_d].should == ["can't be blank"]
+      expect(mapper.errors[:attr_a]).to eq ["can't be blank"]
+      expect(mapper.errors[:attr_b]).to eq ["can't be foo"]
+      expect(mapper.errors[:attr_c]).to eq ["can't be blank"]
+      expect(mapper.errors[:attr_d]).to eq ["can't be blank"]
     end
   end
 end

data/spec/flat_map/mapping/factory_spec.rb

@@ -5,7 +5,7 @@ describe FlatMap::Mapping::Factory do
 
   specify('#create should delegate all initialization params to new mapping') do
     mapper_stub = double('mapper')
-    FlatMap::Mapping.should_receive(:new).with(mapper_stub, :foo, :bar, :baz)
+    expect(FlatMap::Mapping).to receive(:new).with(mapper_stub, :foo, :bar, :baz)
 
     factory.create(mapper_stub)
   end

data/spec/flat_map/mapping/reader/basic_spec.rb

@@ -1,15 +1,15 @@
 require 'spec_helper'
 
 describe FlatMap::Mapping::Reader::Basic do
-  let(:target){ double('target') }
-  let(:mapping){ double('mapping') }
-  let(:reader){ described_class.new(mapping) }
+  let(:target)  { double('target') }
+  let(:mapping) { double('mapping') }
+  let(:reader)  { described_class.new(mapping) }
 
   specify("#read should fetch value from mapping's target_attribute") do
-    mapping.should_receive(:target).and_return(target)
-    mapping.should_receive(:target_attribute).and_return(:foo)
-    target.should_receive(:foo).and_return(:bar)
+    expect(mapping).to receive(:target          ).and_return(target)
+    expect(mapping).to receive(:target_attribute).and_return(:foo)
+    expect(target ).to receive(:foo             ).and_return(:bar)
 
-    reader.read.should == :bar
+    expect(reader.read).to eq :bar
   end
 end

data/spec/flat_map/mapping/reader/formatted_spec.rb

@@ -20,9 +20,9 @@ describe FlatMap::Mapping::Reader::Formatted do
     end
 
     specify "#read should use formatting method for fetching a value" do
-      reader.read.should == 'FOOBAR'
-      reader.read(:downcase).should == 'foobar'
-      reader.read(:unknown).should == 'fOoBaR'
+      expect(reader.read           ).to eq 'FOOBAR'
+      expect(reader.read(:downcase)).to eq 'foobar'
+      expect(reader.read(:unknown )).to eq 'fOoBaR'
     end
   end
 
@@ -32,9 +32,9 @@ describe FlatMap::Mapping::Reader::Formatted do
 
       it "should use I18n_l to format value" do
         formatted_value = "le FooBar"
-        I18n.should_receive(:l).with(value).and_return(formatted_value)
+        expect(I18n).to receive(:l).with(value).and_return(formatted_value)
 
-        reader.read.should == formatted_value
+        expect(reader.read).to eq formatted_value
       end
     end
 
@@ -49,13 +49,13 @@ describe FlatMap::Mapping::Reader::Formatted do
       let(:reader){ described_class.new(mapping, :enum) }
 
       it "should use the name property of the target object for value" do
-        enum.should_receive(:name).and_return(value)
-        reader.read.should == value
+        expect(enum).to receive(:name).and_return(value)
+        expect(reader.read).to eq value
       end
 
       it "should be able to use the desired method to get enum's property" do
-        enum.should_receive(:description).and_return(value)
-        reader.read(:description).should == value
+        expect(enum).to receive(:description).and_return(value)
+        expect(reader.read(:description)).to eq value
       end
     end
   end

data/spec/flat_map/mapping/reader/method_spec.rb

@@ -1,13 +1,13 @@
 require 'spec_helper'
 
 describe FlatMap::Mapping::Reader::Method do
-  let(:mapper){ double('mapper') }
-  let(:mapping){ double('mapping', :mapper => mapper) }
-  let(:reader){ described_class.new(mapping, :read_with_method) }
+  let(:mapper)  { double('mapper') }
+  let(:mapping) { double('mapping', :mapper => mapper) }
+  let(:reader)  { described_class.new(mapping, :read_with_method) }
 
   specify("#read delegates to mapper-defined method and passes mapping to it") do
-    mapper.should_receive(:read_with_method).with(mapping).and_return(:bar)
+    expect(mapper).to receive(:read_with_method).with(mapping).and_return(:bar)
 
-    reader.read.should == :bar
+    expect(reader.read).to eq :bar
   end
 end

data/spec/flat_map/mapping/reader/proc_spec.rb

@@ -1,13 +1,13 @@
 require 'spec_helper'
 
 describe FlatMap::Mapping::Reader::Proc do
-  let(:target){ double('target') }
-  let(:mapping){ double('mapping', :target => target) }
-  let(:reader){ described_class.new(mapping, lambda{ |t| t.foo }) }
+  let(:target)  { double('target') }
+  let(:mapping) { double('mapping', :target => target) }
+  let(:reader)  { described_class.new(mapping, lambda{ |t| t.foo }) }
 
   specify("#read should pass target to Proc object to fetch value") do
-    target.should_receive(:foo).and_return(:bar)
+    expect(target).to receive(:foo).and_return(:bar)
 
-    reader.read.should == :bar
+    expect(reader.read).to eq :bar
   end
 end

data/spec/flat_map/mapping/writer/basic_spec.rb

@@ -1,14 +1,14 @@
 require 'spec_helper'
 
 describe FlatMap::Mapping::Writer::Basic do
-  let(:target){ double('target') }
-  let(:mapping){ double('mapping') }
-  let(:writer){ described_class.new(mapping) }
+  let(:target)  { double('target') }
+  let(:mapping) { double('mapping') }
+  let(:writer)  { described_class.new(mapping) }
 
   specify("#write use target_attribute as writer to assign value to target") do
-    mapping.should_receive(:target).and_return(target)
-    mapping.should_receive(:target_attribute).and_return(:foo)
-    target.should_receive(:foo=).with(:bar)
+    expect(mapping).to receive(:target          ).and_return(target)
+    expect(mapping).to receive(:target_attribute).and_return(:foo)
+    expect(target ).to receive(:foo=).with(:bar)
 
     writer.write(:bar)
   end

data/spec/flat_map/mapping/writer/method_spec.rb

@@ -1,12 +1,12 @@
 require 'spec_helper'
 
 describe FlatMap::Mapping::Writer::Method do
-  let(:mapper){ double('mapper') }
-  let(:mapping){ double('mapping', :mapper => mapper) }
-  let(:writer){ described_class.new(mapping, :write_with_method) }
+  let(:mapper)  { double('mapper') }
+  let(:mapping) { double('mapping', :mapper => mapper) }
+  let(:writer)  { described_class.new(mapping, :write_with_method) }
 
   specify("#write delegates to mapper-defined method and passes mapping and value to it") do
-    mapper.should_receive(:write_with_method).with(mapping, :foo)
+    expect(mapper).to receive(:write_with_method).with(mapping, :foo)
 
     writer.write(:foo)
   end

data/spec/flat_map/mapping/writer/proc_spec.rb

@@ -1,12 +1,12 @@
 require 'spec_helper'
 
 describe FlatMap::Mapping::Writer::Proc do
-  let(:target){ double('target') }
-  let(:mapping){ double('mapping', :target => target) }
-  let(:writer){ described_class.new(mapping, lambda{ |t, v| t.foo(v) }) }
+  let(:target)  { double('target') }
+  let(:mapping) { double('mapping', :target => target) }
+  let(:writer)  { described_class.new(mapping, lambda{ |t, v| t.foo(v) }) }
 
   specify("#write should pass target and value to Proc object for assignment") do
-    target.should_receive(:foo).with(:bar)
+    expect(target).to receive(:foo).with(:bar)
 
     writer.write(:bar)
   end

data/spec/flat_map/mapping_spec.rb

@@ -2,8 +2,8 @@ require 'spec_helper'
 
 module FlatMap
   describe Mapping do
-    let(:mapper){ double('mapper', :suffixed? => false) }
-    let(:mapping){ Mapping.new(mapper, :name, :attr) }
+    let(:mapper)  { double('mapper', :suffixed? => false) }
+    let(:mapping) { Mapping.new(mapper, :name, :attr) }
 
     describe "initialization" do
       it "should be initializable" do
@@ -11,12 +11,12 @@ module FlatMap
       end
 
       it 'should delegate #read to reader' do
-        mapping.reader.should_receive(:read)
+        expect(mapping.reader).to receive(:read)
         mapping.read
       end
 
       it 'should delegate #write to writer' do
-        mapping.writer.should_receive(:write).with(:foo)
+        expect(mapping.writer).to receive(:write).with(:foo)
         mapping.write(:foo)
       end
 
@@ -25,43 +25,43 @@ module FlatMap
 
         subject{ Mapping.new(mapper, :name, :attr, :multiparam => Date) }
 
-        its(:mapper){ should == mapper }
-        its(:name){ should == :name }
-        its(:target_attribute){ should == :attr }
-        its(:full_name){ should == :name_foo }
-        its(:multiparam){ should == Date }
-        its(:multiparam?){ should be true }
+        its(:mapper)           { is_expected.to eq mapper }
+        its(:name)             { is_expected.to eq :name }
+        its(:target_attribute) { is_expected.to eq :attr }
+        its(:full_name)        { is_expected.to eq :name_foo }
+        its(:multiparam)       { is_expected.to eq Date }
+        its(:multiparam?)      { is_expected.to be true }
       end
 
       describe "#fetch_reader" do
         context 'default' do
           subject{ Mapping.new(mapper, :name, :attr) }
 
-          its(:reader){ should be_a(Mapping::Reader::Basic) }
+          its(:reader) { is_expected.to be_a(Mapping::Reader::Basic) }
         end
 
         context 'method' do
           subject{ Mapping.new(mapper, :name, :attr, :reader => :method_name) }
 
-          its(:reader){ should be_a(Mapping::Reader::Method) }
+          its(:reader) { is_expected.to be_a(Mapping::Reader::Method) }
         end
 
         context 'proc' do
           subject{ Mapping.new(mapper, :name, :attr, :reader => lambda{ |t| t.foo }) }
 
-          its(:reader){ should be_a(Mapping::Reader::Proc) }
+          its(:reader) { is_expected.to be_a(Mapping::Reader::Proc) }
         end
 
         context 'formatted' do
           subject{ Mapping.new(mapper, :name, :attr, :format => :i18n_l) }
 
-          its(:reader){ should be_a(Mapping::Reader::Formatted) }
+          its(:reader) { is_expected.to be_a(Mapping::Reader::Formatted) }
         end
 
         context 'blank' do
           subject{ Mapping.new(mapper, :name, :attr, :reader => false) }
 
-          its(:reader){ should be_nil }
+          its(:reader) { is_expected.to be_nil }
         end
       end
     end
@@ -70,32 +70,32 @@ module FlatMap
       context 'default' do
         subject{ Mapping.new(mapper, :name, :attr) }
 
-        its(:writer){ should be_a(Mapping::Writer::Basic) }
+        its(:writer) { is_expected.to be_a(Mapping::Writer::Basic) }
       end
 
       context 'method' do
         subject{ Mapping.new(mapper, :name, :attr, :writer => :method_name) }
 
-        its(:writer){ should be_a(Mapping::Writer::Method) }
+        its(:writer) { is_expected.to be_a(Mapping::Writer::Method) }
       end
 
       context 'proc' do
         subject{ Mapping.new(mapper, :name, :attr, :writer => lambda{ |t| t.foo }) }
 
-        its(:writer){ should be_a(Mapping::Writer::Proc) }
+        its(:writer) { is_expected.to be_a(Mapping::Writer::Proc) }
       end
 
       context 'blank' do
         subject{ Mapping.new(mapper, :name, :attr, :writer => false) }
 
-        its(:writer){ should be_nil }
+        its(:writer) { is_expected.to be_nil }
       end
     end
 
     describe "read_as_params" do
       it "should return mapping as key value pair" do
         stub_target
-        mapping.read_as_params.should == {:name => "target_foo"}
+        expect(mapping.read_as_params).to eq({:name => "target_foo"})
       end
     end
 
@@ -107,16 +107,16 @@ module FlatMap
 
       it "should set no value on the target from params" do
         target = stub_target
-        target.should_not_receive(:attr=)
+        expect(target).not_to receive(:attr=)
         mapping.write_from_params(:not_mapping_name => "value")
-        target.attr.should == 'target_foo'
+        expect(target.attr).to eq 'target_foo'
       end
     end
 
     def stub_target(assignment = nil)
       target = double('target', :attr => 'target_foo')
-      mapper.stub(:target).and_return(target)
-      target.should_receive(:attr=).with(assignment) if assignment.present?
+      allow(mapper).to receive(:target).and_return(target)
+      expect(target).to receive(:attr=).with(assignment) if assignment.present?
       target
     end
   end