rspec 0.8.2 → 0.9.0

data/RELEASE-PLAN

@@ -1,117 +0,0 @@
-Beginning with 0.8.0, RSpec is moving towards a new syntax using Expression Matchers
-instead of adding expectations directly to Object. We'll still be adding a few methods
-to Object, but it will be much less invasive, and will eliminate conflicts with
-other tools and frameworks that utilize method_missing to perform magic.
-
-For more information on Expression Matchers, see the rdoc for Spec::Matchers
-
-Our plan is as follows:
-
-* release 0.8.0 with:
-  - full support for Expression Matchers
-  - a translation tool that will convert the majority of your specs from the old syntax to the new syntax
-  - deprecation warnings for all of the old methods that will be removed
-* release 0.9.0 with all of the old methods removed
-
-Everything that is listed below is already supported and usable right now.
-
-== General: should_xyz
-
-  #before
-  actual.should_xyz expected
-  actual.should_not_xyz expected
-
-  #after
-  actual.should xyz(expected)
-  actual.should_not xyz(expected)
-
-This change applies to all of these as well:
-
-  should_equal
-  should_eql
-  should_be_close
-  should_include
-  should_match
-  should_satisfy
-
-== should_be
-
-  #before
-  result.should_be true
-  result.should_be false
-  result.should_be nil
-  result.should_not_be nil
-
-  #after
-  result.should be(true)
-  result.should be(false)
-  result.should be(nil)
-  result.should_not be(true)
-
-== should_be with arbitrary predicates
-
-  #before
-  true.should_be_arbitrary_predicate
-  true.should_be_a_arbitrary_predicate
-  true.should_be_an_arbitrary_predicate
-
-  #after
-  true.should be_arbitrary_predicate
-  true.should be_a_arbitrary_predicate
-  true.should be_an_arbitrary_predicate
-
-== should_be with comparison operators
-
-  #before
-  5.should_be > 3
-  4.should_be >= 4
-  4.should_be <= 4
-  4.should_be < 4
-
-  #before
-  5.should be > 3
-  4.should be >= 4
-  4.should be <= 4
-  4.should be < 4
-  
-== should ==
-
-  #before
-  actual.should == expected
-  actual.should_not == expected
-  
-  #after - exactly the same
-  actual.should == expected
-  actual.should_not == expected
-
-== should =~
-
-  #before
-  actual.should =~ regexp
-  actual.should_not =~ regexp
-
-  #after - exactly the same
-  actual.should =~ regexp
-  actual.should_not =~ regexp
-  
-== should_have
-
-  #before
-  team.should_have(3).players
-  hash.should_have_key(:a)
-
-  #after
-  team.should have(3).players
-  hash.should have_key(:a)
-
-== should_change
-
-  #before
-  proc.should_change(:target, message)
-  proc.should_change(:target, message).by(1)
-  proc.should_change(:target, message).from("a").to("b")
-  
-  proc.should change(:target, message)
-  proc.should change(:target, message).by(1)
-  proc.should change(:target, message).from("a").to("b")
-  

data/examples/auto_spec_name_generation_example.rb

@@ -1,18 +0,0 @@
-require File.dirname(__FILE__) + '/spec_helper'
-
-# Run spec w/ -fs to see the output of this file
-
-context "specs with no names" do
-  
-  # spec name is auto-generated as "should equal(5)"
-  specify do
-    3.should equal(3)
-    5.should equal(5)
-  end
-  
-  specify { 3.should be < 5 }
-  
-  specify { ["a"].should include("a") }
-  
-  specify { [1,2,3].should respond_to(:size) }
-end

data/lib/spec/callback.rb

@@ -1,11 +0,0 @@
-require 'spec/callback/callback_container'
-require 'spec/callback/extensions/module'
-require 'spec/callback/extensions/object'
-
-# Callback is a fork of Brian Takita's "callback library" (see http://callback.rubyforge.org),
-# which Brian graciously contributed to RSpec in order to avoid the dependency.
-#
-# RSpec uses Callback internally to create hooks to Spec::Runner events. If you're interested
-# in a simple, powerful API for generating callback events, check out http://callback.rubyforge.org.
-module Callback
-end

data/lib/spec/callback/callback_container.rb

