rspec-fire 0.5.0 → 1.0.0

data/Gemfile

@@ -1,3 +1,4 @@
 source :rubygems
 
 gemspec
+

data/HISTORY

@@ -24,3 +24,7 @@
 0.5.0 - 4 July 2012
   * Performance improvements, overhead is now roughly 10% down from 100%
   * Allow both instance and class doubles for unloaded classes.
+
+1.0.0 - 9 July 2012
+  * RSpec 2.11 compatibility, no longer compatible with earlier versions.
+  * Removed `stub_const`, it is now in `rspec-mocks`.

data/README.md

@@ -144,25 +144,6 @@ collaborators (a technique that can sometimes be cumbersome).
 This will probably become the default behaviour once we figure out a better
 name for it.
 
-### Stubbing Constants
-
-The constant stubbing logic used when doubling class constants can be
-used for any constant.
-
-    class MapReduceRunner
-      ITEMS_PER_BATCH = 1000
-    end
-
-    describe MapReduceRunner, "when it has too many items for one batch" do
-      it "breaks the items up into smaller batches" do
-        # the test would be really slow if we had to make more than 1000 items,
-        # so let's change the threshold for this one test.
-        stub_const("MapReduceRunner::ITEMS_PER_BATCH", 10)
-
-        MapReduceRunner.run_with(twenty_items)
-      end
-    end
-
 ### Transferring nested constants to doubled constants
 
 When you use `fire_replaced_class_double` to replace a class or module
@@ -186,9 +167,6 @@ to deal with this:
     # ...or give it a list of constants to transfer
     fire_class_double("MyCoolGem").as_replaced_constant(:transfer_nested_constants => [:Widget])
 
-    # You can also use this when using #stub_const directly
-    stub_const("MyCoolGem", :transfer_nested_constants => true)
-
 ### Doubling class methods
 
 Particularly handy for `ActiveRecord` finders. Use `fire_class_double`. If you
@@ -207,7 +185,7 @@ refactor or use a non-isolated test.
 Compatibility
 -------------
 
