gemrage 0.0.0

data/vendor/ruby/1.8/gems/rspec-mocks-2.0.0/lib/rspec/mocks/order_group.rb

@@ -0,0 +1,29 @@
+module RSpec
+  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/ruby/1.8/gems/rspec-mocks-2.0.0/lib/rspec/mocks/proxy.rb

@@ -0,0 +1,157 @@
+module RSpec
+  module Mocks
+    class Proxy
+      class << self
+        def warn_about_expectations_on_nil
+          defined?(@warn_about_expectations_on_nil) ? @warn_about_expectations_on_nil : true
+        end
+      
+        def warn_about_expectations_on_nil=(new_value)
+          @warn_about_expectations_on_nil = new_value
+        end
+      
+        def 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::space.add(nil) unless RSpec::Mocks::space.nil?
+        end
+
+        def allow_message_expectations_on_nil?
+          !warn_about_expectations_on_nil
+        end
+      end
+
+      def initialize(object, name=nil, options={})
+        @object = object
+        @name = name
+        @error_generator = ErrorGenerator.new object, name, options
+        @expectation_ordering = OrderGroup.new @error_generator
+        @messages_received = []
+        @options = options
+        @already_proxied_respond_to = false
+        @null_object = false
+      end
+
+      def null_object?
+        @null_object
+      end
+
+      # 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
+
+      def already_proxied_respond_to # :nodoc:
+        @already_proxied_respond_to = true
+      end
+
+      def already_proxied_respond_to? # :nodoc:
+        @already_proxied_respond_to
+      end
+
+      def add_message_expectation(location, method_name, opts={}, &block)        
+        method_double[method_name].add_expectation @error_generator, @expectation_ordering, location, opts, &block
+      end
+
+      def add_negative_message_expectation(location, method_name, &implementation)
+        method_double[method_name].add_negative_expectation @error_generator, @expectation_ordering, location, &implementation
+      end
+
+      def add_stub(location, method_name, opts={}, &implementation)
+        method_double[method_name].add_stub @error_generator, @expectation_ordering, location, opts, &implementation
+      end
+      
+      def remove_stub(method_name)
+        method_double[method_name].remove_stub
+      end
+      
+      def verify #:nodoc:
+        method_doubles.each {|d| d.verify}
+      ensure
+        reset
+      end
+
+      def reset
+        method_doubles.each {|d| d.reset}
+      end
+
+      def received_message?(method_name, *args, &block)
+        @messages_received.any? {|array| array == [method_name, args, block]}
+      end
+
+      def has_negative_expectation?(method_name)
+        method_double[method_name].expectations.detect {|expectation| expectation.negative_expectation_for?(method_name)}
+      end
+      
+      def record_message_received(method_name, *args, &block)
+        @messages_received << [method_name, args, block]
+      end
+
+      def message_received(method_name, *args, &block)
+        expectation = find_matching_expectation(method_name, *args)
+        stub = find_matching_method_stub(method_name, *args)
+
+        if (stub && expectation && expectation.called_max_times?) || (stub && !expectation)
+          if expectation = find_almost_matching_expectation(method_name, *args)
+            expectation.advise(*args) unless expectation.expected_messages_received?
+          end
+          stub.invoke(*args, &block)
+        elsif expectation
+          expectation.invoke(*args, &block)
+        elsif expectation = find_almost_matching_expectation(method_name, *args)
+          expectation.advise(*args) if null_object? unless expectation.expected_messages_received?
+          raise_unexpected_message_args_error(expectation, *args) unless (has_negative_expectation?(method_name) or null_object?)
+        elsif stub = find_almost_matching_stub(method_name, *args)
+          stub.advise(*args)
+          raise_unexpected_message_args_error(stub, *args)
+        elsif @object.is_a?(Class)
+          @object.superclass.send(method_name, *args, &block)
+        else
+          @object.__send__(:method_missing, method_name, *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(method_name, *args)
+        @error_generator.raise_unexpected_message_error method_name, *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)
+        method_double[method_name].expectations.find {|expectation| expectation.matches?(method_name, *args) && !expectation.called_max_times?} || 
+        method_double[method_name].expectations.find {|expectation| expectation.matches?(method_name, *args)}
+      end
+
+      def find_almost_matching_expectation(method_name, *args)
+        method_double[method_name].expectations.find {|expectation| expectation.matches_name_but_not_args(method_name, *args)}
+      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/ruby/1.8/gems/rspec-mocks-2.0.0/lib/rspec/mocks/serialization.rb

