pupu 0.0.2 → 0.0.3.pre

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

@@ -1,14 +0,0 @@
-Spec::Matchers.constants.each do |c|
-  if Class === (klass = Spec::Matchers.const_get(c))
-    if klass.public_instance_methods.any? {|m| ['failure_message_for_should',:failure_message_for_should].include?(m)}
-      klass.class_eval do
-        alias_method :failure_message, :failure_message_for_should
-      end
-    end
-    if klass.public_instance_methods.any? {|m| ['failure_message_for_should_not',:failure_message_for_should_not].include?(m)}
-      klass.class_eval do
-        alias_method :negative_failure_message, :failure_message_for_should_not
-      end
-    end
-  end
-end

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

@@ -1,20 +0,0 @@
-module Spec
-  module Matchers
-    module DSL
-      # See Spec::Matchers
-      def define(name, &declarations)
-        define_method name do |*expected|
-          Spec::Matchers::Matcher.new name, *expected, &declarations
-        end
-      end
-      
-      # Deprecated - use define
-      def create(name, &declarations)
-        Spec.deprecate("Spec::Matchers.create","Spec::Matchers.define")
-        define(name, &declarations)
-      end
-    end
-  end
-end
-
-Spec::Matchers.extend Spec::Matchers::DSL

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

@@ -1,42 +0,0 @@
-module Spec
-  module Matchers
-    # :call-seq:
-    #   should eql(expected)
-    #   should_not eql(expected)
-    #
-    # Passes if actual and expected are of equal value, but not necessarily the same object.
-    #
-    # See http://www.ruby-doc.org/core/classes/Object.html#M001057 for more information about equality in Ruby.
-    #
-    # == Examples
-    #
-    #   5.should eql(5)
-    #   5.should_not eql(3)
-    def eql(expected)
-      Matcher.new :eql, expected do |_expected_|
-        match do |actual|
-          actual.eql?(_expected_)
-        end
-
-        failure_message_for_should do |actual|
-          <<-MESSAGE
-
-expected #{_expected_.inspect}
-     got #{actual.inspect}
-
-(compared using eql?)
-MESSAGE
-        end
-
-        failure_message_for_should_not do |actual|
-          <<-MESSAGE
-
-expected #{actual.inspect} not to equal #{_expected_.inspect}
-
-(compared using eql?)
-MESSAGE
-        end
-      end
-    end
-  end
-end

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

@@ -1,53 +0,0 @@
-module Spec
-  module Matchers
-
-    # :call-seq:
-    #   should equal(expected)
-    #   should_not equal(expected)
-    #
-    # Passes if actual and expected are the same object (object identity).
-    #
-    # See http://www.ruby-doc.org/core/classes/Object.html#M001057 for more information about equality in Ruby.
-    #
-    # == Examples
-    #
-    #   5.should equal(5) #Fixnums are equal
-    #   "5".should_not equal("5") #Strings that look the same are not the same object
-    def equal(expected)
-      Matcher.new :equal, expected do |_expected_|
-        match do |actual|
-          actual.equal?(_expected_)
-        end
-        
-        def inspect_object(o)
-          "#<#{o.class}:#{o.object_id}> => #{o.inspect}"
-        end
-        
-        failure_message_for_should do |actual|
-          <<-MESSAGE
-
-expected #{inspect_object(_expected_)}
-     got #{inspect_object(actual)}
-
-Compared using equal?, which compares object identity,
-but expected and actual are not the same object. Use
-'actual.should == expected' if you don't care about
-object identity in this example.
-
-MESSAGE
-        end
-
-        failure_message_for_should_not do |actual|
-          <<-MESSAGE
-
-expected not #{inspect_object(actual)}
-         got #{inspect_object(_expected_)}
-
-Compared using equal?, which compares object identity.
-
-MESSAGE
-        end
-      end
-    end
-  end
-end

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

@@ -1,5 +0,0 @@
-module Spec
-  module Matchers
-    class MatcherError < StandardError; end
-  end
-end

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

@@ -1,16 +0,0 @@
-module Spec
-  module Matchers
-    # :call-seq:
-    #   should exist
-    #   should_not exist
-    #
-    # Passes if actual.exist?
-    def exist(arg=nil)
-      Matcher.new :exist do
-        match do |actual|
-          arg ? actual.exist?(arg) : actual.exist?
-        end
-      end
-    end
-  end
-end

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

