transpec 0.0.8 → 0.0.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ce0f0f3624392da60bc26a32d10f32a93ed866af
-  data.tar.gz: c0492a785742c25c2f718c888253658b6fbe872d
+  metadata.gz: 184be0fbb9de5a2d47804fc8611719692da19749
+  data.tar.gz: abcbeecdc14d0061e07e50542a3fa784e4f890af
 SHA512:
-  metadata.gz: 069b02b6bfd111b9ac243fd0559c6281417ca8be7e0e40d9bbe10cbf46f1a63fc6819d31f0d439acaad3c2f60c0a5dc00eb3d0b59374a9e23d76f4b495829a40
-  data.tar.gz: 64212f1a93153c532e11dd6dc0d397a5f295c4064551663b8c43f2c70cac9f880bcf48b6893ef745a88fb3ec5378d7401384b23f91803708613f001b73519f2d
+  metadata.gz: b6edfa9df6df92ee56fa47a19b1fd389c92835f2e69bdd7a0cd64e9937b7f78af3890fb5cf8fdf408f2c9c167d1d056a5ae0b100f0c655e58edc46bcc7b514a2
+  data.tar.gz: a863cc647d30798d4c5815eef33e555dcb3a70c38c840277f05e57e398f9f40189346ad8f788d1068cb86f91745532ea2daf44edb97f7415cc8b24e0cc050468

data/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 ## Master
 
+## v0.0.9
+
+* Use `--disable allow_to_receive` to disable conversion from `obj.should_receive(:foo).any_number_of_times` to `allow(obj).to receive(:foo)` (Previously it was `--disable expect_to_receive`)
+
 ## v0.0.8
 
 * Support conversion from `not_to raise_error(SpecificErrorClass)` to `not_to raise_error`

data/README.md

@@ -47,7 +47,7 @@ describe Account do
       end
 
       it 'does not raise error' do
-        lambda { account.renew }.should_not raise_error
+        lambda { account.renew }.should_not raise_error(Account::RenewalError)
       end
     end
   end
@@ -150,7 +150,7 @@ $ transpec --disable expect_to_receive,allow_to_receive
 
 Conversion Type     | Target Syntax                    | Converted Syntax
 --------------------|----------------------------------|----------------------------
-`expect_to_matcher` | `obj.should`                     | `expect(obj).to`
+`expect_to_matcher` | `obj.should matcher`             | `expect(obj).to matcher`
 `expect_to_receive` | `obj.should_receive`             | `expect(obj).to receive`
 `allow_to_receive`  | `obj.stub`                       | `allow(obj).to receive`
 `deprecated`        | `obj.stub!`, `mock('foo')`, etc. | `obj.stub`, `double('foo')`
@@ -175,30 +175,30 @@ when parentheses are necessary to keep the meaning of the expression.
 
 ```ruby
 describe 'original spec' do
-  it 'is example' do
+  it 'is an example' do
     1.should == 1
     2.should > 1
-    'string'.should =~ /str/
+    'string'.should =~ /^str/
     [1, 2, 3].should =~ [2, 1, 3]
     { key: value }.should == { key: value }
   end
 end
 
 describe 'converted spec' do
-  it 'is example' do
+  it 'is an example' do
     expect(1).to eq(1)
     expect(2).to be > 1
-    expect('string').to match(/str/)
+    expect('string').to match(/^str/)
     expect([1, 2, 3]).to match_array([2, 1, 3])
     expect({ key: value }).to eq({ key: value })
   end
 end
 
 describe 'converted spec with -p/--no-parentheses-matcher-arg option' do
-  it 'is example' do
+  it 'is an example' do
     expect(1).to eq 1
     expect(2).to be > 1
-    expect('string').to match /str/
+    expect('string').to match /^str/
     expect([1, 2, 3]).to match_array [2, 1, 3]
     # With non-operator method, the parentheses are always required
     # to prevent the hash from being interpreted as a block.
@@ -207,6 +207,180 @@ describe 'converted spec with -p/--no-parentheses-matcher-arg option' do
 end
 ```
 