@@ -0,0 +1,24 @@
+module RSpec
+  module Mocks
+    module Serialization
+      def self.fix_for(object)
+        object.extend(YAML) if defined?(::YAML)
+      end
+
+      module YAML
+        def to_yaml(*a)
+          return super(*a) unless instance_variable_defined?(:@mock_proxy)
+
+          mp = @mock_proxy
+          remove_instance_variable(:@mock_proxy)
+
+          begin
+            super(*a)
+          ensure
+            @mock_proxy = mp
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/ruby/1.8/gems/rspec-mocks-2.0.0/lib/rspec/mocks/space.rb

@@ -0,0 +1,28 @@
+module RSpec
+  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

data/vendor/ruby/1.8/gems/rspec-mocks-2.0.0/lib/rspec/mocks/spec_methods.rb

@@ -0,0 +1,53 @@
+module RSpec
+  module Mocks
+    module ExampleMethods
+      include RSpec::Mocks::ArgumentMatchers
+
+      # Creates an instance of RSpec::Mocks::Mock.
+      #
+      # +name+ is used for failure reporting, so you should use the role that
+      # the mock is playing in the example.
+      #
+      # Use +stubs+ to declare one or more method stubs in one statement.
+      #
+      # == Examples
+      #
+      #   book = double("book", :title => "The RSpec Book")
+      #   book.title => "The RSpec Book"
+      #
+      #   card = double("card", :suit => "Spades", :rank => "A"
+      #   card.suit => "Spades"
+      #   card.rank => "A"
+      def double(*args)
+        declare_double('Double', *args)
+      end
+
+      # Just like double, but use double
+      def mock(*args)
+        declare_double('Mock', *args)
+      end
+
+      # Just like double, but use double
+      def stub(*args)
+        declare_double('Stub', *args)
+      end
+
+      # Disables warning messages about expectations being set on nil.
+      #
+      # By default warning messages are issued when expectations are set on nil.  This is to
+      # prevent false-positives and to catch potential bugs early on.
+      def allow_message_expectations_on_nil
+        Proxy.allow_message_expectations_on_nil
+      end
+
+    private
+      
+      def declare_double(declared_as, *args)
+        args << {} unless Hash === args.last
+        args.last[:__declared_as] = declared_as
+        RSpec::Mocks::Mock.new(*args)
+      end
+
+    end
+  end
+end

data/vendor/ruby/1.8/gems/rspec-mocks-2.0.0/lib/rspec/mocks/version.rb

@@ -0,0 +1,7 @@
+module RSpec # :nodoc:
+  module Mocks # :nodoc:
+    module Version # :nodoc:
+      STRING = '2.0.0'
+    end
+  end
+end

data/vendor/ruby/1.8/gems/rspec-mocks-2.0.0/lib/rspec/mocks.rb