@@ -1,36 +0,0 @@
-module Spec
-  module Matchers
-    class << self
-      attr_accessor :last_matcher, :last_should # :nodoc:
-    end
-
-    def self.clear_generated_description
-      self.last_matcher = nil
-      self.last_should = nil
-    end
-
-    def self.generated_description
-      return nil if last_should.nil?
-      "#{last_should.to_s.gsub('_',' ')} #{last_description}"
-    end
-    
-  private
-    
-    def self.last_description
-      last_matcher.respond_to?(:description) ? last_matcher.description : <<-MESSAGE
-When you call a matcher in an example without a String, like this:
-
-specify { object.should matcher }
-
-or this:
-
-it { should matcher }
-
-RSpec expects the matcher to have a #description method. You should either
-add a String to the example this matcher is being used in, or give it a
-description method. Then you won't have to suffer this lengthy warning again.
-MESSAGE
-    end
-  end
-end
-      

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

@@ -1,35 +0,0 @@
-module Spec
-  module Matchers
-    
-    class Has
-      
-      def initialize(expected, *args, &block)
-        @expected, @args, @block = expected, args, block
-      end
-      
-      def matches?(actual)
-        actual.__send__(predicate(@expected), *@args, &@block)
-      end
-      
-      def failure_message_for_should
-        "expected ##{predicate(@expected)}(#{@args[0].inspect}) to return true, got false"
-      end
-      
-      def failure_message_for_should_not
-        "expected ##{predicate(@expected)}(#{@args[0].inspect}) to return false, got true"
-      end
-      
-      def description
-        "have key #{@args[0].inspect}"
-      end
-    
-    private
-    
-      def predicate(sym)
-        "#{sym.to_s.sub("have_","has_")}?".to_sym
-      end
-      
-    end
-    
-  end
-end

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

