sshp 0.0.1

data/vendor/ruby/1.9.1/gems/rspec-mocks-2.13.1/lib/rspec/mocks/method_double.rb

@@ -0,0 +1,267 @@
+module RSpec
+  module Mocks
+    # @private
+    class MethodDouble < Hash
+      # @private
+      attr_reader :method_name, :object
+
+      # @private
+      def initialize(object, method_name, proxy)
+        @method_name = method_name
+        @object = object
+        @proxy = proxy
+
+        @method_stasher = InstanceMethodStasher.new(object_singleton_class, @method_name)
+        @method_is_proxied = false
+        store(:expectations, [])
+        store(:stubs, [])
+      end
+
+      # @private
+      def expectations
+        self[:expectations]
+      end
+
+      # @private
+      def stubs
+        self[:stubs]
+      end
+
+      # @private
+      def visibility
+        if TestDouble === @object
+          'public'
+        elsif object_singleton_class.private_method_defined?(@method_name)
+          'private'
+        elsif object_singleton_class.protected_method_defined?(@method_name)
+          'protected'
+        else
+          'public'
+        end
+      end
+
+      # @private
+      def original_method
+        if @method_stasher.method_is_stashed?
+          # Example: a singleton method defined on @object
+          ::RSpec::Mocks.method_handle_for(@object, @method_stasher.stashed_method_name)
+        elsif meth = original_unrecorded_any_instance_method
+          # Example: a method that has been mocked through
+          #   klass.any_instance.should_receive(:msg).and_call_original
+          # any_instance.should_receive(:msg) causes the method to be
+          # replaced with a proxy method, and then `and_call_original`
+          # is recorded and played back on the object instance. We need
+          # special handling here to get a handle on the original method
+          # object rather than the proxy method.
+          meth
+        else
+          begin
+            # Example: an instance method defined on one of @object's ancestors.
+            original_method_from_ancestor(object_singleton_class.ancestors)
+          rescue NameError
+            raise unless @object.respond_to?(:superclass)
+
+            # Example: a singleton method defined on @object's superclass.
+            #
+            # Note: we have to give precedence to instance methods
+            # defined on @object's class, because in a case like:
+            #
+            # `klass.should_receive(:new).and_call_original`
+            #
+            # ...we want `Class#new` bound to `klass` (which will return
+            # an instance of `klass`), not `klass.superclass.new` (which
+            # would return an instance of `klass.superclass`).
+            original_method_from_superclass
+          end
+        end
+      rescue NameError
+        # We have no way of knowing if the object's method_missing
+        # will handle this message or not...but we can at least try.
+        # If it's not handled, a `NoMethodError` will be raised, just
+        # like normally.
+        Proc.new do |*args, &block|
+          @object.__send__(:method_missing, @method_name, *args, &block)
+        end
+      end
+
+      def original_unrecorded_any_instance_method
+        return nil unless any_instance_class_recorder_observing_method?(@object.class)
+        alias_name = @object.class.__recorder.build_alias_method_name(@method_name)
+        @object.method(alias_name)
+      end
+
+      def any_instance_class_recorder_observing_method?(klass)
+        return true if klass.__recorder.already_observing?(@method_name)
+        superklass = klass.superclass
+        return false if superklass.nil?
+        any_instance_class_recorder_observing_method?(superklass)
+      end
+
+      def original_method_from_ancestor(ancestors)
+        klass, *rest = ancestors
+        klass.instance_method(@method_name).bind(@object)
+      rescue NameError
+        raise if rest.empty?
+        original_method_from_ancestor(rest)
+      end
+
+      if RUBY_VERSION.to_f > 1.8
+        # @private
+        def original_method_from_superclass
+          @object.superclass.
+                  singleton_class.
+                  instance_method(@method_name).
+                  bind(@object)
+        end
+      else
+        # Our implementation for 1.9 (above) causes an error on 1.8:
+        # TypeError: singleton method bound for a different object
+        #
+        # This doesn't work quite right in all circumstances but it's the
+        # best we can do.
+        # @private
+        def original_method_from_superclass
+          ::Kernel.warn <<-WARNING.gsub(/^ +\|/, '')
+            |
+            |WARNING: On ruby 1.8, rspec-mocks is unable to bind the original
+            |`#{@method_name}` method to your partial mock object (#{@object})
+            |for `and_call_original`. The superclass's `#{@method_name}` is being
+            |used instead; however, it may not work correctly when executed due
+            |to the fact that `self` will be #{@object.superclass}, not #{@object}.
+            |
+            |Called from: #{caller[2]}
+          WARNING
+
+          @object.superclass.method(@method_name)
+        end
+      end
+      # @private
+      def object_singleton_class
+        class << @object; self; end
+      end
+
+      # @private
+      def configure_method
+        RSpec::Mocks::space.add(@object) if RSpec::Mocks::space
+        warn_if_nil_class
+        @original_visibility = visibility_for_method
+        @method_stasher.stash unless @method_is_proxied
+        define_proxy_method
+      end
+
+      # @private
+      def define_proxy_method
+        return if @method_is_proxied
+
+        object_singleton_class.class_eval <<-EOF, __FILE__, __LINE__ + 1
+          def #{@method_name}(*args, &block)
+            __mock_proxy.message_received :#{@method_name}, *args, &block
+          end
+          #{visibility_for_method}
+        EOF
+        @method_is_proxied = true
+      end
+
+      # @private
+      def visibility_for_method
+        "#{visibility} :#{method_name}"
+      end
+
+      # @private
+      def restore_original_method
+        return unless @method_is_proxied
+
+        object_singleton_class.__send__(:remove_method, @method_name)
+        @method_stasher.restore
+        restore_original_visibility
+
+        @method_is_proxied = false
+      end
+
+      # @private
+      def restore_original_visibility
+        return unless object_singleton_class.method_defined?(@method_name) || object_singleton_class.private_method_defined?(@method_name)
+        object_singleton_class.class_eval(@original_visibility, __FILE__, __LINE__)
+      end
+
+      # @private
+      def verify
+        expectations.each {|e| e.verify_messages_received}
+      end
+
+      # @private
+      def reset
+        reset_nil_expectations_warning
+        restore_original_method
+        clear
+      end
+
+      # @private
+      def clear
+        expectations.clear
+        stubs.clear
+      end
+
+      # @private
+      def add_expectation(error_generator, expectation_ordering, expected_from, opts, &implementation)
+        configure_method
+        expectation = MessageExpectation.new(error_generator, expectation_ordering,
+                                             expected_from, self, 1, opts, &implementation)
+        expectations << expectation
+        expectation
+      end
+
+      # @private
+      def add_negative_expectation(error_generator, expectation_ordering, expected_from, &implementation)
+        configure_method
+        expectation = NegativeMessageExpectation.new(error_generator, expectation_ordering,
+                                                     expected_from, self, &implementation)
+        expectations.unshift expectation
+        expectation
+      end
+
+      # @private
+      def add_stub(error_generator, expectation_ordering, expected_from, opts={}, &implementation)
+        configure_method
+        stub = MessageExpectation.new(error_generator, expectation_ordering, expected_from,
+                                      self, :any, opts, &implementation)
+        stubs.unshift stub
+        stub
+      end
+
+      # @private
+      def add_default_stub(*args, &implementation)
+        return if stubs.any?
+        add_stub(*args, &implementation)
+      end
+
+      # @private
+      def remove_stub
+        raise_method_not_stubbed_error if stubs.empty?
+        expectations.empty? ? reset : stubs.clear
+      end
+
+      # @private
+      def proxy_for_nil_class?
+        NilClass === @object
+      end
+
+      # @private
+      def warn_if_nil_class
+        if proxy_for_nil_class? & RSpec::Mocks::Proxy.warn_about_expectations_on_nil
+          Kernel.warn("An expectation of :#{@method_name} was set on nil. Called from #{caller[4]}. Use allow_message_expectations_on_nil to disable warnings.")
+        end
+      end
+
+      # @private
+      def raise_method_not_stubbed_error
+        raise MockExpectationError, "The method `#{method_name}` was not stubbed or was already unstubbed" 
+      end
+
+      # @private
+      def reset_nil_expectations_warning
+        RSpec::Mocks::Proxy.warn_about_expectations_on_nil = true if proxy_for_nil_class?
+      end
+    end
+  end
+end

data/vendor/ruby/1.9.1/gems/rspec-mocks-2.13.1/lib/rspec/mocks/methods.rb

@@ -0,0 +1,155 @@
+module RSpec
+  module Mocks
+    # Methods that are added to every object.
+    module Methods
+      # Sets and expectation that this object should receive a message before
+      # the end of the example.
+      #
+      # @example
+      #
+      #     logger = double('logger')
+      #     thing_that_logs = ThingThatLogs.new(logger)
+      #     logger.should_receive(:log)
+      #     thing_that_logs.do_something_that_logs_a_message
+      def should_receive(message, opts={}, &block)
+        __mock_proxy.add_message_expectation(opts[:expected_from] || caller(1)[0], message.to_sym, opts, &block)
+      end
+
+      # Sets and expectation that this object should _not_ receive a message
+      # during this example.
+      def should_not_receive(message, &block)
+        __mock_proxy.add_negative_message_expectation(caller(1)[0], message.to_sym, &block)
+      end
+
+      # Tells the object to respond to the message with the specified value.
+      #
+      # @example
+      #
+      #     counter.stub(:count).and_return(37)
+      #     counter.stub(:count => 37)
+      #     counter.stub(:count) { 37 }
+      def stub(message_or_hash, opts={}, &block)
+        if Hash === message_or_hash
+          message_or_hash.each {|message, value| stub(message).and_return value }
+        else
+          __mock_proxy.add_stub(caller(1)[0], message_or_hash.to_sym, opts, &block)
+        end
+      end
+
+      # Removes a stub. On a double, the object will no longer respond to
+      # `message`. On a real object, the original method (if it exists) is
+      # restored.
+      #
+      # This is rarely used, but can be useful when a stub is set up during a
+      # shared `before` hook for the common case, but you want to replace it
+      # for a special case.
+      def unstub(message)
+        __mock_proxy.remove_stub(message)
+      end
+
+      alias_method :stub!, :stub
+      alias_method :unstub!, :unstub
+
+      # @overload stub_chain(method1, method2)
+      # @overload stub_chain("method1.method2")
+      # @overload stub_chain(method1, method_to_value_hash)
+      #
+      # Stubs a chain of methods.
+      #
+      # ## Warning:
+      #
+      # Chains can be arbitrarily long, which makes it quite painless to
+      # violate the Law of Demeter in violent ways, so you should consider any
+      # use of `stub_chain` a code smell. Even though not all code smells
+      # indicate real problems (think fluent interfaces), `stub_chain` still
+      # results in brittle examples.  For example, if you write
+      # `foo.stub_chain(:bar, :baz => 37)` in a spec and then the
+      # implementation calls `foo.baz.bar`, the stub will not work.
+      #
+      # @example
+      #
+      #     double.stub_chain("foo.bar") { :baz }
+      #     double.stub_chain(:foo, :bar => :baz)
+      #     double.stub_chain(:foo, :bar) { :baz }
+      #
+      #     # Given any of ^^ these three forms ^^:
+      #     double.foo.bar # => :baz
+      #
+      #     # Common use in Rails/ActiveRecord:
+      #     Article.stub_chain("recent.published") { [Article.new] }
+      def stub_chain(*chain, &blk)
+        chain, blk = format_chain(*chain, &blk)
+        if chain.length > 1
+          if matching_stub = __mock_proxy.__send__(:find_matching_method_stub, chain[0].to_sym)
+            chain.shift
+            matching_stub.invoke(nil).stub_chain(*chain, &blk)
+          else
+            next_in_chain = Mock.new
+            stub(chain.shift) { next_in_chain }
+            next_in_chain.stub_chain(*chain, &blk)
+          end
+        else
+          stub(chain.shift, &blk)
+        end
+      end
+
+      # Tells the object to respond to all messages. If specific stub values
+      # are declared, they'll work as expected. If not, the receiver is
+      # returned.
+      def as_null_object
+        @_null_object = true
+        __mock_proxy.as_null_object
+      end
+
+      # Returns true if this object has received `as_null_object`
+      def null_object?
+        defined?(@_null_object)
+      end
+
+      # @private
+      def received_message?(message, *args, &block)
+        __mock_proxy.received_message?(message, *args, &block)
+      end
+
+      # @private
+      def rspec_verify
+        __mock_proxy.verify
+      end
+
+      # @private
+      def rspec_reset
+        __mock_proxy.reset
+      end
+
+    private
+
+      def __mock_proxy
+        @mock_proxy ||= begin
+          mp = if TestDouble === self
+            Proxy.new(self, @name, @options)
+          else
+            Proxy.new(self)
+          end
+
+          Serialization.fix_for(self)
+          mp
+        end
+      end
+      
+      def __remove_mock_proxy
+        @mock_proxy = nil
+      end
+
+      def format_chain(*chain, &blk)
+        if Hash === chain.last
+          hash = chain.pop
+          hash.each do |k,v|
+            chain << k
+            blk = lambda { v }
+          end
+        end
+        return chain.join('.').split('.'), blk
+      end
+    end
+  end
+end

data/vendor/ruby/1.9.1/gems/rspec-mocks-2.13.1/lib/rspec/mocks/mock.rb

@@ -0,0 +1,7 @@
+module RSpec
+  module Mocks
+    class Mock
+      include TestDouble
+    end
+  end
+end

data/vendor/ruby/1.9.1/gems/rspec-mocks-2.13.1/lib/rspec/mocks/mutate_const.rb

@@ -0,0 +1,415 @@
+module RSpec
+  module Mocks
+    # Provides recursive constant lookup methods useful for
+    # constant stubbing.
+    # @api private
+    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; B = 1; end
+      #   class C < A; end
+      #
+      # On 1.8:
+      #   - C.const_get("Hash") # => ::Hash
+      #   - C.const_defined?("Hash") # => false
+      #   - C.constants # => ["B"]
+      #   - None of these methods accept the extra `inherit` argument
+      # On 1.9:
+      #   - C.const_get("Hash") # => ::Hash
+      #   - C.const_defined?("Hash") # => true
+      #   - C.const_get("Hash", false) # => raises NameError
+      #   - C.const_defined?("Hash", false) # => false
+      #   - C.constants # => [:B]
+      #   - C.constants(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
+
+        def constants_defined_on(mod)
+          mod.constants.select { |c| const_defined_on?(mod, c) }
+        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
+
+        def constants_defined_on(mod)
+          mod.constants(false)
+        end
+      end
+
+      def recursive_const_get(const_name)
+        normalize_const_name(const_name).split('::').inject(Object) do |mod, name|
+          get_const_defined_on(mod, name)
+        end
+      end
+
+      def recursive_const_defined?(const_name)
+        normalize_const_name(const_name).split('::').inject([Object, '']) do |(mod, full_name), name|
+          yield(full_name, name) if block_given? && !mod.is_a?(Module)
+          return false unless const_defined_on?(mod, name)
+          [get_const_defined_on(mod, name), [mod, name].join('::')]
+        end
+      end
+
+      def normalize_const_name(const_name)
+        const_name.sub(/\A::/, '')
+      end
+    end
+
+    # Provides information about constants that may (or may not)
+    # have been mutated by rspec-mocks.
+    class Constant
+      extend RecursiveConstMethods
+
+      # @api private
+      def initialize(name)
+        @name = name
+      end
+
+      # @return [String] The fully qualified name of the constant.
+      attr_reader :name
+
+      # @return [Object, nil] The original value (e.g. before it
+      #   was mutated by rspec-mocks) of the constant, or
+      #   nil if the constant was not previously defined.
+      attr_accessor :original_value
+
+      # @api private
+      attr_writer :previously_defined, :stubbed, :hidden
+
+      # @return [Boolean] Whether or not the constant was defined
+      #   before the current example.
+      def previously_defined?
+        @previously_defined
+      end
+
+      # @return [Boolean] Whether or not rspec-mocks has mutated
+      #   (stubbed or hidden) this constant.
+      def mutated?
+        @stubbed || @hidden
+      end
+
+      # @return [Boolean] Whether or not rspec-mocks has stubbed
+      #   this constant.
+      def stubbed?
+        @stubbed
+      end
+
+      # @return [Boolean] Whether or not rspec-mocks has hidden
+      #   this constant.
+      def hidden?
+        @hidden
+      end
+
+      def to_s
+        "#<#{self.class.name} #{name}>"
+      end
+      alias inspect to_s
+
+      # @api private
+      def self.unmutated(name)
+        const = new(name)
+        const.previously_defined = recursive_const_defined?(name)
+        const.stubbed = false
+        const.hidden = false
+        const.original_value = recursive_const_get(name) if const.previously_defined?
+
+        const
+      end
+      private_class_method :unmutated
+
+      # Queries rspec-mocks to find out information about the named constant.
+      #
+      # @param [String] name the name of the constant
+      # @return [Constant] an object contaning information about the named
+      #   constant.
+      def self.original(name)
+        mutator = ConstantMutator.find(name)
+        mutator ? mutator.to_constant : unmutated(name)
+      end
+    end
+
+    # Provides a means to stub constants.
+    class ConstantMutator
+      extend RecursiveConstMethods
+
+      # Stubs a constant.
+      #
+      # @param (see ExampleMethods#stub_const)
+      # @option (see ExampleMethods#stub_const)
+      # @return (see ExampleMethods#stub_const)
+      #
+      # @see ExampleMethods#stub_const
+      # @note It's recommended that you use `stub_const` in your
+      #  examples. This is an alternate public API that is provided
+      #  so you can stub constants in other contexts (e.g. helper
+      #  classes).
+      def self.stub(constant_name, value, options = {})
+        mutator = if recursive_const_defined?(constant_name, &raise_on_invalid_const)
+          DefinedConstantReplacer
+        else
+          UndefinedConstantSetter
+        end
+
+        mutate(mutator.new(constant_name, value, options[:transfer_nested_constants]))
+        value
+      end
+
+      # Hides a constant.
+      #
+      # @param (see ExampleMethods#hide_const)
+      #
+      # @see ExampleMethods#hide_const
+      # @note It's recommended that you use `hide_const` in your
+      #  examples. This is an alternate public API that is provided
+      #  so you can hide constants in other contexts (e.g. helper
+      #  classes).
+      def self.hide(constant_name)
+        return unless recursive_const_defined?(constant_name)
+
+        mutate(ConstantHider.new(constant_name, nil, { }))
+        nil
+      end
+
+      # Contains common functionality used by all of the constant mutators.
+      #
+      # @api private
+      class BaseMutator
+        include RecursiveConstMethods
+
+        attr_reader :original_value, :full_constant_name
+
+        def initialize(full_constant_name, mutated_value, transfer_nested_constants)
+          @full_constant_name        = normalize_const_name(full_constant_name)
+          @mutated_value             = mutated_value
+          @transfer_nested_constants = transfer_nested_constants
+          @context_parts             = @full_constant_name.split('::')
+          @const_name                = @context_parts.pop
+        end
+
+        def to_constant
+          const = Constant.new(full_constant_name)
+          const.original_value = original_value
+
+          const
+        end
+      end
+
+      # Hides a defined constant for the duration of an example.
+      #
+      # @api private
+      class ConstantHider < BaseMutator
+        def mutate
+          @context = recursive_const_get(@context_parts.join('::'))
+          @original_value = get_const_defined_on(@context, @const_name)
+
+          @context.send(:remove_const, @const_name)
+        end
+
+        def to_constant
+          const = super
+          const.hidden = true
+          const.previously_defined = true
+
+          const
+        end
+
+        def rspec_reset
+          @context.const_set(@const_name, @original_value)
+        end
+      end
+
+      # Replaces a defined constant for the duration of an example.
+      #
+      # @api private
+      class DefinedConstantReplacer < BaseMutator
+        def mutate
+          @context = recursive_const_get(@context_parts.join('::'))
+          @original_value = get_const_defined_on(@context, @const_name)
+
+          constants_to_transfer = verify_constants_to_transfer!
+
+          @context.send(:remove_const, @const_name)
+          @context.const_set(@const_name, @mutated_value)
+
+          transfer_nested_constants(constants_to_transfer)
+        end
+
+        def to_constant
+          const = super
+          const.stubbed = true
+          const.previously_defined = true
+
+          const
+        end
+
+        def rspec_reset
+          @context.send(:remove_const, @const_name)
+          @context.const_set(@const_name, @original_value)
+        end
+
+        def transfer_nested_constants(constants)
+          constants.each do |const|
+            @mutated_value.const_set(const, get_const_defined_on(original_value, const))
+          end
+        end
+
+        def verify_constants_to_transfer!
+          return [] unless @transfer_nested_constants
+
+          { @original_value => "the original value", @mutated_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 - constants_defined_on(@original_value)
+
+            if undefined_constants.any?
+              available_constants = constants_defined_on(@original_value) - @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
+            constants_defined_on(@original_value)
+          end
+        end
+      end
+
+      # Sets an undefined constant for the duration of an example.
+      #
+      # @api private
+      class UndefinedConstantSetter < BaseMutator
+        def mutate
+          remaining_parts = @context_parts.dup
+          @deepest_defined_const = @context_parts.inject(Object) do |klass, name|
+            break klass unless const_defined_on?(klass, name)
+            remaining_parts.shift
+            get_const_defined_on(klass, 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, @mutated_value)
+        end
+
+        def to_constant
+          const = super
+          const.stubbed = true
+          const.previously_defined = false
+
+          const
+        end
+
+        def rspec_reset
+          @deepest_defined_const.send(:remove_const, @const_to_remove)
+        end
+      end
+
+      # Uses the mutator to mutate (stub or hide) a constant. Ensures that
+      # the mutator is correctly registered so it can be backed out at the end
+      # of the test.
+      #
+      # @api private
+      def self.mutate(mutator)
+        register_mutator(mutator)
+        mutator.mutate
+        ensure_registered_with_mocks_space
+      end
+
+      # Ensures the constant stubbing is registered with
+      # rspec-mocks space so that stubbed constants can
+      # be restored when examples finish.
+      #
+      # @api private
+      def self.ensure_registered_with_mocks_space
+        return if defined?(@registered_with_mocks_space) && @registered_with_mocks_space
+        ::RSpec::Mocks.space.add(self)
+        @registered_with_mocks_space = true
+      end
+
+      # Resets all stubbed constants. This is called automatically
+      # by rspec-mocks when an example finishes.
+      #
+      # @api private
+      def self.rspec_reset
+        @registered_with_mocks_space = false
+
+        # We use reverse order so that if the same constant
+        # was stubbed multiple times, the original value gets
+        # properly restored.
+        mutators.reverse.each { |s| s.rspec_reset }
+
+        mutators.clear
+      end
+
+      # The list of constant mutators that have been used for
+      # the current example.
+      #
+      # @api private
+      def self.mutators
+        @mutators ||= []
+      end
+
+      # @api private
+      def self.register_mutator(mutator)
+        mutators << mutator
+      end
+
+      def self.find(name)
+        mutators.find { |s| s.full_constant_name == name }
+      end
+
+      # Used internally by the constant stubbing to raise a helpful
+      # error when a constant like "A::B::C" is stubbed and A::B is
+      # not a module (and thus, it's impossible to define "A::B::C"
+      # since only modules can have nested constants).
+      #
+      # @api private
+      def self.raise_on_invalid_const
+        lambda do |const_name, failed_name|
+          raise "Cannot stub constant #{failed_name} on #{const_name} " +
+                "since #{const_name} is not a module."
+        end
+      end
+    end
+
+    # Keeps backwards compatibility since we had released an rspec-mocks that
+    # only supported stubbing. Later, we released the hide_const feature and
+    # decided that the term "mutator" was a better term to wrap up the concept
+    # of both stubbing and hiding.
+    ConstantStubber = ConstantMutator
+  end
+end
+