gemrage 0.0.0

data/vendor/ruby/1.8/gems/rspec-mocks-2.0.0/features/message_expectations/warn_when_expectation_is_set_on_nil.feature

@@ -0,0 +1,50 @@
+Feature: Warn when expectation is set on nil
+
+  Scenario: nil instance variable
+    Given a file named "example_spec.rb" with:
+      """
+      RSpec.configure {|c| c.mock_with :rspec}
+      describe "something" do
+        it "does something" do
+          @i_do_not_exist.should_receive(:foo)
+          @i_do_not_exist.foo
+        end
+      end
+      """
+    When I run "rspec ./example_spec.rb"
+    Then the output should contain "An expectation of :foo was set on nil"
+
+  Scenario: allow
+    Given a file named "example_spec.rb" with:
+      """
+      RSpec.configure {|c| c.mock_with :rspec}
+      describe "something" do
+        it "does something" do
+          allow_message_expectations_on_nil
+          nil.should_receive(:foo)
+          nil.foo
+        end
+      end
+      """
+    When I run "rspec ./example_spec.rb"
+    Then the output should not contain "An expectation"
+
+  Scenario: allow in one example, but not on another
+    Given a file named "example_spec.rb" with:
+      """
+      RSpec.configure {|c| c.mock_with :rspec}
+      describe "something" do
+        it "does something (foo)" do
+          allow_message_expectations_on_nil
+          nil.should_receive(:foo)
+          nil.foo
+        end
+        it "does something (bar)" do
+          nil.should_receive(:bar)
+          nil.bar
+        end
+      end
+      """
+    When I run "rspec ./example_spec.rb"
+    Then the output should contain "An expectation of :bar"
+    And  the output should not contain "An expectation of :foo"

data/vendor/ruby/1.8/gems/rspec-mocks-2.0.0/features/outside_rspec/configuration.feature

@@ -0,0 +1,82 @@
+Feature: Configure any test framework to use rspec-mocks
+
+  Test frameworks that want to use rspec-mocks can use
+  RSpec::Mocks::setup(self) to hook into rspec-mocks. Doing so adds the
+  following:
+
+    To the object passed to setup:
+
+      double # creates a test double
+      mock   # creates a test double
+      stub   # creates a test double
+
+    To every object in the system:
+
+      should_receive
+      should_not_receive
+      stub
+      
+  In order to give control to the consuming framework, none of these facilities
+  are added until RSpec::Mocks::setup(self) is called. Simply requiring
+  'rspec/mocks' is not sufficient. 
+
+  NOTICE: the stub() method that is added to the object passed to setup is not
+  the same stub() method that is added to every other object.
+
+  Scenario: RSpec::Mocks::setup(object) adds double, mock, and stub methods to the submitted object
+    Given a file named "foo.rb" with:
+      """
+      require 'rspec/mocks'
+
+      class CodeExample
+        def init
+          RSpec::Mocks::setup(self)
+        end
+      end
+
+      example = CodeExample.new
+      example.init
+
+      puts example.respond_to?(:double)
+      puts example.respond_to?(:mock)
+      puts example.respond_to?(:stub)
+      """
+
+    When I run "ruby foo.rb"
+    Then the output should contain "true"
+    But  the output should not contain "false"
+
+  Scenario: RSpec::Mocks::setup(anything) adds methods to Object
+    Given a file named "foo.rb" with:
+      """
+      require 'rspec/mocks'
+
+      RSpec::Mocks::setup(Object.new)
+
+      obj = Object.new
+
+      puts obj.respond_to?(:should_receive)
+      puts obj.respond_to?(:should_not_receive)
+      puts obj.respond_to?(:stub)
+      """
+
+    When I run "ruby foo.rb"
+    Then the output should contain "true"
+    But  the output should not contain "false"
+
+  Scenario: require "rspec/mocks" does not add methods to Object
+    Given a file named "foo.rb" with:
+      """
+      require 'rspec/mocks'
+
+      obj = Object.new
+
+      puts obj.respond_to?(:should_receive)
+      puts obj.respond_to?(:should_not_receive)
+      puts obj.respond_to?(:stub)
+      """
+
+    When I run "ruby foo.rb"
+    Then the output should contain "false"
+    But  the output should not contain "true"
+

