thoughtbot-clearance 0.3.4 → 0.3.7

data/test/rails_root/vendor/gems/mocha-0.9.1/lib/mocha/mock.rb

@@ -1,196 +0,0 @@
-require 'mocha/expectation'
-require 'mocha/expectation_list'
-require 'mocha/metaclass'
-require 'mocha/names'
-require 'mocha/mockery'
-require 'mocha/method_matcher'
-require 'mocha/parameters_matcher'
-require 'mocha/unexpected_invocation'
-
-module Mocha # :nodoc:
-  
-  # Traditional mock object.
-  #
-  # Methods return an Expectation which can be further modified by methods on Expectation.
-  class Mock
-    
-    # :call-seq: expects(method_name) -> expectation
-    #            expects(method_names) -> last expectation
-    #
-    # Adds an expectation that a method identified by +method_name+ symbol must be called exactly once with any parameters.
-    # Returns the new expectation which can be further modified by methods on Expectation.
-    #   object = mock()
-    #   object.expects(:method1)
-    #   object.method1
-    #   # no error raised
-    #
-    #   object = mock()
-    #   object.expects(:method1)
-    #   # error raised, because method1 not called exactly once
-    # If +method_names+ is a +Hash+, an expectation will be set up for each entry using the key as +method_name+ and value as +return_value+.
-    #   object = mock()
-    #   object.expects(:method1 => :result1, :method2 => :result2)
-    #
-    #   # exactly equivalent to
-    #
-    #   object = mock()
-    #   object.expects(:method1).returns(:result1)
-    #   object.expects(:method2).returns(:result2)
-    #
-    # Aliased by <tt>\_\_expects\_\_</tt>
-    def expects(method_name_or_hash, backtrace = nil)
-      if method_name_or_hash.is_a?(Hash) then
-        method_name_or_hash.each do |method_name, return_value|
-          ensure_method_not_already_defined(method_name)
-          @expectations.add(Expectation.new(self, method_name, backtrace).returns(return_value))
-        end
-      else
-        ensure_method_not_already_defined(method_name_or_hash)
-        @expectations.add(Expectation.new(self, method_name_or_hash, backtrace))
-      end
-    end
-    
-    # :call-seq: stubs(method_name) -> expectation
-    #            stubs(method_names) -> last expectation
-    #
-    # Adds an expectation that a method identified by +method_name+ symbol may be called any number of times with any parameters.
-    # Returns the new expectation which can be further modified by methods on Expectation.
-    #   object = mock()
-    #   object.stubs(:method1)
-    #   object.method1
-    #   object.method1
-    #   # no error raised
-    # If +method_names+ is a +Hash+, an expectation will be set up for each entry using the key as +method_name+ and value as +return_value+.
-    #   object = mock()
-    #   object.stubs(:method1 => :result1, :method2 => :result2)
-    #
-    #   # exactly equivalent to
-    #
-    #   object = mock()
-    #   object.stubs(:method1).returns(:result1)
-    #   object.stubs(:method2).returns(:result2)
-    #
-    # Aliased by <tt>\_\_stubs\_\_</tt>
-    def stubs(method_name_or_hash, backtrace = nil)
-      if method_name_or_hash.is_a?(Hash) then
-        method_name_or_hash.each do |method_name, return_value|
-          ensure_method_not_already_defined(method_name)
-          @expectations.add(Expectation.new(self, method_name, backtrace).at_least(0).returns(return_value))
-        end
-      else
-        ensure_method_not_already_defined(method_name_or_hash)
-        @expectations.add(Expectation.new(self, method_name_or_hash, backtrace).at_least(0))
-      end
-    end
-    
-    # :call-seq: responds_like(responder) -> mock
-    #
-    # Constrains the +mock+ so that it can only expect or stub methods to which +responder+ responds. The constraint is only applied at method invocation time.
-    #
-    # A +NoMethodError+ will be raised if the +responder+ does not <tt>respond_to?</tt> a method invocation (even if the method has been expected or stubbed).
-    #
-    # The +mock+ will delegate its <tt>respond_to?</tt> method to the +responder+.
-    #   class Sheep
-    #     def chew(grass); end
-    #     def self.number_of_legs; end
-    #   end
-    #
-    #   sheep = mock('sheep')
-    #   sheep.expects(:chew)
-    #   sheep.expects(:foo)
-    #   sheep.respond_to?(:chew) # => true
-    #   sheep.respond_to?(:foo) # => true
-    #   sheep.chew
-    #   sheep.foo
-    #   # no error raised
-    #
-    #   sheep = mock('sheep')
-    #   sheep.responds_like(Sheep.new)
-    #   sheep.expects(:chew)
-    #   sheep.expects(:foo)
-    #   sheep.respond_to?(:chew) # => true
-    #   sheep.respond_to?(:foo) # => false
-    #   sheep.chew
-    #   sheep.foo # => raises NoMethodError exception
-    #
-    #   sheep_class = mock('sheep_class')
-    #   sheep_class.responds_like(Sheep)
-    #   sheep_class.stubs(:number_of_legs).returns(4)
-    #   sheep_class.expects(:foo)
-    #   sheep_class.respond_to?(:number_of_legs) # => true
-    #   sheep_class.respond_to?(:foo) # => false
-    #   assert_equal 4, sheep_class.number_of_legs
-    #   sheep_class.foo # => raises NoMethodError exception
-    #
-    # Aliased by +quacks_like+
-    def responds_like(object)
-      @responder = object
-      self
-    end
-    
-    # :stopdoc:
-    
-    def initialize(name = nil, &block)
-      @name = name || DefaultName.new(self)
-      @expectations = ExpectationList.new
-      @everything_stubbed = false
-      @responder = nil
-      instance_eval(&block) if block
-    end
-
-    attr_reader :everything_stubbed, :expectations
-
-    alias_method :__expects__, :expects
-
-    alias_method :__stubs__, :stubs
-    
-    alias_method :quacks_like, :responds_like
-
-    def stub_everything
-      @everything_stubbed = true
-    end
-    
-    def method_missing(symbol, *arguments, &block)
-      if @responder and not @responder.respond_to?(symbol)
-        raise NoMethodError, "undefined method `#{symbol}' for #{self.mocha_inspect} which responds like #{@responder.mocha_inspect}"
-      end
-      if matching_expectation_allowing_invocation = @expectations.match_allowing_invocation(symbol, *arguments)
-        matching_expectation_allowing_invocation.invoke(&block)
-      else
-        if (matching_expectation = @expectations.match(symbol, *arguments)) || (!matching_expectation && !@everything_stubbed)
-          message = UnexpectedInvocation.new(self, symbol, *arguments).to_s
-          message << Mockery.instance.mocha_inspect
-          raise ExpectationError.new(message, caller)
-        end
-      end
-    end
-    
-    def respond_to?(symbol)
-      if @responder then
-        @responder.respond_to?(symbol)
-      else
-        @expectations.matches_method?(symbol)
-      end
-    end
-    
-    def __verified__?(assertion_counter = nil)
-      @expectations.verified?(assertion_counter)
-    end
-    
-    def mocha_inspect
-      @name.mocha_inspect
-    end
-    
-    def inspect
-      mocha_inspect
-    end
-    
-    def ensure_method_not_already_defined(method_name)
-      self.__metaclass__.send(:undef_method, method_name) if self.__metaclass__.method_defined?(method_name)
-    end
-
-    # :startdoc:
-
-  end
-
-end

