rspec 1.2.9 → 1.3.0

data/features/mocks/block_local_expectations.feature

@@ -0,0 +1,62 @@
+Feature: block local expectations
+
+  In order to set message expectations on ...
+  As an RSpec user
+  I want to configure the evaluation context
+
+  Background:
+    Given a file named "account.rb" with:
+      """
+      class Account
+        def self.create
+          yield new
+        end
+
+        def opening_balance(amount, currency)
+        end
+      end
+      """
+
+  Scenario: passing example
+    Given a file named "account_dsl.rb" with:
+      """
+      require 'spec_helper'
+      require 'account'
+
+      describe "account DSL" do
+        it " .... " do
+          account = Account.new
+          Account.should_receive(:create).and_yield do |account|
+            account.should_receive(:opening_balance).with(100, :USD)
+          end
+          Account.create do
+            opening_balance 100, :USD
+          end
+        end
+      end
+      """
+    When I run "spec account_dsl.rb"
+    Then the stdout should include "1 example, 0 failures"
+    
+  Scenario: failing example
+    
+    Given a file named "account_dsl.rb" with:
+      """
+      require 'spec_helper'
+      require 'account'
+
+      describe "account DSL" do
+        it " .... " do
+          account = Account.new
+          Account.should_receive(:create).and_yield do |account|
+            account.should_receive(:opening_balance).with(100, :USD)
+          end
+          Account.create do
+            # opening_balance is not called here
+          end
+        end
+      end
+      """
+
+    When I run "spec account_dsl.rb"
+    Then the stdout should include "1 example, 1 failure"

data/features/step_definitions/running_rspec_steps.rb

@@ -27,6 +27,15 @@ Then /^the (.*) should include (.*)$/ do |stream, string_or_regex|
   written.should smart_match(string_or_regex)
 end
 
+Then /^the (.*) should include$/ do |stream, string_or_regex|
+  written = case(stream)
+    when 'stdout' then last_stdout
+    when 'stderr' then last_stderr
+    else raise "Unknown stream: #{stream}"
+  end
+  written.should smart_match(string_or_regex)
+end
+
 Then /^the (.*) should not match (.*)$/ do |stream, string_or_regex|
   written = case(stream)
     when 'stdout' then last_stdout

data/features/step_definitions/stubbing_steps.rb

@@ -0,0 +1,16 @@
+When /^I stub "([^\"]*)" on "([^\"]*)" to "([^\"]*)"$/ do |method_name, const_name, value|
+  const = Object.const_get(const_name)
+  const.stub!(method_name.to_sym).and_return(value)
+end
+
+Then /^calling "([^\"]*)" on "([^\"]*)" should return "([^\"]*)"$/ do |method_name, const_name, value|
+  const = Object.const_get(const_name)
+  const.send(method_name.to_sym).should == value
+end
+
+Then /^"([^\"]*)" should not be defined on "([^\"]*)"$/ do |method_name, const_name|
+  const = Object.const_get(const_name)
+  lambda {
+    const.send(method_name.to_sym)
+  }.should raise_error(NameError, /#{method_name}/)
+end

data/features/support/env.rb

@@ -5,6 +5,7 @@ require 'forwardable'
 require 'tempfile'
 require 'spec/ruby_forker'
 require 'features/support/matchers/smart_match'
+require 'spec/stubs/cucumber'
 
 class RspecWorld
   include Spec::Expectations

data/features/support/matchers/smart_match.rb

@@ -1,12 +1,31 @@
 Spec::Matchers.define :smart_match do |expected|
+  def regexp?
+    /^\/.*\/?$/
+  end
+
+  def quoted?
+    /^".*"$/
+  end
+
   match do |actual|
     case expected
-    when /^\/.*\/?$/
+    when regexp?
       actual =~ eval(expected)
-    when /^".*"$/
+    when quoted?
       actual.index(eval(expected))
-    else
-      false
+    else # multi-line string
+      actual.index(expected)
     end
   end
+
+  failure_message_for_should do |actual|
+    <<-MESSAGE
+#{'*'*50}
+got:
+#{'*'*30}
+#{actual}
+#{'*'*50}
+MESSAGE
+  end
 end
+

data/geminstaller.yml

@@ -0,0 +1,28 @@
+# Basics needed to run 'rake' from this directory
+gems:
+- name: cucumber
+  version: '>= 0.3.101'
+- name: diff-lcs
+  version: '>= 1.1.2'
+- name: fakefs
+  version: '>= 0.2'
+- name: flexmock
+  version: '>= 0.8.6'
+- name: heckle
+  version: '>= 1.4.2'
+- name: hoe
+  version: '>= 2.0'
+- name: nokogiri
+  version: '>= 1.2.3'
+- name: mocha
+  version: '>= 0.9.5'
+- name: rake
+  version: '>= 0.8.4'
+- name: spicycode-rcov
+  version: '>= 0.8.2.1'
+- name: syntax
+  version: '>= 1.0.0'
+- name: rr
+  version: '>= 0.10.0'
+- name: ruby-debug
+  version: '>= 0.10.3'

data/lib/autotest/rspec.rb

@@ -2,9 +2,8 @@ require 'autotest'
 
 Autotest.add_hook :initialize do |at|
   at.clear_mappings
-  # watch out: Ruby bug (1.8.6):
-  # %r(/) != /\//
-  at.add_mapping(%r%^spec/.*_spec.rb$%) { |filename, _|
+  # watch out for Ruby bug (1.8.6): %r(/) != /\//
+  at.add_mapping(%r%^spec/.*_spec\.rb$%) { |filename, _|
     filename
   }
   at.add_mapping(%r%^lib/(.*)\.rb$%) { |_, m|
@@ -18,6 +17,8 @@ end
 class RspecCommandError < StandardError; end
 
 class Autotest::Rspec < Autotest
+  
+  SPEC_PROGRAM = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'bin', 'spec'))
 
   def initialize
     super
@@ -36,12 +37,18 @@ class Autotest::Rspec < Autotest
   end
 
   def make_test_cmd(files_to_test)
-    return '' if files_to_test.empty?
-    spec_program = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'bin', 'spec'))
-    return "#{ruby} #{spec_program} --autospec #{files_to_test.keys.flatten.join(' ')} #{add_options_if_present}"
+    files_to_test.empty? ? '' :
+      "#{ruby} #{SPEC_PROGRAM} --autospec #{normalize(files_to_test).keys.flatten.join(' ')} #{add_options_if_present}"
+  end
+
+  def normalize(files_to_test)
+    files_to_test.keys.inject({}) do |result, filename|
+      result[File.expand_path(filename)] = []
+      result
+    end
   end
 
   def add_options_if_present # :nodoc:
-    File.exist?("spec/spec.opts") ? "-O spec/spec.opts " : ""
+    File.exist?("spec/spec.opts") ? "-O #{File.join('spec','spec.opts')} " : ""
   end
 end

data/lib/spec/dsl/main.rb

@@ -27,7 +27,7 @@ module Spec
         set_location(args.options, caller(0)[1])
         Spec::Example::ExampleGroupFactory.create_example_group(*args, &block)
       end
-      alias :context :describe
+      alias :context :describe unless defined?(IRB::Context)
 
       # Creates an example group that can be shared by other example groups
       #

data/lib/spec/example/example_methods.rb

@@ -38,11 +38,15 @@ module Spec
           begin
             before_each_example
             instance_eval(&@_implementation)
+          rescue Interrupt
+            exit 1
           rescue Exception => e
             execution_error ||= e
           end
           begin
             after_each_example
+          rescue Interrupt
+            exit 1
           rescue Exception => e
             execution_error ||= e
           end

data/lib/spec/interop/test.rb

@@ -23,7 +23,7 @@ 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
+* uninstall test-unit-#{Test::Unit::VERSION}
 * use 'script/spec' instead of 'rake spec'
 #{'*' * 50}
 MESSAGE

data/lib/spec/matchers.rb

@@ -1,4 +1,4 @@
-require 'spec/matchers/extensions/instance_exec'
+require 'spec/extensions/instance_exec'
 require 'spec/matchers/pretty'
 require 'spec/matchers/matcher'
 require 'spec/matchers/operator_matcher'
@@ -18,7 +18,7 @@ require 'spec/matchers/include'
 require 'spec/matchers/match'
 require 'spec/matchers/match_array'
 require 'spec/matchers/method_missing'
-require 'spec/matchers/raise_error'
+require 'spec/matchers/raise_exception'
 require 'spec/matchers/respond_to'
 require 'spec/matchers/satisfy'
 require 'spec/matchers/simple_matcher'
@@ -139,6 +139,25 @@ module Spec
   # <tt>failure_message_for_should_not</tt>) are passed the actual value (the
   # receiver of <tt>should</tt> or <tt>should_not</tt>).
   #
+  # You can also create matchers that obey a fluent interface using the
+  # <tt>chain</tt> method:
+  #
+  #   Spec::Matchers.define :tip do |expected_tip|
+  #     chain :on do |bill|
+  #       @bill = bill
+  #     end
+  #
+  #     match do |person|
+  #       person.tip_for(bill) == expected_tip
+  #     end
+  #   end
+  #
+  # This matcher can be used as follows:
+  #
+  #   describe Customer do
+  #     it { should tip(10).on(50 }
+  #   end
+  #
   # === Custom Matcher from scratch
   #
   # You could also write a custom matcher from scratch, as follows:

data/lib/spec/matchers/be.rb

@@ -1,169 +1,206 @@
+require 'spec/matchers/dsl'
+
+Spec::Matchers.define :be_true do
+  match do |actual|
+    !!actual
+  end
+end
+
+Spec::Matchers.define :be_false do
+  match do |actual|
+    !actual
+  end
+end
+
+Spec::Matchers.define :be_nil do
+  match do |actual|
+    actual.nil?
+  end
+
+  failure_message_for_should do |actual|
+    "expected nil, got #{actual.inspect}"
+  end
+
+  failure_message_for_should_not do
+    "expected not nil, got nil"
+  end
+end
+
 module Spec
   module Matchers
