pupu 0.0.2 → 0.0.3.pre

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

@@ -1,31 +0,0 @@
-module Spec
-  module Matchers
-    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(:__instance_exec, &block) }
-          ensure
-            Thread.critical = orig_critical
-          end
-          begin
-            return send(:__instance_exec, *args)
-          ensure
-            singleton_class.module_eval{ remove_method(:__instance_exec) } rescue nil
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/rspec/lib/spec/interop/test/unit/autorunner.rb

@@ -1,6 +0,0 @@
-class Test::Unit::AutoRunner
-  remove_method :process_args
-  def process_args(argv)
-    true
-  end
-end

data/vendor/rspec/lib/spec/interop/test/unit/testcase.rb

@@ -1,56 +0,0 @@
-require 'test/unit/testcase'
-
-module Test
-  module Unit
-    # This extension of the standard Test::Unit::TestCase makes RSpec
-    # available from within, so that you can do things like:
-    #
-    # require 'spec/test/unit'
-    #
-    # class MyTest < Test::Unit::TestCase
-    #   it "should work with Test::Unit assertions" do
-    #     assert_equal 4, 2+1
-    #   end
-    #
-    #   def test_should_work_with_rspec_expectations
-    #     (3+1).should == 5
-    #   end
-    # end
-    #
-    # See also Spec::Example::ExampleGroup
-    class TestCase
-      extend Spec::Example::ExampleGroupMethods
-      include Spec::Example::ExampleMethods
-
-      def self.suite
-        Test::Unit::TestSuiteAdapter.new(self)
-      end
-
-      def self.example_method?(method_name)
-        should_method?(method_name) || test_method?(method_name)
-      end
-
-      def self.test_method?(method_name)
-        method_name =~ /^test./ && (
-          instance_method(method_name).arity == 0 ||
-          instance_method(method_name).arity == -1
-        )
-      end
-
-      before(:each) {setup}
-      after(:each) {teardown}
-
-      def initialize(description, &implementation)
-        super
-        # Some Test::Unit extensions depend on @method_name being present.
-        @method_name = description.description
-        @_result = ::Test::Unit::TestResult.new
-      end
-
-      def run(ignore_this_argument=nil)
-        super()
-      end
-
-    end
-  end
-end

data/vendor/rspec/lib/spec/interop/test/unit/testresult.rb

@@ -1,6 +0,0 @@
-class Test::Unit::TestResult
-  alias_method :tu_passed?, :passed?
-  def passed?
-    return tu_passed? & ::Spec::Runner.run
-  end
-end

data/vendor/rspec/lib/spec/interop/test/unit/testsuite_adapter.rb

@@ -1,34 +0,0 @@
-module Test
-  module Unit
-    class TestSuiteAdapter < TestSuite
-      attr_reader :example_group, :examples
-      alias_method :tests, :examples
-      def initialize(example_group)
-        @example_group = example_group
-        @examples = example_group.examples
-      end
-
-      def name
-        example_group.description
-      end
-
-      def run(*args)
-        return true unless args.empty?
-        example_group.run(Spec::Runner.options)
-      end
-
-      def size
-        example_group.number_of_examples
-      end
-
-      def delete(example)
-        examples.delete example
-      end
-
-      def empty?
-        examples.empty?
-      end
-    end
-  end
-end
-

data/vendor/rspec/lib/spec/interop/test/unit/ui/console/testrunner.rb