data/test/rails_root/vendor/gems/mocha-0.9.1/lib/mocha/mockery.rb

@@ -1,181 +0,0 @@
-require 'mocha/central'
-require 'mocha/mock'
-require 'mocha/names'
-require 'mocha/state_machine'
-require 'mocha/logger'
-require 'mocha/configuration'
-require 'mocha/stubbing_error'
-
-module Mocha
-  
-  class Mockery
-    
-    class << self
-      
-      def instance
-        @instance ||= new
-      end
-      
-      def reset_instance
-        @instance = nil
-      end
-      
-    end
-    
-    def named_mock(name, &block)
-      add_mock(Mock.new(Name.new(name), &block))
-    end
-    
-    def unnamed_mock(&block)
-      add_mock(Mock.new(&block))
-    end
-    
-    def mock_impersonating(object, &block)
-      add_mock(Mock.new(ImpersonatingName.new(object), &block))
-    end
-    
-    def mock_impersonating_any_instance_of(klass, &block)
-      add_mock(Mock.new(ImpersonatingAnyInstanceName.new(klass), &block))
-    end
-    
-    def new_state_machine(name)
-      add_state_machine(StateMachine.new(name))
-    end
-    
-    def verify(assertion_counter = nil)
-      unless mocks.all? { |mock| mock.__verified__?(assertion_counter) }
-        message = "not all expectations were satisfied\n#{mocha_inspect}"
-        if unsatisfied_expectations.empty?
-          backtrace = caller
-        else
-          backtrace = unsatisfied_expectations[0].backtrace
-        end
-        raise ExpectationError.new(message, backtrace)
-      end
-      expectations.each do |e|
-        unless Mocha::Configuration.allow?(:stubbing_method_unnecessarily)
-          unless e.used?
-            on_stubbing_method_unnecessarily(e)
-          end
-        end
-      end
-    end
-    
-    def teardown
-      stubba.unstub_all
-      reset
-    end
-    
-    def stubba
-      @stubba ||= Central.new
-    end
-    
-    def mocks
-      @mocks ||= []
-    end
-    
-    def state_machines
-      @state_machines ||= []
-    end
-    
-    def mocha_inspect
-      message = ""
-      message << "unsatisfied expectations:\n- #{unsatisfied_expectations.map { |e| e.mocha_inspect }.join("\n- ")}\n" unless unsatisfied_expectations.empty?
-      message << "satisfied expectations:\n- #{satisfied_expectations.map { |e| e.mocha_inspect }.join("\n- ")}\n" unless satisfied_expectations.empty?
-      message << "states:\n- #{state_machines.map { |sm| sm.mocha_inspect }.join("\n- ")}" unless state_machines.empty?
-      message
-    end
-    
-    def on_stubbing(object, method)
-      method = RUBY_VERSION < '1.9' ? method.to_s : method.to_sym
-      unless Mocha::Configuration.allow?(:stubbing_non_existent_method)
-        unless object.method_exists?(method, include_public_methods = true)
-          on_stubbing_non_existent_method(object, method)
-        end
-      end
-      unless Mocha::Configuration.allow?(:stubbing_non_public_method)
-        if object.method_exists?(method, include_public_methods = false)
-          on_stubbing_non_public_method(object, method)
-        end
-      end
-      unless Mocha::Configuration.allow?(:stubbing_method_on_non_mock_object)
-        on_stubbing_method_on_non_mock_object(object, method)
-      end
-    end
-    
-    def on_stubbing_non_existent_method(object, method)
-      if Mocha::Configuration.prevent?(:stubbing_non_existent_method)
-        raise StubbingError.new("stubbing non-existent method: #{object.mocha_inspect}.#{method}", caller)
-      end
-      if Mocha::Configuration.warn_when?(:stubbing_non_existent_method)
-        logger.warn "stubbing non-existent method: #{object.mocha_inspect}.#{method}"
-      end
-    end
-    
-    def on_stubbing_non_public_method(object, method)
-      if Mocha::Configuration.prevent?(:stubbing_non_public_method)
-        raise StubbingError.new("stubbing non-public method: #{object.mocha_inspect}.#{method}", caller)
-      end
-      if Mocha::Configuration.warn_when?(:stubbing_non_public_method)
-        logger.warn "stubbing non-public method: #{object.mocha_inspect}.#{method}"
-      end
-    end
-    
-    def on_stubbing_method_on_non_mock_object(object, method)
-      if Mocha::Configuration.prevent?(:stubbing_method_on_non_mock_object)
-        raise StubbingError.new("stubbing method on non-mock object: #{object.mocha_inspect}.#{method}", caller)
-      end
-      if Mocha::Configuration.warn_when?(:stubbing_method_on_non_mock_object)
-        logger.warn "stubbing method on non-mock object: #{object.mocha_inspect}.#{method}"
-      end
-    end
-    
-    def on_stubbing_method_unnecessarily(expectation)
-      if Mocha::Configuration.prevent?(:stubbing_method_unnecessarily)
-        raise StubbingError.new("stubbing method unnecessarily: #{expectation.method_signature}", expectation.backtrace)
-      end
-      if Mocha::Configuration.warn_when?(:stubbing_method_unnecessarily)
-        logger.warn "stubbing method unnecessarily: #{expectation.method_signature}"
-      end
-    end
-    
-    attr_writer :logger
-    
-    def logger
-      @logger ||= Logger.new($stderr)
-    end
-    
-    
-    private
-    
-    def expectations
-      mocks.map { |mock| mock.expectations.to_a }.flatten
-    end
-    
-    def unsatisfied_expectations
-      expectations.reject { |e| e.verified? }
-    end
-    
-    def satisfied_expectations
-      expectations.select { |e| e.verified? }
-    end
-    
-    def add_mock(mock)
-      mocks << mock
-      mock
-    end
-    
-    def add_state_machine(state_machine)
-      state_machines << state_machine
-      state_machine
-    end
-    
-    def reset
-      @stubba = nil
-      @mocks = nil
-      @state_machines = nil
-    end
-    
-  end
-  
-end