data/vendor/ruby/1.8/gems/rspec-mocks-2.0.0/features/stubs/simple_return_value.feature

@@ -0,0 +1,55 @@
+Feature: Stub with simple return value
+
+  Use the stub() method on a test double or a real object to tell the object to
+  return a value (or values) in response to a given message. If the message is
+  never received, nothing happens.
+
+  Scenario: simple stub with no return value
+    Given a file named "example_spec.rb" with:
+      """
+      describe "a simple stub with no return value specified" do
+        let(:receiver) { double("receiver") }
+
+        it "returns nil" do
+          receiver.stub(:message)
+          receiver.message.should be(nil)
+        end
+
+        it "quietly carries on when not called" do
+          receiver.stub(:message)
+        end
+      end
+      """
+    When I run "rspec example_spec.rb"
+    Then the output should contain "0 failures"
+
+  Scenario: single return value
+    Given a file named "example_spec.rb" with:
+      """
+      describe "a simple stub with a return value" do
+        context "specified in a block" do
+          it "returns the specified value" do
+            receiver = double("receiver")
+            receiver.stub(:message) { :return_value }
+            receiver.message.should eq(:return_value)
+          end
+        end
+
+        context "specified in the double declaration" do
+          it "returns the specified value" do
+            receiver = double("receiver", :message => :return_value)
+            receiver.message.should eq(:return_value)
+          end
+        end
+
+        context "specified with and_return" do
+          it "returns the specified value" do
+            receiver = double("receiver")
+            receiver.stub(:message).and_return(:return_value)
+            receiver.message.should eq(:return_value)
+          end
+        end
+      end
+      """
+    When I run "rspec example_spec.rb"
+    Then the output should contain "0 failures"

data/vendor/ruby/1.8/gems/rspec-mocks-2.0.0/features/stubs/stub_chain.feature

@@ -0,0 +1,44 @@
+Feature: Stub a chain of methods
+
+  The stub_chain method lets you to stub a chain of methods in one statement.
+  Method chains are considered a design smell, but it's not really the method
+  chain that is the problem - it's the dependency chain represented by a chain
+  of messages to different objects:
+
+    foo.get_bar.get_baz
+
+  This is a Law of Demeter violation if get_bar() returns an object other than
+  foo, and get_baz() returns yet another object.
+
+  Fluent interfaces look similar from a caller's perspective, but don't
+  represent a dependency chain (the caller depends only on the object it is
+  calling). Consider this common example from Ruby on Rails:
+
+    Article.recent.by(current_user)
+
+  The recent() and by() methods return the same object, so this is not
+  a Law of Demeter violation.
+
+  Scenario: stub a chain of methods
+    Given a file named "stub_chain_spec.rb" with:
+      """
+      describe "stubbing a chain of methods" do
+        subject { Object.new }
+
+        context "given symbols representing methods" do
+          it "returns the correct value" do
+            subject.stub_chain(:one, :two, :three).and_return(:four)
+            subject.one.two.three.should eq(:four)
+          end
+        end
+
+        context "given a string of methods separated by dots" do
+          it "returns the correct value" do
+            subject.stub_chain("one.two.three").and_return(:four)
+            subject.one.two.three.should eq(:four)
+          end
+        end
+      end
+      """
+    When I run "rspec stub_chain_spec.rb"
+    Then the output should contain "2 examples, 0 failures"

data/vendor/ruby/1.8/gems/rspec-mocks-2.0.0/features/stubs/stub_implementation.feature

@@ -0,0 +1,26 @@
+Feature: Stub with substitute implementation
+
+  You can stub an implementation of a method (a.k.a. fake) by passing a block
+  to the stub() method.
+  
+  Scenario: stub implementation
+    Given a file named "stub_implementation_spec.rb" with:
+      """
+      describe "a stubbed implementation" do
+        it "works" do
+          object = Object.new
+          object.stub(:foo) do |arg|
+            if arg == :this
+              "got this"
+            elsif arg == :that
+              "got that"
+            end
+          end
+          
+          object.foo(:this).should eq("got this")
+          object.foo(:that).should eq("got that")
+        end
+      end
+      """
+    When I run "rspec ./stub_implementation_spec.rb"
+    Then the output should contain "1 example, 0 failures"

