pupu 0.0.2 → 0.0.3.pre

data/vendor/rspec/lib/spec/example/example_proxy.rb

@@ -1,41 +0,0 @@
-module Spec
-  module Example
-    # Lightweight proxy for an example. This is the object that is passed to
-    # example-related methods in Spec::Runner::Formatter::BaseFormatter
-    class ExampleProxy
-
-      def initialize(description=nil, options={}, location=nil) # :nodoc:
-        @description, @options, @location = description, options, location
-      end
-
-      # Optional hash passed to the example declaration
-      attr_reader :options
-
-      # This is the docstring passed to the <tt>it()</tt> method or any
-      # of its aliases
-      attr_reader :description
-
-      # The file and line number at which the represented example
-      # was declared. This is extracted from <tt>caller</tt>, and is therefore
-      # formatted as an individual line in a backtrace.
-      attr_reader :location
-
-      # Deprecated - use location()
-      def backtrace
-        Spec.deprecate("ExampleProxy#backtrace","ExampleProxy#location")
-        location
-      end
-
-      # Convenience method for example group - updates the value of
-      # <tt>description</tt> and returns self.
-      def update(description) # :nodoc:
-        @description = description
-        self
-      end
-
-      def ==(other) # :nodoc:
-        (other.description == description) & (other.location == location)
-      end
-    end
-  end
-end

data/vendor/rspec/lib/spec/example/module_reopening_fix.rb

@@ -1,43 +0,0 @@
-module Spec
-  module Example
-    # When you reopen a module that is included in another module that is included in a class,
-    # the new material you define does not make it to the class. This fixes that.
-    #
-    # == Example
-    #
-    #   module M1; end
-    #
-    #   module M2
-    #     def foo; "FOO"; end
-    #   end
-    #
-    #   class C
-    #     include M1
-    #   end
-    #
-    #   module M1
-    #     include M2
-    #   end
-    #
-    #   c = C.new
-    #   c.foo
-    #   NoMethodError: undefined method `foo' for #<C:0x5e89a4>
-    #     from (irb):12
-    module ModuleReopeningFix
-      def child_modules
-        @child_modules ||= []
-      end
-
-      def included(mod)
-        child_modules << mod
-      end
-
-      def include(mod)
-        super
-        child_modules.each do |child_module|
-          child_module.__send__(:include, mod)
-        end
-      end
-    end
-  end
-end

data/vendor/rspec/lib/spec/example/pending.rb

@@ -1,18 +0,0 @@
-module Spec
-  module Example
-    module Pending
-      def pending(message = "TODO")
-        if block_given?
-          begin
-            yield
-          rescue Exception
-            raise Spec::Example::ExamplePendingError.new(message)
-          end
-          raise Spec::Example::PendingExampleFixedError.new("Expected pending '#{message}' to fail. No Error was raised.")
-        else
-          raise Spec::Example::ExamplePendingError.new(message)
-        end
-      end
-    end
-  end
-end

data/vendor/rspec/lib/spec/example/predicate_matchers.rb

@@ -1,46 +0,0 @@
-module Spec
-  module Example
-    module PredicateMatchers
-      # :call-seq:
-      #   predicate_matchers[matcher_name] = method_on_object
-      #   predicate_matchers[matcher_name] = [method1_on_object, method2_on_object]
-      #
-      # Dynamically generates a custom matcher that will match
-      # a predicate on your class. RSpec provides a couple of these
-      # out of the box:
-      #
-      #   exist (for state expectations)
-      #     File.should exist("path/to/file")
-      #
-      #   an_instance_of (for mock argument matchers)
-      #     mock.should_receive(:message).with(an_instance_of(String))
-      #
-      # == Examples
-      #
-      #   class Fish
-      #     def can_swim?
-      #       true
-      #     end
-      #   end
-      #
-      #   describe Fish do
-      #     predicate_matchers[:swim] = :can_swim?
-      #     it "should swim" do
-      #       Fish.new.should swim
-      #     end
-      #   end
-      def predicate_matchers
-        @predicate_matchers ||= Spec::HashWithDeprecationNotice.new("predicate_matchers", "the new Matcher DSL")
-      end
-
-      def define_methods_from_predicate_matchers # :nodoc:
-        predicate_matchers.each_pair do |matcher_method, method_on_object|
-          define_method matcher_method do |*args|
-            eval("be_#{method_on_object.to_s.gsub('?','')}(*args)")
-          end
-        end
-      end
-
-    end
-  end
-end

