rspec-fire 1.2.0 → 1.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e86bfffbe18d293983737f7d60713a010565fd33
+  data.tar.gz: 544afff69dfe86663b90a805108e0ddcbfa74d75
+SHA512:
+  metadata.gz: 509aaa64ac7fababd932c9aeae28b935702866eb58efc8232d248c7c399c2594931f71c8217efa38cdbf0e2639c81320d7d335c2a05aea593e7486bf32ad3646
+  data.tar.gz: f0d73156a6f2dc1429a84a3ef0148847cfc58c61e4bba52b8b96fa8f496df084b9549f414db69a5f079b8ad2ddfe325bd0008a1d022910ad1237305fa1c85fcb

data/HISTORY

@@ -46,3 +46,7 @@
   * Support `expect` syntax.
   * Better naming in the API: `instance_double` and `class_double`. Deprecate
     `fire_double` and `fire_class_double`.
+
+1.3.0 - 7 November 2013
+  * Support for RSpec 3. When it is loaded, this library is now a no-op since
+    all the functionality (and more!) was ported.

data/README.md

@@ -1,7 +1,8 @@
 rspec-fire
 ==========
 
-Making your test doubles more resilient.
+Checks that stubbed methods on your test double exist, but still allow you to run in isolation
+when you choose. A failure will be triggered if an invalid method is being stubbed.
 
     Once,
     a younger brother came to him,
@@ -72,7 +73,7 @@ Specify the class being doubled in your specs:
     describe User, '#suspend!' do
       it 'sends a notification' do
         # Only this one line differs from how you write specs normally
-        notifier = fire_double("EmailNotifier")
+        notifier = instance_double("EmailNotifier")
 
         notifier.should_receive(:notify).with("suspended as")
 
@@ -117,7 +118,7 @@ A workaround is to explicitly define the methods you are mocking:
 ### Doubling constants
 
 A particularly excellent feature. You can stub out constants using
-`fire_replaced_class_double`, removing the need to dependency inject
+`class_double`, removing the need to dependency inject
 collaborators (a technique that can sometimes be cumbersome).
 
     class User
@@ -129,10 +130,7 @@ collaborators (a technique that can sometimes be cumbersome).
     describe User, '#suspend!' do
       it 'sends a notification' do
         # Only this one line differs from how you write specs normally
-        notifier = fire_replaced_class_double("EmailNotifier")
-
-        # Alternately, you can use this fluent interface
-        notifier = fire_class_double("EmailNotifier").as_replaced_constant
+        notifier = class_double("EmailNotifier").as_stubbed_const
 
         notifier.should_receive(:notify).with("suspended as")
 
@@ -146,7 +144,7 @@ name for it.
 
 ### Transferring nested constants to doubled constants
 
