rspec
diff --git a/‎spec/rspec/mocks/and_call_original_spec.rb‎
Lines changed: 7 additions & 7 deletions b/‎spec/rspec/mocks/and_call_original_spec.rb‎
Lines changed: 7 additions & 7 deletions
diff --git a/‎spec/rspec/mocks/and_yield_spec.rb‎
Lines changed: 8 additions & 8 deletions b/‎spec/rspec/mocks/and_yield_spec.rb‎
Lines changed: 8 additions & 8 deletions
diff --git a/‎spec/rspec/mocks/any_instance_spec.rb‎
Lines changed: 14 additions & 14 deletions b/‎spec/rspec/mocks/any_instance_spec.rb‎
Lines changed: 14 additions & 14 deletions
diff --git a/‎spec/rspec/mocks/combining_implementation_instructions_spec.rb‎
Lines changed: 8 additions & 8 deletions b/‎spec/rspec/mocks/combining_implementation_instructions_spec.rb‎
Lines changed: 8 additions & 8 deletions
diff --git a/‎spec/rspec/mocks/double_spec.rb‎
Lines changed: 2 additions & 2 deletions b/‎spec/rspec/mocks/double_spec.rb‎
Lines changed: 2 additions & 2 deletions
@@ -81,10 +81,10 @@ def instance.foo; :bar; end
       end
 
       it 'works for SimpleDelegator subclasses', :if => (RUBY_VERSION.to_f > 1.8) do
-        instance = Class.new(SimpleDelegator).new(1)
-        def instance.foo; :bar; end
-        expect(instance).to receive(:foo).and_call_original
-        expect(instance.foo).to eq(:bar)
+        inst = Class.new(SimpleDelegator).new(1)
+        def inst.foo; :bar; end
+        expect(inst).to receive(:foo).and_call_original
+        expect(inst.foo).to eq(:bar)
       end
     end
 
@@ -162,14 +162,14 @@ def instance.foo; :bar; end
     end
 
     it 'works for aliased methods' do
-      klass = Class.new do
+      klazz = Class.new do
         class << self
           alias alternate_new new
         end
       end
 
-      expect(klass).to receive(:alternate_new).and_call_original
-      expect(klass.alternate_new).to be_an_instance_of(klass)
+      expect(klazz).to receive(:alternate_new).and_call_original
+      expect(klazz.alternate_new).to be_an_instance_of(klazz)
     end
 
     context 'on an object that defines method_missing' do
 
@@ -90,8 +90,8 @@
             expect(yielded_arg).to receive(:bar)
           end
 
-          obj.method_that_accepts_a_block do |obj|
-            obj.bar
+          obj.method_that_accepts_a_block do |object|
+            object.bar
             foo
           end
 
@@ -103,25 +103,25 @@
           it "yields the default argument when the argument is not given" do
             pending "Not sure how to achieve this yet. See rspec/rspec-mocks#714 and rspec/rspec-support#85."
             default_arg = Object.new
-            obj = Object.new
+            object = Object.new
 
-            allow(obj).to receive(:a_message).and_yield
+            allow(object).to receive(:a_message).and_yield
             expect(default_arg).to receive(:bar)
 
-            eval("obj.a_message { |receiver=default_arg| receiver.bar }")
+            eval("object.a_message { |receiver=default_arg| receiver.bar }")
           end
 
           it "yields given argument when the argument is given" do
             default_arg = Object.new
             allow(default_arg).to receive(:bar)
 
             given_arg = Object.new
-            obj = Object.new
+            object = Object.new
 
-            allow(obj).to receive(:a_message).and_yield(given_arg)
+            allow(object).to receive(:a_message).and_yield(given_arg)
             expect(given_arg).to receive(:bar)
 
-            eval("obj.a_message { |receiver=default_arg| receiver.bar }")
+            eval("object.a_message { |receiver=default_arg| receiver.bar }")
           end
         end
 
 
@@ -695,22 +695,22 @@ def inspect
         end
 
         it 'works with a BasicObject subclass that mixes in Kernel', :if => defined?(BasicObject) do
-          klass = Class.new(BasicObject) do
+          klazz = Class.new(BasicObject) do
             include ::Kernel
             def foo; end
           end
 