@@ -1,61 +0,0 @@
-require 'test/unit/ui/console/testrunner'
-
-module Test
-  module Unit
-    module UI
-      module Console
-        class TestRunner
-
-          alias_method :started_without_rspec, :started
-          def started_with_rspec(result)
-            @result = result
-            @need_to_output_started = true
-          end
-          alias_method :started, :started_with_rspec
-
-          alias_method :test_started_without_rspec, :test_started
-          def test_started_with_rspec(name)
-            if @need_to_output_started
-              if @rspec_io
-                @rspec_io.rewind
-                output(@rspec_io.read)
-              end
-              output("Started")
-              @need_to_output_started = false
-            end
-            test_started_without_rspec(name)
-          end
-          alias_method :test_started, :test_started_with_rspec
-
-          alias_method :test_finished_without_rspec, :test_finished
-          def test_finished_with_rspec(name)
-            test_finished_without_rspec(name)
-            @ran_test = true
-          end
-          alias_method :test_finished, :test_finished_with_rspec
-
-          alias_method :finished_without_rspec, :finished
-          def finished_with_rspec(elapsed_time)
-            @ran_test ||= false
-            if @ran_test
-              finished_without_rspec(elapsed_time)
-            end
-          end
-          alias_method :finished, :finished_with_rspec
-          
-          alias_method :setup_mediator_without_rspec, :setup_mediator
-          def setup_mediator_with_rspec
-            orig_io = @io
-            @io = StringIO.new
-            setup_mediator_without_rspec
-          ensure
-            @rspec_io = @io
-            @io = orig_io
-          end
-          alias_method :setup_mediator, :setup_mediator_with_rspec
-          
-        end
-      end
-    end
-  end
-end

data/vendor/rspec/lib/spec/interop/test.rb

@@ -1,44 +0,0 @@
-require 'spec'
-
-if Spec::Ruby.version.to_f >= 1.9
-  gem 'test-unit','= 1.2.3'
-end
-
-require 'test/unit'
-
-if Spec::Ruby.version.to_f >= 1.9
-  require 'test/unit/version'
-  if Test::Unit::VERSION > '1.2.3'
-    raise <<-MESSAGE
-#{'*' * 50}
-Required: test-unit-1.2.3
-Loaded:   test-unit-#{Test::Unit::VERSION}
-
-With ruby-1.9, rspec-#{Spec::VERSION::STRING} requires test-unit-1.2.3, and
-tries to force it with "gem 'test-unit', '= 1.2.3'" in:
-
-  #{__FILE__}
-  
-Unfortunately, test-unit-#{Test::Unit::VERSION} was loaded anyway. While we are
-aware of this bug we have not been able to track down its source.
-Until we do, you have two alternatives:
-
-* uninstall test-unit-2.0.3
-* use 'script/spec' instead of 'rake spec'
-#{'*' * 50}
-MESSAGE
-  end
-end
-
-
-require 'test/unit/testresult'
-
-require 'spec/interop/test/unit/testcase'
-require 'spec/interop/test/unit/testsuite_adapter'
-require 'spec/interop/test/unit/autorunner'
-require 'spec/interop/test/unit/testresult'
-require 'spec/interop/test/unit/ui/console/testrunner'
-
-Spec::Example::ExampleGroupFactory.default(Test::Unit::TestCase)
-
-Test::Unit.run = true

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