-When you use `fire_replaced_class_double` to replace a class or module
+When you use `class_double` to replace a class or module
 that also acts as a namespace for other classes and constants, your
 access to these constants is cut off for the duration of the example
 (since the doubled constant does not automatically have all of the
@@ -159,23 +157,23 @@ to deal with this:
     end
 
     # once you do this, you can no longer access MyCoolGem::Widget in your example...
-    fire_replaced_class_double("MyCoolGem")
+    class_double("MyCoolGem")
 
     # ...unless you tell rspec-fire to transfer all nested constants
-    fire_class_double("MyCoolGem").as_replaced_constant(:transfer_nested_constants => true)
+    class_double("MyCoolGem").as_stubbed_const(:transfer_nested_constants => true)
 
     # ...or give it a list of constants to transfer
-    fire_class_double("MyCoolGem").as_replaced_constant(:transfer_nested_constants => [:Widget])
+    class_double("MyCoolGem").as_stubbed_const(:transfer_nested_constants => [:Widget])
 
 ### Doubling class methods
 
-Particularly handy for `ActiveRecord` finders. Use `fire_class_double`. If you
+Particularly handy for `ActiveRecord` finders. Use `class_double`. If you
 dig into the code, you'll find you can create subclasses of `FireDouble` to
 check for *any* set of methods.
 
 ### Preventing Typo'd Constant Names
 
-`fire_double("MyClas")` will not verify any mocked methods, even when
+`instance_double("MyClas")` will not verify any mocked methods, even when
 `MyClass` is loaded, because of the typo in the constant name. There's
 an option to help prevent these sorts of fat-finger errors:
 

data/lib/rspec/fire.rb

@@ -1,362 +1,11 @@
 require 'rspec/mocks'
 require 'rspec/expectations'
-require 'delegate'
 
-module RSpec
-  module Fire
-    class Configuration
-      attr_accessor :verify_constant_names
-      alias verify_constant_names? verify_constant_names
-
-      def initialize
-        self.verify_constant_names = false
-      end
-    end
-
-    def self.configuration
-      @configuration ||= Configuration.new
-    end
-
-    def self.configure
-      yield configuration
-    end
-
-    Error = Class.new(StandardError)
-    UndefinedConstantError = Class.new(Error)
-
-    class SupportArityMatcher
-      def initialize(arity)
-        @arity = arity
-      end
-
-      attr_reader :arity, :method
-
-      def matches?(method)
-        @method = method
-        min_arity <= arity && arity <= max_arity
-      end
-
-      def failure_message_for_should
-        "Wrong number of arguments for #{method.name}. " +
-          "Expected #{arity_description}, got #{arity}."
-      end
-
-    private
-
-      INFINITY = 1/0.0
-
-      if method(:method).respond_to?(:parameters)
-        def max_arity
-          params = method.parameters
-          return INFINITY if params.any? { |(type, name)| type == :rest } # splat
-          params.count { |(type, name)| type != :block }
-        end
-      else
-        # On 1.8, Method#parameters does not exist.
-        # There's no way to distinguish between default and splat args, so
-        # there's no way to have it work correctly for both default and splat args,
-        # as far as I can tell.
-        # The best we can do is consider it INFINITY (to be tolerant of splat args).
-        def max_arity
-          method.arity < 0 ? INFINITY : method.arity
-        end
-      end
-
-      def min_arity
-        return method.arity if method.arity >= 0
-        # ~ inverts the one's complement and gives us the number of required args
-        ~method.arity
-      end
-
-      def arity_description
-        return min_arity if min_arity == max_arity
-        return "#{min_arity} or more" if max_arity == INFINITY
-        "#{min_arity} to #{max_arity}"
-      end
-    end
-
-    module RecursiveConstMethods
-      # We only want to consider constants that are defined directly on a
-      # particular module, and not include top-level/inherited constants.
-      # Unfortunately, the constant API changed between 1.8 and 1.9, so
-      # we need to conditionally define methods to ignore the top-level/inherited
-      # constants.
-      #
-      # Given `class A; end`:
-      #
-      # On 1.8:
-      #   - A.const_get("Hash") # => ::Hash
-      #   - A.const_defined?("Hash") # => false
-      #   - Neither method accepts the extra `inherit` argument
-      # On 1.9:
-      #   - A.const_get("Hash") # => ::Hash
-      #   - A.const_defined?("Hash") # => true
-      #   - A.const_get("Hash", false) # => raises NameError
-      #   - A.const_defined?("Hash", false) # => false
-      if Module.method(:const_defined?).arity == 1
-        def const_defined_on?(mod, const_name)
-          mod.const_defined?(const_name)
-        end
-
-        def get_const_defined_on(mod, const_name)
-          if const_defined_on?(mod, const_name)
-            return mod.const_get(const_name)
-          end
-
-          raise NameError, "uninitialized constant #{mod.name}::#{const_name}"
-        end
-      else
-        def const_defined_on?(mod, const_name)
-          mod.const_defined?(const_name, false)
-        end
-
-        def get_const_defined_on(mod, const_name)
-          mod.const_get(const_name, false)
-        end
-      end
-
-      def recursive_const_get name
-        name.split('::').inject(Object) {|klass,name| get_const_defined_on(klass, name) }
-      end
-
-      def recursive_const_defined? name
-        !!name.split('::').inject(Object) {|klass,name|
-          if klass && const_defined_on?(klass, name)
-            get_const_defined_on(klass, name)
-          end
-        }
-      end
-    end
-
-    class ShouldProxy < SimpleDelegator
-      include RecursiveConstMethods
-
-      AM = RSpec::Mocks::ArgumentMatchers
-
-      def initialize(double, method_finder, backing)
-        @double             = double
-        @method_finder      = method_finder
-        @backing            = backing
-        @sym = backing.respond_to?(:sym) ? @backing.sym : @backing.message
-        super(backing)
-      end
-
-      def with(*args, &block)
-        unless AM::AnyArgsMatcher === args.first
-          expected_arity = if AM::NoArgsMatcher === args.first
-            0
-          elsif args.length > 0
-            args.length
-          elsif block
-            block.arity
-          else
-            raise ArgumentError.new("No arguments nor block given.")
-          end
-          ensure_arity(expected_arity)
-        end
-        __getobj__.with(*args, &block)
-      end
-
-      protected
-
-      def expect(value)
-        ::RSpec::Expectations::ExpectationTarget.new(value)
-      end
-
-      def ensure_arity(actual)
-        @double.with_doubled_class do |klass|
-          expect(klass.__send__(@method_finder, @sym)).to support_arity(actual)
-        end
-      end
-
-      def support_arity(arity)
-        SupportArityMatcher.new(arity)
-      end
-    end
-
-    module FireDoublable
-      include RecursiveConstMethods
-
-      def should_receive(method_name)
-        ensure_implemented(method_name)
-        ShouldProxy.new(self, @__method_finder, super)
-      end
-
-      def should_not_receive(method_name)
-        ensure_implemented(method_name)
-        super
-      end
-
-      def stub(method_name)
-        ensure_implemented(method_name) unless method_name.is_a?(Hash)
-        super
-      end
-
-      def stub!(method_name)
-        stub(method_name)
-      end
-
-      def with_doubled_class
-        ::RSpec::Fire.find_original_value_for(@__doubled_class_name) do |value|
-          yield value if value
-          return
-        end
-
-        if recursive_const_defined?(@__doubled_class_name)
-          yield recursive_const_get(@__doubled_class_name)
-        end
-      end
-
-      protected
-
-      # This cache gives a decent speed up when a class is doubled a lot.
-      def implemented_methods(doubled_class, checked_methods)
-        @@_implemented_methods_cache ||= {}
-
-        # to_sym for non-1.9 compat
-        @@_implemented_methods_cache[[doubled_class, checked_methods]] ||=
-          doubled_class.__send__(checked_methods).map(&:to_sym)
-      end
-
-      def unimplemented_methods(doubled_class, expected_methods, checked_methods)
-        expected_methods.map(&:to_sym) -
-          implemented_methods(doubled_class, checked_methods)
-      end
-
-      def ensure_implemented(*method_names)
-        with_doubled_class do |doubled_class|
-          methods = unimplemented_methods(
-            doubled_class,
-            method_names,
-            @__checked_methods
-          )
-
-          if methods.any?
-            implemented_methods =
-              Object.public_methods -
-                implemented_methods(doubled_class, @__checked_methods)
-
-            msg = "%s does not implement:\n%s" % [
-              doubled_class,
-              methods.sort.map {|x|
-                "  #{x}"
-              }.join("\n")
-
-            ]
-            raise RSpec::Expectations::ExpectationNotMetError, msg
-          end
-        end
-      end
-
-      def verify_constant_name
-        return if recursive_const_defined?(@__doubled_class_name)
-
-        raise UndefinedConstantError, "#{@__doubled_class_name} is not a defined constant."
-      end
-    end
-
-    class FireObjectDouble < RSpec::Mocks::Mock
-      include FireDoublable
-
-      def initialize(doubled_class, *args)
-        args << {} unless Hash === args.last
-
-        @__doubled_class_name = doubled_class
-        verify_constant_name if RSpec::Fire.configuration.verify_constant_names?
-
-        # __declared_as copied from rspec/mocks definition of `double`
-        args.last[:__declared_as] = 'FireDouble'
-
-        @__checked_methods = :public_instance_methods
-        @__method_finder   = :instance_method
-
-        super
-      end
-    end
-
-    class FireClassDouble < Module
-      include FireDoublable
-
-      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?
-
-        ::RSpec::Mocks::TestDouble.extend_onto self,
-          doubled_class, stubs.merge(:__declared_as => "FireClassDouble")
-
-        # This needs to come after `::RSpec::Mocks::TestDouble.extend_onto`
-        # so that it gets precedence...
-        extend StringRepresentations
-      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
-
-        extend AsReplacedConstant
-        self
-      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 name
-        @__doubled_class_name
-      end
-
-      module StringRepresentations
-        def to_s
-          @__doubled_class_name + " (fire double)"
-        end
-
-        def inspect
-          to_s
-        end
-      end
-
-      module AsReplacedConstant
-        def with_doubled_class
-          yield @__original_class if @__original_class
-        end
-      end
-    end
-
-    def self.find_original_value_for(constant_name)
-      const = ::RSpec::Mocks::Constant.original(constant_name)
-      yield const.original_value if const.stubbed?
-    end
-
-    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)
-      DEPRECATED["fire_class_double is deprecated, use class_double instead."]
-      class_double(*args)
-    end
-
-    def fire_replaced_class_double(*args)
-      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
+if RSpec::Mocks::Version::STRING.to_f >= 3
+  warn "rspec-fire functionality is now provided by rspec-mocks and is " +
+    "no longer required. You can remove it from your dependencies."
+else
+  require 'rspec/fire/legacy'
 end