data/vendor/ruby/1.8/gems/rspec-mocks-2.0.0/features/support/env.rb

@@ -0,0 +1,2 @@
+require 'aruba'
+require 'rspec/expectations'

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

@@ -0,0 +1,48 @@
+module RSpec
+  module Mocks
+    class ArgumentExpectation
+      attr_reader :args
+      
+      def initialize(*args, &block)
+        @args = args
+        @matchers_block = block if args.empty?
+        @match_any_args = false
+        @matchers = nil
+        
+        if ArgumentMatchers::AnyArgsMatcher === args.first
+          @match_any_args = true
+        elsif ArgumentMatchers::NoArgsMatcher === args.first
+          @matchers = []
+        else
+          @matchers = args.collect {|arg| matcher_for(arg)}
+        end
+      end
+      
+      def matcher_for(arg)
+        return ArgumentMatchers::MatcherMatcher.new(arg)   if is_matcher?(arg)
+        return ArgumentMatchers::RegexpMatcher.new(arg) if arg.is_a?(Regexp)
+        return ArgumentMatchers::EqualityProxy.new(arg)
+      end
+      
+      def is_matcher?(obj)
+        return obj.respond_to?(:matches?) & obj.respond_to?(:description)
+      end
+      
+      def args_match?(*args)
+        match_any_args? || matchers_block_matches?(*args) || matchers_match?(*args)
+      end
+      
+      def matchers_block_matches?(*args)
+        @matchers_block ? @matchers_block.call(*args) : nil
+      end
+      
+      def matchers_match?(*args)
+        @matchers == args
+      end
+      
+      def match_any_args?
+        @match_any_args
+      end
+    end
+  end
+end

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

