thoughtbot-clearance 0.3.4 → 0.3.7

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

@@ -1,43 +0,0 @@
-require 'mocha/parameter_matchers/base'
-require 'yaml'
-
-module Mocha
-
-  module ParameterMatchers
-
-    # :call-seq: yaml_equivalent(object) -> parameter_matcher
-    #
-    # Matches any YAML that represents the specified +object+
-    #   object = mock()
-    #   object.expects(:method_1).with(yaml_equivalent(1, 2, 3))
-    #   object.method_1("--- \n- 1\n- 2\n- 3\n")
-    #   # no error raised
-    #
-    #   object = mock()
-    #   object.expects(:method_1).with(yaml_equivalent(1, 2, 3))
-    #   object.method_1("--- \n- 1\n- 2\n")
-    #   # error raised, because method_1 was not called with YAML representing the specified Array
-    def yaml_equivalent(object)
-      YamlEquivalent.new(object)
-    end
-
-    class YamlEquivalent < Base # :nodoc:
-
-      def initialize(object)
-        @object = object
-      end
-
-      def matches?(available_parameters)
-        parameter = available_parameters.shift
-        @object == YAML.load(parameter)
-      end
-
-      def mocha_inspect
-        "yaml_equivalent(#{@object.mocha_inspect})"
-      end
-      
-    end
-    
-  end
-  
-end

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

@@ -1,26 +0,0 @@
-module Mocha
-  
-  # Used as parameters for Expectation#with to restrict the parameter values which will match the expectation. Can be nested.
-  module ParameterMatchers; end
-  
-end
-
-require 'mocha/parameter_matchers/object'
-
-require 'mocha/parameter_matchers/all_of'
-require 'mocha/parameter_matchers/any_of'
-require 'mocha/parameter_matchers/any_parameters'
-require 'mocha/parameter_matchers/anything'
-require 'mocha/parameter_matchers/equals'
-require 'mocha/parameter_matchers/has_entry'
-require 'mocha/parameter_matchers/has_entries'
-require 'mocha/parameter_matchers/has_key'
-require 'mocha/parameter_matchers/has_value'
-require 'mocha/parameter_matchers/includes'
-require 'mocha/parameter_matchers/instance_of'
-require 'mocha/parameter_matchers/is_a'
-require 'mocha/parameter_matchers/kind_of'
-require 'mocha/parameter_matchers/not'
-require 'mocha/parameter_matchers/optionally'
-require 'mocha/parameter_matchers/regexp_matches'
-require 'mocha/parameter_matchers/yaml_equivalent'

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

@@ -1,37 +0,0 @@
-require 'mocha/inspect'
-require 'mocha/parameter_matchers'
-
-module Mocha
-  
-  class ParametersMatcher
-    
-    def initialize(expected_parameters = [ParameterMatchers::AnyParameters.new], &matching_block)
-      @expected_parameters, @matching_block = expected_parameters, matching_block
-    end
-    
-    def match?(actual_parameters = [])
-      if @matching_block
-        return @matching_block.call(*actual_parameters)
-      else
-        return parameters_match?(actual_parameters)
-      end
-    end
-    
-    def parameters_match?(actual_parameters)
-      matchers.all? { |matcher| matcher.matches?(actual_parameters) } && (actual_parameters.length == 0)
-    end
-    
-    def mocha_inspect
-      signature = matchers.mocha_inspect
-      signature = signature.gsub(/^\[|\]$/, '')
-      signature = signature.gsub(/^\{|\}$/, '') if matchers.length == 1
-      "(#{signature})"
-    end
-    
-    def matchers
-      @expected_parameters.map { |parameter| parameter.to_matcher }
-    end
-    
-  end
-
-end

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

@@ -1,28 +0,0 @@
-require 'mocha/inspect'
-
-module Mocha
-
-  class PrettyParameters
-  
-    def initialize(params)
-      @params = params
-      @params_string = params.mocha_inspect
-    end
-  
-    def pretty
-      remove_outer_array_braces!
-      remove_outer_hash_braces!
-      @params_string
-    end
-  
-    def remove_outer_array_braces!
-      @params_string = @params_string.gsub(/^\[|\]$/, '')
-    end
-  
-    def remove_outer_hash_braces!
-      @params_string = @params_string.gsub(/^\{|\}$/, '') if @params.length == 1
-    end
-  
-  end
-  
-end

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