+
+require 'rspec/fire/configuration'

data/lib/rspec/fire/configuration.rb

@@ -0,0 +1,20 @@
+module RSpec
+  module Fire
+    class Configuration
+      attr_accessor :verify_constant_names
+      alias verify_constant_names? verify_constant_names
+
+      def initialize
+        self.verify_constant_names = false
+      end
+    end
+
+    def self.configuration
+      @configuration ||= Configuration.new
+    end
+
+    def self.configure
+      yield configuration
+    end
+  end
+end

data/lib/rspec/fire/legacy.rb

@@ -0,0 +1,343 @@
+require 'delegate'
+
+module RSpec
+  module Fire
+    Error = Class.new(StandardError)
+    UndefinedConstantError = Class.new(Error)
+
+    class SupportArityMatcher
+      def initialize(arity)
+        @arity = arity
+      end
+
+      attr_reader :arity, :method
+
+      def matches?(method)
+        @method = method
+        min_arity <= arity && arity <= max_arity
+      end
+
+      def failure_message_for_should
+        "Wrong number of arguments for #{method.name}. " +
+          "Expected #{arity_description}, got #{arity}."
+      end
+
+    private
+
+      INFINITY = 1/0.0
+
+      if method(:method).respond_to?(:parameters)
+        def max_arity
+          params = method.parameters
+          return INFINITY if params.any? { |(type, name)| type == :rest } # splat
+          params.count { |(type, name)| type != :block }
+        end
+      else
+        # On 1.8, Method#parameters does not exist.
+        # There's no way to distinguish between default and splat args, so
+        # there's no way to have it work correctly for both default and splat args,
+        # as far as I can tell.
+        # The best we can do is consider it INFINITY (to be tolerant of splat args).
+        def max_arity
+          method.arity < 0 ? INFINITY : method.arity
+        end
+      end
+
+      def min_arity
+        return method.arity if method.arity >= 0
+        # ~ inverts the one's complement and gives us the number of required args
+        ~method.arity
+      end
+
+      def arity_description
+        return min_arity if min_arity == max_arity
+        return "#{min_arity} or more" if max_arity == INFINITY
+        "#{min_arity} to #{max_arity}"
+      end
+    end
+
+    module RecursiveConstMethods
+      # We only want to consider constants that are defined directly on a
+      # particular module, and not include top-level/inherited constants.
+      # Unfortunately, the constant API changed between 1.8 and 1.9, so
+      # we need to conditionally define methods to ignore the top-level/inherited
+      # constants.
+      #
+      # Given `class A; end`:
+      #
+      # On 1.8:
+      #   - A.const_get("Hash") # => ::Hash
+      #   - A.const_defined?("Hash") # => false
+      #   - Neither method accepts the extra `inherit` argument
+      # On 1.9:
+      #   - A.const_get("Hash") # => ::Hash
+      #   - A.const_defined?("Hash") # => true
+      #   - A.const_get("Hash", false) # => raises NameError
+      #   - A.const_defined?("Hash", false) # => false
+      if Module.method(:const_defined?).arity == 1
+        def const_defined_on?(mod, const_name)
+          mod.const_defined?(const_name)
+        end
+
+        def get_const_defined_on(mod, const_name)
+          if const_defined_on?(mod, const_name)
+            return mod.const_get(const_name)
+          end
+
+          raise NameError, "uninitialized constant #{mod.name}::#{const_name}"
+        end
+      else
+        def const_defined_on?(mod, const_name)
+          mod.const_defined?(const_name, false)
+        end
+
+        def get_const_defined_on(mod, const_name)
+          mod.const_get(const_name, false)
+        end
+      end
+
+      def recursive_const_get name
+        name.split('::').inject(Object) {|klass,name| get_const_defined_on(klass, name) }
+      end
+
+      def recursive_const_defined? name
+        !!name.split('::').inject(Object) {|klass,name|
+          if klass && const_defined_on?(klass, name)
+            get_const_defined_on(klass, name)
+          end
+        }
+      end
+    end
+
+    class ShouldProxy < SimpleDelegator
+      include RecursiveConstMethods
+
+      AM = RSpec::Mocks::ArgumentMatchers
+
+      def initialize(double, method_finder, backing)
+        @double             = double
+        @method_finder      = method_finder
+        @backing            = backing
+        @sym = backing.respond_to?(:sym) ? @backing.sym : @backing.message
+        super(backing)
+      end
+
+      def with(*args, &block)
+        unless AM::AnyArgsMatcher === args.first
+          expected_arity = if AM::NoArgsMatcher === args.first
+            0
+          elsif args.length > 0
+            args.length
+          elsif block
+            block.arity
+          else
+            raise ArgumentError.new("No arguments nor block given.")
+          end
+          ensure_arity(expected_arity)
+        end
+        __getobj__.with(*args, &block)
+      end
+
+      protected
+
+      def expect(value)
+        ::RSpec::Expectations::ExpectationTarget.new(value)
+      end
+
+      def ensure_arity(actual)
+        @double.with_doubled_class do |klass|
+          expect(klass.__send__(@method_finder, @sym)).to support_arity(actual)
+        end
+      end
+
+      def support_arity(arity)
+        SupportArityMatcher.new(arity)
+      end
+    end
+
+    module FireDoublable
+      include RecursiveConstMethods
+
+      def should_receive(method_name)
+        ensure_implemented(method_name)
+        ShouldProxy.new(self, @__method_finder, super)
+      end
+
+      def should_not_receive(method_name)
+        ensure_implemented(method_name)
+        super
+      end
+
+      def stub(method_name)
+        ensure_implemented(method_name) unless method_name.is_a?(Hash)
+        super
+      end
+
+      def stub!(method_name)
+        stub(method_name)
+      end
+
+      def with_doubled_class
+        ::RSpec::Fire.find_original_value_for(@__doubled_class_name) do |value|
+          yield value if value
+          return
+        end
+
+        if recursive_const_defined?(@__doubled_class_name)
+          yield recursive_const_get(@__doubled_class_name)
+        end
+      end
+
+      protected
+
+      # This cache gives a decent speed up when a class is doubled a lot.
+      def implemented_methods(doubled_class, checked_methods)
+        @@_implemented_methods_cache ||= {}
+
+        # to_sym for non-1.9 compat
+        @@_implemented_methods_cache[[doubled_class, checked_methods]] ||=
+          doubled_class.__send__(checked_methods).map(&:to_sym)
+      end
+
+      def unimplemented_methods(doubled_class, expected_methods, checked_methods)
+        expected_methods.map(&:to_sym) -
+          implemented_methods(doubled_class, checked_methods)
+      end
+
+      def ensure_implemented(*method_names)
+        with_doubled_class do |doubled_class|
+          methods = unimplemented_methods(
+            doubled_class,
+            method_names,
+            @__checked_methods
+          )
+
+          if methods.any?
+            implemented_methods =
+              Object.public_methods -
+                implemented_methods(doubled_class, @__checked_methods)
+
+            msg = "%s does not implement:\n%s" % [
+              doubled_class,
+              methods.sort.map {|x|
+                "  #{x}"
+              }.join("\n")
+
+            ]
+            raise RSpec::Expectations::ExpectationNotMetError, msg
+          end
+        end
+      end
+
+      def verify_constant_name
+        return if recursive_const_defined?(@__doubled_class_name)
+
+        raise UndefinedConstantError, "#{@__doubled_class_name} is not a defined constant."
+      end
+    end
+
+    class FireObjectDouble < RSpec::Mocks::Mock
+      include FireDoublable
+
+      def initialize(doubled_class, *args)
+        args << {} unless Hash === args.last
+
+        @__doubled_class_name = doubled_class
+        verify_constant_name if RSpec::Fire.configuration.verify_constant_names?
+
+        # __declared_as copied from rspec/mocks definition of `double`
+        args.last[:__declared_as] = 'FireDouble'
+
+        @__checked_methods = :public_instance_methods
+        @__method_finder   = :instance_method
+
+        super
+      end
+    end
+
+    class FireClassDouble < Module
+      include FireDoublable
+
+      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?
+
+        ::RSpec::Mocks::TestDouble.extend_onto self,
+          doubled_class, stubs.merge(:__declared_as => "FireClassDouble")
+
+        # This needs to come after `::RSpec::Mocks::TestDouble.extend_onto`
+        # so that it gets precedence...
+        extend StringRepresentations
+      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
+
+        extend AsReplacedConstant
+        self
+      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 name
+        @__doubled_class_name
+      end
+
+      module StringRepresentations
+        def to_s
+          @__doubled_class_name + " (fire double)"
+        end
+
+        def inspect
+          to_s
+        end
+      end
+
+      module AsReplacedConstant
+        def with_doubled_class
+          yield @__original_class if @__original_class
+        end
+      end
+    end
+
+    def self.find_original_value_for(constant_name)
+      const = ::RSpec::Mocks::Constant.original(constant_name)
+      yield const.original_value if const.stubbed?
+    end
+
+    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)
+      DEPRECATED["fire_class_double is deprecated, use class_double instead."]
+      class_double(*args)
+    end
+
+    def fire_replaced_class_double(*args)
+      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.2.0'
+  s.version  = '1.3.0'
   s.summary  = 'More resilient test doubles for RSpec.'
   s.platform = Gem::Platform::RUBY
   s.authors  = ["Xavier Shay"]