@@ -1,60 +0,0 @@
-module Callback
-  class CallbackContainer
-    def initialize
-      @callback_registry = Hash.new do |hash, key|
-        hash[key] = Array.new
-      end
-    end
-
-    # Defines the callback with the key in this container.
-    def define(key, callback_proc=nil, &callback_block)
-      callback = extract_callback(callback_block, callback_proc) do
-        raise "You must define the callback that accepts the call method."
-      end
-      @callback_registry[key] << callback
-      callback
-    end
-
-    # Undefines the callback with the key in this container.
-    def undefine(key, callback_proc)
-      callback = extract_callback(callback_proc) do
-        raise "You may only undefine callbacks that use the call method."
-      end
-      @callback_registry[key].delete callback
-      callback
-    end
-
-    # Notifies the callbacks for the key. Arguments may be passed.
-    # An error handler may be passed in as a block. If there is an error, the block is called with
-    # error object as an argument.
-    # An array of the return values of the callbacks is returned.
-    def notify(key, *args, &error_handler)
-      @callback_registry[key].collect do |callback|
-        begin
-          callback.call(*args)
-        rescue Exception => e
-          yield(e) if error_handler
-        end
-      end
-    end
-
-    # Clears all of the callbacks in this container.
-    def clear
-      @callback_registry.clear
-    end
-
-    protected
-    def extract_callback(first_choice_callback, second_choice_callback = nil)
-      callback = nil
-      if first_choice_callback
-        callback = first_choice_callback
-      elsif second_choice_callback
-        callback = second_choice_callback
-      end
-      unless callback.respond_to? :call
-        yield
-      end
-      return callback
-    end
-  end
-end

data/lib/spec/callback/extensions/module.rb