@@ -1,31 +0,0 @@
-require 'mocha/single_return_value'
-
-module Mocha # :nodoc:
-  
-  class ReturnValues # :nodoc:
-    
-    def self.build(*values)
-      new(*values.map { |value| SingleReturnValue.new(value) })
-    end
-    
-    attr_accessor :values
-    
-    def initialize(*values)
-      @values = values
-    end
-    
-    def next
-      case @values.length
-        when 0 then nil
-        when 1 then @values.first.evaluate
-        else @values.shift.evaluate
-      end
-    end
-    
-    def +(other)
-      self.class.new(*(@values + other.values))
-    end
-    
-  end
-  
-end

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

@@ -1,42 +0,0 @@
-module Mocha # :nodoc:
-  
-  class Sequence
-    
-    class InSequenceOrderingConstraint
-      
-      def initialize(sequence, index)
-        @sequence, @index = sequence, index
-      end
-      
-      def allows_invocation_now?
-        @sequence.satisfied_to_index?(@index)
-      end
-      
-      def mocha_inspect
-        "in sequence #{@sequence.mocha_inspect}"
-      end
-      
-    end
-    
-    def initialize(name)
-      @name = name
-      @expectations = []
-    end
-    
-    def constrain_as_next_in_sequence(expectation)
-      index = @expectations.length
-      @expectations << expectation
-      expectation.add_ordering_constraint(InSequenceOrderingConstraint.new(self, index))
-    end
-    
-    def satisfied_to_index?(index)
-      @expectations[0...index].all? { |expectation| expectation.satisfied? }
-    end
-    
-    def mocha_inspect
-      "#{@name.mocha_inspect}"
-    end
-    
-  end
-  
-end

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

@@ -1,17 +0,0 @@
-require 'mocha/is_a'
-
-module Mocha # :nodoc:
-  
-  class SingleReturnValue # :nodoc:
-    
-    def initialize(value)
-      @value = value
-    end
-    
-    def evaluate
-      @value
-    end
-    
-  end
-  
-end

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

@@ -1,18 +0,0 @@
-module Mocha # :nodoc:
-  
-  class SingleYield # :nodoc:
-    
-    attr_reader :parameters
-    
-    def initialize(*parameters)
-      @parameters = parameters
-    end
-    
-    def each
-      yield(@parameters)
-    end
-    
-  end
-  
-end
-    

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