@@ -0,0 +1,233 @@
+module RSpec
+  module Mocks
+
+    # ArgumentMatchers are messages that you can include in message
+    # expectations to match arguments against a broader check than simple
+    # equality.
+    #
+    # With the exception of any_args() and no_args(), the matchers
+    # are all positional - they match against the arg in the given position.
+    module ArgumentMatchers
+
+      class AnyArgsMatcher
+        def description
+          "any args"
+        end
+      end
+
+      class AnyArgMatcher
+        def initialize(ignore)
+        end
+
+        def ==(other)
+          true
+        end
+      end
+
+      class NoArgsMatcher
+        def description
+          "no args"
+        end
+      end
+
+      class RegexpMatcher
+        def initialize(regexp)
+          @regexp = regexp
+        end
+
+        def ==(value)
+          return value =~ @regexp unless value.is_a?(Regexp)
+          value == @regexp
+        end
+      end
+
+      class BooleanMatcher
+        def initialize(ignore)
+        end
+
+        def ==(value)
+          TrueClass === value || FalseClass === value
+        end
+      end
+
+      class HashIncludingMatcher
+        def initialize(expected)
+          @expected = expected
+        end
+
+        def ==(actual)
+          @expected.each do | key, value |
+            return false unless actual.has_key?(key) && value == actual[key]
+          end
+          true
+        rescue NoMethodError => ex
+          return false
+        end
+
+        def description
+          "hash_including(#{@expected.inspect.sub(/^\{/,"").sub(/\}$/,"")})"
+        end
+      end
+      
+      class HashNotIncludingMatcher
+        def initialize(expected)
+          @expected = expected
+        end
+
+        def ==(actual)
+          @expected.each do | key, value |
+            return false if actual.has_key?(key) && value == actual[key]
+          end
+          true
+        rescue NoMethodError => ex
+          return false
+        end
+
+        def description
+          "hash_not_including(#{@expected.inspect.sub(/^\{/,"").sub(/\}$/,"")})"
+        end
+      end
+      
+      class DuckTypeMatcher
+        def initialize(*methods_to_respond_to)
+          @methods_to_respond_to = methods_to_respond_to
+        end
+
+        def ==(value)
+          @methods_to_respond_to.all? { |sym| value.respond_to?(sym) }
+        end
+      end
+
+      class MatcherMatcher
+        def initialize(matcher)
+          @matcher = matcher
+        end
+
+        def ==(value)
+          @matcher.matches?(value)
+        end
+      end
+
+      class EqualityProxy
+        def initialize(given)
+          @given = given
+        end
+
+        def ==(expected)
+          @given == expected
+        end
+      end
+      
+      class InstanceOf
+        def initialize(klass)
+          @klass = klass
+        end
+        
+        def ==(actual)
+          actual.instance_of?(@klass)
+        end
+      end
+      
+      class KindOf
+        def initialize(klass)
+          @klass = klass
+        end
+        
+        def ==(actual)
+          actual.kind_of?(@klass)
+        end
+      end
+
+      # :call-seq:
+      #   object.should_receive(:message).with(any_args())
+      #
+      # Passes if object receives :message with any args at all. This is
+      # really a more explicit variation of object.should_receive(:message)
+      def any_args
+        AnyArgsMatcher.new
+      end
+      
+      # :call-seq:
+      #   object.should_receive(:message).with(anything())
+      #
+      # Passes as long as there is an argument.
+      def anything
+        AnyArgMatcher.new(nil)
+      end
+      
+      # :call-seq:
+      #   object.should_receive(:message).with(no_args)
+      #
+      # Passes if no arguments are passed along with the message
+      def no_args
+        NoArgsMatcher.new
+      end
+      
+      # :call-seq:
+      #   object.should_receive(:message).with(duck_type(:hello))
+      #   object.should_receive(:message).with(duck_type(:hello, :goodbye))
+      #
+      # Passes if the argument responds to the specified messages.
+      #
+      # == Examples
+      #
+      #   array = []
+      #   display = double('display')
+      #   display.should_receive(:present_names).with(duck_type(:length, :each))
+      #   => passes
+      def duck_type(*args)
+        DuckTypeMatcher.new(*args)
+      end
+
+      # :call-seq:
+      #   object.should_receive(:message).with(boolean())
+      #
+      # Passes if the argument is boolean.
+      def boolean
+        BooleanMatcher.new(nil)
+      end
+      
+      # :call-seq:
+      #   object.should_receive(:message).with(hash_including(:key => val))
+      #   object.should_receive(:message).with(hash_including(:key))
+      #   object.should_receive(:message).with(hash_including(:key, :key2 => val2))
+      # Passes if the argument is a hash that includes the specified key(s) or key/value
+      # pairs. If the hash includes other keys, it will still pass.
+      def hash_including(*args)
+        HashIncludingMatcher.new(anythingize_lonely_keys(*args))
+      end
+      
+      # :call-seq:
+      #   object.should_receive(:message).with(hash_not_including(:key => val))
+      #   object.should_receive(:message).with(hash_not_including(:key))
+      #   object.should_receive(:message).with(hash_not_including(:key, :key2 => :val2))
+      #
+      # Passes if the argument is a hash that doesn't include the specified key(s) or key/value
+      def hash_not_including(*args)
+        HashNotIncludingMatcher.new(anythingize_lonely_keys(*args))
+      end
+      
+      # Passes if arg.instance_of?(klass)
+      def instance_of(klass)
+        InstanceOf.new(klass)
+      end
+      
+      alias_method :an_instance_of, :instance_of
+      
+      # Passes if arg.kind_of?(klass)
+      def kind_of(klass)
+        KindOf.new(klass)
+      end
+      
+      alias_method :a_kind_of, :kind_of
+      
+      private
+      
+      def anythingize_lonely_keys(*args)
+        hash = args.last.class == Hash ? args.delete_at(-1) : {}
+        args.each { | arg | hash[arg] = anything }
+        hash
+      end
+    end
+  end
+end

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