@@ -1,211 +0,0 @@
-module Spec
-  module Matchers
-    
-    class Be #:nodoc:
-      include Spec::Matchers::Pretty
-      
-      def initialize(*args, &block)
-        @expected = args.empty? ? true : set_expected(args.shift)
-        @args = args
-        @block = block
-        @comparison_method = nil
-      end
-      
-      def matches?(actual)
-        @actual = actual
-        handling_predicate? ? run_predicate_on(actual) : match_or_compare(actual)
-      end
-      
-      def run_predicate_on(actual)
-        begin
-          return @result = actual.__send__(predicate, *@args, &@block)
-        rescue NameError => predicate_missing_error
-          "this needs to be here or rcov will not count this branch even though it's executed in a code example"
-        end
-
-        begin
-          return @result = actual.__send__(present_tense_predicate, *@args, &@block)
-        rescue NameError
-          raise predicate_missing_error
-        end
-      end
-      
-      def failure_message_for_should
-        if handling_predicate?
-          if predicate == :nil?
-            "expected nil, got #{@actual.inspect}"
-          else
-            "expected #{predicate}#{args_to_s} to return true, got #{@result.inspect}"
-          end
-        else
-          "expected #{@comparison_method} #{expected}, got #{@actual.inspect}".gsub('  ',' ')
-        end
-      end
-      
-      def failure_message_for_should_not
-        if handling_predicate?
-          if predicate == :nil?
-            "expected not nil, got nil"
-          else
-          "expected #{predicate}#{args_to_s} to return false, got #{@result.inspect}"
-          end
-        else
-          message = <<-MESSAGE
-'should_not be #{@comparison_method} #{expected}' not only FAILED,
-it is a bit confusing.
-          MESSAGE
-          
-          raise message << ([:===,:==].include?(@comparison_method) ?
-            "It might be more clearly expressed without the \"be\"?" :
-            "It might be more clearly expressed in the positive?")
-        end
-      end
-      
-      def description
-        "#{prefix_to_sentence}#{comparison} #{expected_to_sentence}#{args_to_sentence}".gsub(/\s+/,' ')
-      end
-
-      [:==, :<, :<=, :>=, :>, :===].each do |method|
-        define_method method do |expected|
-          compare_to(expected, :using => method)
-          self
-        end
-      end
-
-      private
-        def match_or_compare(actual)
-          TrueClass === @expected ? @actual : @actual.__send__(comparison_method, @expected)
-        end
-      
-        def comparison_method
-          @comparison_method || :equal?
-        end
-      
-        def expected
-          @expected
-        end
-
-        def compare_to(expected, opts)
-          @expected, @comparison_method = expected, opts[:using]
-        end
-
-        def set_expected(expected)
-          Symbol === expected ? parse_expected(expected) : expected
-        end
-        
-        def parse_expected(expected)
-          ["be_an_","be_a_","be_"].each do |prefix|
-            handling_predicate!
-            if expected.to_s =~ /^#{prefix}/
-              set_prefix(prefix)
-              expected = expected.to_s.sub(prefix,"")
-              [true, false, nil].each do |val|
-                return val if val.to_s == expected
-              end
-              return expected.to_sym
-            end
-          end
-        end
-        
-        def set_prefix(prefix)
-          @prefix = prefix
-        end
-        
-        def prefix
-          # FIXME - this is a bit goofy - but we get failures
-          # if just defining @prefix = nil in initialize
-          @prefix = nil unless defined?(@prefix)
-          @prefix
-        end
-
-        def handling_predicate!
-          @handling_predicate = true
-        end
-        
-        def handling_predicate?
-          return false if [true, false, nil].include?(expected)
-          # FIXME - this is a bit goofy - but we get failures
-          # if just defining @handling_predicate = nil or false in initialize
-          return defined?(@handling_predicate) ? @handling_predicate : nil
-        end
-
-        def predicate
-          "#{@expected.to_s}?".to_sym
-        end
-        
-        def present_tense_predicate
-          "#{@expected.to_s}s?".to_sym
-        end
-        
-        def args_to_s
-          @args.empty? ? "" : parenthesize(inspected_args.join(', '))
-        end
-        
-        def parenthesize(string)
-          return "(#{string})"
-        end
-        
-        def inspected_args
-          @args.collect{|a| a.inspect}
-        end
-        
-        def comparison
-          @comparison_method.nil? ? " " : "be #{@comparison_method.to_s} "
-        end
-        
-        def expected_to_sentence
-          split_words(expected)
-        end
-        
-        def prefix_to_sentence
-          split_words(prefix)
-        end
-
-        def args_to_sentence
-          to_sentence(@args)
-        end
-        
-    end
- 
-    # :call-seq:
-    #   should be_true
-    #   should be_false
-    #   should be_nil
-    #   should be_[arbitrary_predicate](*args)
-    #   should_not be_nil
-    #   should_not be_[arbitrary_predicate](*args)
-    #
-    # Given true, false, or nil, will pass if actual value is
-    # true, false or nil (respectively). Given no args means
-    # the caller should satisfy an if condition (to be or not to be). 
-    #
-    # Predicates are any Ruby method that ends in a "?" and returns true or false.
-    # Given be_ followed by arbitrary_predicate (without the "?"), RSpec will match
-    # convert that into a query against the target object.
-    #
-    # The arbitrary_predicate feature will handle any predicate
-    # prefixed with "be_an_" (e.g. be_an_instance_of), "be_a_" (e.g. be_a_kind_of)
-    # or "be_" (e.g. be_empty), letting you choose the prefix that best suits the predicate.
-    #
-    # == Examples 
-    #
-    #   target.should be_true
-    #   target.should be_false
-    #   target.should be_nil
-    #   target.should_not be_nil
-    #
-    #   collection.should be_empty #passes if target.empty?
-    #   target.should_not be_empty #passes unless target.empty?
-    #   target.should_not be_old_enough(16) #passes unless target.old_enough?(16)
-    def be(*args, &block)
-      Matchers::Be.new(*args, &block)
-    end
-
-    # passes if target.kind_of?(klass)
-    def be_a(klass)
-      be_a_kind_of(klass)
-    end
-    
-    alias_method :be_an, :be_a
-  end
-end

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