@@ -1,166 +0,0 @@
-require 'mocha/parameter_matchers'
-require 'mocha/mockery'
-require 'mocha/sequence'
-
-module Mocha # :nodoc:
-  
-  # Methods added to Test::Unit::TestCase or equivalent.
-  module Standalone
-    
-    include ParameterMatchers
-    
-    # :call-seq: mock(name, &block) -> mock object
-    #            mock(expected_methods = {}, &block) -> mock object
-    #            mock(name, expected_methods = {}, &block) -> mock object
-    #
-    # Creates a mock object.
-    #
-    # +name+ is a +String+ identifier for the mock object.
-    #
-    # +expected_methods+ is a +Hash+ with expected method name symbols as keys and corresponding return values as values.
-    #
-    # Note that (contrary to expectations set up by #stub) these expectations <b>must</b> be fulfilled during the test.
-    #   def test_product
-    #     product = mock('ipod_product', :manufacturer => 'ipod', :price => 100)
-    #     assert_equal 'ipod', product.manufacturer
-    #     assert_equal 100, product.price
-    #     # an error will be raised unless both Product#manufacturer and Product#price have been called
-    #   end 
-    #
-    # +block+ is an optional block to be evaluated against the mock object instance, giving an alernative way to set up expectations & stubs.
-    #   def test_product
-    #     product = mock('ipod_product') do
-    #       expects(:manufacturer).returns('ipod')
-    #       expects(:price).returns(100)
-    #     end
-    #     assert_equal 'ipod', product.manufacturer
-    #     assert_equal 100, product.price
-    #     # an error will be raised unless both Product#manufacturer and Product#price have been called
-    #   end 
-    def mock(*arguments, &block)
-      name = arguments.shift if arguments.first.is_a?(String)
-      expectations = arguments.shift || {}
-      mock = name ? Mockery.instance.named_mock(name, &block) : Mockery.instance.unnamed_mock(&block)
-      mock.expects(expectations)
-      mock
-    end
-    
-    # :call-seq: stub(name, &block) -> mock object
-    #            stub(stubbed_methods = {}, &block) -> mock object
-    #            stub(name, stubbed_methods = {}, &block) -> mock object
-    #
-    # Creates a mock object.
-    #
-    # +name+ is a +String+ identifier for the mock object.
-    #
-    # +stubbed_methods+ is a +Hash+ with stubbed method name symbols as keys and corresponding return values as values.
-    # Note that (contrary to expectations set up by #mock) these expectations <b>need not</b> be fulfilled during the test.
-    #   def test_product
-    #     product = stub('ipod_product', :manufacturer => 'ipod', :price => 100)
-    #     assert_equal 'ipod', product.manufacturer
-    #     assert_equal 100, product.price
-    #     # an error will not be raised even if Product#manufacturer and Product#price have not been called
-    #   end
-    #
-    # +block+ is an optional block to be evaluated against the mock object instance, giving an alernative way to set up expectations & stubs.
-    #   def test_product
-    #     product = stub('ipod_product') do
-    #       stubs(:manufacturer).returns('ipod')
-    #       stubs(:price).returns(100)
-    #     end
-    #     assert_equal 'ipod', product.manufacturer
-    #     assert_equal 100, product.price
-    #     # an error will not be raised even if Product#manufacturer and Product#price have not been called
-    #   end
-    def stub(*arguments, &block)
-      name = arguments.shift if arguments.first.is_a?(String)
-      expectations = arguments.shift || {}
-      stub = name ? Mockery.instance.named_mock(name, &block) : Mockery.instance.unnamed_mock(&block)
-      stub.stubs(expectations)
-      stub
-    end
-    
-    # :call-seq: stub_everything(name, &block) -> mock object
-    #            stub_everything(stubbed_methods = {}, &block) -> mock object
-    #            stub_everything(name, stubbed_methods = {}, &block) -> mock object
-    #
-    # Creates a mock object that accepts calls to any method.
-    #
-    # By default it will return +nil+ for any method call.
-    #
-    # +block+ is a block to be evaluated against the mock object instance, giving an alernative way to set up expectations & stubs.
-    #
-    # +name+ and +stubbed_methods+ work in the same way as for #stub.
-    #   def test_product
-    #     product = stub_everything('ipod_product', :price => 100)
-    #     assert_nil product.manufacturer
-    #     assert_nil product.any_old_method
-    #     assert_equal 100, product.price
-    #   end
-    def stub_everything(*arguments, &block)
-      name = arguments.shift if arguments.first.is_a?(String)
-      expectations = arguments.shift || {}
-      stub = name ? Mockery.instance.named_mock(name, &block) : Mockery.instance.unnamed_mock(&block)
-      stub.stub_everything
-      stub.stubs(expectations)
-      stub
-    end
-    
-    # :call-seq: sequence(name) -> sequence
-    #
-    # Returns a new sequence that is used to constrain the order in which expectations can occur.
-    #
-    # Specify that an expected invocation must occur in within a named +sequence+ by using Expectation#in_sequence.
-    #
-    # See also Expectation#in_sequence.
-    #   breakfast = sequence('breakfast')
-    #
-    #   egg = mock('egg')
-    #   egg.expects(:crack).in_sequence(breakfast)
-    #   egg.expects(:fry).in_sequence(breakfast)
-    #   egg.expects(:eat).in_sequence(breakfast)
-    def sequence(name)
-      Sequence.new(name)
-    end
-    
-    # :call-seq: states(name) -> state_machine
-    #
-    # Returns a new +state_machine+ that is used to constrain the order in which expectations can occur.
-    #
-    # Specify the initial +state+ of the +state_machine+ by using StateMachine#starts_as.
-    #
-    # Specify that an expected invocation should change the +state+ of the +state_machine+ by using Expectation#then.
-    #
-    # Specify that an expected invocation should be constrained to occur within a particular +state+ by using Expectation#when.
-    #
-    # A test can contain multiple +state_machines+.
-    #
-    # See also Expectation#then, Expectation#when and StateMachine.
-    #   power = states('power').starts_as('off')
-    #
-    #   radio = mock('radio')
-    #   radio.expects(:switch_on).then(power.is('on'))
-    #   radio.expects(:select_channel).with('BBC Radio 4').when(power.is('on'))
-    #   radio.expects(:adjust_volume).with(+5).when(power.is('on'))
-    #   radio.expects(:select_channel).with('BBC World Service').when(power.is('on'))
-    #   radio.expects(:adjust_volume).with(-5).when(power.is('on'))
-    #   radio.expects(:switch_off).then(power.is('off'))
-    def states(name)
-      Mockery.instance.new_state_machine(name)
-    end
-    
-    def mocha_setup # :nodoc:
-    end
-    
-    def mocha_verify(assertion_counter = nil) # :nodoc:
-      Mockery.instance.verify(assertion_counter)
-    end
-    
-    def mocha_teardown # :nodoc:
-      Mockery.instance.teardown
-      Mockery.reset_instance
-    end
-    
-  end
-  
-end

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