-    
+
     class Be #:nodoc:
       include Spec::Matchers::Pretty
       
-      def initialize(*args)
-        @expected = args.empty? ? true : set_expected(args.shift)
+      def initialize(*args, &block)
         @args = args
-        @comparison_method = nil
       end
       
       def matches?(actual)
         @actual = actual
-        handling_predicate? ? run_predicate_on(actual) : match_or_compare(actual)
+        !!@actual
+      end
+
+      def failure_message_for_should
+        "expected #{@actual.inspect} to evaluate to true"
+      end
+      
+      def failure_message_for_should_not
+        "expected #{@actual.inspect} to evaluate to false"
+      end
+      
+      def description
+        "be"
+      end
+
+      [:==, :<, :<=, :>=, :>, :===].each do |operator|
+        define_method operator do |operand|
+          BeComparedTo.new(operand, operator)
+        end
+      end
+
+    private
+
+      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 expected_to_sentence
+        split_words(@expected)
+      end
+      
+      def args_to_sentence
+        to_sentence(@args)
+      end
+        
+    end
+
+    class BeComparedTo < Be
+
+      def initialize(operand, operator)
+        @expected, @operator = operand, operator
+        @args = []
+      end
+
+      def matches?(actual)
+        @actual = actual
+        @actual.__send__(@operator, @expected)
+      end
+
+      def failure_message_for_should
+        "expected #{@operator} #{@expected}, got #{@actual.inspect}"
+      end
+      
+      def failure_message_for_should_not
+        message = <<-MESSAGE
+'should_not be #{@operator} #{@expected}' not only FAILED,
+it is a bit confusing.
+          MESSAGE
+          
+        raise message << ([:===,:==].include?(@operator) ?
+          "It might be more clearly expressed without the \"be\"?" :
+          "It might be more clearly expressed in the positive?")
+      end
+
+      def description
+        "be #{@operator} #{expected_to_sentence}#{args_to_sentence}"
+      end
+
+    end
+
+    class BePredicate < Be
+
+      def initialize(*args, &block)
+        @expected = parse_expected(args.shift)
+        @args = args
+        @block = block
       end
       
-      def run_predicate_on(actual)
+      def matches?(actual)
+        @actual = actual
         begin
-          return @result = actual.__send__(predicate, *@args)
+          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)
+          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
+        "expected #{predicate}#{args_to_s} to return true, got #{@result.inspect}"
       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
+        "expected #{predicate}#{args_to_s} to return false, got #{@result.inspect}"
       end
-      
+
       def description
-        "#{prefix_to_sentence}#{comparison} #{expected_to_sentence}#{args_to_sentence}".gsub(/\s+/,' ')
+        "#{prefix_to_sentence}#{expected_to_sentence}#{args_to_sentence}"
       end
 
-      [:==, :<, :<=, :>=, :>, :===].each do |method|
-        define_method method do |expected|
-          compare_to(expected, :using => method)
-          self
-        end
-      end
+    private
 
-      private
-        def match_or_compare(actual)
-          TrueClass === @expected ? @actual : @actual.__send__(comparison_method, @expected)
-        end
+      def predicate
+        "#{@expected}?".to_sym
+      end
       
-        def comparison_method
-          @comparison_method || :equal?
-        end
+      def present_tense_predicate
+        "#{@expected}s?".to_sym
+      end
       
-        def expected
-          @expected
-        end
+      def parse_expected(expected)
+        @prefix, expected = prefix_and_expected(expected)
+        expected
+      end
 
-        def compare_to(expected, opts)
-          @expected, @comparison_method = expected, opts[:using]
-        end
+      def prefix_and_expected(symbol)
+        symbol.to_s =~ /^(be_(an?_)?)(.*)/
+        return $1, $3
+      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 prefix_to_sentence
+        split_words(@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
+    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
+    class BeSameAs < Be
+      
+      def initialize(*args, &block)
+        @expected = args.shift
+        @args = args
+      end
+      
+      def matches?(actual)
+        @actual = actual
+        @actual.equal?(@expected)
+      end
+
+      def failure_message_for_should
+        "expected #{@expected}, got #{@actual.inspect}"
+      end
+      
+      def failure_message_for_should_not
+        "expected not #{@expected}, got #{@actual.inspect}"
+      end
+
+      def description
+        "be #{expected_to_sentence}#{args_to_sentence}"
+      end
 
-        def args_to_sentence
-          to_sentence(@args)
-        end
-        
     end
  
     # :call-seq:
@@ -197,7 +234,9 @@ it is a bit confusing.
     #   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)
+      args.empty? ?
+        Matchers::Be.new :
+        Matchers::BeSameAs.new(*args)
     end
 
     # passes if target.kind_of?(klass)