@@ -1,32 +0,0 @@
-module Spec
-  module Matchers
-    # :call-seq:
-    #   should be_close(expected, delta)
-    #   should_not be_close(expected, delta)
-    #
-    # Passes if actual == expected +/- delta
-    #
-    # == Example
-    #
-    #   result.should be_close(3.0, 0.5)
-    def be_close(expected, delta)
-      Matcher.new :be_close, expected, delta do |_expected_, _delta_|
-        match do |actual|
-          (actual - _expected_).abs < _delta_
-        end
-
-        failure_message_for_should do |actual|
-          "expected #{_expected_} +/- (< #{_delta_}), got #{actual}"
-        end
-
-        failure_message_for_should_not do |actual|
-          "expected #{_expected_} +/- (< #{_delta_}), got #{actual}"
-        end
-
-        description do
-          "be close to #{_expected_} (within +- #{_delta_})"
-        end
-      end
-    end
-  end
-end

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

@@ -1,26 +0,0 @@
-module Spec
-  module Matchers
-    # :call-seq:
-    #   should be_instance_of(expected)
-    #   should be_an_instance_of(expected)
-    #   should_not be_instance_of(expected)
-    #   should_not be_an_instance_of(expected)
-    #
-    # Passes if actual.instance_of?(expected)
-    #
-    # == Examples
-    #
-    #   5.should be_instance_of(Fixnum)
-    #   5.should_not be_instance_of(Numeric)
-    #   5.should_not be_instance_of(Float)
-    def be_an_instance_of(expected)
-      Matcher.new :be_an_instance_of, expected do |_expected_|
-        match do |actual|
-          actual.instance_of?(_expected_)
-        end
-      end
-    end
-    
-    alias_method :be_instance_of, :be_an_instance_of
-  end
-end

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

@@ -1,26 +0,0 @@
-module Spec
-  module Matchers
-    # :call-seq:
-    #   should be_kind_of(expected)
-    #   should be_a_kind_of(expected)
-    #   should_not be_kind_of(expected)
-    #   should_not be_a_kind_of(expected)
-    #
-    # Passes if actual.kind_of?(expected)
-    #
-    # == Examples
-    #
-    #   5.should be_kind_of(Fixnum)
-    #   5.should be_kind_of(Numeric)
-    #   5.should_not be_kind_of(Float)
-    def be_a_kind_of(expected)
-      Matcher.new :be_a_kind_of, expected do |_expected_|
-        match do |actual|
-          actual.kind_of?(_expected_)
-        end
-      end
-    end
-    
-    alias_method :be_kind_of, :be_a_kind_of
-  end
-end

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

