newbamboo-rspec 1.1.12

data/lib/spec/example.rb

@@ -0,0 +1,187 @@
+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
+    class << self
+      def args_and_options(*args) # :nodoc:
+        with_options_from(args) do |options|
+          return args, options
+        end
+      end
+
+      def scope_from(*args) # :nodoc:
+        args[0] || :each
+      end
+
+      def scope_and_options(*args) # :nodoc:
+        args, options = args_and_options(*args)
+        return scope_from(*args), options
+      end
+
+      def add_spec_path_to(args) # :nodoc:
+        args << {} unless Hash === args.last
+        args.last[:spec_path] ||= caller(0)[2]
+      end
+
+    private
+    
+      def with_options_from(args)
+        yield Hash === args.last ? args.pop : {} if block_given?
+      end
+    end
+  end
+end
+
+require 'timeout'
+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_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/lib/spec/expectations/differs/default.rb

@@ -0,0 +1,66 @@
+begin
+  require 'rubygems'
+  require 'diff/lcs' #necessary due to loading bug on some machines - not sure why - DaC
+  require 'diff/lcs/hunk'
+rescue LoadError ; raise "You must gem install diff-lcs to use diffing" ; end
+
+require 'pp'
+
+module Spec
+  module Expectations
+    module Differs
+
+      # TODO add some rdoc
+      class Default
+        def initialize(options)
+          @options = options
+        end
+
+        # This is snagged from diff/lcs/ldiff.rb (which is a commandline tool)
+        def diff_as_string(data_new, data_old)
+          data_old = data_old.split(/\n/).map! { |e| e.chomp }
+          data_new = data_new.split(/\n/).map! { |e| e.chomp }
+          output = ""
+          diffs = Diff::LCS.diff(data_old, data_new)
+          return output if diffs.empty?
+          oldhunk = hunk = nil  
+          file_length_difference = 0
+          diffs.each do |piece|
+            begin
+              hunk = Diff::LCS::Hunk.new(data_old, data_new, piece, context_lines,
+                                         file_length_difference)
+              file_length_difference = hunk.file_length_difference      
+              next unless oldhunk      
+              # Hunks may overlap, which is why we need to be careful when our
+              # diff includes lines of context. Otherwise, we might print
+              # redundant lines.
+              if (context_lines > 0) and hunk.overlaps?(oldhunk)
+                hunk.unshift(oldhunk)
+              else
+                output << oldhunk.diff(format)
+              end
+            ensure
+              oldhunk = hunk
+              output << "\n"
+            end
+          end  
+          #Handle the last remaining hunk
+          output << oldhunk.diff(format) << "\n"
+        end  
+
+        def diff_as_object(target,expected)
+          diff_as_string(PP.pp(target,""), PP.pp(expected,""))
+        end
+
+        protected
+        def format
+          @options.diff_format
+        end
+
+        def context_lines
+          @options.context_lines
+        end
+      end
+    end
+  end
+end

data/lib/spec/expectations/errors.rb

@@ -0,0 +1,12 @@
+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/lib/spec/expectations/extensions/object.rb

@@ -0,0 +1,63 @@
+module Spec
+  module Expectations
+    # rspec adds #should and #should_not to every Object (and,
+    # implicitly, every Class).
+    module ObjectExpectations
+      # :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, &block)
+        ExpectationMatcherHandler.handle_matcher(self, matcher, &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, &block)
+        NegativeExpectationMatcherHandler.handle_matcher(self, matcher, &block)
+      end
+
+    end
+  end
+end
+
+class Object
+  include Spec::Expectations::ObjectExpectations
+end

data/lib/spec/expectations/extensions/string_and_symbol.rb

@@ -0,0 +1,17 @@
+module Spec
+  module Expectations
+    module StringHelpers
+      def starts_with?(prefix)
+        to_s[0..(prefix.to_s.length - 1)] == prefix.to_s
+      end
+    end
+  end
+end
+
+class String
+  include Spec::Expectations::StringHelpers
+end
+
+class Symbol
+  include Spec::Expectations::StringHelpers
+end

data/lib/spec/expectations/extensions.rb

@@ -0,0 +1,2 @@
+require 'spec/expectations/extensions/object'
+require 'spec/expectations/extensions/string_and_symbol'

data/lib/spec/expectations/handler.rb

@@ -0,0 +1,32 @@
+module Spec
+  module Expectations
+    class InvalidMatcherError < ArgumentError; end        
+    
+    class ExpectationMatcherHandler        
+      def self.handle_matcher(actual, matcher, &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)
+        ::Spec::Expectations.fail_with(matcher.failure_message) unless match
+        match
+      end
+    end
+
+    class NegativeExpectationMatcherHandler
+      def self.handle_matcher(actual, matcher, &block)
+        ::Spec::Matchers.last_should = :should_not
+        ::Spec::Matchers.last_matcher = matcher
+
+        return ::Spec::Matchers::NegativeOperatorMatcher.new(actual) if matcher.nil?
+        
+        match = matcher.matches?(actual, &block)
+        ::Spec::Expectations.fail_with(matcher.negative_failure_message) if match
+        match
+      end
+    end
+  end
+end
+

data/lib/spec/expectations.rb

@@ -0,0 +1,60 @@
+require 'spec/matchers'
+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
+    def self.differ
+      @differ
+    end
+    
+    def self.differ=(differ)
+      @differ = differ
+    end
+
+    # 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 self.fail_with(message, expected=nil, target=nil) # :nodoc:
+      if Array === message && message.length == 3
+        message, expected, target = message[0], message[1], message[2]
+      end
+      unless (differ.nil? || expected.nil? || target.nil?)
+        if expected.is_a?(String)
+          message << "\nDiff:" << self.differ.diff_as_string(target.to_s, expected)
+        elsif !target.is_a?(Proc)
+          message << "\nDiff:" << self.differ.diff_as_object(target, expected)
+        end
+      end
+      Kernel::raise(Spec::Expectations::ExpectationNotMetError.new(message))
+    end
+  end
+end

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

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

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

@@ -0,0 +1,73 @@
+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 'test/unit'
+    # require 'spec'
+    #
+    # 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[_A-Z]./ && (
+          instance_method(method_name).arity == 0 ||
+          instance_method(method_name).arity == -1
+        )
+      end
+
+      before(:each) {setup}
+      after(:each) {teardown}
+
+      def initialize(defined_description, options={}, &implementation)
+        @_defined_description = defined_description
+        
+        # TODO - examples fail in rspec-rails if we remove "|| pending_implementation"
+        #      - find a way to fail without it in rspec's code examples
+        @_implementation = implementation || pending_implementation
+
+        @_result = ::Test::Unit::TestResult.new
+        # @method_name is important to set here because it complies with Test::Unit's interface.
+        # Some Test::Unit extensions depend on @method_name being present.
+        @method_name = @_defined_description
+
+        # TODO - this is necessary to run single examples in rspec-rails, but I haven't
+        # found a good way to write a failing example just within rspec core
+        @_backtrace = caller
+      end
+
+      def run(ignore_this_argument=nil)
+        super()
+      end
+
+    private
+
+      def pending_implementation
+        error = Spec::Example::NotYetImplementedError.new(caller)
+        lambda { raise(error) }
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,34 @@
+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/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/spec/interop/test.rb

@@ -0,0 +1,12 @@
+require 'test/unit'
+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