hubbub 0.0.6

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

@@ -0,0 +1,61 @@
+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/lib/vendor/plugins/rspec/lib/spec/interop/test.rb

@@ -0,0 +1,44 @@
+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/lib/vendor/plugins/rspec/lib/spec/matchers/be.rb

@@ -0,0 +1,210 @@
+module Spec
+  module Matchers
+    
+    class Be #:nodoc:
+      include Spec::Matchers::Pretty
+      
+      def initialize(*args)
+        @expected = args.empty? ? true : set_expected(args.shift)
+        @args = args
+        @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)
+        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)
+        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)
+      Matchers::Be.new(*args)
+    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/lib/vendor/plugins/rspec/lib/spec/matchers/be_close.rb

@@ -0,0 +1,32 @@
+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/lib/vendor/plugins/rspec/lib/spec/matchers/be_instance_of.rb

@@ -0,0 +1,26 @@
+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/lib/vendor/plugins/rspec/lib/spec/matchers/be_kind_of.rb

@@ -0,0 +1,26 @@
+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/lib/vendor/plugins/rspec/lib/spec/matchers/change.rb

@@ -0,0 +1,151 @@
+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

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

@@ -0,0 +1,14 @@
+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/lib/vendor/plugins/rspec/lib/spec/matchers/dsl.rb

@@ -0,0 +1,20 @@
+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/lib/vendor/plugins/rspec/lib/spec/matchers/eql.rb

@@ -0,0 +1,42 @@
+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/lib/vendor/plugins/rspec/lib/spec/matchers/equal.rb

@@ -0,0 +1,53 @@
+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/lib/vendor/plugins/rspec/lib/spec/matchers/errors.rb

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