data/test/rails_root/vendor/gems/mocha-0.9.1/lib/mocha/module_method.rb

@@ -1,16 +0,0 @@
-require 'mocha/module_method'
-
-module Mocha
-
-  class ModuleMethod < ClassMethod
-
-    def method_exists?(method)
-      return true if stubbee.public_methods(false).include?(method)
-      return true if stubbee.protected_methods(false).include?(method)
-      return true if stubbee.private_methods(false).include?(method)
-      return false
-    end
-
-  end
-  
-end

data/test/rails_root/vendor/gems/mocha-0.9.1/lib/mocha/multiple_yields.rb

@@ -1,20 +0,0 @@
-module Mocha # :nodoc:
-  
-  class MultipleYields # :nodoc:
-    
-    attr_reader :parameter_groups
-    
-    def initialize(*parameter_groups)
-      @parameter_groups = parameter_groups
-    end
-    
-    def each
-      @parameter_groups.each do |parameter_group|
-        yield(parameter_group)
-      end
-    end
-    
-  end
-  
-end
-    

data/test/rails_root/vendor/gems/mocha-0.9.1/lib/mocha/names.rb

@@ -1,53 +0,0 @@
-module Mocha
-  
-  class ImpersonatingName
-    
-    def initialize(object)
-      @object = object
-    end
-    
-    def mocha_inspect
-      @object.mocha_inspect
-    end
-    
-  end
-  
-  class ImpersonatingAnyInstanceName
-    
-    def initialize(klass)
-      @klass = klass
-    end
-    
-    def mocha_inspect
-      "#<AnyInstance:#{@klass.mocha_inspect}>"
-    end
-    
-  end
-  
-  class Name
-    
-    def initialize(name)
-      @name = name
-    end
-    
-    def mocha_inspect
-      "#<Mock:#{@name}>"
-    end
-    
-  end
-  
-  class DefaultName
-    
-    def initialize(mock)
-      @mock = mock
-    end
-    
-    def mocha_inspect
-      address = @mock.__id__ * 2
-      address += 0x100000000 if address < 0
-      "#<Mock:0x#{'%x' % address}>"
-    end
-    
-  end
-  
-end

