clickable_link 0.0.1 → 0.0.2

data/vendor/bundle/ruby/1.9.1/gems/rspec-mocks-2.14.3/lib/rspec/mocks/order_group.rb

@@ -0,0 +1,40 @@
+module RSpec
+  module Mocks
+    # @private
+    class OrderGroup
+      def initialize
+        @ordering = Array.new
+      end
+
+      # @private
+      def register(expectation)
+        @ordering << expectation
+      end
+
+      # @private
+      def ready_for?(expectation)
+        @ordering.first == expectation
+      end
+
+      # @private
+      def consume
+        @ordering.shift
+      end
+
+      # @private
+      def handle_order_constraint(expectation)
+        return unless @ordering.include?(expectation)
+        return consume if ready_for?(expectation)
+        expectation.raise_out_of_order_error
+      end
+
+      def clear
+        @ordering.clear
+      end
+
+      def empty?
+        @ordering.empty?
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/1.9.1/gems/rspec-mocks-2.14.3/lib/rspec/mocks/proxy.rb

@@ -0,0 +1,216 @@
+module RSpec
+  module Mocks
+    # @private
+    class Proxy
+
+      # @private
+      def initialize(object, name=nil, options={})
+        @object = object
+        @name = name
+        @error_generator = ErrorGenerator.new object, name, options
+        @expectation_ordering = RSpec::Mocks::space.expectation_ordering
+        @messages_received = []
+        @options = options
+        @already_proxied_respond_to = false
+        @null_object = false
+      end
+
+      # @private
+      def null_object?
+        @null_object
+      end
+
+      # @private
+      # Tells the object to ignore any messages that aren't explicitly set as
+      # stubs or message expectations.
+      def as_null_object
+        @null_object = true
+        @object
+      end
+
+      # @private
+      def already_proxied_respond_to
+        @already_proxied_respond_to = true
+      end
+
+      # @private
+      def already_proxied_respond_to?
+        @already_proxied_respond_to
+      end
+
+      # @private
+      def add_message_expectation(location, method_name, opts={}, &block)
+        meth_double = method_double[method_name]
+
+        if null_object? && !block
+          meth_double.add_default_stub(@error_generator, @expectation_ordering, location, opts) do
+            @object
+          end
+        end
+
+        meth_double.add_expectation @error_generator, @expectation_ordering, location, opts, &block
+      end
+
+      # @private
+      def build_expectation(method_name)
+        meth_double = method_double[method_name]
+
+        meth_double.build_expectation(
+          @error_generator,
+          @expectation_ordering
+        )
+      end
+
+      # @private
+      def replay_received_message_on(expectation)
+        expected_method_name = expectation.message
+        meth_double = method_double[expected_method_name]
+
+        if meth_double.expectations.any?
+          @error_generator.raise_expectation_on_mocked_method(expected_method_name)
+        end
+
+        unless null_object? || meth_double.stubs.any?
+          @error_generator.raise_expectation_on_unstubbed_method(expected_method_name)
+        end
+
+        @messages_received.each do |(actual_method_name, args, _)|
+          if expectation.matches?(actual_method_name, *args)
+            expectation.invoke(nil)
+          end
+        end
+      end
+
+      # @private
+      def check_for_unexpected_arguments(expectation)
+        @messages_received.each do |(method_name, args, _)|
+          if expectation.matches_name_but_not_args(method_name, *args)
+            raise_unexpected_message_args_error(expectation, *args)
+          end
+        end
+      end
+
+      # @private
+      def add_stub(location, method_name, opts={}, &implementation)
+        method_double[method_name].add_stub @error_generator, @expectation_ordering, location, opts, &implementation
+      end
+
+      # @private
+      def remove_stub(method_name)
+        method_double[method_name].remove_stub
+      end
+
+      # @private
+      def verify
+        method_doubles.each {|d| d.verify}
+      ensure
+        reset
+      end
+
+      # @private
+      def reset
+        method_doubles.each {|d| d.reset}
+        @messages_received.clear
+      end
+
+      # @private
+      def received_message?(method_name, *args, &block)
+        @messages_received.any? {|array| array == [method_name, args, block]}
+      end
+
+      # @private
+      def has_negative_expectation?(message)
+        method_double[message].expectations.detect {|expectation| expectation.negative_expectation_for?(message)}
+      end
+
+      # @private
+      def record_message_received(message, *args, &block)
+        @messages_received << [message, args, block]
+      end
+
+      # @private
+      def message_received(message, *args, &block)
+        record_message_received message, *args, &block
+        expectation = find_matching_expectation(message, *args)
+        stub = find_matching_method_stub(message, *args)
+
+        if (stub && expectation && expectation.called_max_times?) || (stub && !expectation)
+          expectation.increase_actual_received_count! if expectation && expectation.actual_received_count_matters?
+          if expectation = find_almost_matching_expectation(message, *args)
+            expectation.advise(*args) unless expectation.expected_messages_received?
+          end
+          stub.invoke(nil, *args, &block)
+        elsif expectation
+          expectation.invoke(stub, *args, &block)
+        elsif expectation = find_almost_matching_expectation(message, *args)
+          expectation.advise(*args) if null_object? unless expectation.expected_messages_received?
+          raise_unexpected_message_args_error(expectation, *args) unless (has_negative_expectation?(message) or null_object?)
+        elsif stub = find_almost_matching_stub(message, *args)
+          stub.advise(*args)
+          raise_missing_default_stub_error(stub, *args)
+        elsif @object.is_a?(Class)
+          @object.superclass.__send__(message, *args, &block)
+        else
+          @object.__send__(:method_missing, message, *args, &block)
+        end
+      end
+
+      # @private
+      def raise_unexpected_message_error(method_name, *args)
+        @error_generator.raise_unexpected_message_error method_name, *args
+      end
+
+      # @private
+      def raise_unexpected_message_args_error(expectation, *args)
+        @error_generator.raise_unexpected_message_args_error(expectation, *args)
+      end
+
+      # @private
+      def raise_missing_default_stub_error(expectation, *args)
+        @error_generator.raise_missing_default_stub_error(expectation, *args)
+      end
+
+      private
+
+      def method_double
+        @method_double ||= Hash.new {|h,k| h[k] = MethodDouble.new(@object, k, self) }
+      end
+
+      def method_doubles
+        method_double.values
+      end
+
+      def find_matching_expectation(method_name, *args)
+        find_best_matching_expectation_for(method_name) do |expectation|
+          expectation.matches?(method_name, *args)
+        end
+      end
+
+      def find_almost_matching_expectation(method_name, *args)
+        find_best_matching_expectation_for(method_name) do |expectation|
+          expectation.matches_name_but_not_args(method_name, *args)
+        end
+      end
+
+      def find_best_matching_expectation_for(method_name)
+        first_match = nil
+
+        method_double[method_name].expectations.each do |expectation|
+          next unless yield expectation
+          return expectation unless expectation.called_max_times?
+          first_match ||= expectation
+        end
+
+        first_match
+      end
+
+      def find_matching_method_stub(method_name, *args)
+        method_double[method_name].stubs.find {|stub| stub.matches?(method_name, *args)}
+      end
+
+      def find_almost_matching_stub(method_name, *args)
+        method_double[method_name].stubs.find {|stub| stub.matches_name_but_not_args(method_name, *args)}
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/1.9.1/gems/rspec-mocks-2.14.3/lib/rspec/mocks/proxy_for_nil.rb

