pupu 0.0.2 → 0.0.3.pre

data/vendor/rspec/lib/spec/matchers.rb

@@ -1,195 +0,0 @@
-require 'spec/extensions/instance_exec'
-require 'spec/matchers/pretty'
-require 'spec/matchers/matcher'
-require 'spec/matchers/operator_matcher'
-require 'spec/matchers/be'
-require 'spec/matchers/be_close'
-require 'spec/matchers/be_instance_of'
-require 'spec/matchers/be_kind_of'
-require 'spec/matchers/change'
-require 'spec/matchers/eql'
-require 'spec/matchers/equal'
-require 'spec/matchers/errors'
-require 'spec/matchers/exist'
-require 'spec/matchers/generated_descriptions'
-require 'spec/matchers/has'
-require 'spec/matchers/have'
-require 'spec/matchers/include'
-require 'spec/matchers/match'
-require 'spec/matchers/match_array'
-require 'spec/matchers/method_missing'
-require 'spec/matchers/raise_error'
-require 'spec/matchers/respond_to'
-require 'spec/matchers/satisfy'
-require 'spec/matchers/simple_matcher'
-require 'spec/matchers/throw_symbol'
-require 'spec/matchers/wrap_expectation'
-require 'spec/matchers/compatibility'
-require 'spec/matchers/dsl'
-
-module Spec
-
-  # RSpec ships with a number of useful Expression Matchers. An Expression Matcher
-  # is any object that responds to the following methods:
-  #
-  #   matches?(actual)
-  #   failure_message_for_should
-  #
-  # These methods are also part of the matcher protocol, but are optional:
-  #
-  #   does_not_match?(actual)
-  #   failure_message_for_should_not
-  #   description #optional
-  #
-  # These methods are from older versions of the protocol. They are still supported,
-  # but are not recommended:
-  #
-  #   failure_message          (use failure_message_for_should instead)
-  #   negative_failure_message (use failure_message_for_should_not instead)
-  #
-  # See Spec::Expectations to learn how to use these as Expectation Matchers.
-  #
-  # == Predicates
-  #
-  # In addition to those Expression Matchers that are defined explicitly, RSpec will
-  # create custom Matchers on the fly for any arbitrary predicate, giving your specs
-  # a much more natural language feel. 
-  #
-  # A Ruby predicate is a method that ends with a "?" and returns true or false.
-  # Common examples are +empty?+, +nil?+, and +instance_of?+.
-  #
-  # All you need to do is write +should be_+ followed by the predicate without
-  # the question mark, and RSpec will figure it out from there. For example:
-  #
-  #   [].should be_empty => [].empty? #passes
-  #   [].should_not be_empty => [].empty? #fails
-  #
-  # In addtion to prefixing the predicate matchers with "be_", you can also use "be_a_"
-  # and "be_an_", making your specs read much more naturally:
-  #
-  #   "a string".should be_an_instance_of(String) =>"a string".instance_of?(String) #passes
-  #
-  #   3.should be_a_kind_of(Fixnum) => 3.kind_of?(Numeric) #passes
-  #   3.should be_a_kind_of(Numeric) => 3.kind_of?(Numeric) #passes
-  #   3.should be_an_instance_of(Fixnum) => 3.instance_of?(Fixnum) #passes
-  #   3.should_not be_instance_of(Numeric) => 3.instance_of?(Numeric) #fails
-  #
-  # RSpec will also create custom matchers for predicates like +has_key?+. To
-  # use this feature, just state that the object should have_key(:key) and RSpec will
-  # call has_key?(:key) on the target. For example:
-  #
-  #   {:a => "A"}.should have_key(:a) => {:a => "A"}.has_key?(:a) #passes
-  #   {:a => "A"}.should have_key(:b) => {:a => "A"}.has_key?(:b) #fails
-  #
-  # You can use this feature to invoke any predicate that begins with "has_", whether it is
-  # part of the Ruby libraries (like +Hash#has_key?+) or a method you wrote on your own class.
-  #
-  # == Custom Matchers
-  #
-  # When you find that none of the stock Expectation Matchers provide a natural
-  # feeling expectation, you can very easily write your own using RSpec's matcher
-  # DSL or writing one from scratch.
-  #
-  # === Matcher DSL
-  #
-  # Imagine that you are writing a game in which players can be in various
-  # zones on a virtual board. To specify that bob should be in zone 4, you
-  # could say:
-  #
-  #   bob.current_zone.should eql(Zone.new("4"))
-  #
-  # But you might find it more expressive to say:
-  #
-  #   bob.should be_in_zone("4")
-  #
-  # and/or
-  #
-  #   bob.should_not be_in_zone("3")
-  #
-  # You can create such a matcher like so:
-  #
-  #   Spec::Matchers.define :be_in_zone do |zone|
-  #     match do |player|
-  #       player.in_zone?(zone)
-  #     end
-  #   end
-  #
-  # This will generate a <tt>be_in_zone</tt> method that returns a matcher
-  # with logical default messages for failures. You can override the failure
-  # messages and the generated description as follows:
-  #
-  #   Spec::Matchers.define :be_in_zone do |zone|
-  #     match do |player|
-  #       player.in_zone?(zone)
-  #     end
-  #     failure_message_for_should do |player|
-  #       # generate and return the appropriate string.
-  #     end
-  #     failure_message_for_should_not do |player|
-  #       # generate and return the appropriate string.
-  #     end
-  #     description do
-  #       # generate and return the appropriate string.
-  #     end
-  #   end
-  #
-  # Each of the message-generation methods has access to the block arguments
-  # passed to the <tt>create</tt> method (in this case, <tt>zone</tt>). The
-  # failure message methods (<tt>failure_message_for_should</tt> and
-  # <tt>failure_message_for_should_not</tt>) are passed the actual value (the
-  # receiver of <tt>should</tt> or <tt>should_not</tt>).
-  #
-  # === Custom Matcher from scratch
-  #
-  # You could also write a custom matcher from scratch, as follows:
-  #
-  #   class BeInZone
-  #     def initialize(expected)
-  #       @expected = expected
-  #     end
-  #     def matches?(target)
-  #       @target = target
-  #       @target.current_zone.eql?(Zone.new(@expected))
-  #     end
-  #     def failure_message_for_should
-  #       "expected #{@target.inspect} to be in Zone #{@expected}"
-  #     end
-  #     def failure_message_for_should_not
-  #       "expected #{@target.inspect} not to be in Zone #{@expected}"
-  #     end
-  #   end
-  #
-  # ... and a method like this:
-  #
-  #   def be_in_zone(expected)
-  #     BeInZone.new(expected)
-  #   end
-  #
-  # And then expose the method to your specs. This is normally done
-  # by including the method and the class in a module, which is then
-  # included in your spec:
-  #
-  #   module CustomGameMatchers
-  #     class BeInZone
-  #       ...
-  #     end
-  #
-  #     def be_in_zone(expected)
-  #       ...
-  #     end
-  #   end
-  #
-  #   describe "Player behaviour" do
-  #     include CustomGameMatchers
-  #     ...
-  #   end
-  #
-  # or you can include in globally in a spec_helper.rb file <tt>require</tt>d
-  # from your spec file(s):
-  #
-  #   Spec::Runner.configure do |config|
-  #     config.include(CustomGameMatchers)
-  #   end
-  #
-  module Matchers; end
-end

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