@@ -0,0 +1,97 @@
+module RSpec
+  module Mocks
+    class ErrorGenerator
+      attr_writer :opts
+      
+      def initialize(target, name, options={})
+        @declared_as = options[:__declared_as] || 'Mock'
+        @target = target
+        @name = name
+      end
+      
+      def opts
+        @opts ||= {}
+      end
+
+      def raise_unexpected_message_error(sym, *args)
+        __raise "#{intro} received unexpected message :#{sym}#{arg_message(*args)}"
+      end
+      
+      def raise_unexpected_message_args_error(expectation, *args)
+        expected_args = format_args(*expectation.expected_args)
+        actual_args = format_args(*args)
+        __raise "#{intro} received #{expectation.sym.inspect} with unexpected arguments\n  expected: #{expected_args}\n       got: #{actual_args}"
+      end
+      
+      def raise_similar_message_args_error(expectation, *args)
+        expected_args = format_args(*expectation.expected_args)
+        actual_args = args.collect {|a| format_args(*a)}.join(", ")
+        __raise "#{intro} received #{expectation.sym.inspect} with unexpected arguments\n  expected: #{expected_args}\n       got: #{actual_args}"
+      end
+      
+      def raise_expectation_error(sym, expected_received_count, actual_received_count, *args)
+        __raise "(#{intro}).#{sym}#{format_args(*args)}\n    expected: #{count_message(expected_received_count)}\n    received: #{count_message(actual_received_count)}"
+      end
+      
+      def raise_out_of_order_error(sym)
+        __raise "#{intro} received :#{sym} out of order"
+      end
+      
+      def raise_block_failed_error(sym, detail)
+        __raise "#{intro} received :#{sym} but passed block failed with: #{detail}"
+      end
+      
+      def raise_missing_block_error(args_to_yield)
+        __raise "#{intro} asked to yield |#{arg_list(*args_to_yield)}| but no block was passed"
+      end
+      
+      def raise_wrong_arity_error(args_to_yield, arity)
+        __raise "#{intro} yielded |#{arg_list(*args_to_yield)}| to block with arity of #{arity}"
+      end
+      
+    private
+
+      def intro
+        if @name
+          "#{@declared_as} #{@name.inspect}"
+        elsif Mock === @target
+          @declared_as
+        elsif Class === @target
+          "<#{@target.inspect} (class)>"
+        elsif @target
+          @target
+        else
+          "nil"
+        end
+      end
+      
+      def __raise(message)
+        message = opts[:message] unless opts[:message].nil?
+        Kernel::raise(RSpec::Mocks::MockExpectationError, message)
+      end
+      
+      def arg_message(*args)
+        " with " + format_args(*args)
+      end
+      
+      def format_args(*args)
+        args.empty? ? "(no args)" : "(" + arg_list(*args) + ")"
+      end
+
+      def arg_list(*args)
+        args.collect {|arg| arg.respond_to?(:description) ? arg.description : arg.inspect}.join(", ")
+      end
+      
+      def count_message(count)
+        return "at least #{pretty_print(count.abs)}" if count < 0
+        return pretty_print(count)
+      end
+
+      def pretty_print(count)
+        "#{count} time#{count == 1 ? '' : 's'}"
+      end
+
+    end
+  end
+end
+

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

@@ -0,0 +1,10 @@
+module RSpec
+  module Mocks
+    class MockExpectationError < Exception
+    end
+    
+    class AmbiguousReturnError < StandardError
+    end
+  end
+end
+

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

@@ -0,0 +1,31 @@
+module RSpec
+  module Mocks
+    module InstanceExec
+      unless respond_to?(:instance_exec)
+        # based on Bounded Spec InstanceExec (Mauricio Fernandez)
+        # http://eigenclass.org/hiki/bounded+space+instance_exec
+        # - uses singleton_class of matcher instead of global
+        #   InstanceExecHelper module
+        # - this keeps it scoped to this class only, which is the
+        #   only place we need it
+        # - only necessary for ruby 1.8.6
+        def instance_exec(*args, &block)
+          singleton_class = (class << self; self; end)
+          begin
+            orig_critical, Thread.critical = Thread.critical, true
+            n = 0
+            n += 1 while respond_to?(method_name="__instance_exec#{n}")
+            singleton_class.module_eval{ define_method(method_name, &block) }
+          ensure
+            Thread.critical = orig_critical
+          end
+          begin
+            return send(method_name, *args)
+          ensure
+            singleton_class.module_eval{ remove_method(method_name) } rescue nil
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,3 @@
+class Object
+  include RSpec::Mocks::Methods
+end