@@ -0,0 +1,196 @@
+require 'rspec/mocks/framework'
+require 'rspec/mocks/version'
+
+module RSpec
+  # == Test Doubles
+  #
+  # A Test Double is an object that stands in for a real object in a test.
+  # RSpec creates test doubles that support method stubs and message
+  # expectations.
+  #
+  #   book = double("book")
+  #
+  # == Method Stubs
+  #
+  # A method stub is an implementation that returns a pre-determined value.
+  #
+  #   book = double("book")
+  #   double.stub(:title) { "The RSpec Book" }
+  #   double.title => "The RSpec Book"
+  #
+  # When we declare a stub, we say we are "stubbing" a method.
+  #
+  # == Message Expectations
+  #
+  # A message expectation is an expectation that the test double will receive a
+  # message some time before the example ends. If the message is received, the
+  # expectation is satisfied. If not, the example fails.
+  #
+  #   validator = double("validator")
+  #   validator.should_receive(:validate).with("02134")
+  #   zipcode = Zipcode.new("02134", validator)
+  #   zipcode.valid?
+  #   
+  # When we declare a message expectation, we say we are "mocking" a method.
+  #
+  # == Mock Objects and Test Stubs
+  #
+  # The names Mock Object and Test Stub suggest specialized Test Doubles.  i.e.
+  # Test Stub evokes Test Double that only supports method stubs, and a Mock
+  # Object evokes a Test Double that only supports message expectations, or
+  # sometimes supports message expectations in addition to method stubs.
+  #
+  # There is a lot of overlapping nomenclature here, and there are many
+  # variations of these patterns (fakes, spies, etc). Keep in mind that most of
+  # the time we're talking about method-level concepts that are variations of
+  # method stubs and message expectations, and we're applying to them to _one_
+  # generic kind of object: a Test Double.
+  #
+  # == Test-Specific Extension
+  #
+  # a.k.a. Partial Stub/Mock, a Test-Specific Extension is an extension of a
+  # real object in a system that is instrumented with test-double like
+  # behaviour in the context of a test. This technique is very common in Ruby
+  # because we often see class objects acting as global namespaces for methods.
+  # For example, in Rails:
+  #
+  #   person = double("person")
+  #   Person.stub(:find) { person }
+  #
+  # In this case we're instrumenting Person to return the person object we've
+  # defined whenever it receives the +find+ message. We can do this with any
+  # object in a system because RSpec adds the +stub+ and +should_receive+
+  # methods to every object. When we use either, RSpec replaces the method
+  # we're stubbing or mocking with it's own test-double-like method. At the
+  # end of the example, RSpec verifies any message expectations, and then
+  # restores the original methods.
+  # 
+  # == Expecting Arguments
+  #
+  #   double.should_receive(:msg).with(*args)
+  #   double.should_not_receive(:msg).with(*args)
+  #
+  # == Argument Matchers
+  #
+  # Arguments that are passed to #with are compared with actual arguments received
+  # using == by default. In cases in which you want to specify things about the arguments
+  # rather than the arguments themselves, you can use any of RSpec's Expression Matchers.
+  # They don't all make syntactic sense (they were primarily designed for use with
+  # RSpec::Expectations), but you are free to create your own custom RSpec::Matchers.
+  #
+  # RSpec::Mocks does provide one additional Matcher method named #ducktype.
+  #
+  # In addition, RSpec::Mocks adds some keyword Symbols that you can use to
+  # specify certain kinds of arguments:
+  #
+  #   double.should_receive(:msg).with(no_args())
+  #   double.should_receive(:msg).with(any_args())
+  #   double.should_receive(:msg).with(1, kind_of(Numeric), "b") #2nd argument can any kind of Numeric
+  #   double.should_receive(:msg).with(1, boolean(), "b") #2nd argument can true or false
+  #   double.should_receive(:msg).with(1, /abc/, "b") #2nd argument can be any String matching the submitted Regexp
+  #   double.should_receive(:msg).with(1, anything(), "b") #2nd argument can be anything at all
+  #   double.should_receive(:msg).with(1, ducktype(:abs, :div), "b")
+  #                            #2nd argument can be object that responds to #abs and #div
+  #                                                                       
+  # == Receive Counts
+  #
+  #   double.should_receive(:msg).once
+  #   double.should_receive(:msg).twice
+  #   double.should_receive(:msg).exactly(n).times
+  #   double.should_receive(:msg).at_least(:once)
+  #   double.should_receive(:msg).at_least(:twice)
+  #   double.should_receive(:msg).at_least(n).times
+  #   double.should_receive(:msg).at_most(:once)
+  #   double.should_receive(:msg).at_most(:twice)
+  #   double.should_receive(:msg).at_most(n).times
+  #   double.should_receive(:msg).any_number_of_times
+  #
+  # == Ordering
+  #
+  #   double.should_receive(:msg).ordered
+  #   double.should_receive(:other_msg).ordered
+  #     #This will fail if the messages are received out of order
+  #
+  # == Setting Reponses
+  #
+  # Whether you are setting a message expectation or a method stub, you can
+  # tell the object precisely how to respond. The most generic way is to pass
+  # a block to +stub+ or +should_receive+:
+  #
+  #   double.should_receive(:msg) { value }
+  #
+  # When the double receives the +msg+ message, it evaluates the block and returns
+  # the result.
+  #
+  #   double.should_receive(:msg).and_return(value)
+  #   double.should_receive(:msg).exactly(3).times.and_return(value1, value2, value3)
+  #     # returns value1 the first time, value2 the second, etc
+  #   double.should_receive(:msg).and_raise(error)
+  #     #error can be an instantiated object or a class
+  #     #if it is a class, it must be instantiable with no args
+  #   double.should_receive(:msg).and_throw(:msg)
+  #   double.should_receive(:msg).and_yield(values,to,yield)
+  #   double.should_receive(:msg).and_yield(values,to,yield).and_yield(some,other,values,this,time)
+  #     # for methods that yield to a block multiple times
+  #
+  # Any of these responses can be applied to a stub as well
+  #
+  #   double.stub(:msg).and_return(value)
+  #   double.stub(:msg).and_return(value1, value2, value3)
+  #   double.stub(:msg).and_raise(error)
+  #   double.stub(:msg).and_throw(:msg)
+  #   double.stub(:msg).and_yield(values,to,yield)
+  #   double.stub(:msg).and_yield(values,to,yield).and_yield(some,other,values,this,time)
+  #
+  # == Arbitrary Handling
+  #
+  # Once in a while you'll find that the available expectations don't solve the
+  # particular problem you are trying to solve. Imagine that you expect the message
+  # to come with an Array argument that has a specific length, but you don't care
+  # what is in it. You could do this:
+  #
+  #   double.should_receive(:msg) do |arg|
+  #     arg.should be_an_istance_of(Array)
+  #     arg.length.should == 7
+  #   end
+  #
+  # == Combining Expectation Details
+  #
+  # Combining the message name with specific arguments, receive counts and responses
+  # you can get quite a bit of detail in your expectations:
+  #
+  #   double.should_receive(:<<).with("illegal value").once.and_raise(ArgumentError)
+  #
+  # == Further Reading
+  # 
+  # There are many different viewpoints about the meaning of mocks and stubs. If you are interested
+  # in learning more, here is some recommended reading:
+  # 
+  # * Mock Objects: http://www.mockobjects.com/
+  # * Endo-Testing: http://www.mockobjects.com/files/endotesting.pdf
+  # * Mock Roles, Not Objects: http://www.mockobjects.com/files/mockrolesnotobjects.pdf
+  # * Test Double Patterns: http://xunitpatterns.com/Test%20Double%20Patterns.html
+  # * Mocks aren't stubs: http://www.martinfowler.com/articles/mocksArentStubs.html
+  module Mocks
+    class << self
+      attr_accessor :space
+
+      def setup(includer)
+        require 'rspec/mocks/extensions/object'
+        require 'rspec/mocks/spec_methods'
+        (class << includer; self; end).class_eval do
+          include RSpec::Mocks::ExampleMethods
+        end
+        self.space ||= RSpec::Mocks::Space.new
+      end
+
+      def verify
+        space.verify_all
+      end
+
+      def teardown
+        space.reset_all
+      end
+    end
+  end
+end