@@ -19,6 +19,6 @@ Gem::Specification.new do |s|
                      rspec-fire.gemspec
                    )
 
-  s.add_dependency 'rspec', '~> 2.11'
+  s.add_dependency 'rspec', ['>= 2.11', '< 4']
   s.add_development_dependency 'rake'
 end

data/spec/fire_double_spec.rb

@@ -166,25 +166,6 @@ shared_examples_for 'a fire-enhanced double' do
     let(:method_under_test) { :should_not_receive }
     it_should_behave_like 'a fire-enhanced double method'
   end
-
-  [ :stub, :stub! ].each do |stubber|
-    describe "##{stubber}" do
-      let(:method_under_test) { stubber }
-      it_should_behave_like 'a fire-enhanced double method'
-
-      context "RSpec's hash shortcut syntax" do
-        context 'doubled class is not loaded' do
-          let(:doubled_object) { instance_double("UnloadedObject") }
-          should_allow(:undefined_method => 123)
-        end
-
-        context 'doubled class is loaded' do
-          should_allow(:defined_method => 456)
-          should_not_allow(:undefined_method => 789)
-        end
-      end
-    end
-  end
 end
 
 describe '#instance_double' do

metadata

@@ -1,46 +1,47 @@
 --- !ruby/object:Gem::Specification
 name: rspec-fire
 version: !ruby/object:Gem::Version
-  version: 1.2.0
-  prerelease: 
+  version: 1.3.0
 platform: ruby
 authors:
 - Xavier Shay
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-03 00:00:00.000000000 Z
+date: 2013-11-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - '>='
       - !ruby/object:Gem::Version
         version: '2.11'
+    - - <
+      - !ruby/object:Gem::Version
+        version: '4'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - '>='
       - !ruby/object:Gem::Version
         version: '2.11'
+    - - <
+      - !ruby/object:Gem::Version
+        version: '4'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 description: 
@@ -52,6 +53,8 @@ extra_rdoc_files: []
 files:
 - spec/fire_double_spec.rb
 - spec/spec_helper.rb
+- lib/rspec/fire/configuration.rb
+- lib/rspec/fire/legacy.rb
 - lib/rspec/fire.rb
 - Gemfile
 - README.md
@@ -61,26 +64,26 @@ files:
 homepage: http://github.com/xaviershay/rspec-fire
 licenses:
 - MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 2.0.3
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: More resilient test doubles for RSpec.
 test_files: []
+has_rdoc: false