hashrocket-clearance 0.4.3 → 0.4.4

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

@@ -1,15 +0,0 @@
-require 'mocha/backtrace_filter'
-
-module Mocha
-
-  class ExpectationError < StandardError
-    
-    def initialize(message = nil, backtrace = [])
-      super(message)
-      filter = BacktraceFilter.new
-      set_backtrace(filter.filtered(backtrace))
-    end
-
-  end
-  
-end

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

@@ -1,50 +0,0 @@
-module Mocha # :nodoc:
-
-  class ExpectationList
-
-    def initialize
-      @expectations = []
-    end
-    
-    def add(expectation)
-      @expectations.unshift(expectation)
-      expectation
-    end
-    
-    def matches_method?(method_name)
-      @expectations.any? { |expectation| expectation.matches_method?(method_name) }
-    end
-    
-    def match(method_name, *arguments)
-      matching_expectations(method_name, *arguments).first
-    end
-    
-    def match_allowing_invocation(method_name, *arguments)
-      matching_expectations(method_name, *arguments).detect { |e| e.invocations_allowed? }
-    end
-    
-    def verified?(assertion_counter = nil)
-      @expectations.all? { |expectation| expectation.verified?(assertion_counter) }
-    end
-    
-    def to_a
-      @expectations
-    end
-    
-    def to_set
-      @expectations.to_set
-    end
-    
-    def length
-      @expectations.length
-    end
-    
-    private
-    
-    def matching_expectations(method_name, *arguments)
-      @expectations.select { |e| e.match?(method_name, *arguments) }
-    end
-    
-  end
-
-end

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

@@ -1,19 +0,0 @@
-module Mocha
-
-  class InStateOrderingConstraint
-  
-    def initialize(state_predicate)
-      @state_predicate = state_predicate
-    end
-  
-    def allows_invocation_now?
-      @state_predicate.active?
-    end
-  
-    def mocha_inspect
-      "when #{@state_predicate.mocha_inspect}"
-    end
-  
-  end
-
-end

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

@@ -1,39 +0,0 @@
-require 'date'
-
-class Object
-  def mocha_inspect
-    address = self.__id__ * 2
-    address += 0x100000000 if address < 0
-    inspect =~ /#</ ? "#<#{self.class}:0x#{'%x' % address}>" : inspect
-  end
-end
-
-class String
-  def mocha_inspect
-    inspect.gsub(/\"/, "'")
-  end
-end
-
-class Array
-  def mocha_inspect
-    "[#{collect { |member| member.mocha_inspect }.join(', ')}]"
-  end
-end
-
-class Hash
-  def mocha_inspect
-    "{#{collect { |key, value| "#{key.mocha_inspect} => #{value.mocha_inspect}" }.join(', ')}}"
-  end
-end
-
-class Time
-  def mocha_inspect
-    "#{inspect} (#{to_f} secs)"
-  end
-end
-
-class Date
-  def mocha_inspect
-    to_s
-  end
-end

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

@@ -1,16 +0,0 @@
-require 'mocha/class_method'
-
-module Mocha
-
-  class InstanceMethod < 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/is_a.rb

@@ -1,9 +0,0 @@
-class Object
-
-  # :stopdoc:
-
-  alias_method :__is_a__, :is_a?
-
-  # :startdoc:
-  
-end

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

@@ -1,15 +0,0 @@
-module Mocha
-  
-  class Logger
-    
-    def initialize(io)
-      @io = io
-    end
-    
-    def warn(message)
-      @io.puts "WARNING: #{message}"
-    end
-    
-  end
-  
-end

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

@@ -1,7 +0,0 @@
-class Object
-  
-  def __metaclass__
-    class << self; self; end
-  end
-
-end

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

@@ -1,21 +0,0 @@
-module Mocha
-  
-  class MethodMatcher
-    
-    attr_reader :expected_method_name
-    
-    def initialize(expected_method_name)
-      @expected_method_name = expected_method_name
-    end
-    
-    def match?(actual_method_name)
-      @expected_method_name == actual_method_name
-    end
-    
-    def mocha_inspect
-      "#{@expected_method_name}"
-    end
-    
-  end
-
-end

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