@@ -1,91 +0,0 @@
-module Mocha # :nodoc:
-
-  # A state machine that is used to constrain the order of invocations.
-  # An invocation can be constrained to occur when a state is, or is_not, active.
-  class StateMachine
-  
-    class State # :nodoc:
-    
-      def initialize(state_machine, state)
-        @state_machine, @state = state_machine, state
-      end
-    
-      def activate
-        @state_machine.current_state = @state
-      end
-    
-      def active?
-        @state_machine.current_state == @state
-      end
-    
-      def mocha_inspect
-        "#{@state_machine.name} is #{@state.mocha_inspect}"
-      end
-    
-    end
-    
-    class StatePredicate # :nodoc:
-      
-      def initialize(state_machine, state)
-        @state_machine, @state = state_machine, state
-      end
-    
-      def active?
-        @state_machine.current_state != @state
-      end
-    
-      def mocha_inspect
-        "#{@state_machine.name} is not #{@state.mocha_inspect}"
-      end
-      
-    end
-    
-    attr_reader :name # :nodoc:
-    
-    attr_accessor :current_state # :nodoc:
-    
-    def initialize(name) # :nodoc:
-      @name = name
-      @current_state = nil
-    end
-    
-    # :call-seq: starts_as(initial_state) -> state_machine
-    #
-    # Put the +state_machine+ into the +initial_state+.
-    def starts_as(initial_state)
-      become(initial_state)
-      self
-    end
-  
-    # :call-seq: become(next_state)
-    #
-    # Put the +state_machine+ into the +next_state+.
-    def become(next_state)
-      @current_state = next_state
-    end
-  
-    # :call-seq: is(state)
-    #
-    # Determines whether the +state_machine+ is in the specified +state+.
-    def is(state)
-      State.new(self, state)
-    end
-  
-    # :call-seq: is_not(state)
-    #
-    # Determines whether the +state_machine+ is not in the specified +state+.
-    def is_not(state)
-      StatePredicate.new(self, state)
-    end
-  
-    def mocha_inspect # :nodoc:
-      if @current_state
-        "#{@name} is #{@current_state.mocha_inspect}"
-      else
-        "#{@name} has no current state"
-      end
-    end
-  
-  end
-
-end

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

@@ -1,16 +0,0 @@
-require 'mocha/backtrace_filter'
-
-module Mocha # :nodoc:
-  
-  # Exception raised when an action prevented by Configuration#prevent is attempted.
-  class StubbingError < StandardError
-
-    def initialize(message = nil, backtrace = []) # :nodoc:
-      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/test_case_adapter.rb