-Only RSpec 2 is supported. Tested on all the rubies thanks to [Travis
+Only RSpec 2.11+ is supported. Tested on all the rubies thanks to [Travis
 CI][build-link].
 
 [build-link]:  http://travis-ci.org/xaviershay/rspec-fire

data/lib/rspec/fire.rb

@@ -135,7 +135,7 @@ module RSpec
       end
 
       def with_doubled_class
-        ConstantStubber.find_original_value_for(@__doubled_class_name) do |value|
+        ::RSpec::Fire.find_original_value_for(@__doubled_class_name) do |value|
           yield value if value
           return
         end
@@ -230,7 +230,9 @@ module RSpec
           end
 
           def self.as_replaced_constant(options = {})
-            @__original_class = ConstantStubber.stub!(@__doubled_class_name, self, options)
+            RSpec::Mocks::ConstantStubber.stub(@__doubled_class_name, self, options)
+            @__original_class = RSpec::Mocks::Constant.original(@__doubled_class_name).original_value
+
             extend AsReplacedConstant
             self
           end
@@ -256,161 +258,9 @@ module RSpec
       end
     end
 
-    class ConstantStubber
-      extend RecursiveConstMethods
-
-      class DefinedConstantReplacer
-        include RecursiveConstMethods
-        attr_reader :original_value, :full_constant_name
-
-        def initialize(full_constant_name, stubbed_value, transfer_nested_constants)
-          @full_constant_name        = full_constant_name
-          @stubbed_value             = stubbed_value
-          @transfer_nested_constants = transfer_nested_constants
-        end
-
-        def stub!
-          context_parts = @full_constant_name.split('::')
-          @const_name = context_parts.pop
-          @context = recursive_const_get(context_parts.join('::'))
-          @original_value = @context.const_get(@const_name)
-
-          constants_to_transfer = verify_constants_to_transfer!
-
-          @context.send(:remove_const, @const_name)
-          @context.const_set(@const_name, @stubbed_value)
-
-          transfer_nested_constants(constants_to_transfer)
-        end
-
-        def rspec_reset
-          if recursive_const_get(@full_constant_name).equal?(@stubbed_value)
-            @context.send(:remove_const, @const_name)
-            @context.const_set(@const_name, @original_value)
-          end
-        end
-
-        def transfer_nested_constants(constants)
-          constants.each do |const|
-            @stubbed_value.const_set(const, original_value.const_get(const))
-          end
-        end
-
-        def verify_constants_to_transfer!
-          return [] unless @transfer_nested_constants
-
-          { @original_value => "the original value", @stubbed_value => "the stubbed value" }.each do |value, description|
-            unless value.respond_to?(:constants)
-              raise ArgumentError,
-                "Cannot transfer nested constants for #{@full_constant_name} " +
-                "since #{description} is not a class or module and only classes " +
-                "and modules support nested constants."
-            end
-          end
-
-          if @transfer_nested_constants.is_a?(Array)
-            @transfer_nested_constants = @transfer_nested_constants.map(&:to_s) if RUBY_VERSION == '1.8.7'
-            undefined_constants = @transfer_nested_constants - @original_value.constants
-
-            if undefined_constants.any?
-              available_constants = @original_value.constants - @transfer_nested_constants
-              raise ArgumentError,
-                "Cannot transfer nested constant(s) #{undefined_constants.join(' and ')} " +
-                "for #{@full_constant_name} since they are not defined. Did you mean " +
-                "#{available_constants.join(' or ')}?"
-            end
-
-            @transfer_nested_constants
-          else
-            @original_value.constants
-          end
-        end
-      end
-
-      class UndefinedConstantSetter
-        include RecursiveConstMethods
-
-        attr_reader :full_constant_name
-
-        def initialize(full_constant_name, stubbed_value)
-          @full_constant_name = full_constant_name
-          @stubbed_value      = stubbed_value
-        end
-
-        def original_value
-          # always nil
-        end
-
-        def stub!
-          context_parts = @full_constant_name.split('::')
-          const_name = context_parts.pop
-
-          remaining_parts = context_parts.dup
-          @deepest_defined_const = context_parts.inject(Object) do |klass, name|
-            break klass unless klass.const_defined?(name)
-            remaining_parts.shift
-            klass.const_get(name)
-          end
-
-          context = remaining_parts.inject(@deepest_defined_const) do |klass, name|
-            klass.const_set(name, Module.new)
-          end
-
-          @const_to_remove = remaining_parts.first || const_name
-          context.const_set(const_name, @stubbed_value)
-        end
-
-        def rspec_reset
-          if recursive_const_get(@full_constant_name).equal?(@stubbed_value)
-            @deepest_defined_const.send(:remove_const, @const_to_remove)
-          end
-        end
-      end
-
-      def self.stub!(constant_name, value, options = {})
-        stubber = if recursive_const_defined?(constant_name)
-          DefinedConstantReplacer.new(constant_name, value, options[:transfer_nested_constants])
-        else
-          UndefinedConstantSetter.new(constant_name, value)
-        end
-
-        stubbers << stubber
-
-        stubber.stub!
-        ensure_registered_with_rspec_mocks
-        stubber.original_value
-      end
-
-      def self.ensure_registered_with_rspec_mocks
-        return if @registered_with_rspec_mocks
-        ::RSpec::Mocks.space.add(self)
-        @registered_with_rspec_mocks = true
-      end
-
-      def self.rspec_reset
-        @registered_with_rspec_mocks = false
-
-        # We use reverse order so that if the same constant
-        # was stubbed multiple times, the original value gets
-        # properly restored.
-        stubbers.reverse.each { |s| s.rspec_reset }
-
-        stubbers.clear
-      end
-
-      def self.stubbers
-        @stubbers ||= []
-      end
-
-      def self.find_original_value_for(constant_name)
-        stubber = stubbers.find { |s| s.full_constant_name == constant_name }
-        yield stubber.original_value if stubber
-        self
-      end
-    end
-
-    def stub_const(name, value, options = {})
-      ConstantStubber.stub!(name, value, options)
+    def self.find_original_value_for(constant_name)
+      const = ::RSpec::Mocks::Constant.original(constant_name)
+      yield const.original_value if const.stubbed?
     end
 
     def fire_double(*args)

data/rspec-fire.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name     = 'rspec-fire'
-  s.version  = '0.5.0'
+  s.version  = '1.0.0'
   s.summary  = 'More resilient test doubles for RSpec.'
   s.platform = Gem::Platform::RUBY
   s.authors  = ["Xavier Shay"]
@@ -18,6 +18,6 @@ Gem::Specification.new do |s|
                      rspec-fire.gemspec
                    )
 
+  s.add_dependency 'rspec', '~> 2.11'
   s.add_development_dependency 'rake'
-  s.add_development_dependency 'rspec', '~> 2.5'
 end

data/spec/fire_double_spec.rb

@@ -3,8 +3,6 @@ require 'spec_helper'
 def use; end
 private :use
 
-TOP_LEVEL_VALUE_CONST = 7
-
 module TestMethods
   def defined_method
     raise "Y U NO MOCK?"
@@ -26,11 +24,6 @@ class TestClass
   M = :m
   N = :n
 
-  class Nested
-    class NestedEvenMore
-    end
-  end
-
   def self.use
     raise "Y U NO MOCK?"
   end