@@ -1,51 +0,0 @@
-module Spec
-  module Mocks
-    
-    class ArgumentExpectation
-      attr_reader :args
-      
-      def initialize(args, &block)
-        @args = args
-        @matchers_block = block
-        @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?(given_args)
-        match_any_args? || matchers_block_matches?(given_args) || matchers_match?(given_args)
-      end
-      
-      def matchers_block_matches?(given_args)
-        @matchers_block ? @matchers_block.call(*given_args) : nil
-      end
-      
-      def matchers_match?(given_args)
-        @matchers == given_args
-      end
-      
-      def match_any_args?
-        @match_any_args
-      end
-      
-    end
-    
-  end
-end

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

@@ -1,237 +0,0 @@
-module Spec
-  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 NoArgsMatcher
-        def description
-          "no args"
-        end
-      end
-
-      class AnyArgMatcher
-        def initialize(ignore)
-        end
-
-        def ==(other)
-          true
-        end
-        
-        def description
-          "anything"
-        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(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(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(duck_type(:hello))
-      #   object.should_receive(:message).with(duck_type(:hello, :goodbye))
-      #
-      # Passes if the argument responds to the specified messages.
-      #
-      # == Examples
-      #
-      #   array = []
-      #   display = mock('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/rspec/lib/spec/mocks/error_generator.rb

@@ -1,92 +0,0 @@
-module Spec
-  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 = args.empty? ? "(no args)" : format_args(*args)
-        __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} expected :#{sym}#{arg_message(*args)} #{count_message(expected_received_count)}, but received it #{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(Spec::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)
-        return "once" if count == 1
-        return "twice" if count == 2
-        return "#{count} times"
-      end
-
-    end
-  end
-end

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

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

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

@@ -1,69 +0,0 @@
-module Spec
-  module Mocks
-    module ExampleMethods
-      include Spec::Mocks::ArgumentMatchers
-
-      # Shortcut for creating an instance of Spec::Mocks::Mock.
-      #
-      # +name+ is used for failure reporting, so you should use the
-      # role that the double is playing in the example.
-      #
-      # +stubs_and_options+ lets you assign options and stub values
-      # at the same time. The only option available is :null_object.
-      # Anything else is treated as a stub value.
-      #
-      # == Examples
-      #
-      #   thing = double("thing", :a => "A")
-      #   thing.a == "A" => true
-      #
-      #   person = double("thing", :name => "Joe", :email => "joe@domain.com")
-      #   person.name => "Joe"
-      #   person.email => "joe@domain.com"
-      def double(*args)
-        __declare_double('Double', *args)
-      end
-
-      # Alias for double
-      def mock(*args)
-        __declare_double('Mock', *args)
-      end
-
-      # Alias for double
-      def stub(*args)
-        __declare_double('Stub', *args)
-      end
-
-      def __declare_double(declared_as, *args) # :nodoc:
-        args << {} unless Hash === args.last
-        args.last[:__declared_as] = declared_as
-        Spec::Mocks::Mock.new(*args)
-      end
-
-      # DEPRECATED - use double('name').as_null_object instead
-      #
-      # Shortcut for creating a mock object that will return itself in response
-      # to any message it receives that it hasn't been explicitly instructed
-      # to respond to.
-      def stub_everything(name = 'stub')
-        Spec.warn(<<-WARNING)
-
-DEPRECATION: stub_everything('#{name}') is deprecated and will be removed
-from a future version of rspec. Please use double('#{name}').as_null_object
-(or stub('#{name}').as_null_object or mock('#{name}').as_null_object instead.
-
-WARNING
-        mock(name, :null_object => true)
-      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
-
-    end
-  end
-end

data/vendor/rspec/lib/spec/mocks/extensions/object.rb

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

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

@@ -1 +0,0 @@
-require 'spec/mocks/extensions/object'

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

@@ -1,15 +0,0 @@
-# Require everything except the global extensions of class and object. This
-# supports wrapping rspec's mocking functionality without invading every
-# object in the system.
-
-require 'spec/mocks/methods'
-require 'spec/mocks/argument_matchers'
-require 'spec/mocks/example_methods'
-require 'spec/mocks/proxy'
-require 'spec/mocks/mock'
-require 'spec/mocks/argument_expectation'
-require 'spec/mocks/message_expectation'
-require 'spec/mocks/order_group'
-require 'spec/mocks/errors'
-require 'spec/mocks/error_generator'
-require 'spec/mocks/space'