data/vendor/rspec/lib/spec/example/shared_example_group.rb

@@ -1,59 +0,0 @@
-module Spec
-  module Example
-    class SharedExampleGroup < Module
-      module ClassMethods
-        def register(*args, &block)
-          new_example_group = new(*args, &block)
-          shared_example_groups << new_example_group unless already_registered?(new_example_group)
-          new_example_group
-        end
-
-        def find(example_group_description)
-          shared_example_groups.find {|b| b.description == example_group_description}
-        end
-
-        def clear
-          shared_example_groups.clear
-        end
-
-        def include?(group)
-          shared_example_groups.include?(group)
-        end
-
-        def count
-          shared_example_groups.length
-        end
-
-      private
-
-        def shared_example_groups
-          @shared_example_groups ||= []
-        end
-
-        def already_registered?(new_example_group)
-          existing_example_group = find(new_example_group.description)
-          return false unless existing_example_group
-          return true if new_example_group.equal?(existing_example_group)
-          return true if expanded_path(new_example_group) == expanded_path(existing_example_group)
-          raise ArgumentError.new("Shared Example '#{existing_example_group.description}' already exists")
-        end
-
-        def expanded_path(example_group)
-          File.expand_path(example_group.location)
-        end
-      end
-
-      extend ClassMethods
-      include ExampleGroupMethods
-
-      def initialize(*args, &example_group_block)
-        set_description(*args)
-        @example_group_block = example_group_block
-      end
-
-      def included(mod) # :nodoc:
-        mod.module_eval(&@example_group_block)
-      end
-    end
-  end
-end

data/vendor/rspec/lib/spec/example/subject.rb

@@ -1,108 +0,0 @@
-module Spec
-  module Example
-    module Subject
-      module ExampleGroupMethods
-        # Defines an explicit subject for an example group which can then be the
-        # implicit receiver (through delegation) of calls to +should+.
-        #
-        # == Examples
-        #
-        #   describe CheckingAccount, "with $50" do
-        #     subject { CheckingAccount.new(:amount => 50, :currency => :USD) }
-        #     it { should have_a_balance_of(50, :USD) }
-        #     it { should_not be_overdrawn }
-        #     its(:currency) { should == :USD }
-        #   end
-        #
-        # See +ExampleMethods#should+ for more information about this approach.
-        def subject(&block)
-          block.nil? ?
-            explicit_subject || implicit_subject : @explicit_subject_block = block
-        end
-        
-        def its(attribute, &block)
-          describe(attribute) do
-            define_method(:subject) { super().send(attribute) }
-            it(&block)
-          end
-        end
-
-        attr_reader :explicit_subject_block # :nodoc:
-
-      private
-
-        def explicit_subject
-          group = self
-          while group.respond_to?(:explicit_subject_block)
-            return group.explicit_subject_block if group.explicit_subject_block
-            group = group.superclass
-          end
-        end
-
-        def implicit_subject
-          (described_class ? lambda {described_class.new} : lambda {description_args.first})
-        end
-      end
-
-      module ExampleMethods
-
-        alias_method :__should_for_example_group__,     :should
-        alias_method :__should_not_for_example_group__, :should_not
-
-        # Returns the subject defined in ExampleGroupMethods#subject. The
-        # subject block is only executed once per example, the result of which
-        # is cached and returned by any subsequent calls to +subject+.
-        #
-        # If a class is passed to +describe+ and no subject is explicitly
-        # declared in the example group, then +subject+ will return a new
-        # instance of that class.
-        #
-        # == Examples
-        #
-        #   # explicit subject defined by the subject method
-        #   describe Person do
-        #     subject { Person.new(:birthdate => 19.years.ago) }
-        #     it "should be eligible to vote" do
-        #       subject.should be_eligible_to_vote
-        #     end
-        #   end
-        #
-        #   # implicit subject => { Person.new }
-        #   describe Person do
-        #     it "should be eligible to vote" do
-        #       subject.should be_eligible_to_vote
-        #     end
-        #   end
-        def subject
-          @subject ||= instance_eval(&self.class.subject)
-        end
-
-        # When +should+ is called with no explicit receiver, the call is
-        # delegated to the object returned by +subject+. Combined with
-        # an implicit subject (see +subject+), this supports very concise
-        # expressions.
-        #
-        # == Examples
-        #
-        #   describe Person do
-        #     it { should be_eligible_to_vote }
-        #   end
-        def should(matcher=nil, message=nil)
-          self == subject ? self.__should_for_example_group__(matcher) : subject.should(matcher,message)
-        end
-
-        # Just like +should+, +should_not+ delegates to the subject (implicit or
-        # explicit) of the example group.
-        #
-        # == Examples
-        #
-        #   describe Person do
-        #     it { should_not be_eligible_to_vote }
-        #   end
-        def should_not(matcher=nil, message=nil)
-          self == subject ? self.__should_not_for_example_group__(matcher) : subject.should_not(matcher,message)
-        end
-      end
-    end
-  end
-end

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