data/test/rails_root/vendor/gems/mocha-0.9.1/lib/mocha/no_yields.rb

@@ -1,11 +0,0 @@
-module Mocha # :nodoc:
-  
-  class NoYields # :nodoc:
-    
-    def each
-    end
-    
-  end
-  
-end
-    

data/test/rails_root/vendor/gems/mocha-0.9.1/lib/mocha/object.rb

@@ -1,134 +0,0 @@
-require 'mocha/mockery'
-require 'mocha/instance_method'
-require 'mocha/class_method'
-require 'mocha/module_method'
-require 'mocha/any_instance_method'
-
-# Methods added all objects to allow mocking and stubbing on real objects.
-#
-# Methods return a Mocha::Expectation which can be further modified by methods on Mocha::Expectation.
-class Object
-  
-  def mocha # :nodoc:
-    @mocha ||= Mocha::Mockery.instance.mock_impersonating(self)
-  end
-  
-  def reset_mocha # :nodoc:
-    @mocha = nil
-  end
-  
-  def stubba_method # :nodoc:
-    Mocha::InstanceMethod
-  end
-  
-  def stubba_object # :nodoc:
-    self
-  end
-  
-  # :call-seq: expects(symbol) -> expectation
-  #
-  # Adds an expectation that a method identified by +symbol+ must be called exactly once with any parameters.
-  # Returns the new expectation which can be further modified by methods on Mocha::Expectation.
-  #   product = Product.new
-  #   product.expects(:save).returns(true)
-  #   assert_equal false, product.save
-  #
-  # The original implementation of <tt>Product#save</tt> is replaced temporarily.
-  #
-  # The original implementation of <tt>Product#save</tt> is restored at the end of the test.
-  def expects(symbol)
-    mockery = Mocha::Mockery.instance
-    mockery.on_stubbing(self, symbol)
-    method = stubba_method.new(stubba_object, symbol)
-    mockery.stubba.stub(method)
-    mocha.expects(symbol, caller)
-  end
-  
-  # :call-seq: stubs(symbol) -> expectation
-  #
-  # Adds an expectation that a method identified by +symbol+ may be called any number of times with any parameters.
-  # Returns the new expectation which can be further modified by methods on Mocha::Expectation.
-  #   product = Product.new
-  #   product.stubs(:save).returns(true)
-  #   assert_equal false, product.save
-  #
-  # The original implementation of <tt>Product#save</tt> is replaced temporarily.
-  #
-  # The original implementation of <tt>Product#save</tt> is restored at the end of the test.
-  def stubs(symbol)
-    mockery = Mocha::Mockery.instance
-    mockery.on_stubbing(self, symbol)
-    method = stubba_method.new(stubba_object, symbol)
-    mockery.stubba.stub(method)
-    mocha.stubs(symbol, caller)
-  end
-  
-  def method_exists?(method, include_public_methods = true)
-    if include_public_methods
-      return true if public_methods(include_superclass_methods = true).include?(method)
-      return true if respond_to?(method)
-    end
-    return true if protected_methods(include_superclass_methods = true).include?(method)
-    return true if private_methods(include_superclass_methods = true).include?(method)
-    return false
-  end
-  
-end
-
-class Module # :nodoc:
-  
-  def stubba_method
-    Mocha::ModuleMethod
-  end
-    
-end
-  
-class Class
-  
-  def stubba_method # :nodoc:
-    Mocha::ClassMethod
-  end
-
-  class AnyInstance # :nodoc:
-    
-    def initialize(klass)
-      @stubba_object = klass
-    end
-    
-    def mocha
-      @mocha ||= Mocha::Mockery.instance.mock_impersonating_any_instance_of(@stubba_object)
-    end
-
-    def stubba_method
-      Mocha::AnyInstanceMethod
-    end
-    
-    def stubba_object
-      @stubba_object
-    end
-    
-    def method_exists?(method, include_public_methods = true)
-      if include_public_methods
-        return true if @stubba_object.public_instance_methods(include_superclass_methods = true).include?(method)
-      end
-      return true if @stubba_object.protected_instance_methods(include_superclass_methods = true).include?(method)
-      return true if @stubba_object.private_instance_methods(include_superclass_methods = true).include?(method)
-      return false
-    end
-    
-  end
-  
-  # :call-seq: any_instance -> mock object
-  #
-  # Returns a mock object which will detect calls to any instance of this class.
-  #   Product.any_instance.stubs(:save).returns(false)
-  #   product_1 = Product.new
-  #   assert_equal false, product_1.save
-  #   product_2 = Product.new
-  #   assert_equal false, product_2.save
-  def any_instance
-    @any_instance ||= AnyInstance.new(self)
-  end
-  
-end
-

