rspec 1.3.0 → 2.0.0

data/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/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/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/lib/spec/expectations/extensions.rb

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

data/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/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/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

data/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/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/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/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/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/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/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-#{Test::Unit::VERSION}
-* 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