@@ -294,248 +287,6 @@ describe '#fire_replaced_class_double (for a non-existant class)' do
   end
 end
 
-shared_examples_for "loaded constant stubbing" do |const_name|
-  include RSpec::Fire::RecursiveConstMethods
-  let!(:original_const_value) { const }
-  after { change_const_value_to(original_const_value) }
-
-  define_method :const do
-    recursive_const_get(const_name)
-  end
-
-  define_method :parent_const do
-    recursive_const_get("Object::" + const_name.sub(/(::)?[^:]+\z/, ''))
-  end
-
-  define_method :last_const_part do
-    const_name.split('::').last
-  end
-
-  def change_const_value_to(value)
-    parent_const.send(:remove_const, last_const_part)
-    parent_const.const_set(last_const_part, value)
-  end
-
-  it 'allows it to be stubbed' do
-    const.should_not eq(7)
-    stub_const(const_name, 7)
-    const.should eq(7)
-  end
-
-  it 'resets it to its original value when rspec clears its mocks' do
-    original_value = const
-    original_value.should_not eq(:a)
-    stub_const(const_name, :a)
-    reset_rspec_mocks
-    const.should be(original_value)
-  end
-
-  it 'does not reset the value to its original value when rspec clears its mocks if the example modifies the value of the constant' do
-    stub_const(const_name, :a)
-    change_const_value_to(new_const_value = Object.new)
-    reset_rspec_mocks
-    const.should be(new_const_value)
-  end
-
-  it 'returns the original value' do
-    orig_value = const
-    returned_value = stub_const(const_name, 7)
-    returned_value.should be(orig_value)
-  end
-end
-
-shared_examples_for "unloaded constant stubbing" do |const_name|
-  include RSpec::Fire::RecursiveConstMethods
-  before { recursive_const_defined?(const_name).should be_false }
-
-  define_method :const do
-    recursive_const_get(const_name)
-  end
-
-  define_method :parent_const do
-    recursive_const_get("Object::" + const_name.sub(/(::)?[^:]+\z/, ''))
-  end
-
-  define_method :last_const_part do
-    const_name.split('::').last
-  end
-
-  def change_const_value_to(value)
-    parent_const.send(:remove_const, last_const_part)
-    parent_const.const_set(last_const_part, value)
-  end
-
-  it 'allows it to be stubbed' do
-    stub_const(const_name, 7)
-    const.should eq(7)
-  end
-
-  it 'removes the constant when rspec clears its mocks' do
-    stub_const(const_name, 7)
-    reset_rspec_mocks
-    recursive_const_defined?(const_name).should be_false
-  end
-
-  it 'does not remove the constant when the example manually sets it' do
-    begin
-      stub_const(const_name, 7)
-      stubber = RSpec::Fire::ConstantStubber.stubbers.first
-      change_const_value_to(new_const_value = Object.new)
-      reset_rspec_mocks
-      const.should equal(new_const_value)
-    ensure
-      change_const_value_to(7)
-      stubber.rspec_reset
-    end
-  end
-
-  it 'returns nil since it was not originally set' do
-    stub_const(const_name, 7).should be_nil
-  end
-
-  it 'ignores the :transfer_nested_constants if passed' do
-    stub = Module.new
-    stub_const(const_name, stub, :transfer_nested_constants => true)
-    stub.constants.should eq([])
-  end
-end
-
-describe "#stub_const" do
-  context 'for a loaded unnested constant' do
-    it_behaves_like "loaded constant stubbing", "TestClass"
-
-    it 'can be stubbed multiple times but still restores the original value properly' do
-      orig_value = TestClass
-      stub1, stub2 = Module.new, Module.new
-      stub_const("TestClass", stub1)
-      stub_const("TestClass", stub2)
-
-      reset_rspec_mocks
-      TestClass.should be(orig_value)
-    end
-
-    it 'allows nested constants to be transferred to a stub module' do
-      tc_nested = TestClass::Nested
-      stub = Module.new
-      stub_const("TestClass", stub, :transfer_nested_constants => true)
-      stub::M.should eq(:m)
-      stub::N.should eq(:n)
-      stub::Nested.should be(tc_nested)
-    end
-
-    it 'allows nested constants to be selectively transferred to a stub module' do
-      stub = Module.new
-      stub_const("TestClass", stub, :transfer_nested_constants => [:M, :N])
-      stub::M.should eq(:m)
-      stub::N.should eq(:n)
-      defined?(stub::Nested).should be_false
-    end
-
-    it 'raises an error if asked to transfer nested constants but given an object that does not support them' do
-      original_tc = TestClass
-      stub = Object.new
-      expect {
-        stub_const("TestClass", stub, :transfer_nested_constants => true)
-      }.to raise_error(ArgumentError)
-
-      TestClass.should be(original_tc)
-
-      expect {
-        stub_const("TestClass", stub, :transfer_nested_constants => [:M])
-      }.to raise_error(ArgumentError)
-
-      TestClass.should be(original_tc)
-    end
-
-    it 'raises an error if asked to transfer nested constants on a constant that does not support nested constants' do
-      stub = Module.new
-      expect {
-        stub_const("TOP_LEVEL_VALUE_CONST", stub, :transfer_nested_constants => true)
-      }.to raise_error(ArgumentError)
-
-      TOP_LEVEL_VALUE_CONST.should eq(7)
-
-      expect {
-        stub_const("TOP_LEVEL_VALUE_CONST", stub, :transfer_nested_constants => [:M])
-      }.to raise_error(ArgumentError)
-
-      TOP_LEVEL_VALUE_CONST.should eq(7)
-    end
-
-    it 'raises an error if asked to transfer a nested constant that is not defined' do
-      original_tc = TestClass
-      defined?(TestClass::V).should be_false
-      stub = Module.new
-
-      expect {
-        stub_const("TestClass", stub, :transfer_nested_constants => [:V])
-      }.to raise_error(/cannot transfer nested constant.*V/i)
-
-      TestClass.should be(original_tc)
-    end
-  end
-
-  context 'for a loaded nested constant' do
-    it_behaves_like "loaded constant stubbing", "TestClass::Nested"
-  end
-
-  context 'for a loaded deeply nested constant' do
-    it_behaves_like "loaded constant stubbing", "TestClass::Nested::NestedEvenMore"
-  end
-
-  context 'for an unloaded unnested constant' do
-    it_behaves_like "unloaded constant stubbing", "X"
-  end
-
-  context 'for an unloaded nested constant' do
-    it_behaves_like "unloaded constant stubbing", "X::Y"
-
-    it 'removes the root constant when rspec clears its mocks' do
-      defined?(X).should be_false
-      stub_const("X::Y", 7)
-      reset_rspec_mocks
-      defined?(X).should be_false
-    end
-  end
-
-  context 'for an unloaded deeply nested constant' do
-    it_behaves_like "unloaded constant stubbing", "X::Y::Z"
-
-    it 'removes the root constant when rspec clears its mocks' do
-      defined?(X).should be_false
-      stub_const("X::Y::Z", 7)
-      reset_rspec_mocks
-      defined?(X).should be_false
-    end
-  end
-
-  context 'for an unloaded constant nested within a loaded constant' do
-    it_behaves_like "unloaded constant stubbing", "TestClass::X"
-
-    it 'removes the unloaded constant but leaves the loaded constant when rspec resets its mocks' do
-      defined?(TestClass).should be_true
-      defined?(TestClass::X).should be_false
-      stub_const("TestClass::X", 7)
-      reset_rspec_mocks
-      defined?(TestClass).should be_true
-      defined?(TestClass::X).should be_false
-    end
-  end
-
-  context 'for an unloaded constant nested deeply within a deeply nested loaded constant' do
-    it_behaves_like "unloaded constant stubbing", "TestClass::Nested::NestedEvenMore::X::Y::Z"
-
-    it 'removes the first unloaded constant but leaves the loaded nested constant when rspec resets its mocks' do
-      defined?(TestClass::Nested::NestedEvenMore).should be_true
-      defined?(TestClass::Nested::NestedEvenMore::X).should be_false
-      stub_const("TestClass::Nested::NestedEvenMore::X::Y::Z", 7)
-      reset_rspec_mocks
-      defined?(TestClass::Nested::NestedEvenMore).should be_true
-      defined?(TestClass::Nested::NestedEvenMore::X).should be_false
-    end
-  end
-end
-
 describe RSpec::Fire::SupportArityMatcher do
   def support_arity(arity)
     RSpec::Fire::SupportArityMatcher.new(arity)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rspec-fire
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 1.0.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,30 +9,30 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-07-04 00:00:00.000000000Z
+date: 2012-07-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: rake
-  requirement: &2159223000 !ruby/object:Gem::Requirement
+  name: rspec
+  requirement: &2156163500 !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
+        version: '2.11'
+  type: :runtime
   prerelease: false
-  version_requirements: *2159223000
+  version_requirements: *2156163500
 - !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: &2159222320 !ruby/object:Gem::Requirement
+  name: rake
+  requirement: &2156162900 !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ~>
+    - - ! '>='
       - !ruby/object:Gem::Version
-        version: '2.5'
+        version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2159222320
+  version_requirements: *2156162900
 description: 
 email:
 - hello@xaviershay.com
@@ -68,7 +68,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.10
+rubygems_version: 1.8.6
 signing_key: 
 specification_version: 3
 summary: More resilient test doubles for RSpec.