data/test/rails_root/vendor/gems/mocha-0.9.1/lib/mocha/parameter_matchers/all_of.rb

@@ -1,42 +0,0 @@
-require 'mocha/parameter_matchers/base'
-
-module Mocha
-  
-  module ParameterMatchers
-
-    # :call-seq: all_of(*parameter_matchers) -> parameter_matcher
-    #
-    # Matches if all +parameter_matchers+ match.
-    #   object = mock()
-    #   object.expects(:method_1).with(all_of(includes(1), includes(3)))
-    #   object.method_1([1, 3])
-    #   # no error raised
-    #
-    #   object = mock()
-    #   object.expects(:method_1).with(all_of(includes(1), includes(3)))
-    #   object.method_1([1, 2])
-    #   # error raised, because method_1 was not called with object including 1 and 3
-    def all_of(*matchers)
-      AllOf.new(*matchers)
-    end
-    
-    class AllOf < Base # :nodoc:
-      
-      def initialize(*matchers)
-        @matchers = matchers
-      end
-    
-      def matches?(available_parameters)
-        parameter = available_parameters.shift
-        @matchers.all? { |matcher| matcher.to_matcher.matches?([parameter]) }
-      end
-      
-      def mocha_inspect
-        "all_of(#{@matchers.map { |matcher| matcher.mocha_inspect }.join(", ") })"
-      end
-      
-    end
-    
-  end
-  
-end