@@ -0,0 +1,37 @@
+module RSpec
+  module Mocks
+    # @private
+    class ProxyForNil < Proxy
+
+      def initialize
+        @warn_about_expectations = true
+        super nil
+      end
+      attr_accessor :warn_about_expectations
+      alias warn_about_expectations? warn_about_expectations
+
+      def add_message_expectation(location, method_name, opts={}, &block)
+        warn(method_name) if warn_about_expectations?
+        super
+      end
+
+      def add_negative_message_expectation(location, method_name, &implementation)
+        warn(method_name) if warn_about_expectations?
+        super
+      end
+
+      def add_stub(location, method_name, opts={}, &implementation)
+        warn(method_name) if warn_about_expectations?
+        super
+      end
+
+      private
+
+      def warn method_name
+        non_rspec_caller = caller.find { |line| !line.include?('lib/rspec/mocks') }
+        Kernel.warn("An expectation of :#{method_name} was set on nil. Called from #{non_rspec_caller}. Use allow_message_expectations_on_nil to disable warnings.")
+      end
+
+    end
+  end
+end

data/vendor/bundle/ruby/1.9.1/gems/rspec-mocks-2.14.3/lib/rspec/mocks/space.rb

@@ -0,0 +1,87 @@
+module RSpec
+  module Mocks
+    # @api private
+    class Space
+      attr_reader :proxies, :any_instance_recorders
+
+      def initialize
+        @proxies = {}
+        @any_instance_recorders = {}
+      end
+
+      def verify_all
+        proxies.each_value do |object|
+          object.verify
+        end
+
+        any_instance_recorders.each_value do |recorder|
+          recorder.verify
+        end
+      end
+
+      def reset_all
+        ConstantMutator.reset_all
+
+        proxies.each_value do |object|
+          object.reset
+        end
+
+        proxies.clear
+        any_instance_recorders.clear
+        expectation_ordering.clear
+      end
+
+      def expectation_ordering
+        @expectation_ordering ||= OrderGroup.new
+      end
+
+      def any_instance_recorder_for(klass)
+        id = klass.__id__
+        any_instance_recorders.fetch(id) do
+          any_instance_recorders[id] = AnyInstance::Recorder.new(klass)
+        end
+      end
+
+      def remove_any_instance_recorder_for(klass)
+        any_instance_recorders.delete(klass.__id__)
+      end
+
+      def proxy_for(object)
+        id = id_for(object)
+        proxies.fetch(id) do
+          proxies[id] = case object
+                        when NilClass   then ProxyForNil.new
+                        when TestDouble then object.__build_mock_proxy
+                        else
+                          Proxy.new(object)
+                        end
+        end
+      end
+
+      alias ensure_registered proxy_for
+
+      def registered?(object)
+        proxies.has_key?(id_for object)
+      end
+
+      if defined?(::BasicObject) && !::BasicObject.method_defined?(:__id__) # for 1.9.2
+        require 'securerandom'
+
+        def id_for(object)
+          id = object.__id__
+
+          return id if object.equal?(::ObjectSpace._id2ref(id))
+          # this suggests that object.__id__ is proxying through to some wrapped object
+
+          object.instance_eval do
+            @__id_for_rspec_mocks_space ||= ::SecureRandom.uuid
+          end
+        end
+      else
+        def id_for(object)
+          object.__id__
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/1.9.1/gems/rspec-mocks-2.14.3/lib/rspec/mocks/standalone.rb

