rspec 1.0.0 → 1.3.1

data/lib/spec/example/shared_example_group.rb

@@ -0,0 +1,59 @@
+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/lib/spec/example/subject.rb

@@ -0,0 +1,114 @@
+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
+            example do
+              self.class.class_eval do
+                define_method(:subject) do
+                  super().send(attribute)
+                end
+              end
+              instance_eval(&block)
+            end
+          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 ? proc {described_class.new} : proc {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/lib/spec/example.rb

@@ -0,0 +1,164 @@
+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,6 +1,12 @@
 module Spec
   module Expectations
-    class ExpectationNotMetError < StandardError
+    # 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

@@ -0,0 +1,52 @@
+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,2 +1 @@
-require 'spec/expectations/extensions/object'
-require 'spec/expectations/extensions/string_and_symbol'
+require 'spec/expectations/extensions/kernel'

data/lib/spec/expectations/fail_with.rb

@@ -0,0 +1,45 @@
+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,43 +1,50 @@
 module Spec
   module Expectations
+    class InvalidMatcherError < ArgumentError; end        
     
-    module MatcherHandlerHelper
-      def describe(matcher)
-        matcher.respond_to?(:description) ? matcher.description : "[#{matcher.class.name} does not provide a description]"
-      end
-    end
-    
-    class ExpectationMatcherHandler
-      class << self
-        include MatcherHandlerHelper
-        def handle_matcher(actual, matcher, &block)
-          match = matcher.matches?(actual, &block)
-          ::Spec::Matchers.generated_description = "should #{describe(matcher)}"
-          Spec::Expectations.fail_with(matcher.failure_message) unless match
+    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 NegativeExpectationMatcherHandler
-      class << self
-        include MatcherHandlerHelper
-        def handle_matcher(actual, matcher, &block)
-          unless matcher.respond_to?(:negative_failure_message)
-            Spec::Expectations.fail_with(
-<<-EOF
-Matcher does not support should_not.
-See Spec::Matchers for more information
-about matchers.
-EOF
-)
-          end
-          match = matcher.matches?(actual, &block)
-          ::Spec::Matchers.generated_description = "should not #{describe(matcher)}"
-          Spec::Expectations.fail_with(matcher.negative_failure_message) if match
+    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,4 +1,5 @@
 require 'spec/matchers'
+require 'spec/expectations/fail_with'
 require 'spec/expectations/errors'
 require 'spec/expectations/extensions'
 require 'spec/expectations/handler'
@@ -30,27 +31,5 @@ module Spec
   # RSpec ships with a standard set of useful matchers, and writing your own
   # matchers is quite simple. See Spec::Matchers for details.
   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 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
-end
+end

data/lib/spec/extensions/instance_exec.rb

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

@@ -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,56 @@
+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

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