@@ -1,164 +0,0 @@
-module Spec
-  # == Example Groups and Code Examples
-  #
-  # A Code Example is an executable example of how a bit of code is expected
-  # to behave.
-  #
-  # An Example Group is a group of code examples.
-  #
-  # RSpec exposes a DSL to describe groups of examples.
-  #
-  #   describe Account do
-  #     it "should have a balance of $0" do
-  #       account = Account.new
-  #       account.balance.should == Money.new(0, :dollars)
-  #     end
-  #   end
-  #
-  # == Before and After
-  #
-  # You can use the <tt>before()</tt> and <tt>after()</tt> methods to extract
-  # common code within an Example Group. Both methods take an optional scope
-  # argument so you can run the block before :each example or before :all
-  # examples
-  #
-  #   describe "..." do
-  #     before :all do
-  #       ...
-  #     end
-  #
-  #     before :each do
-  #       ...
-  #     end
-  #
-  #     it "should do something" do
-  #       ...
-  #     end
-  #
-  #     it "should do something else" do
-  #       ...
-  #     end
-  #
-  #     after :each do
-  #       ...
-  #     end
-  #
-  #     after :all do
-  #       ...
-  #     end
-  #
-  #   end
-  #
-  # The <tt>before :each</tt> block will run before each of the examples, once
-  # for each example. Likewise, the <tt>after :each</tt> block will run after
-  # each of the examples.
-  #
-  # It is also possible to specify a <tt>before :all</tt> and <tt>after
-  # :all</tt> block that will run only once for each example group, before the
-  # first <code>before :each</code> and after the last <code>after
-  # :each</code> respectively. The use of these is generally discouraged,
-  # because it introduces dependencies between the examples. Still, it might
-  # prove useful for very expensive operations if you know what you are doing.
-  #
-  # == Local helper methods
-  #
-  # You can include local helper methods by simply expressing them within an
-  # example group:
-  #
-  #   describe "..." do
-  #
-  #     it "..." do
-  #       helper_method
-  #     end
-  #
-  #     def helper_method
-  #       ...
-  #     end
-  #
-  #   end
-  #
-  # == Included helper methods
-  #
-  # You can include helper methods in multiple example groups by expressing
-  # them within a module, and then including that module in your example
-  # groups:
-  #
-  #   module AccountExampleHelperMethods
-  #     def helper_method
-  #       ...
-  #     end
-  #   end
-  #
-  #   describe "A new account" do
-  #     include AccountExampleHelperMethods
-  #     before do
-  #       @account = Account.new
-  #     end
-  #
-  #     it "should have a balance of $0" do
-  #       helper_method
-  #       @account.balance.should eql(Money.new(0, :dollars))
-  #     end
-  #   end
-  #
-  # == Shared Example Groups
-  #
-  # You can define a shared example group, that may be used on other groups
-  #
-  #  share_examples_for "All Editions" do
-  #    it "all editions behaviour" ...
-  #  end
-  #
-  #  describe SmallEdition do
-  #    it_should_behave_like "All Editions"
-  #
-  #    it "should do small edition stuff" do
-  #      ...
-  #    end
-  #  end
-  #
-  # You can also assign the shared group to a module and include that
-  #
-  #  share_as :AllEditions do
-  #    it "should do all editions stuff" ...
-  #  end
-  #
-  #  describe SmallEdition do
-  #    it_should_behave_like AllEditions
-  #
-  #    it "should do small edition stuff" do
-  #      ...
-  #    end
-  #  end
-  #
-  # And, for those of you who prefer to use something more like Ruby, you can
-  # just include the module directly
-  #
-  #  describe SmallEdition do
-  #    include AllEditions
-  #
-  #    it "should do small edition stuff" do
-  #      ...
-  #    end
-  #  end
-  module Example
-  end
-end
-
-require 'timeout'
-require 'spec/example/args_and_options'
-require 'spec/example/predicate_matchers'
-require 'spec/example/example_group_proxy'
-require 'spec/example/example_proxy'
-require 'spec/example/subject'
-require 'spec/example/before_and_after_hooks'
-require 'spec/example/pending'
-require 'spec/example/module_reopening_fix'
-require 'spec/example/example_group_hierarchy'
-require 'spec/example/example_group_methods'
-require 'spec/example/example_methods'
-require 'spec/example/example_group'
-require 'spec/example/shared_example_group'
-require 'spec/example/example_group_factory'
-require 'spec/example/errors'
-require 'spec/example/example_matcher'

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