@@ -0,0 +1,3 @@
+require 'rspec/mocks'
+
+RSpec::Mocks.setup(self)

data/vendor/bundle/ruby/1.9.1/gems/rspec-mocks-2.14.3/lib/rspec/mocks/stub_chain.rb

@@ -0,0 +1,51 @@
+module RSpec
+  module Mocks
+    # @private
+    class StubChain
+      def self.stub_chain_on(object, *chain, &blk)
+        new(object, *chain, &blk).stub_chain
+      end
+
+      attr_reader :object, :chain, :block
+
+      def initialize(object, *chain, &blk)
+        @object = object
+        @chain, @block = format_chain(*chain, &blk)
+      end
+
+      def stub_chain
+        if chain.length > 1
+          if matching_stub = find_matching_stub
+            chain.shift
+            matching_stub.invoke(nil).stub_chain(*chain, &block)
+          else
+            next_in_chain = Mock.new
+            object.stub(chain.shift) { next_in_chain }
+            StubChain.stub_chain_on(next_in_chain, *chain, &block)
+          end
+        else
+          object.stub(chain.shift, &block)
+        end
+      end
+
+    private
+
+      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
+
+      def find_matching_stub
+        ::RSpec::Mocks.proxy_for(object).
+          __send__(:find_matching_method_stub, chain.first.to_sym)
+      end
+    end
+  end
+end
+

data/vendor/bundle/ruby/1.9.1/gems/rspec-mocks-2.14.3/lib/rspec/mocks/syntax.rb