@@ -1,151 +0,0 @@
-module Spec
-  module Matchers
-    
-    #Based on patch from Wilson Bilkovich
-    class Change #:nodoc:
-      def initialize(receiver=nil, message=nil, &block)
-        @message = message || "result"
-        @value_proc = block || lambda {receiver.__send__(message)}
-        @to = @from = @minimum = @maximum = @amount = nil
-      end
-      
-      def matches?(event_proc)
-        raise_block_syntax_error if block_given?
-        
-        @before = evaluate_value_proc
-        event_proc.call
-        @after = evaluate_value_proc
-        
-        return (@to = false) if @from unless @from == @before
-        return false if @to unless @to == @after
-        return (@before + @amount == @after) if @amount
-        return ((@after - @before) >= @minimum) if @minimum
-        return ((@after - @before) <= @maximum) if @maximum        
-        return @before != @after
-      end
-      
-      def raise_block_syntax_error
-        raise MatcherError.new(<<-MESSAGE
-block passed to should or should_not change must use {} instead of do/end
-MESSAGE
-        )
-      end
-      
-      def evaluate_value_proc
-        @value_proc.call
-      end
-      
-      def failure_message_for_should
-        if @to
-          "#{@message} should have been changed to #{@to.inspect}, but is now #{@after.inspect}"
-        elsif @from
-          "#{@message} should have initially been #{@from.inspect}, but was #{@before.inspect}"
-        elsif @amount
-          "#{@message} should have been changed by #{@amount.inspect}, but was changed by #{actual_delta.inspect}"
-        elsif @minimum
-          "#{@message} should have been changed by at least #{@minimum.inspect}, but was changed by #{actual_delta.inspect}"
-        elsif @maximum
-          "#{@message} should have been changed by at most #{@maximum.inspect}, but was changed by #{actual_delta.inspect}"
-        else
-          "#{@message} should have changed, but is still #{@before.inspect}"
-        end
-      end
-      
-      def actual_delta
-        @after - @before
-      end
-      
-      def failure_message_for_should_not
-        "#{@message} should not have changed, but did change from #{@before.inspect} to #{@after.inspect}"
-      end
-      
-      def by(amount)
-        @amount = amount
-        self
-      end
-      
-      def by_at_least(minimum)
-        @minimum = minimum
-        self
-      end
-      
-      def by_at_most(maximum)
-        @maximum = maximum
-        self
-      end      
-      
-      def to(to)
-        @to = to
-        self
-      end
-      
-      def from (from)
-        @from = from
-        self
-      end
-      
-      def description
-        "change ##{@message}"
-      end
-    end
-    
-    # :call-seq:
-    #   should change(receiver, message, &block)
-    #   should change(receiver, message, &block).by(value)
-    #   should change(receiver, message, &block).from(old).to(new)
-    #   should_not change(receiver, message, &block)
-    #
-    # Allows you to specify that a Proc will cause some value to change.
-    #
-    # == Examples
-    #
-    #   lambda {
-    #     team.add_player(player) 
-    #   }.should change(roster, :count)
-    #
-    #   lambda {
-    #     team.add_player(player) 
-    #   }.should change(roster, :count).by(1)
-    #
-    #   lambda {
-    #     team.add_player(player) 
-    #   }.should change(roster, :count).by_at_least(1)
-    #
-    #   lambda {
-    #     team.add_player(player)
-    #   }.should change(roster, :count).by_at_most(1)    
-    #
-    #   string = "string"
-    #   lambda {
-    #     string.reverse!
-    #   }.should change { string }.from("string").to("gnirts")
-    #
-    #   lambda {
-    #     person.happy_birthday
-    #   }.should change(person, :birthday).from(32).to(33)
-    #       
-    #   lambda {
-    #     employee.develop_great_new_social_networking_app
-    #   }.should change(employee, :title).from("Mail Clerk").to("CEO")
-    #
-    # Evaluates <tt>receiver.message</tt> or <tt>block</tt> before and after
-    # it evaluates the c object (generated by the lambdas in the examples
-    # above).
-    #
-    # Then compares the values before and after the <tt>receiver.message</tt>
-    # and evaluates the difference compared to the expected difference.
-    #
-    # == WARNING
-    # <tt>should_not change</tt> only supports the form with no
-    # subsequent calls to <tt>by</tt>, <tt>by_at_least</tt>,
-    # <tt>by_at_most</tt>, <tt>to</tt> or <tt>from</tt>.
-    #
-    # blocks passed to <tt>should</tt> <tt>change</tt> and <tt>should_not</tt>
-    # <tt>change</tt> must use the <tt>{}</tt> form (<tt>do/end</tt> is not
-    # supported).
-    #
-    def change(receiver=nil, message=nil, &block)
-      Matchers::Change.new(receiver, message, &block)
-    end
-  end
-end