@@ -1,12 +0,0 @@
-module Spec
-  module Expectations
-    # If Test::Unit is loaed, we'll use its error as baseclass, so that Test::Unit
-    # will report unmet RSpec expectations as failures rather than errors.
-    superclass = ['Test::Unit::AssertionFailedError', '::StandardError'].map do |c|
-      eval(c) rescue nil
-    end.compact.first
-    
-    class ExpectationNotMetError < superclass
-    end
-  end
-end

data/vendor/rspec/lib/spec/expectations/extensions/kernel.rb

@@ -1,52 +0,0 @@
-module Kernel
-  # :call-seq:
-  #   should(matcher)
-  #   should == expected
-  #   should === expected
-  #   should =~ expected
-  #
-  #   receiver.should(matcher)
-  #     => Passes if matcher.matches?(receiver)
-  #
-  #   receiver.should == expected #any value
-  #     => Passes if (receiver == expected)
-  #
-  #   receiver.should === expected #any value
-  #     => Passes if (receiver === expected)
-  #
-  #   receiver.should =~ regexp
-  #     => Passes if (receiver =~ regexp)
-  #
-  # See Spec::Matchers for more information about matchers
-  #
-  # == Warning
-  #
-  # NOTE that this does NOT support receiver.should != expected.
-  # Instead, use receiver.should_not == expected
-  def should(matcher=nil, message=nil, &block)
-    Spec::Expectations::PositiveExpectationHandler.handle_matcher(self, matcher, message, &block)
-  end
-  
-  # :call-seq:
-  #   should_not(matcher)
-  #   should_not == expected
-  #   should_not === expected
-  #   should_not =~ expected
-  #
-  #   receiver.should_not(matcher)
-  #     => Passes unless matcher.matches?(receiver)
-  #
-  #   receiver.should_not == expected
-  #     => Passes unless (receiver == expected)
-  #
-  #   receiver.should_not === expected
-  #     => Passes unless (receiver === expected)
-  #
-  #   receiver.should_not =~ regexp
-  #     => Passes unless (receiver =~ regexp)
-  #
-  # See Spec::Matchers for more information about matchers
-  def should_not(matcher=nil, message=nil, &block)
-    Spec::Expectations::NegativeExpectationHandler.handle_matcher(self, matcher, message, &block)
-  end
-end

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

@@ -1 +0,0 @@
-require 'spec/expectations/extensions/kernel'

data/vendor/rspec/lib/spec/expectations/fail_with.rb