@@ -1,103 +0,0 @@
-require 'mocha/expectation_error'
-
-module Mocha
-  
-  module TestCaseAdapter
-    
-    class AssertionCounter
-      
-      def initialize(test_result)
-        @test_result = test_result
-      end
-      
-      def increment
-        @test_result.add_assertion
-      end
-      
-    end
-
-    def self.included(base)
-      if RUBY_VERSION < '1.8.6'
-        base.class_eval do
-
-          alias_method :run_before_mocha_test_case_adapter, :run
-
-          def run(result)
-            assertion_counter = AssertionCounter.new(result)
-            yield(Test::Unit::TestCase::STARTED, name)
-            @_result = result
-            begin
-              begin
-                setup
-                __send__(@method_name)
-                mocha_verify(assertion_counter)
-              rescue Mocha::ExpectationError => e
-                add_failure(e.message, e.backtrace)
-              rescue Test::Unit::AssertionFailedError => e
-                add_failure(e.message, e.backtrace)
-              rescue StandardError, ScriptError
-                add_error($!)
-              ensure
-                begin
-                  teardown
-                rescue Test::Unit::AssertionFailedError => e
-                  add_failure(e.message, e.backtrace)
-                rescue StandardError, ScriptError
-                  add_error($!)
-                end
-              end
-            ensure
-              mocha_teardown
-            end
-            result.add_run
-            yield(Test::Unit::TestCase::FINISHED, name)
-          end
-
-        end
-      else
-        base.class_eval do
-
-          alias_method :run_before_mocha_test_case_adapter, :run
-
-          def run(result)
-            assertion_counter = AssertionCounter.new(result)
-            yield(Test::Unit::TestCase::STARTED, name)
-            @_result = result
-            begin
-              begin
-                setup
-                __send__(@method_name)
-                mocha_verify(assertion_counter)
-              rescue Mocha::ExpectationError => e
-                add_failure(e.message, e.backtrace)
-              rescue Test::Unit::AssertionFailedError => e
-                add_failure(e.message, e.backtrace)
-              rescue Exception
-                raise if Test::Unit::TestCase::PASSTHROUGH_EXCEPTIONS.include? $!.class
-                add_error($!)
-              ensure
-                begin
-                  teardown
-                rescue Test::Unit::AssertionFailedError => e
-                  add_failure(e.message, e.backtrace)
-                rescue Exception
-                  raise if Test::Unit::TestCase::PASSTHROUGH_EXCEPTIONS.include? $!.class
-                  add_error($!)
-                end
-              end
-            ensure
-              mocha_teardown
-            end
-            result.add_run
-            yield(Test::Unit::TestCase::FINISHED, name)
-          end
-                
-        end
-        
-      end
-      
-    end
-    
-  end
-  
-end

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

@@ -1,18 +0,0 @@
-module Mocha # :nodoc:
-
-  class UnexpectedInvocation
-    
-    def initialize(mock, symbol, *arguments)
-      @mock = mock
-      @method_matcher = MethodMatcher.new(symbol)
-      @parameters_matcher = ParametersMatcher.new(arguments)
-    end
-    
-    def to_s
-      method_signature = "#{@mock.mocha_inspect}.#{@method_matcher.mocha_inspect}#{@parameters_matcher.mocha_inspect}"
-      "unexpected invocation: #{method_signature}\n"
-    end
-    
-  end
-  
-end

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

@@ -1,31 +0,0 @@
-require 'mocha/no_yields'
-require 'mocha/single_yield'
-require 'mocha/multiple_yields'
-
-module Mocha # :nodoc:
-  
-  class YieldParameters # :nodoc:
-    
-    def initialize
-      @parameter_groups = []
-    end
-    
-    def next_invocation
-      case @parameter_groups.length
-        when 0 then NoYields.new
-        when 1 then @parameter_groups.first
-        else @parameter_groups.shift
-      end
-    end
-    
-    def add(*parameters)
-      @parameter_groups << SingleYield.new(*parameters)
-    end
-    
-    def multiple_add(*parameter_groups)
-      @parameter_groups << MultipleYields.new(*parameter_groups)
-    end
-    
-  end
-  
-end