+## Supported Conversions
+
+### Standard expectations
+
+```ruby
+# Target
+obj.should matcher
+obj.should_not matcher
+
+# Converted
+expect(obj).to matcher
+expect(obj).not_to matcher
+expect(obj).to_not matcher # with `--negative-form to_not`
+```
+
+Disabled by: `--disable expect_to_matcher`
+
+### Operator matchers
+
+```ruby
+# Target
+1.should == 1
+1.should < 2
+Integer.should === 1
+'string'.should =~ /^str/
+[1, 2, 3].should =~ [2, 1, 3]
+
+# Converted
+expect(1).to eq(1)
+expect(1).to be < 2
+expect(Integer).to be === 1
+expect('string').to match(/^str/)
+expect([1, 2, 3]).to match_array([2, 1, 3])
+```
+
+### `be_close` matcher
+
+```ruby
+# Target
+(1.0 / 3.0).should be_close(0.333, 0.001)
+
+# Converted
+(1.0 / 3.0).should be_within(0.001).of(0.333)
+```
+
+Disabled by: `--disable deprecated`
+
+### Error expectations
+
+```ruby
+# Target
+lambda { do_something }.should raise_error
+proc { do_something }.should raise_error
+-> { do_something }.should raise_error
+
+# Converted
+expect { do_something }.to raise_error
+```
+
+Disabled by: `--disable expect_to_matcher`
+
+### Negative error expectations with specific error
+
+```ruby
+# Target
+expect { do_something }.not_to raise_error(SomeErrorClass)
+expect { do_something }.not_to raise_error('message')
+expect { do_something }.not_to raise_error(SomeErrorClass, 'message')
+lambda { do_something }.should_not raise_error(SomeErrorClass)
+
+# Converted
+expect { do_something }.not_to raise_error
+lambda { do_something }.should_not raise_error # with `--disable expect_to_matcher`
+```
+
+Disabled by: `--disable deprecated`
+
+### Message expectations
+
+```ruby
+# Target
+obj.should_receive(:foo)
+SomeClass.any_instance.should_receive(:foo)
+
+# Converted
+expect(obj).to receive(:foo)
+expect_any_instance_of(SomeClass).to receive(:foo)
+```
+
+Disabled by: `--disable expect_to_receive`
+
+### Message expectations with `any_number_of_times`
+
+```ruby
+# Target
+obj.should_receive(:foo).any_number_of_times
+
+SomeClass.any_instance.should_receive(:foo).any_number_of_times
+
+# Converted
+allow(obj).to receive(:foo)
+obj.stub(:foo) # with `--disable allow_to_receive`
+
+allow_any_instance_of(SomeClass).to receive(:foo)
+SomeClass.any_instance.stub(:foo) # with `--disable allow_to_receive`
+```
+
+Disabled by: `--disable deprecated`
+
+### Method stubs
+
+```ruby
+# Target
+obj.stub(:foo)
+
+obj.stub!(:foo)
+
+obj.stub(:foo => 1, :bar => 2)
+
+SomeClass.any_instance.stub(:foo)
+
+# Converted
+allow(obj).to receive(:foo)
+
+allow(obj).to receive(:foo)
+
+allow(obj).to receive(:foo).and_return(1)
+allow(obj).to receive(:bar).and_return(2)
+
+allow_any_instance_of(SomeClass).to receive(:foo)
+```
+
+Disabled by: `--disable allow_to_receive`
+
+### Deprecated method stub aliases
+
+```ruby
+# Target
+obj.stub!(:foo)
+obj.unstub!(:foo)
+
+# Converted
+obj.stub(:foo) # with `--disable allow_to_receive`
+obj.unstub(:foo)
+```
+
+Disabled by: `--disable deprecated`
+
+### Method stubs with `any_number_of_times`
+
+```ruby
+# Target
+obj.stub(:foo).any_number_of_times
+
+# Converted
+allow(obj).to receive(:foo)
+obj.stub(:foo) # with `--disable allow_to_receive`
+```
+
+Disabled by: `--disable deprecated`
+
+### Deprecated test double aliases
+
+```ruby
+# Target
+stub('something')
+mock('something')
+
+# Converted
+double('something')
+```
+
+Disabled by: `--disable deprecated`
+
 ## Compatibility
 
 Tested on MRI 1.9, MRI 2.0 and JRuby in 1.9 mode.

data/README.md.erb

@@ -49,7 +49,7 @@ describe Account do
       end
 
       it 'does not raise error' do
-        lambda { account.renew }.should_not raise_error
+        lambda { account.renew }.should_not raise_error(Account::RenewalError)
       end
     end
   end
@@ -125,7 +125,7 @@ Conversion Type     | Target Syntax                    | Converted Syntax
 --------------------|----------------------------------|----------------------------
 <%=
 conversion_type_table = <<END