data/test/rails_root/vendor/gems/mocha-0.9.1/lib/mocha/parameter_matchers/any_of.rb

@@ -1,47 +0,0 @@
-require 'mocha/parameter_matchers/base'
-
-module Mocha
-  
-  module ParameterMatchers
-
-    # :call-seq: any_of(*parameter_matchers) -> parameter_matcher
-    #
-    # Matches if any +parameter_matchers+ match.
-    #   object = mock()
-    #   object.expects(:method_1).with(any_of(1, 3))
-    #   object.method_1(1)
-    #   # no error raised
-    #
-    #   object = mock()
-    #   object.expects(:method_1).with(any_of(1, 3))
-    #   object.method_1(3)
-    #   # no error raised
-    #
-    #   object = mock()
-    #   object.expects(:method_1).with(any_of(1, 3))
-    #   object.method_1(2)
-    #   # error raised, because method_1 was not called with 1 or 3
-    def any_of(*matchers)
-      AnyOf.new(*matchers)
-    end
-    
-    class AnyOf < Base # :nodoc:
-      
-      def initialize(*matchers)
-        @matchers = matchers
-      end
-    
-      def matches?(available_parameters)
-        parameter = available_parameters.shift
-        @matchers.any? { |matcher| matcher.to_matcher.matches?([parameter]) }
-      end
-      
-      def mocha_inspect
-        "any_of(#{@matchers.map { |matcher| matcher.mocha_inspect }.join(", ") })"
-      end
-      
-    end
-    
-  end
-  
-end