pupu 0.0.1

data/vendor/rspec/lib/spec/mocks/methods.rb

@@ -0,0 +1,89 @@
+module Spec
+  module Mocks
+    module Methods
+      def should_receive(sym, opts={}, &block)
+        __mock_proxy.add_message_expectation(opts[:expected_from] || caller(1)[0], sym.to_sym, opts, &block)
+      end
+
+      def should_not_receive(sym, &block)
+        __mock_proxy.add_negative_message_expectation(caller(1)[0], sym.to_sym, &block)
+      end
+      
+      def stub!(sym_or_hash, opts={}, &block)
+        if Hash === sym_or_hash
+          sym_or_hash.each {|method, value| stub!(method).and_return value }
+        else
+          __mock_proxy.add_stub(caller(1)[0], sym_or_hash.to_sym, opts, &block)
+        end
+      end
+      
+      alias_method :stub, :stub!
+
+      def unstub!(message)
+        __mock_proxy.remove_stub(message)
+      end
+
+      alias_method :unstub, :unstub!
+
+      # :call-seq:
+      #   object.stub_chain(:first, :second, :third).and_return(:this)
+      #
+      # Supports stubbing a chain of methods. Each argument represents
+      # a method name to stub, and each one returns a proxy object that
+      # can accept more stubs, until the last, which returns whatever
+      # is passed to +and_return_.
+      #
+      # == Examples
+      #   
+      #   # with this in an example ...
+      #   article = double('article')
+      #   Article.stub_chain(:authored_by, :published, :recent).and_return([article])
+      #   # then this will return an Array with the article double in it:
+      #   Article.authored_by(params[:author_id]).published.recent
+      def stub_chain(*methods)
+        if methods.length > 1
+          if matching_stub = __mock_proxy.find_matching_method_stub(methods[0])
+            methods.shift
+            matching_stub.invoke_return_block.stub_chain(*methods)
+          else
+            next_in_chain = Object.new
+            stub!(methods.shift) {next_in_chain}
+            next_in_chain.stub_chain(*methods)
+          end
+        else
+          stub!(methods.shift)
+        end
+      end
+      
+      def received_message?(sym, *args, &block) #:nodoc:
+        __mock_proxy.received_message?(sym.to_sym, *args, &block)
+      end
+      
+      def rspec_verify #:nodoc:
+        __mock_proxy.verify
+      end
+
+      def rspec_reset #:nodoc:
+        __mock_proxy.reset
+      end
+      
+      def as_null_object
+        __mock_proxy.as_null_object
+      end
+      
+      def null_object?
+        __mock_proxy.null_object?
+      end
+
+    private
+
+      def __mock_proxy
+        if Mock === self
+          @mock_proxy ||= Proxy.new(self, @name, @options)
+        else
+          @mock_proxy ||= Proxy.new(self)
+        end
+      end
+    end
+  end
+end

data/vendor/rspec/lib/spec/mocks/mock.rb

@@ -0,0 +1,71 @@
+module Spec
+  module Mocks
+    class Mock
+      include Methods
+
+      # Creates a new mock with a +name+ (that will be used in error messages
+      # only) == Options:
+      # * <tt>:null_object</tt> - if true, the mock object acts as a forgiving
+      #   null object allowing any message to be sent to it.
+      def initialize(name=nil, stubs_and_options={})
+        if name.is_a?(Hash) && stubs_and_options.empty?
+          stubs_and_options = name
+          @name = nil
+        else
+          @name = name
+        end
+        @options = extract_options(stubs_and_options)
+        assign_stubs(stubs_and_options)
+      end
+
+      # This allows for comparing the mock to other objects that proxy such as
+      # ActiveRecords belongs_to proxy objects. By making the other object run
+      # the comparison, we're sure the call gets delegated to the proxy
+      # target.
+      def ==(other)
+        other == __mock_proxy
+      end
+
+      def inspect
+        "#<#{self.class}:#{sprintf '0x%x', self.object_id} @name=#{@name.inspect}>"
+      end
+
+      def to_s
+        inspect.gsub('<','[').gsub('>',']')
+      end
+
+    private
+
+      def method_missing(sym, *args, &block)
+        __mock_proxy.record_message_received(sym, args, block)
+        begin
+          return self if __mock_proxy.null_object?
+          super(sym, *args, &block)
+        rescue NameError
+          __mock_proxy.raise_unexpected_message_error sym, *args
+        end
+      end
+
+      def extract_options(stubs_and_options)
+        options = {}
+        extract_option(stubs_and_options, options, :null_object)
+        extract_option(stubs_and_options, options, :__declared_as, 'Mock')
+        options
+      end
+      
+      def extract_option(source, target, key, default=nil)
+        if source[key]
+          target[key] = source.delete(key)
+        elsif default
+          target[key] = default
+        end
+      end
+
+      def assign_stubs(stubs)
+        stubs.each_pair do |message, response|
+          stub!(message).and_return(response)
+        end
+      end
+    end
+  end
+end