@@ -0,0 +1,349 @@
+module RSpec
+  module Mocks
+    # @api private
+    # Provides methods for enabling and disabling the available syntaxes
+    # provided by rspec-mocks.
+    module Syntax
+      # @api private
+      #
+      # Common stubbing logic for both `stub` and `stub!`. This used to
+      # live in `stub`, and `stub!` delegated to `stub`, but we discovered
+      # that `stub!` was delegating to `RSpec::Mocks::ExampleMethods#stub`
+      # (which declares a test double) when called with an implicit receiver,
+      # which was a regression in 2.14.0.
+      def self.stub_object(object, message_or_hash, opts = {}, &block)
+        if ::Hash === message_or_hash
+          message_or_hash.each {|message, value| stub_object(object, message).and_return value }
+        else
+          opts[:expected_from] = caller(1)[1]
+          ::RSpec::Mocks.allow_message(object, message_or_hash, opts, &block)
+        end
+      end
+
+      # @api private
+      # Enables the should syntax (`dbl.stub`, `dbl.should_receive`, etc).
+      def self.enable_should(syntax_host = default_should_syntax_host)
+        return if should_enabled?(syntax_host)
+
+        syntax_host.class_eval do
+          def should_receive(message, opts={}, &block)
+            opts[:expected_from] ||= caller(1)[0]
+            ::RSpec::Mocks.expect_message(self, message.to_sym, opts, &block)
+          end
+
+          def should_not_receive(message, &block)
+            opts = {:expected_from => caller(1)[0]}
+            ::RSpec::Mocks.expect_message(self, message.to_sym, opts, &block).never
+          end
+
+          def stub(message_or_hash, opts={}, &block)
+            ::RSpec::Mocks::Syntax.stub_object(self, message_or_hash, opts, &block)
+          end
+
+          def unstub(message)
+            ::RSpec::Mocks.space.proxy_for(self).remove_stub(message)
+          end
+
+          def stub!(message_or_hash, opts={}, &block)
+            ::RSpec.deprecate "stub!", :replacement => "stub"
+            ::RSpec::Mocks::Syntax.stub_object(self, message_or_hash, opts, &block)
+          end
+
+          def unstub!(message)
+            ::RSpec.deprecate "unstub!", :replacement => "unstub"
+            unstub(message)
+          end
+
+          def stub_chain(*chain, &blk)
+            ::RSpec::Mocks::StubChain.stub_chain_on(self, *chain, &blk)
+          end
+
+          def as_null_object
+            @_null_object = true
+            ::RSpec::Mocks.proxy_for(self).as_null_object
+          end
+
+          def null_object?
+            defined?(@_null_object)
+          end
+
+          def received_message?(message, *args, &block)
+            ::RSpec::Mocks.proxy_for(self).received_message?(message, *args, &block)
+          end
+
+          unless Class.respond_to? :any_instance
+            Class.class_eval do
+              def any_instance
+                ::RSpec::Mocks.any_instance_recorder_for(self)
+              end
+            end
+          end
+        end
+      end
+
+      # @api private
+      # Disables the should syntax (`dbl.stub`, `dbl.should_receive`, etc).
+      def self.disable_should(syntax_host = default_should_syntax_host)
+        return unless should_enabled?(syntax_host)
+
+        syntax_host.class_eval do
+          undef should_receive
+          undef should_not_receive
+          undef stub
+          undef unstub
+          undef stub!
+          undef unstub!
+          undef stub_chain
+          undef as_null_object
+          undef null_object?
+          undef received_message?
+        end
+
+        Class.class_eval do
+          undef any_instance
+        end
+      end
+
+      # @api private
+      # Enables the expect syntax (`expect(dbl).to receive`, `allow(dbl).to receive`, etc).
+      def self.enable_expect(syntax_host = ::RSpec::Mocks::ExampleMethods)
+        return if expect_enabled?(syntax_host)
+
+        syntax_host.class_eval do
+          def receive(method_name, &block)
+            Matchers::Receive.new(method_name, block)
+          end
+
+          def allow(target)
+            AllowanceTarget.new(target)
+          end
+
+          def expect_any_instance_of(klass)
+            AnyInstanceExpectationTarget.new(klass)
+          end
+
+          def allow_any_instance_of(klass)
+            AnyInstanceAllowanceTarget.new(klass)
+          end
+        end
+
+        RSpec::Mocks::ExampleMethods::ExpectHost.class_eval do
+          def expect(target)
+            ExpectationTarget.new(target)
+          end
+        end
+      end
+
+      # @api private
+      # Disables the expect syntax (`expect(dbl).to receive`, `allow(dbl).to receive`, etc).
+      def self.disable_expect(syntax_host = ::RSpec::Mocks::ExampleMethods)
+        return unless expect_enabled?(syntax_host)
+
+        syntax_host.class_eval do
+          undef receive
+          undef allow
+          undef expect_any_instance_of
+          undef allow_any_instance_of
+        end
+
+        RSpec::Mocks::ExampleMethods::ExpectHost.class_eval do
+          undef expect
+        end
+      end
+
+      # @api private
+      # Indicates whether or not the should syntax is enabled.
+      def self.should_enabled?(syntax_host = default_should_syntax_host)
+        syntax_host.method_defined?(:should_receive)
+      end
+
+      # @api private
+      # Indicates whether or not the expect syntax is enabled.
+      def self.expect_enabled?(syntax_host = ::RSpec::Mocks::ExampleMethods)
+        syntax_host.method_defined?(:allow)
+      end
+
+      # @api private
+      # Determines where the methods like `should_receive`, and `stub` are added.
+      def self.default_should_syntax_host
+        # JRuby 1.7.4 introduces a regression whereby `defined?(::BasicObject) => nil`
+        # yet `BasicObject` still exists and patching onto ::Object breaks things
+        # e.g. SimpleDelegator expectations won't work
+        #
+        # See: https://github.com/jruby/jruby/issues/814
+        if defined?(JRUBY_VERSION) && JRUBY_VERSION == '1.7.4' && RUBY_VERSION.to_f > 1.8
+          return ::BasicObject
+        end
+
+        # On 1.8.7, Object.ancestors.last == Kernel but
+        # things blow up if we include `RSpec::Mocks::Methods`
+        # into Kernel...not sure why.
+        return Object unless defined?(::BasicObject)
+
+        # MacRuby has BasicObject but it's not the root class.
+        return Object unless Object.ancestors.last == ::BasicObject
+
+        ::BasicObject
+      end
+
+      # @method should_receive
+      # Sets an 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
+      #
+      # @note This is only available when you have enabled the `should` syntax.
+
+      # @method should_not_receive
+      # Sets and expectation that this object should _not_ receive a message
+      # during this example.
+
+      # @method stub
+      # 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 }
+      #
+      # @note This is only available when you have enabled the `should` syntax.
+
+      # @method unstub
+      # 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.
+      #
+      # @note This is only available when you have enabled the `should` syntax.
+
+      # @method stub_chain
+      # @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] }
+      #
+      # @note This is only available when you have enabled the `should` syntax.
+
+      # @method as_null_object
+      # 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.
+      #
+      # @note This is only available when you have enabled the `should` syntax.
+
+      # @method null_object?
+      # Returns true if this object has received `as_null_object`
+      #
+      # @note This is only available when you have enabled the `should` syntax.
+
+      # @method any_instance
+      # Used to set stubs and message expectations on any instance of a given
+      # class. Returns a [Recorder](Recorder), which records messages like
+      # `stub` and `should_receive` for later playback on instances of the
+      # class.
+      #
+      # @example
+      #
+      #     Car.any_instance.should_receive(:go)
+      #     race = Race.new
+      #     race.cars << Car.new
+      #     race.go # assuming this delegates to all of its cars
+      #             # this example would pass
+      #
+      #     Account.any_instance.stub(:balance) { Money.new(:USD, 25) }
+      #     Account.new.balance # => Money.new(:USD, 25))
+      #
+      # @return [Recorder]
+      #
+      # @note This is only available when you have enabled the `should` syntax.
+
+      # @method expect
+      # Used to wrap an object in preparation for setting a mock expectation
+      # on it.
+      #
+      # @example
+      #
+      #   expect(obj).to receive(:foo).with(5).and_return(:return_value)
+      #
+      # @note This method is usually provided by rspec-expectations, unless
+      #   you are using rspec-mocks w/o rspec-expectations, in which case it
+      #   is only made available if you enable the `expect` syntax.
+
+      # @method allow
+      # Used to wrap an object in preparation for stubbing a method
+      # on it.
+      #
+      # @example
+      #
+      #   allow(dbl).to receive(:foo).with(5).and_return(:return_value)
+      #
+      # @note This is only available when you have enabled the `expect` syntax.
+
+      # @method expect_any_instance_of
+      # Used to wrap a class in preparation for setting a mock expectation
+      # on instances of it.
+      #
+      # @example
+      #
+      #   expect_any_instance_of(MyClass).to receive(:foo)
+      #
+      # @note This is only available when you have enabled the `expect` syntax.
+
+      # @method allow_any_instance_of
+      # Used to wrap a class in preparation for stubbing a method
+      # on instances of it.
+      #
+      # @example
+      #
+      #   allow_any_instance_of(MyClass).to receive(:foo)
+      #
+      # @note This is only available when you have enabled the `expect` syntax.
+
+      # @method receive
+      # Used to specify a message that you expect or allow an object
+      # to receive. The object returned by `receive` supports the same
+      # fluent interface that `should_receive` and `stub` have always
+      # supported, allowing you to constrain the arguments or number of
+      # times, and configure how the object should respond to the message.
+      #
+      # @example
+      #
+      #   expect(obj).to receive(:hello).with("world").exactly(3).times
+      #
+      # @note This is only available when you have enabled the `expect` syntax.
+    end
+  end
+end
+