data/vendor/ruby/1.8/gems/rspec-mocks-2.0.0/lib/spec/mocks.rb

@@ -0,0 +1,2 @@
+# For backward compatibility with rspec-1
+require 'rspec/mocks'

data/vendor/ruby/1.8/gems/rspec-mocks-2.0.0/rspec-mocks.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+$LOAD_PATH.unshift File.expand_path("../lib", __FILE__)
+require "rspec/mocks/version"
+
+Gem::Specification.new do |s|
+  s.name        = "rspec-mocks"
+  s.version     = RSpec::Mocks::Version::STRING
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["David Chelimsky", "Chad Humphries"]
+  s.email       = "dchelimsky@gmail.com;chad.humphries@gmail.com"
+  s.homepage    = "http://github.com/rspec/rspec-mocks"
+  s.summary     = "rspec-mocks-#{RSpec::Mocks::Version::STRING}"
+  s.description = "RSpec's 'test double' framework, with support for stubbing and mocking"
+
+  s.rubygems_version   = "1.3.7"
+  s.rubyforge_project  = "rspec"
+
+  s.files            = `git ls-files`.split("\n")
+  s.test_files       = `git ls-files -- {spec,features}/*`.split("\n")
+  s.executables      = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.extra_rdoc_files = [ "README.markdown" ]
+  s.rdoc_options     = ["--charset=UTF-8"]
+  s.require_path     = "lib"
+
+  s.add_dependency "rspec-core",         RSpec::Mocks::Version::STRING
+  s.add_dependency "rspec-expectations", RSpec::Mocks::Version::STRING
+end
+

data/vendor/ruby/1.8/gems/rspec-mocks-2.0.0/spec/rspec/mocks/and_yield_spec.rb