data/vendor/rspec/lib/spec/mocks/order_group.rb

@@ -0,0 +1,29 @@
+module Spec
+  module Mocks
+    class OrderGroup
+      def initialize error_generator
+        @error_generator = error_generator
+        @ordering = Array.new
+      end
+      
+      def register(expectation)
+        @ordering << expectation
+      end
+      
+      def ready_for?(expectation)
+        return @ordering.first == expectation
+      end
+      
+      def consume
+        @ordering.shift
+      end
+      
+      def handle_order_constraint expectation
+        return unless @ordering.include? expectation
+        return consume if ready_for?(expectation)
+        @error_generator.raise_out_of_order_error expectation.sym
+      end
+      
+    end
+  end
+end

data/vendor/rspec/lib/spec/mocks/proxy.rb

@@ -0,0 +1,245 @@
+module Spec
+  module Mocks
+    class Proxy
+      DEFAULT_OPTIONS = {
+        :null_object => false,
+      }
+      
+      @@warn_about_expectations_on_nil = true
+      
+      def self.allow_message_expectations_on_nil
+        @@warn_about_expectations_on_nil = false
+        
+        # ensure nil.rspec_verify is called even if an expectation is not set in the example
+        # otherwise the allowance would effect subsequent examples
+        $rspec_mocks.add(nil) unless $rspec_mocks.nil?
+      end
+
+      def initialize(target, name=nil, options={})
+        @target = target
+        @name = name
+        @error_generator = ErrorGenerator.new target, name, options
+        @expectation_ordering = OrderGroup.new @error_generator
+        @expectations = []
+        @messages_received = []
+        @stubs = []
+        @proxied_methods = []
+        @options = options ? DEFAULT_OPTIONS.dup.merge(options) : DEFAULT_OPTIONS
+        @already_proxied_respond_to = false
+      end
+
+      def null_object?
+        @options[:null_object]
+      end
+      
+      def as_null_object
+        @options[:null_object] = true
+        @target
+      end
+
+      def add_message_expectation(expected_from, sym, opts={}, &block)        
+        __add sym
+        warn_if_nil_class sym
+        if existing_stub = @stubs.detect {|s| s.sym == sym }
+          expectation = existing_stub.build_child(expected_from, block_given?? block : nil, 1, opts)
+        else
+          expectation = MessageExpectation.new(@error_generator, @expectation_ordering, expected_from, sym, block_given? ? block : nil, 1, opts)
+        end
+        @expectations << expectation
+        @expectations.last
+      end
+
+      def add_negative_message_expectation(expected_from, sym, &block)
+        __add sym
+        warn_if_nil_class sym
+        @expectations << NegativeMessageExpectation.new(@error_generator, @expectation_ordering, expected_from, sym, block_given? ? block : nil)
+        @expectations.last
+      end
+
+      def add_stub(expected_from, sym, opts={}, &implementation)
+        __add sym
+        @stubs.unshift MessageExpectation.new(@error_generator, @expectation_ordering, expected_from, sym, nil, :any, opts, &implementation)
+        @stubs.first
+      end
+
+      def remove_stub(message)
+        message = message.to_sym
+        
+        if stub_to_remove = @stubs.detect { |s| s.matches_name?(message) }
+          reset_proxied_method(message)
+          @stubs.delete(stub_to_remove)
+        else
+          raise MockExpectationError, "The method `#{message}` was not stubbed or was already unstubbed"
+        end
+      end
+      
+      def verify #:nodoc:
+        verify_expectations
+      ensure
+        reset
+      end
+
+      def reset
+        clear_expectations
+        clear_stubs
+        reset_proxied_methods
+        clear_proxied_methods
+        reset_nil_expectations_warning
+      end
+
+      def received_message?(sym, *args, &block)
+        @messages_received.any? {|array| array == [sym, args, block]}
+      end
+
+      def has_negative_expectation?(sym)
+        @expectations.detect {|expectation| expectation.negative_expectation_for?(sym)}
+      end
+      
+      def record_message_received(sym, args, block)
+        @messages_received << [sym, args, block]
+      end
+
+      def message_received(sym, *args, &block)
+        expectation = find_matching_expectation(sym, *args)
+        stub = find_matching_method_stub(sym, *args)
+
+        if (stub && expectation && expectation.called_max_times?) || (stub && !expectation)
+          if expectation = find_almost_matching_expectation(sym, *args)
+            expectation.advise(args, block) unless expectation.expected_messages_received?
+          end
+          stub.invoke(*args, &block)
+        elsif expectation
+          expectation.invoke(*args, &block)
+        elsif expectation = find_almost_matching_expectation(sym, *args)
+          expectation.advise(args, block) if null_object? unless expectation.expected_messages_received?
+          raise_unexpected_message_args_error(expectation, *args) unless (has_negative_expectation?(sym) or null_object?)
+        else
+          @target.__send__ :method_missing, sym, *args, &block
+        end
+      end
+
+      def raise_unexpected_message_args_error(expectation, *args)
+        @error_generator.raise_unexpected_message_args_error expectation, *args
+      end
+
+      def raise_unexpected_message_error(sym, *args)
+        @error_generator.raise_unexpected_message_error sym, *args
+      end
+      
+      def find_matching_method_stub(sym, *args)
+        @stubs.find {|stub| stub.matches(sym, args)}
+      end
+      
+    private
+
+      def __add(sym)
+        $rspec_mocks.add(@target) unless $rspec_mocks.nil?
+        define_expected_method(sym)
+      end
+      
+      def warn_if_nil_class(sym)
+        if proxy_for_nil_class? & @@warn_about_expectations_on_nil          
+          Kernel.warn("An expectation of :#{sym} was set on nil. Called from #{caller[2]}. Use allow_message_expectations_on_nil to disable warnings.")
+        end
+      end
+      
+      def define_expected_method(sym)
+        unless @proxied_methods.include?(sym)
+          visibility_string = "#{visibility(sym)} :#{sym}"
+          if target_responds_to?(sym)
+            munged_sym = munge(sym)
+            target_metaclass.instance_eval do
+              alias_method munged_sym, sym if method_defined?(sym)
+            end
+            @proxied_methods << sym
+          end
+          target_metaclass.class_eval(<<-EOF, __FILE__, __LINE__)
+            def #{sym}(*args, &block)
+              __mock_proxy.message_received :#{sym}, *args, &block
+            end
+            #{visibility_string}
+          EOF
+        end
+      end
+
+      def target_responds_to?(sym)
+        return @target.__send__(munge(:respond_to?),sym) if @already_proxied_respond_to
+        return @already_proxied_respond_to = true if sym == :respond_to?
+        return @target.respond_to?(sym, true)
+      end
+
+      def visibility(sym)
+        if Mock === @target
+          'public'
+        elsif target_metaclass.private_method_defined?(sym)
+          'private'
+        elsif target_metaclass.protected_method_defined?(sym)
+          'protected'
+        else
+          'public'
+        end
+      end
+
+      def munge(sym)
+        "proxied_by_rspec__#{sym}"
+      end
+
+      def clear_expectations
+        @expectations.clear
+      end
+
+      def clear_stubs
+        @stubs.clear
+      end
+
+      def clear_proxied_methods
+        @proxied_methods.clear
+      end
+
+      def target_metaclass
+        class << @target; self; end
+      end
+
+      def verify_expectations
+        @expectations.each do |expectation|
+          expectation.verify_messages_received
+        end
+      end
+
+      def reset_proxied_methods
+        @proxied_methods.each do |sym|
+          reset_proxied_method(sym)
+        end
+      end
+
+      def reset_proxied_method(sym)
+        munged_sym = munge(sym)
+        target_metaclass.instance_eval do
+          remove_method sym
+          if method_defined?(munged_sym)
+            alias_method sym, munged_sym
+            remove_method munged_sym
+          end
+        end
+      end
+      
+      def proxy_for_nil_class?
+        @target.nil?
+      end
+      
+      def reset_nil_expectations_warning
+        @@warn_about_expectations_on_nil = true if proxy_for_nil_class?
+      end
+
+      def find_matching_expectation(sym, *args)
+        @expectations.find {|expectation| expectation.matches(sym, args) && !expectation.called_max_times?} || 
+        @expectations.find {|expectation| expectation.matches(sym, args)}
+      end
+
+      def find_almost_matching_expectation(sym, *args)
+        @expectations.find {|expectation| expectation.matches_name_but_not_args(sym, args)}
+      end
+
+    end
+  end
+end

data/vendor/rspec/lib/spec/mocks/space.rb

@@ -0,0 +1,28 @@
+module Spec
+  module Mocks
+    class Space
+      def add(obj)
+        mocks << obj unless mocks.detect {|m| m.equal? obj}
+      end
+
+      def verify_all
+        mocks.each do |mock|
+          mock.rspec_verify
+        end
+      end
+      
+      def reset_all
+        mocks.each do |mock|
+          mock.rspec_reset
+        end
+        mocks.clear
+      end
+      
+    private
+    
+      def mocks
+        @mocks ||= []
+      end
+    end
+  end
+end