@@ -1,45 +0,0 @@
-module Spec
-  module Expectations
-    class << self
-      attr_accessor :differ
-      
-      # raises a Spec::Expectations::ExpectationNotMetError with message
-      #
-      # When a differ has been assigned and fail_with is passed
-      # <code>expected</code> and <code>target</code>, passes them
-      # to the differ to append a diff message to the failure message.
-      def fail_with(message, expected=nil, target=nil) # :nodoc:
-        if message.nil?
-          raise ArgumentError, "Failure message is nil. Does your matcher define the " +
-                               "appropriate failure_message_for_* method to return a string?"
-        end
-        if (Array === message) & (message.length == 3)
-          ::Spec.warn(<<-NOTICE
-
-*****************************************************************
-DEPRECATION WARNING: you are using deprecated behaviour that will
-be removed from a future version of RSpec.
-
-* Support for matchers that return arrays from failure message
-methods is deprecated.
-* Instead, the matcher should return a string, and expose methods
-for the expected() and actual() values.
-*****************************************************************
-NOTICE
-          )
-          message, expected, target = message[0], message[1], message[2]
-        end
-        unless (differ.nil? || expected.nil? || target.nil?)
-          if expected.is_a?(String)
-            message << "\n\n Diff:" << self.differ.diff_as_string(target.to_s, expected)
-          elsif expected.is_a?(Hash) && target.is_a?(Hash)
-            message << "\n\n Diff:" << self.differ.diff_as_hash(target, expected)
-          elsif !target.is_a?(Proc)
-            message << "\n\n Diff:" << self.differ.diff_as_object(target, expected)
-          end
-        end
-        Kernel::raise(Spec::Expectations::ExpectationNotMetError.new(message))
-      end
-    end
-  end
-end

data/vendor/rspec/lib/spec/expectations/handler.rb

@@ -1,50 +0,0 @@
-module Spec
-  module Expectations
-    class InvalidMatcherError < ArgumentError; end        
-    
-    class PositiveExpectationHandler        
-      def self.handle_matcher(actual, matcher, message=nil, &block)
-        ::Spec::Matchers.last_should = :should
-        ::Spec::Matchers.last_matcher = matcher
-        return ::Spec::Matchers::PositiveOperatorMatcher.new(actual) if matcher.nil?
-
-        match = matcher.matches?(actual, &block)
-        return match if match
-        
-        message ||= matcher.respond_to?(:failure_message_for_should) ?
-                    matcher.failure_message_for_should :
-                    matcher.failure_message
-        
-        if matcher.respond_to?(:diffable?) && matcher.diffable?
-          ::Spec::Expectations.fail_with message, matcher.expected.first, matcher.actual
-        else
-          ::Spec::Expectations.fail_with message
-        end
-      end
-    end
-
-    class NegativeExpectationHandler
-      def self.handle_matcher(actual, matcher, message=nil, &block)
-        ::Spec::Matchers.last_should = :should_not
-        ::Spec::Matchers.last_matcher = matcher
-        return ::Spec::Matchers::NegativeOperatorMatcher.new(actual) if matcher.nil?
-        
-        match = matcher.respond_to?(:does_not_match?) ?
-                !matcher.does_not_match?(actual, &block) :
-                matcher.matches?(actual, &block)
-        return match unless match
-        
-        message ||= matcher.respond_to?(:failure_message_for_should_not) ?
-                    matcher.failure_message_for_should_not :
-                    matcher.negative_failure_message
-
-        if matcher.respond_to?(:diffable?) && matcher.diffable?
-          ::Spec::Expectations.fail_with message, matcher.expected.first, matcher.actual
-        else
-          ::Spec::Expectations.fail_with message
-        end
-      end
-    end
-  end
-end
-

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

@@ -1,35 +0,0 @@
-require 'spec/matchers'
-require 'spec/expectations/fail_with'
-require 'spec/expectations/errors'
-require 'spec/expectations/extensions'
-require 'spec/expectations/handler'
-
-module Spec
-  
-  # Spec::Expectations lets you set expectations on your objects.
-  #
-  #   result.should == 37
-  #   team.should have(11).players_on_the_field
-  #
-  # == How Expectations work.
-  #
-  # Spec::Expectations adds two methods to Object:
-  #
-  #   should(matcher=nil)
-  #   should_not(matcher=nil)
-  #
-  # Both methods take an optional Expression Matcher (See Spec::Matchers).
-  #
-  # When +should+ receives an Expression Matcher, it calls <tt>matches?(self)</tt>. If
-  # it returns +true+, the spec passes and execution continues. If it returns
-  # +false+, then the spec fails with the message returned by <tt>matcher.failure_message</tt>.
-  #
-  # Similarly, when +should_not+ receives a matcher, it calls <tt>matches?(self)</tt>. If
-  # it returns +false+, the spec passes and execution continues. If it returns
-  # +true+, then the spec fails with the message returned by <tt>matcher.negative_failure_message</tt>.
-  #
-  # RSpec ships with a standard set of useful matchers, and writing your own
-  # matchers is quite simple. See Spec::Matchers for details.
-  module Expectations
-  end
-end