@@ -1,24 +0,0 @@
-module Callback
-  module ModuleMethods
-    # For each event_name submitted, defines a callback event with this name.
-    # Client code can then register as a callback listener using object.event_name.
-    def callback_events(*event_names)
-      event_names.each do |event_name|
-        define_callback_event(event_name)
-      end
-    end
-
-    private
-    def define_callback_event(event_name)
-      module_eval <<-EOS
-        def #{event_name}(&block)
-          register_callback(:#{event_name}, &block)
-        end
-      EOS
-    end
-  end
-end
-
-class Module
-  include Callback::ModuleMethods
-end

data/lib/spec/callback/extensions/object.rb

@@ -1,37 +0,0 @@
-module Callback
-  module InstanceMethods
-    # Registers a callback for the event on the object. The callback can either be a block or a proc.
-    # When the callbacks are notified, the return value of the proc is passed to the caller.
-    def register_callback(event, callback_proc=nil, &callback_block)
-      callbacks.define(event, callback_proc, &callback_block)
-    end
-
-    # Removes the callback from the event. The callback proc must be the same
-    # object as the one that was passed to register_callback.
-    def unregister_callback(event, callback_proc)
-      callbacks.undefine(event, callback_proc)
-    end
-
-    protected
-    # Notifies the callbacks registered with the event on the object. Arguments can be passed to the callbacks.
-    # An error handler may be passed in as a block. If there is an error, the block is called with
-    # error object as an argument.
-    # An array of the return values of the callbacks is returned.
-    def notify_callbacks(event, *args, &error_handler)
-      callbacks.notify(event, *args, &error_handler)
-    end
-
-    def notify_class_callbacks(event, *args, &error_handler)
-      self.class.send(:notify_callbacks, event, *args, &error_handler)      
-    end
-
-    # The CallbackContainer for this object.
-    def callbacks
-      @callbacks ||= CallbackContainer.new
-    end
-  end
-end
-
-class Object
-  include Callback::InstanceMethods
-end

data/lib/spec/deprecated.rb

@@ -1,3 +0,0 @@
-def deprecated(&block)
-  block.call unless ENV['RSPEC_DISABLE_DEPRECATED_FEATURES'] == 'true'
-end

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

@@ -1,57 +0,0 @@
-module Spec
-  module Expectations
-    module ProcExpectations
-      # Given a receiver and a message (Symbol), specifies that the result
-      # of sending that message that receiver should change after
-      # executing the proc.
-      #
-      #   lambda { @team.add player }.should_change(@team.players, :size)
-      #   lambda { @team.add player }.should_change(@team.players, :size).by(1)
-      #   lambda { @team.add player }.should_change(@team.players, :size).to(23)
-      #   lambda { @team.add player }.should_change(@team.players, :size).from(22).to(23)
-      #
-      # You can use a block instead of a message and receiver.
-      #
-      #   lambda { @team.add player }.should_change{@team.players.size}
-      #   lambda { @team.add player }.should_change{@team.players.size}.by(1)
-      #   lambda { @team.add player }.should_change{@team.players.size}.to(23)
-      #   lambda { @team.add player }.should_change{@team.players.size}.from(22).to(23)
-      def should_change(receiver=nil, message=nil, &block)
-        should.change(receiver, message, &block)
-      end
-  
-      # Given a receiver and a message (Symbol), specifies that the result
-      # of sending that message that receiver should NOT change after
-      # executing the proc.
-      #
-      #   lambda { @team.add player }.should_not_change(@team.players, :size)
-      #
-      # You can use a block instead of a message and receiver.
-      #
-      #   lambda { @team.add player }.should_not_change{@team.players.size}
-      def should_not_change(receiver, message)
-        should.not.change(receiver, message)
-      end
-
-      def should_raise(exception=Exception, message=nil)
-        should.raise(exception, message)
-      end
-      
-      def should_not_raise(exception=Exception, message=nil)
-        should.not.raise(exception, message)
-      end
-      
-      def should_throw(symbol)
-        should.throw(symbol)
-      end
-      
-      def should_not_throw(symbol=:___this_is_a_symbol_that_will_likely_never_occur___)
-        should.not.throw(symbol)
-      end
-    end
-  end
-end
-
-class Proc
-  include Spec::Expectations::ProcExpectations
-end

data/lib/spec/expectations/should.rb

@@ -1,5 +0,0 @@
-require 'spec/expectations/should/base'
-require 'spec/expectations/should/have'
-require 'spec/expectations/should/not'
-require 'spec/expectations/should/should'
-require 'spec/expectations/should/change'

data/lib/spec/expectations/should/base.rb

@@ -1,64 +0,0 @@
-module Spec
-  module Expectations
-    module Should
-      class Base
-        
-        #== and =~ will stay after the new syntax
-        def ==(expected)
-          __delegate_method_missing_to_target "==", "==", expected
-        end
-        
-        def =~(expected)
-          __delegate_method_missing_to_target "=~", "=~", expected
-        end
-        
-        #<, <=, >=, > are all implemented in Spec::Matchers::Be
-        # and will be removed with 0.9
-        deprecated do
-          def <(expected)
-            __delegate_method_missing_to_target "<", "<", expected
-          end
-        
-          def <=(expected)
-            __delegate_method_missing_to_target "<=", "<=", expected
-          end
-        
-          def >=(expected)
-            __delegate_method_missing_to_target ">=", ">=", expected
-          end
-        
-          def >(expected)
-            __delegate_method_missing_to_target ">", ">", expected
-          end
-        end
-
-        def default_message(expectation, expected=nil)
-          return "expected #{expected.inspect}, got #{@target.inspect} (using #{expectation})" if expectation == '=='
-          "expected #{expectation} #{expected.inspect}, got #{@target.inspect}" unless expectation == '=='
-        end
-
-        def fail_with_message(message, expected=nil, target=nil)
-          Spec::Expectations.fail_with(message, expected, target)
-        end
-    
-        def find_supported_sym(original_sym)
-          ["#{original_sym}?", "#{original_sym}s?"].each do |alternate_sym|
-            return alternate_sym.to_s if @target.respond_to?(alternate_sym.to_s)
-          end
-        end
-
-        deprecated do
-          def method_missing(original_sym, *args, &block)
-            if original_sym.to_s =~ /^not_/
-              return Not.new(@target).__send__(sym, *args, &block)
-            end
-            if original_sym.to_s =~ /^have_/
-              return have.__send__(original_sym.to_s[5..-1].to_sym, *args, &block)
-            end
-            __delegate_method_missing_to_target original_sym, find_supported_sym(original_sym), *args
-          end
-        end
-      end
-    end
-  end
-end

data/lib/spec/expectations/should/change.rb

@@ -1,69 +0,0 @@
-module Spec
-  module Expectations
-    module Should
-      class Change < Base
-
-        def initialize(target, receiver=nil, message=nil, &block)
-          @block = block
-          @target = target
-          @receiver = receiver
-          @message = message
-          execute_change
-          evaluate_change
-        end
-
-        def execute_change
-          @before_change = @block.nil? ? @receiver.send(@message) : @block.call
-          @target.call
-          @after_change = @block.nil? ? @receiver.send(@message) : @block.call
-        end
-        
-        def message
-          @message.nil? ? 'result' : @message
-        end
-
-        def evaluate_change
-          if @before_change == @after_change
-            fail_with_message "#{message} should have changed, but is still #{@after_change.inspect}"
-          end
-        end
-
-        def from(value)
-          if @before_change != value
-            fail_with_message "#{message} should have initially been #{value.inspect}, but was #{@before_change.inspect}"
-          end
-          self
-        end
-
-        def to(value)
-          if @after_change != value
-            fail_with_message "#{message} should have been changed to #{value.inspect}, but is now #{@after_change.inspect}"
-          end
-          self
-        end
-
-        def by(expected_delta)
-          if actual_delta != expected_delta
-            fail_with_message "#{message} should have been changed by #{expected_delta}, but was changed by #{actual_delta}"
-          end
-          self
-        end
-        
-        private
-          def actual_delta
-            @after_change - @before_change
-          end
-      end
-      
-      class NotChange < Change
-        def evaluate_change
-          if @before_change != @after_change
-            fail_with_message "#{@message} should not have changed, but did change from #{@before_change.inspect} to #{@after_change.inspect}"
-          end
-        end
-      end
-
-    end
-  end
-end
-