@@ -0,0 +1,114 @@
+require 'spec_helper'
+def obj
+  @obj ||= mock
+end
+
+describe RSpec::Mocks::Mock do
+  describe "#and_yield" do
+    context "with eval context as block argument" do
+      
+      it "evaluates the supplied block as it is read" do
+        evaluated = false
+        obj.stub(:method_that_accepts_a_block).and_yield do |eval_context|
+          evaluated = true
+        end
+        evaluated.should be_true
+      end
+
+      it "passes an eval context object to the supplied block" do
+        obj.stub(:method_that_accepts_a_block).and_yield do |eval_context|
+          eval_context.should_not be_nil
+        end
+      end
+
+      it "evaluates the block passed to the stubbed method in the context of the supplied eval context" do
+        expected_eval_context = nil
+        actual_eval_context = nil
+
+        obj.stub(:method_that_accepts_a_block).and_yield do |eval_context|
+          expected_eval_context = eval_context
+        end
+
+        obj.method_that_accepts_a_block do
+          actual_eval_context = self
+        end
+
+        actual_eval_context.should equal(expected_eval_context)
+      end
+
+      context "and no yielded arguments" do
+
+        it "passes when expectations set on the eval context are met" do
+          configured_eval_context = nil
+          obj.stub(:method_that_accepts_a_block).and_yield do |eval_context|
+            configured_eval_context = eval_context
+            configured_eval_context.should_receive(:foo)
+          end
+
+          obj.method_that_accepts_a_block do
+            foo
+          end
+
+          configured_eval_context.rspec_verify
+        end
+
+        it "fails when expectations set on the eval context are not met" do
+          configured_eval_context = nil
+          obj.stub(:method_that_accepts_a_block).and_yield do |eval_context|
+            configured_eval_context = eval_context
+            configured_eval_context.should_receive(:foo)
+          end
+
+          obj.method_that_accepts_a_block do
+            # foo is not called here
+          end
+
+          lambda {configured_eval_context.rspec_verify}.should raise_error(RSpec::Mocks::MockExpectationError)
+        end
+
+      end
+
+      context "and yielded arguments" do
+
+        it "passes when expectations set on the eval context and yielded arguments are met" do
+          configured_eval_context = nil
+          yielded_arg = Object.new
+          obj.stub(:method_that_accepts_a_block).and_yield(yielded_arg) do |eval_context|
+            configured_eval_context = eval_context
+            configured_eval_context.should_receive(:foo)
+            yielded_arg.should_receive(:bar)
+          end
+
+          obj.method_that_accepts_a_block do |obj|
+            obj.bar
+            foo
+          end
+
+          configured_eval_context.rspec_verify
+          yielded_arg.rspec_verify
+        end
+
+        it "fails when expectations set on the eval context and yielded arguments are not met" do
+          configured_eval_context = nil
+          yielded_arg = Object.new
+          obj.stub(:method_that_accepts_a_block).and_yield(yielded_arg) do |eval_context|
+            configured_eval_context = eval_context
+            configured_eval_context.should_receive(:foo)
+            yielded_arg.should_receive(:bar)
+          end
+
+          obj.method_that_accepts_a_block do |obj|
+            # obj.bar is not called here
+            # foo is not called here
+          end
+
+          lambda {configured_eval_context.rspec_verify}.should raise_error(RSpec::Mocks::MockExpectationError)
+          lambda {yielded_arg.rspec_verify}.should raise_error(RSpec::Mocks::MockExpectationError)
+        end
+
+      end
+
+    end
+  end
+end
+

data/vendor/ruby/1.8/gems/rspec-mocks-2.0.0/spec/rspec/mocks/any_number_of_times_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+module RSpec
+  module Mocks
+    
+    describe "AnyNumberOfTimes" do
+      before(:each) do
+        @mock = RSpec::Mocks::Mock.new("test mock")
+      end
+
+      it "passes if any number of times method is called many times" do
+        @mock.should_receive(:random_call).any_number_of_times
+        (1..10).each do
+          @mock.random_call
+        end
+      end
+
+      it "passes if any number of times method is called once" do
+        @mock.should_receive(:random_call).any_number_of_times
+        @mock.random_call
+      end
+      
+      it "passes if any number of times method is not called" do
+        @mock.should_receive(:random_call).any_number_of_times
+      end
+
+      it "returns the mocked value when called after a similar stub" do
+        @mock.stub(:message).and_return :stub_value
+        @mock.should_receive(:message).any_number_of_times.and_return(:mock_value)
+        @mock.message.should == :mock_value
+        @mock.message.should == :mock_value
+      end
+    end
+
+  end
+end