-`expect_to_matcher` | `obj.should`                     | `expect(obj).to`
+`expect_to_matcher` | `obj.should matcher`             | `expect(obj).to matcher`
 `expect_to_receive` | `obj.should_receive`             | `expect(obj).to receive`
 `allow_to_receive`  | `obj.stub`                       | `allow(obj).to receive`
 `deprecated`        | `obj.stub!`, `mock('foo')`, etc. | `obj.stub`, `double('foo')`
@@ -168,10 +168,10 @@ when parentheses are necessary to keep the meaning of the expression.
 <%=
 parenthesizing_example = <<END
 describe 'original spec' do
-  it 'is example' do
+  it 'is an example' do
     1.should == 1
     2.should > 1
-    'string'.should =~ /str/
+    'string'.should =~ /^str/
     [1, 2, 3].should =~ [2, 1, 3]
     { key: value }.should == { key: value }
   end
@@ -203,6 +203,180 @@ rewriter.rewrite(parenthesizing_example)
 -%>
 ```
 
+## Supported Conversions
+
+### Standard expectations
+
+```ruby
+# Target
+obj.should matcher
+obj.should_not matcher
+
+# Converted
+expect(obj).to matcher
+expect(obj).not_to matcher
+expect(obj).to_not matcher # with `--negative-form to_not`
+```
+
+Disabled by: `--disable expect_to_matcher`
+
+### Operator matchers
+
+```ruby
+# Target
+1.should == 1
+1.should < 2
+Integer.should === 1
+'string'.should =~ /^str/
+[1, 2, 3].should =~ [2, 1, 3]
+
+# Converted
+expect(1).to eq(1)
+expect(1).to be < 2
+expect(Integer).to be === 1
+expect('string').to match(/^str/)
+expect([1, 2, 3]).to match_array([2, 1, 3])
+```
+
+### `be_close` matcher
+
+```ruby
+# Target
+(1.0 / 3.0).should be_close(0.333, 0.001)
+
+# Converted
+(1.0 / 3.0).should be_within(0.001).of(0.333)
+```
+
+Disabled by: `--disable deprecated`
+
+### Error expectations
+
+```ruby
+# Target
+lambda { do_something }.should raise_error
+proc { do_something }.should raise_error
+-> { do_something }.should raise_error
+
+# Converted
+expect { do_something }.to raise_error
+```
+
+Disabled by: `--disable expect_to_matcher`
+
+### Negative error expectations with specific error
+
+```ruby
+# Target
+expect { do_something }.not_to raise_error(SomeErrorClass)
+expect { do_something }.not_to raise_error('message')
+expect { do_something }.not_to raise_error(SomeErrorClass, 'message')
+lambda { do_something }.should_not raise_error(SomeErrorClass)
+
+# Converted
+expect { do_something }.not_to raise_error
+lambda { do_something }.should_not raise_error # with `--disable expect_to_matcher`
+```
+
+Disabled by: `--disable deprecated`
+
+### Message expectations
+
+```ruby
+# Target
+obj.should_receive(:foo)
+SomeClass.any_instance.should_receive(:foo)
+
+# Converted
+expect(obj).to receive(:foo)
+expect_any_instance_of(SomeClass).to receive(:foo)
+```
+
+Disabled by: `--disable expect_to_receive`
+
+### Message expectations with `any_number_of_times`
+
+```ruby
+# Target
+obj.should_receive(:foo).any_number_of_times
+
+SomeClass.any_instance.should_receive(:foo).any_number_of_times
+
+# Converted
+allow(obj).to receive(:foo)
+obj.stub(:foo) # with `--disable allow_to_receive`
+
+allow_any_instance_of(SomeClass).to receive(:foo)
+SomeClass.any_instance.stub(:foo) # with `--disable allow_to_receive`
+```
+
+Disabled by: `--disable deprecated`
+
+### Method stubs
+
+```ruby
+# Target
+obj.stub(:foo)
+
+obj.stub!(:foo)
+
+obj.stub(:foo => 1, :bar => 2)
+
+SomeClass.any_instance.stub(:foo)
+
+# Converted
+allow(obj).to receive(:foo)
+
+allow(obj).to receive(:foo)
+
+allow(obj).to receive(:foo).and_return(1)
+allow(obj).to receive(:bar).and_return(2)
+
+allow_any_instance_of(SomeClass).to receive(:foo)
+```
+
+Disabled by: `--disable allow_to_receive`
+
+### Deprecated method stub aliases
+
+```ruby
+# Target
+obj.stub!(:foo)
+obj.unstub!(:foo)
+
+# Converted
+obj.stub(:foo) # with `--disable allow_to_receive`
+obj.unstub(:foo)
+```
+
+Disabled by: `--disable deprecated`
+
+### Method stubs with `any_number_of_times`
+
+```ruby
+# Target
+obj.stub(:foo).any_number_of_times
+
+# Converted
+allow(obj).to receive(:foo)
+obj.stub(:foo) # with `--disable allow_to_receive`
+```
+
+Disabled by: `--disable deprecated`
+
+### Deprecated test double aliases
+
+```ruby
+# Target
+stub('something')
+mock('something')
+
+# Converted
+double('something')
+```
+
+Disabled by: `--disable deprecated`
+
 ## Compatibility
 
 Tested on MRI 1.9, MRI 2.0 and JRuby in 1.9 mode.

data/lib/transpec/rewriter.rb

@@ -99,14 +99,18 @@ module Transpec
     end
 
     def process_should_receive(should_receive)
-      if @configuration.convert_to_expect_to_receive?
-        if should_receive.any_number_of_times? && @configuration.replace_deprecated_method?
-          should_receive.allowize_any_number_of_times!(@configuration.negative_form_of_to)
-        else
+      if should_receive.any_number_of_times?
+        if @configuration.replace_deprecated_method?
+          if @configuration.convert_to_allow_to_receive?
+            should_receive.allowize_any_number_of_times!(@configuration.negative_form_of_to)
+          else
+            should_receive.stubize_any_number_of_times!
+          end
+        elsif @configuration.convert_to_expect_to_receive?
           should_receive.expectize!(@configuration.negative_form_of_to)
         end
-      elsif should_receive.any_number_of_times? && @configuration.replace_deprecated_method?
-        should_receive.stubize_any_number_of_times!
+      elsif @configuration.convert_to_expect_to_receive?
+        should_receive.expectize!(@configuration.negative_form_of_to)
       end
     end
 

data/lib/transpec/version.rb

@@ -5,7 +5,7 @@ module Transpec
   module Version
     MAJOR = 0
     MINOR = 0
-    PATCH = 8
+    PATCH = 9
 
     def self.to_s
       [MAJOR, MINOR, PATCH].join('.')

data/spec/transpec/rewriter_spec.rb

@@ -163,129 +163,158 @@ module Transpec
     describe '#process_should_receive' do
       let(:should_receive_object) { double('should_receive_object').as_null_object }
 
-      context 'when Configuration#convert_to_expect_to_receive? is true' do
-        before { configuration.convert_to_expect_to_receive = true }
+      shared_examples 'does nothing' do
+        it 'does nothing' do
+          should_receive_object.should_not_receive(:expectize!)
+          should_receive_object.should_not_receive(:allowize_any_number_of_times!)
+          should_receive_object.should_not_receive(:stubize_any_number_of_times!)
+          rewriter.process_should_receive(should_receive_object)
+        end
+      end
 
-        context 'and ShouldReceive#any_number_of_times? returns true' do
-          before { should_receive_object.stub(:any_number_of_times?).and_return(true) }
+      context 'when ShouldReceive#any_number_of_times? returns true' do
+        before { should_receive_object.stub(:any_number_of_times?).and_return(true) }
 
-          context 'when Configuration#replace_deprecated_method? is true' do
-            before { configuration.replace_deprecated_method = true }
+        context 'and Configuration#replace_deprecated_method? is true' do
+          before { configuration.replace_deprecated_method = true }
 
-            context 'and Configuration#negative_form_of_to is "not_to"' do
-              before { configuration.negative_form_of_to = 'not_to' }
+          context 'and Configuration#convert_to_allow_to_receive? is true' do
+            before { configuration.convert_to_allow_to_receive = true }
 
-              it 'invokes ShouldReceive#allowize_any_number_of_times! with "not_to"' do
-                should_receive_object.should_receive(:allowize_any_number_of_times!).with('not_to')
-                rewriter.process_should_receive(should_receive_object)
-              end
-            end
+            [true, false].each do |convert_to_expect_to_receive|
+              context "and Configuration#convert_to_expect_to_receive? is #{convert_to_expect_to_receive}" do
+                before { configuration.convert_to_expect_to_receive = convert_to_expect_to_receive }
 
-            context 'and Configuration#negative_form_of_to is "to_not"' do
-              before { configuration.negative_form_of_to = 'to_not' }
+                context 'and Configuration#negative_form_of_to is "not_to"' do
+                  before { configuration.negative_form_of_to = 'not_to' }
 
-              it 'invokes ShouldReceive#allowize_any_number_of_times! with "to_not"' do
-                should_receive_object.should_receive(:allowize_any_number_of_times!).with('to_not')
-                rewriter.process_should_receive(should_receive_object)
-              end
-            end
-          end
-
-          context 'when Configuration#replace_deprecated_method? is false' do
-            before { configuration.replace_deprecated_method = false }
+                  it 'invokes ShouldReceive#allowize_any_number_of_times! with "not_to"' do
+                    should_receive_object.should_receive(:allowize_any_number_of_times!).with('not_to')
+                    rewriter.process_should_receive(should_receive_object)
+                  end
+                end
 
-            context 'and Configuration#negative_form_of_to is "not_to"' do
-              before { configuration.negative_form_of_to = 'not_to' }
+                context 'and Configuration#negative_form_of_to is "to_not"' do
+                  before { configuration.negative_form_of_to = 'to_not' }
 
-              it 'invokes ShouldReceive#expectize! with "not_to"' do
-                should_receive_object.should_receive(:expectize!).with('not_to')
-                rewriter.process_should_receive(should_receive_object)
+                  it 'invokes ShouldReceive#allowize_any_number_of_times! with "to_not"' do
+                    should_receive_object.should_receive(:allowize_any_number_of_times!).with('to_not')
+                    rewriter.process_should_receive(should_receive_object)
+                  end
+                end
               end
             end
+          end
+
+          context 'and Configuration#convert_to_allow_to_receive? is false' do
+            before { configuration.convert_to_allow_to_receive = false }
 
-            context 'and Configuration#negative_form_of_to is "to_not"' do
-              before { configuration.negative_form_of_to = 'to_not' }
+            [true, false].each do |convert_to_expect_to_receive|
+              context "and Configuration#convert_to_expect_to_receive? is #{convert_to_expect_to_receive}" do
+                before { configuration.convert_to_expect_to_receive = convert_to_expect_to_receive }
 
-              it 'invokes ShouldReceive#expectize! with "to_not"' do
-                should_receive_object.should_receive(:expectize!).with('to_not')
-                rewriter.process_should_receive(should_receive_object)
+                it 'invokes ShouldReceive#stubize_any_number_of_times!' do
+                  should_receive_object.should_receive(:stubize_any_number_of_times!)
+                  rewriter.process_should_receive(should_receive_object)
+                end
               end
             end
           end
         end
 
-        context 'and ShouldReceive#any_number_of_times? returns false' do
-          before { should_receive_object.stub(:any_number_of_times?).and_return(false) }
+        context 'and Configuration#replace_deprecated_method? is false' do
+          before { configuration.replace_deprecated_method = false }
 
-          [true, false].each do |replace_deprecated_method|
-            context "when Configuration#replace_deprecated_method? is #{replace_deprecated_method}" do
-              before { configuration.replace_deprecated_method = replace_deprecated_method }
+          [true, false].each do |convert_to_allow_to_receive|
+            context "and Configuration#convert_to_allow_to_receive? is #{convert_to_allow_to_receive}" do
+              before { configuration.convert_to_allow_to_receive = convert_to_allow_to_receive }
 
-              context 'and Configuration#negative_form_of_to is "not_to"' do
-                before { configuration.negative_form_of_to = 'not_to' }
+              context 'and Configuration#convert_to_expect_to_receive? is true' do
+                before { configuration.convert_to_expect_to_receive = true }
 
-                it 'invokes ShouldReceive#expectize! with "not_to"' do
-                  should_receive_object.should_receive(:expectize!).with('not_to')
-                  rewriter.process_should_receive(should_receive_object)
+                context 'and Configuration#negative_form_of_to is "not_to"' do
+                  before { configuration.negative_form_of_to = 'not_to' }
+
+                  it 'invokes ShouldReceive#expectize! with "not_to"' do
+                    should_receive_object.should_receive(:expectize!).with('not_to')
+                    rewriter.process_should_receive(should_receive_object)
+                  end
                 end
-              end
 
-              context 'and Configuration#negative_form_of_to is "to_not"' do
-                before { configuration.negative_form_of_to = 'to_not' }
+                context 'and Configuration#negative_form_of_to is "to_not"' do
+                  before { configuration.negative_form_of_to = 'to_not' }
 
-                it 'invokes ShouldReceive#expectize! with "to_not"' do
-                  should_receive_object.should_receive(:expectize!).with('to_not')
-                  rewriter.process_should_receive(should_receive_object)
+                  it 'invokes ShouldReceive#expectize! with "to_not"' do
+                    should_receive_object.should_receive(:expectize!).with('to_not')
+                    rewriter.process_should_receive(should_receive_object)
+                  end
                 end
               end
+
+              context 'and Configuration#convert_to_expect_to_receive? is false' do
+                before { configuration.convert_to_expect_to_receive = false }
+
+                include_examples 'does nothing'
+              end
             end
           end
         end
       end
 
-      shared_examples 'does nothing' do
-        it 'does nothing' do
-          should_receive_object.should_not_receive(:expectize!)
-          should_receive_object.should_not_receive(:allowize_any_number_of_times!)
-          should_receive_object.should_not_receive(:stubize_any_number_of_times!)
-          rewriter.process_should_receive(should_receive_object)
-        end
-      end
+      context 'when ShouldReceive#any_number_of_times? returns false' do
+        before { should_receive_object.stub(:any_number_of_times?).and_return(false) }
 
-      context 'when Configuration#convert_to_expect_to_receive? is false' do
-        before { configuration.convert_to_expect_to_receive = false }
+        context 'and Configuration#convert_to_expect_to_receive? is true' do
+          before { configuration.convert_to_expect_to_receive = true }
 
-        context 'and ShouldReceive#any_number_of_times? returns true' do
-          before { should_receive_object.stub(:any_number_of_times?).and_return(true) }
+          [true, false].each do |replace_deprecated_method|
+            context "and Configuration#replace_deprecated_method? is #{replace_deprecated_method}" do
+              before { configuration.replace_deprecated_method = replace_deprecated_method }
 
-          context 'when Configuration#replace_deprecated_method? is true' do
-            before { configuration.replace_deprecated_method = true }
+              [true, false].each do |convert_to_allow_to_receive|
+                context "and Configuration#convert_to_allow_to_receive? is #{convert_to_allow_to_receive}" do
+                  before { configuration.convert_to_allow_to_receive = convert_to_allow_to_receive }
 
-            it 'invokes ShouldReceive#stubize_any_number_of_times! with "not_to"' do
-              should_receive_object.should_receive(:stubize_any_number_of_times!)
-              rewriter.process_should_receive(should_receive_object)
-            end
-          end
+                  context 'and Configuration#negative_form_of_to is "not_to"' do
+                    before { configuration.negative_form_of_to = 'not_to' }
+
+                    it 'invokes ShouldReceive#expectize! with "not_to"' do
+                      should_receive_object.should_receive(:expectize!).with('not_to')
+                      rewriter.process_should_receive(should_receive_object)
+                    end
+                  end
 
-          context 'when Configuration#replace_deprecated_method? is false' do
-            before { configuration.replace_deprecated_method = false }
+                  context 'and Configuration#negative_form_of_to is "to_not"' do
+                    before { configuration.negative_form_of_to = 'to_not' }
 
-            include_examples 'does nothing'
+                    it 'invokes ShouldReceive#expectize! with "to_not"' do
+                      should_receive_object.should_receive(:expectize!).with('to_not')
+                      rewriter.process_should_receive(should_receive_object)
+                    end
+                  end
+                end
+              end
+            end
           end
         end
 
-        context 'and ShouldReceive#any_number_of_times? returns false' do
-          before { should_receive_object.stub(:any_number_of_times?).and_return(false) }
+        context 'and Configuration#convert_to_expect_to_receive? is false' do
+          before { configuration.convert_to_expect_to_receive = false }
 
           [true, false].each do |replace_deprecated_method|
-            context "when Configuration#replace_deprecated_method? is #{replace_deprecated_method}" do
+            context "and Configuration#replace_deprecated_method? is #{replace_deprecated_method}" do
               before { configuration.replace_deprecated_method = replace_deprecated_method }
 
-              include_examples 'does nothing'
+              [true, false].each do |convert_to_allow_to_receive|
+                context "and Configuration#convert_to_allow_to_receive? is #{convert_to_allow_to_receive}" do
+                  before { configuration.convert_to_allow_to_receive = convert_to_allow_to_receive }
+
+                  include_examples 'does nothing'
+                end
+              end
             end
           end
         end
-
       end
     end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: transpec
 version: !ruby/object:Gem::Version
-  version: 0.0.8
+  version: 0.0.9
 platform: ruby
 authors:
 - Yuji Nakayama
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-09-22 00:00:00.000000000 Z
+date: 2013-09-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parser