-          expect_any_instance_of(klass).to receive(:foo)
-          klass.new.foo
+          expect_any_instance_of(klazz).to receive(:foo)
+          klazz.new.foo
         end
 
         it 'works with a SimpleDelegator subclass', :if => (RUBY_VERSION.to_f > 1.8) do
-          klass = Class.new(SimpleDelegator) do
+          klazz = Class.new(SimpleDelegator) do
             def foo; end
           end
 
-          expect_any_instance_of(klass).to receive(:foo)
-          klass.new(Object.new).foo
+          expect_any_instance_of(klazz).to receive(:foo)
+          klazz.new(Object.new).foo
         end
 
         context "with argument matching" do
@@ -1094,13 +1094,13 @@ def foo; end
             end
 
             it "does not pass the instance to and_call_original" do
-              klass = Class.new do
+              klazz = Class.new do
                 def call(*args)
                   args.first
                 end
               end
-              expect_any_instance_of(klass).to receive(:call).and_call_original
-              instance = klass.new
+              expect_any_instance_of(klazz).to receive(:call).and_call_original
+              instance = klazz.new
               expect(instance.call(:bees)).to be :bees
             end
           end
@@ -1159,21 +1159,21 @@ def call(*args)
         end
 
         it "doesn't bomb if the object doesn't support `dup`" do
-          klass = Class.new do
+          klazz = Class.new do
             undef_method :dup
           end
-          allow_any_instance_of(klass).to receive(:foo)
+          allow_any_instance_of(klazz).to receive(:foo)
         end
 
         it "doesn't fail when dup accepts parameters" do
-          klass = Class.new do
+          klazz = Class.new do
             def dup(funky_option)
             end
           end
 
-          allow_any_instance_of(klass).to receive(:foo)
+          allow_any_instance_of(klazz).to receive(:foo)
 
-          expect { klass.new.dup('Dup dup dup') }.to_not raise_error
+          expect { klazz.new.dup('Dup dup dup') }.to_not raise_error
         end
       end
 
 
@@ -125,35 +125,35 @@ def verify_combined_implementation
       end
 
       describe "a double that already has a terminal `and_return(x)` action" do
-        let(:dbl) { double }
-        let(:stubbed_double) { allow(dbl).to receive(:foo) }
+        let(:the_dbl) { double }
+        let(:stubbed_double) { allow(the_dbl).to receive(:foo) }
         before { stubbed_double.and_return(1) }
 
         it 'allows the terminal action to be overriden to `and_return(y)`' do
           stubbed_double.and_return(3)
-          expect(dbl.foo).to eq(3)
+          expect(the_dbl.foo).to eq(3)
         end
 
         it 'allows the terminal action to be overriden to `and_raise(y)`' do
           stubbed_double.and_raise("boom")
-          expect { dbl.foo }.to raise_error("boom")
+          expect { the_dbl.foo }.to raise_error("boom")
         end
 
         it 'allows the terminal action to be overriden to `and_throw(y)`' do
           stubbed_double.and_throw(:bar)
-          expect { dbl.foo }.to throw_symbol(:bar)
+          expect { the_dbl.foo }.to throw_symbol(:bar)
         end
       end
 
       describe "a double that already has a terminal block action" do
-        let(:dbl) { double }
-        let(:stubbed_double) { allow(dbl).to receive(:foo) }
+        let(:the_dbl) { double }
+        let(:stubbed_double) { allow(the_dbl).to receive(:foo) }
 
         it "allows the block action to be overridden" do
           allow(RSpec).to receive(:warning)
           stubbed_double.with(:arg) { :with_block }
           stubbed_double.at_least(:once) { :at_least_block }
-          expect(dbl.foo(:arg)).to eq(:at_least_block)
+          expect(the_dbl.foo(:arg)).to eq(:at_least_block)
         end
       end
 
 
@@ -13,8 +13,8 @@ module Mocks
       end
 
       it "uses 'Double' in failure messages" do
-        double = double('name')
-        expect { double.foo }.to raise_error(/Double "name" received/)
+        dbl = double('name')
+        expect { dbl.foo }.to raise_error(/Double "name" received/)
       end
 
       it "hides internals in its inspect representation" do