@@ -1,152 +0,0 @@
-module Spec
-  module Matchers
-    class Have #:nodoc:
-      def initialize(expected, relativity=:exactly)
-        @expected = (expected == :no ? 0 : expected)
-        @relativity = relativity
-        @actual = nil
-        @plural_collection_name = nil
-      end
-    
-      def relativities
-        @relativities ||= {
-          :exactly => "",
-          :at_least => "at least ",
-          :at_most => "at most "
-        }
-      end
-    
-      def matches?(collection_owner)
-        if collection_owner.respond_to?(@collection_name)
-          collection = collection_owner.__send__(@collection_name, *@args, &@block)
-        elsif (@plural_collection_name && collection_owner.respond_to?(@plural_collection_name))
-          collection = collection_owner.__send__(@plural_collection_name, *@args, &@block)
-        elsif (collection_owner.respond_to?(:length) || collection_owner.respond_to?(:size))
-          collection = collection_owner
-        else
-          collection_owner.__send__(@collection_name, *@args, &@block)
-        end
-        @actual = collection.size if collection.respond_to?(:size)
-        @actual = collection.length if collection.respond_to?(:length)
-        raise not_a_collection if @actual.nil?
-        return @actual >= @expected if @relativity == :at_least
-        return @actual <= @expected if @relativity == :at_most
-        return @actual == @expected
-      end
-      
-      def not_a_collection
-        "expected #{@collection_name} to be a collection but it does not respond to #length or #size"
-      end
-    
-      def failure_message_for_should
-        "expected #{relative_expectation} #{@collection_name}, got #{@actual}"
-      end
-
-      def failure_message_for_should_not
-        if @relativity == :exactly
-          return "expected target not to have #{@expected} #{@collection_name}, got #{@actual}"
-        elsif @relativity == :at_most
-          return <<-EOF
-Isn't life confusing enough?
-Instead of having to figure out the meaning of this:
-  should_not have_at_most(#{@expected}).#{@collection_name}
-We recommend that you use this instead:
-  should have_at_least(#{@expected + 1}).#{@collection_name}
-EOF
-        elsif @relativity == :at_least
-          return <<-EOF
-Isn't life confusing enough?
-Instead of having to figure out the meaning of this:
-  should_not have_at_least(#{@expected}).#{@collection_name}
-We recommend that you use this instead:
-  should have_at_most(#{@expected - 1}).#{@collection_name}
-EOF
-        end
-      end
-      
-      def description
-        "have #{relative_expectation} #{@collection_name}"
-      end
-      
-      def respond_to?(sym)
-        @expected.respond_to?(sym) || super
-      end
-    
-      private
-      
-      def method_missing(sym, *args, &block)
-        @collection_name = sym
-        if inflector = (defined?(ActiveSupport::Inflector) ? ActiveSupport::Inflector : (defined?(Inflector) ? Inflector : nil))
-          @plural_collection_name = inflector.pluralize(sym.to_s)
-        end
-        @args = args
-        @block = block
-        self
-      end
-      
-      def relative_expectation
-        "#{relativities[@relativity]}#{@expected}"
-      end
-    end
-
-    # :call-seq:
-    #   should have(number).named_collection__or__sugar
-    #   should_not have(number).named_collection__or__sugar
-    #
-    # Passes if receiver is a collection with the submitted
-    # number of items OR if the receiver OWNS a collection
-    # with the submitted number of items.
-    #
-    # If the receiver OWNS the collection, you must use the name
-    # of the collection. So if a <tt>Team</tt> instance has a
-    # collection named <tt>#players</tt>, you must use that name
-    # to set the expectation.
-    #
-    # If the receiver IS the collection, you can use any name
-    # you like for <tt>named_collection</tt>. We'd recommend using
-    # either "elements", "members", or "items" as these are all
-    # standard ways of describing the things IN a collection.
-    #
-    # This also works for Strings, letting you set an expectation
-    # about its length
-    #
-    # == Examples
-    #
-    #   # Passes if team.players.size == 11
-    #   team.should have(11).players
-    #
-    #   # Passes if [1,2,3].length == 3
-    #   [1,2,3].should have(3).items #"items" is pure sugar
-    #
-    #   # Passes if "this string".length == 11
-    #   "this string".should have(11).characters #"characters" is pure sugar
-    def have(n)
-      Matchers::Have.new(n)
-    end
-    alias :have_exactly :have
-
-    # :call-seq:
-    #   should have_at_least(number).items
-    #
-    # Exactly like have() with >=.
-    #
-    # == Warning
-    #
-    # +should_not+ +have_at_least+ is not supported
-    def have_at_least(n)
-      Matchers::Have.new(n, :at_least)
-    end
-
-    # :call-seq:
-    #   should have_at_most(number).items
-    #
-    # Exactly like have() with <=.
-    #
-    # == Warning
-    #
-    # +should_not+ +have_at_most+ is not supported
-    def have_at_most(n)
-      Matchers::Have.new(n, :at_most)
-    end
-  end
-end

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

@@ -1,44 +0,0 @@
-module Spec
-  module Matchers
-    # :call-seq:
-    #   should include(expected)
-    #   should_not include(expected)
-    #
-    # Passes if actual includes expected. This works for
-    # collections and Strings. You can also pass in multiple args
-    # and it will only pass if all args are found in collection.
-    #
-    # == Examples
-    #
-    #   [1,2,3].should include(3)
-    #   [1,2,3].should include(2,3) #would pass
-    #   [1,2,3].should include(2,3,4) #would fail
-    #   [1,2,3].should_not include(4)
-    #   "spread".should include("read")
-    #   "spread".should_not include("red")
-    def include(*expected)
-      Matcher.new :include, *expected do |*_expected_|
-        match do |actual|
-          helper(actual, *_expected_)
-        end
-        
-        def helper(actual, *_expected_)
-          _expected_.each do |expected|
-            if actual.is_a?(Hash)
-              if expected.is_a?(Hash)
-                expected.each_pair do |k,v|
-                  return false unless actual[k] == v
-                end
-              else
-                return false unless actual.has_key?(expected)
-              end
-            else
-              return false unless actual.include?(expected)
-            end
-          end
-          true
-        end
-      end
-    end
-  end
-end

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

@@ -1,21 +0,0 @@
-module Spec
-  module Matchers
-    # :call-seq:
-    #   should match(pattern)
-    #   should_not match(pattern)
-    #
-    # Given a Regexp or String, passes if actual.match(pattern)
-    #
-    # == Examples
-    #
-    #   email.should match(/^([^\s]+)((?:[-a-z0-9]+\.)+[a-z]{2,})$/i)
-    #   email.should match("@example.com")
-    def match(expected)
-      Matcher.new :match, expected do |_expected_|
-        match do |actual|
-          actual.match(_expected_)
-        end
-      end
-    end
-  end
-end

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

@@ -1,71 +0,0 @@
-module Spec
-  module Matchers
-
-    class MatchArray #:nodoc:
-      include Spec::Matchers::Pretty
-      
-      def initialize(expected)
-        @expected = expected
-      end
-
-      def matches?(actual)
-        @actual = actual        
-        @extra_items = difference_between_arrays(@actual, @expected)
-        @missing_items = difference_between_arrays(@expected, @actual)
-        @extra_items.empty? & @missing_items.empty?
-      end
-
-      def failure_message_for_should
-        message =  "expected collection contained:  #{safe_sort(@expected).inspect}\n"
-        message += "actual collection contained:    #{safe_sort(@actual).inspect}\n"
-        message += "the missing elements were:      #{safe_sort(@missing_items).inspect}\n" unless @missing_items.empty?
-        message += "the extra elements were:        #{safe_sort(@extra_items).inspect}\n"   unless @extra_items.empty?
-        message
-      end
-      
-      def failure_message_for_should_not
-        "Matcher does not support should_not"
-      end
-      
-      def description
-        "contain exactly #{_pretty_print(@expected)}"
-      end
-
-      private
-
-        def safe_sort(array)
-          array.all?{|item| item.respond_to?(:<=>)} ? array.sort : array
-        end
-
-        def difference_between_arrays(array_1, array_2)
-          difference = array_1.dup
-          array_2.each do |element|
-            if index = difference.index(element)
-              difference.delete_at(index)
-            end
-          end
-          difference
-        end
-
-
-    end
-
-    # :call-seq:
-    #   should =~ expected
-    #
-    # Passes if actual contains all of the expected regardless of order. 
-    # This works for collections. Pass in multiple args  and it will only 
-    # pass if all args are found in collection.
-    #
-    # NOTE: there is no should_not version of array.should =~ other_array
-    # 
-    # == Examples
-    #
-    #   [1,2,3].should   =~ [1,2,3]   # => would pass
-    #   [1,2,3].should   =~ [2,3,1]   # => would pass
-    #   [1,2,3,4].should =~ [1,2,3]   # => would fail
-    #   [1,2,2,3].should =~ [1,2,3]   # => would fail
-    #   [1,2,3].should   =~ [1,2,3,4] # => would fail
-    OperatorMatcher.register(Array, '=~', Spec::Matchers::MatchArray)
-  end
-end

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

@@ -1,102 +0,0 @@
-module Spec
-  module Matchers
-    class Matcher
-      include Spec::Matchers::InstanceExec
-      include Spec::Matchers::Pretty
-      include Spec::Matchers
-
-      attr_reader :expected, :actual
-
-      def initialize(name, *expected, &declarations)
-        @name     = name
-        @expected = expected
-        @actual   = nil
-        @diffable = false
-        @error_to_watch_for = nil
-        @messages = {
-          :description => lambda {"#{name_to_sentence}#{expected_to_sentence}"},
-          :failure_message_for_should => lambda {|actual| "expected #{actual.inspect} to #{name_to_sentence}#{expected_to_sentence}"},
-          :failure_message_for_should_not => lambda {|actual| "expected #{actual.inspect} not to #{name_to_sentence}#{expected_to_sentence}"}
-        }
-        making_declared_methods_public do
-          instance_exec(*@expected, &declarations)
-        end
-      end
-
-      def matches?(actual)
-        if @error_to_watch_for
-          begin
-            instance_exec(@actual = actual, &@match_block)
-            true
-          rescue @error_to_watch_for
-            false
-          end
-        else
-          instance_exec(@actual = actual, &@match_block)
-        end
-      end
-      
-      def description(&block)
-        cache_or_call_cached(:description, &block)
-      end
-
-      def failure_message_for_should(&block)
-        cache_or_call_cached(:failure_message_for_should, actual, &block)
-      end
-
-      def failure_message_for_should_not(&block)
-        cache_or_call_cached(:failure_message_for_should_not, actual, &block)
-      end
-
-      def match(&block)
-        @match_block = block
-      end
-
-      def match_unless_raises(error=StandardError, &block)
-        @error_to_watch_for = error
-        match(&block)
-      end
-
-      def diffable?
-        @diffable
-      end
-
-      def diffable
-        @diffable = true
-      end
-      
-    private
-
-      def making_declared_methods_public # :nodoc:
-        # Our home-grown instance_exec in ruby 1.8.6 results in any methods
-        # declared in the block eval'd by instance_exec in the block to which we
-        # are yielding here are scoped private. This is NOT the case for Ruby
-        # 1.8.7 or 1.9.
-        #
-        # Also, due some crazy scoping that I don't understand, these methods
-        # are actually available in the specs (something about the matcher being
-        # defined in the scope of Spec::Matchers or within an example), so not
-        # doing the following will not cause specs to fail, but they *will*
-        # cause features to fail and that will make users unhappy. So don't.
-        orig_private_methods = private_methods
-        yield
-        st = (class << self; self; end)
-        (private_methods - orig_private_methods).each {|m| st.__send__ :public, m}
-      end
-
-      def cache_or_call_cached(key, actual=nil, &block)
-        block ? @messages[key] = block :
-                actual.nil? ? @messages[key].call : @messages[key].call(actual)
-      end
-
-      def name_to_sentence
-        split_words(@name)
-      end
-
-      def expected_to_sentence
-        to_sentence(@expected)
-      end
-
-    end
-  end
-end

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

@@ -1,9 +0,0 @@
-module Spec
-  module Matchers
-    def method_missing(sym, *args, &block) # :nodoc:
-      return Matchers::Be.new(sym, *args, &block) if sym.to_s =~ /^be_/
-      return Matchers::Has.new(sym, *args, &block) if sym.to_s =~ /^have_/
-      super
-    end
-  end
-end