rspec-fire 1.1.3 → 1.2.0

data/Gemfile

@@ -1,4 +1,4 @@
-source :rubygems
+source 'https://rubygems.org'
 
 gemspec
 

data/HISTORY

@@ -41,3 +41,8 @@
 
 1.1.3 - 3 September 2012
   * Use __send__ in case classes have overriden it. (#25)
+
+1.2.0 - 2 June 2013
+  * Support `expect` syntax.
+  * Better naming in the API: `instance_double` and `class_double`. Deprecate
+    `fire_double` and `fire_class_double`.

data/README.md

@@ -87,7 +87,7 @@ Run your specs:
     rspec spec/user_spec.rb
 
     # Will fail if EmailNotifier#notify method is not defined
-    rspec -Ilib/email_notifier.rb spec/user_spec.rb
+    rspec -Ilib -remail_notifier.rb spec/user_spec.rb
 
 Method presence/absence is checked, and if a `with` is provided then so is
 arity.

data/lib/rspec/fire.rb

@@ -159,9 +159,13 @@ module RSpec
 
       protected
 
+      def expect(value)
+        ::RSpec::Expectations::ExpectationTarget.new(value)
+      end
+
       def ensure_arity(actual)
         @double.with_doubled_class do |klass|
-          klass.__send__(@method_finder, @sym).should support_arity(actual)
+          expect(klass.__send__(@method_finder, @sym)).to support_arity(actual)
         end
       end
 
@@ -171,7 +175,6 @@ module RSpec
     end
 
     module FireDoublable
-      extend RSpec::Matchers::DSL
       include RecursiveConstMethods
 
       def should_receive(method_name)
@@ -271,39 +274,48 @@ module RSpec
       end
     end
 
-    class FireClassDoubleBuilder
-      def self.build(doubled_class, stubs = {})
-        Module.new do
-          extend FireDoublable
+    class FireClassDouble < Module
+      include FireDoublable
 
-          @__doubled_class_name = doubled_class
-          @__checked_methods = :public_methods
-          @__method_finder   = :method
+      def initialize(doubled_class, stubs = {})
+        @__doubled_class_name = doubled_class
+        @__checked_methods = :public_methods
+        @__method_finder   = :method
 
-          verify_constant_name if RSpec::Fire.configuration.verify_constant_names?
+        verify_constant_name if RSpec::Fire.configuration.verify_constant_names?
 
-          ::RSpec::Mocks::TestDouble.extend_onto self,
-            doubled_class, stubs.merge(:__declared_as => "FireClassDouble")
+        ::RSpec::Mocks::TestDouble.extend_onto self,
+          doubled_class, stubs.merge(:__declared_as => "FireClassDouble")
 
-          def self.as_replaced_constant(options = {})
-            RSpec::Mocks::ConstantStubber.stub(@__doubled_class_name, self, options)
-            @__original_class = RSpec::Mocks::Constant.original(@__doubled_class_name).original_value
+        # This needs to come after `::RSpec::Mocks::TestDouble.extend_onto`
+        # so that it gets precedence...
+        extend StringRepresentations
+      end
 
-            extend AsReplacedConstant
-            self
-          end
+      def as_stubbed_const(options = {})
+        RSpec::Mocks::ConstantStubber.stub(@__doubled_class_name, self, options)
+        @__original_class = RSpec::Mocks::Constant.original(@__doubled_class_name).original_value
 
-          def self.to_s
-            @__doubled_class_name + " (fire double)"
-          end
+        extend AsReplacedConstant
+        self
+      end
 
-          def self.inspect
-            to_s
-          end
+      def as_replaced_constant(*args)
+        RSpec::Fire::DEPRECATED["as_replaced_constant is deprecated, use as_stubbed_const instead."]
+        as_stubbed_const(*args)
+      end
 
-          def self.name
-            @__doubled_class_name
-          end
+      def name
+        @__doubled_class_name
+      end
+
+      module StringRepresentations
+        def to_s
+          @__doubled_class_name + " (fire double)"
+        end
+
+        def inspect
+          to_s
         end
       end
 
@@ -319,16 +331,32 @@ module RSpec
       yield const.original_value if const.stubbed?
     end
 
-    def fire_double(*args)
+    def instance_double(*args)
       FireObjectDouble.new(*args)
     end
 
+    def class_double(*args)
+      FireClassDouble.new(*args)
+    end
+
+    def fire_double(*args)
+      DEPRECATED["fire_double is deprecated, use instance_double instead."]
+      instance_double(*args)
+    end
+
     def fire_class_double(*args)
-      FireClassDoubleBuilder.build(*args)
+      DEPRECATED["fire_class_double is deprecated, use class_double instead."]
+      class_double(*args)
     end
 
     def fire_replaced_class_double(*args)
-      fire_class_double(*args).as_replaced_constant
+      DEPRECATED["fire_replaced_class_double is deprecated, use class_double with as_stubbed_const instead."]
+      class_double(*args).as_stubbed_const
     end
+
+    DEPRECATED = lambda do |msg|
+      Kernel.warn caller[2] + ": " + msg
+    end
+
   end
 end

data/rspec-fire.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name     = 'rspec-fire'
-  s.version  = '1.1.3'
+  s.version  = '1.2.0'
   s.summary  = 'More resilient test doubles for RSpec.'
   s.platform = Gem::Platform::RUBY
   s.authors  = ["Xavier Shay"]

data/spec/fire_double_spec.rb

@@ -60,7 +60,7 @@ end
 
 shared_examples_for 'a fire-enhanced double method' do
   describe 'doubled class is not loaded' do
-    let(:doubled_object) { fire_double("UnloadedObject") }
+    let(:doubled_object) { instance_double("UnloadedObject") }
     should_allow(:undefined_method)
     should_allow('undefined_method')
   end
@@ -174,7 +174,7 @@ shared_examples_for 'a fire-enhanced double' do
 
       context "RSpec's hash shortcut syntax" do
         context 'doubled class is not loaded' do
-          let(:doubled_object) { fire_double("UnloadedObject") }
+          let(:doubled_object) { instance_double("UnloadedObject") }
           should_allow(:undefined_method => 123)
         end
 
@@ -187,29 +187,47 @@ shared_examples_for 'a fire-enhanced double' do
   end
 end
 
-describe '#fire_double' do
-  let(:doubled_object) { fire_double("TestObject") }
+describe '#instance_double' do
+  let(:doubled_object) { instance_double("TestObject") }
 
   it_should_behave_like 'a fire-enhanced double'
-  it_should_behave_like "verifying named constants", :fire_double
+  it_should_behave_like "verifying named constants", :instance_double
 
   it 'allows stubs to be passed as a hash' do
-    double = fire_double("TestObject", :defined_method => 17)
+    double = instance_double("TestObject", :defined_method => 17)
     double.defined_method.should eq(17)
   end
 
   it 'does not prevent stubbing methods on an unloaded nested constant with a name that matches a top-level constant' do
-    double = fire_double("TestObject::Hash")
+    double = instance_double("TestObject::Hash")
     double.stub(:foo).and_return("bar")
     double.foo.should eq("bar")
   end
+
+  def with_isolated_syntax_change
+    original_syntax = ::RSpec::Matchers.configuration.syntax
+    yield
+  ensure
+    ::RSpec::Matchers.configuration.syntax = original_syntax
+  end
+
+  it 'works when the `should` syntax is disabled' do
+    with_isolated_syntax_change do
+      ::RSpec::Matchers.configuration.syntax = :expect
+      expect(5).not_to respond_to(:should, :should_not)
+
+      double = instance_double("TestObject")
+      double.should_receive(:defined_method_one_arg).with(8)
+      double.defined_method_one_arg(8)
+    end
+  end
 end
 
-describe '#fire_class_double' do
-  let(:doubled_object) { fire_class_double("TestClass") }
+describe '#class_double' do
+  let(:doubled_object) { class_double("TestClass") }
 
   it_should_behave_like 'a fire-enhanced double'
-  it_should_behave_like "verifying named constants", :fire_class_double
+  it_should_behave_like "verifying named constants", :class_double
 
   it 'uses a module for the doubled object so that it supports nested constants like a real class' do
     doubled_object.should be_a(Module)
@@ -232,7 +250,7 @@ describe '#fire_class_double' do
   end
 
   it 'allows stubs to be specified as a hash' do
-    double = fire_class_double("SomeClass", :a => 5, :b => 8)
+    double = class_double("SomeClass", :a => 5, :b => 8)
     double.a.should eq(5)
     double.b.should eq(8)
   end
@@ -242,7 +260,7 @@ describe '#fire_class_double' do
     mod.stub(:use)
     expect { mod.use }.to raise_error(/private method `use' called/)
 
-    fire_double = fire_class_double("TestClass")
+    fire_double = class_double("TestClass")
     fire_double.stub(:use)
     fire_double.use # should not raise an error
   end if defined?(::RSpec::Mocks::TestDouble)
@@ -252,8 +270,8 @@ def reset_rspec_mocks
   ::RSpec::Mocks.space.reset_all
 end
 
-describe '#fire_replaced_class_double (for an existing class)' do
-  let(:doubled_object) { fire_replaced_class_double("TestClass") }
+describe '.as_stubbed_const (for an existing class)' do
+  let(:doubled_object) { class_double("TestClass").as_stubbed_const }
 
   it_should_behave_like 'a fire-enhanced double'
 
@@ -266,40 +284,34 @@ describe '#fire_replaced_class_double (for an existing class)' do
   end
 
   it 'supports transferring nested constants to the double' do
-    fire_class_double("TestClass").as_replaced_constant(:transfer_nested_constants => true)
+    class_double("TestClass").as_stubbed_const(:transfer_nested_constants => true)
     TestClass::M.should eq(:m)
     TestClass::N.should eq(:n)
   end
 
-  def use_doubles(class_double, instance_double)
-    instance_double.should_receive(:defined_method).and_return(3)
-    class_double.should_receive(:defined_method).and_return(4)
+  def use_doubles(class_double_obj, instance_double_obj)
+    instance_double_obj.should_receive(:defined_method).and_return(3)
+    class_double_obj.should_receive(:defined_method).and_return(4)
 
-    instance_double.defined_method.should eq(3)
-    class_double.defined_method.should eq(4)
+    instance_double_obj.defined_method.should eq(3)
+    class_double_obj.defined_method.should eq(4)
 
-    expect { instance_double.should_receive(:undefined_method) }.to fail_matching("does not implement")
-    expect { class_double.should_receive(:undefined_method) }.to fail_matching("does not implement")
+    expect { instance_double_obj.should_receive(:undefined_method) }.to fail_matching("does not implement")
+    expect { class_double_obj.should_receive(:undefined_method) }.to fail_matching("does not implement")
   end
 
   it 'can be used after a declared fire_double for the same class' do
-    instance_double = fire_double("TestClass")
-    class_double = fire_replaced_class_double("TestClass")
-
-    use_doubles class_double, instance_double
+    use_doubles instance_double("TestClass"), class_double("TestClass")
   end
 
   it 'can be used before a declared fire_double for the same class' do
-    class_double = fire_replaced_class_double("TestClass")
-    instance_double = fire_double("TestClass")
-
-    use_doubles class_double, instance_double
+    use_doubles class_double("TestClass"), instance_double("TestClass")
   end
 end
 
-describe '#fire_replaced_class_double (for a non-existant class)' do
+describe '.as_stubbed_const (for a non-existant class)' do
   it 'allows any method to be mocked' do
-    double = fire_replaced_class_double("A::B::C")
+    double = class_double("A::B::C").as_stubbed_const
     double.should_receive(:foo).with("a").and_return(:bar)
     A::B::C.foo("a").should eq(:bar)
   end
@@ -313,17 +325,13 @@ describe '#fire_replaced_class_double (for a non-existant class)' do
   end
 
   it 'can be used after a declared fire_double for the same class' do
-    instance_double = fire_double("A::B::C")
-    class_double = fire_replaced_class_double("A::B::C")
-
-    use_doubles class_double, instance_double
+    use_doubles class_double("A::B::C").as_stubbed_const,
+                instance_double("A::B::C")
   end
 
   it 'can be used before a declared fire_double for the same class' do
-    class_double = fire_replaced_class_double("A::B::C")
-    instance_double = fire_double("A::B::C")
-
-    use_doubles class_double, instance_double
+    use_doubles class_double("A::B::C").as_stubbed_const,
+                instance_double("A::B::C")
   end
 end
 
@@ -409,3 +417,25 @@ describe RSpec::Fire::SupportArityMatcher do
     end
   end
 end
+
+describe 'deprecation' do
+  specify '#fire_double warns user of deprecated usage' do
+    Kernel.should_receive(:warn)
+    fire_double("TestClass")
+  end
+
+  specify '#fire_class_double warns user of deprecated usage' do
+    Kernel.should_receive(:warn)
+    fire_class_double("TestClass")
+  end
+
+  specify '#fire_replaced_class_double warns user of deprecated usage' do
+    Kernel.should_receive(:warn)
+    fire_replaced_class_double("TestClass")
+  end
+
+  specify '#fire_replaced_class_double warns user of deprecated usage' do
+    Kernel.should_receive(:warn)
+    class_double("TestClass").as_replaced_constant
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rspec-fire
 version: !ruby/object:Gem::Version
-  version: 1.1.3
+  version: 1.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-03 00:00:00.000000000 Z
+date: 2013-06-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -79,7 +79,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
 summary: More resilient test doubles for RSpec.