riess 0.0.8

data/vendor/rspec-0.8.2/examples/stubbing_example.rb

@@ -0,0 +1,69 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+context "A consumer of a stub" do
+  specify "should be able to stub methods on any Object" do
+    obj = Object.new
+    obj.stub!(:foobar).and_return {:return_value}
+    obj.foobar.should equal(:return_value)
+  end
+end
+
+class StubbableClass
+  def self.find id
+    return :original_return
+  end
+end
+
+context "A stubbed method on a class" do
+  specify "should return the stubbed value" do
+    StubbableClass.stub!(:find).and_return(:stub_return)
+    StubbableClass.find(1).should equal(:stub_return)
+  end
+  
+  specify "should revert to the original method after each spec" do
+    StubbableClass.find(1).should equal(:original_return)
+  end
+
+  specify "can stub! and mock the same message" do
+    StubbableClass.stub!(:msg).and_return(:stub_value)
+    StubbableClass.should_receive(:msg).with(:arg).and_return(:mock_value)
+
+    StubbableClass.msg.should equal(:stub_value)
+    StubbableClass.msg(:other_arg).should equal(:stub_value)
+    StubbableClass.msg(:arg).should equal(:mock_value)
+    StubbableClass.msg(:another_arg).should equal(:stub_value)
+    StubbableClass.msg(:yet_another_arg).should equal(:stub_value)
+    StubbableClass.msg.should equal(:stub_value)
+  end
+end
+
+context "A mock" do
+  specify "can stub!" do
+    mock = mock("stubbing mock")
+    mock.stub!(:msg).and_return(:value)
+    (1..10).each {mock.msg.should equal(:value)}
+  end
+  
+  specify "can stub! and mock" do
+    mock = mock("stubbing mock")
+    mock.stub!(:stub_message).and_return(:stub_value)
+    mock.should_receive(:mock_message).once.and_return(:mock_value)
+    (1..10).each {mock.stub_message.should equal(:stub_value)}
+    mock.mock_message.should equal(:mock_value)
+    (1..10).each {mock.stub_message.should equal(:stub_value)}
+  end
+  
+  specify "can stub! and mock the same message" do
+    mock = mock("stubbing mock")
+    mock.stub!(:msg).and_return(:stub_value)
+    mock.should_receive(:msg).with(:arg).and_return(:mock_value)
+    mock.msg.should equal(:stub_value)
+    mock.msg(:other_arg).should equal(:stub_value)
+    mock.msg(:arg).should equal(:mock_value)
+    mock.msg(:another_arg).should equal(:stub_value)
+    mock.msg(:yet_another_arg).should equal(:stub_value)
+    mock.msg.should equal(:stub_value)
+  end
+end
+
+    

data/vendor/rspec-0.8.2/examples/test_case_spec.rb

@@ -0,0 +1,63 @@
+require File.dirname(__FILE__) + '/spec_helper'
+require 'test/unit'
+
+class RSpecIntegrationTest < Test::Unit::TestCase
+  def self.fixtures(*args)
+    @@fixtures = true
+  end
+  
+  def self.verify_class_method
+    @@fixtures.should == true
+  end
+  
+  def setup
+    @test_case_setup_called = true
+  end
+
+  def teardown
+    @test_case_teardown_called = true
+  end
+
+  def run(result)
+  end
+
+  def helper_method
+    @helper_method_called = true
+  end
+end
+
+module RandomHelperModule
+  def random_task
+    @random_task_called = true
+  end
+end
+
+context "RSpec should integrate with Test::Unit::TestCase" do
+  inherit RSpecIntegrationTest
+  include RandomHelperModule
+  
+  fixtures :some_table
+
+  setup do
+    @rspec_setup_called = true
+  end
+
+  specify "TestCase#setup should be called." do
+    @test_case_setup_called.should be_true
+    @rspec_setup_called.should be_true
+  end
+
+  specify "RSpec should be able to access TestCase methods" do
+    helper_method
+    @helper_method_called.should be_true
+  end
+
+  specify "RSpec should be able to accept included modules" do
+    random_task
+    @random_task_called.should be_true
+  end
+  
+  teardown do
+    RSpecIntegrationTest.verify_class_method
+  end
+end

data/vendor/rspec-0.8.2/lib/spec.rb

@@ -0,0 +1,11 @@
+vendor_path = __FILE__.gsub('spec.rb','')
+$LOAD_PATH << vendor_path
+
+require 'spec/deprecated'
+require 'spec/version'
+require 'spec/callback'
+require 'spec/matchers'
+require 'spec/expectations'
+require 'spec/mocks'
+require 'spec/runner'
+require 'spec/translator'

data/vendor/rspec-0.8.2/lib/spec/callback.rb

@@ -0,0 +1,11 @@
+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/vendor/rspec-0.8.2/lib/spec/callback/callback_container.rb

@@ -0,0 +1,60 @@
+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/vendor/rspec-0.8.2/lib/spec/callback/extensions/module.rb

@@ -0,0 +1,24 @@
+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/vendor/rspec-0.8.2/lib/spec/callback/extensions/object.rb

@@ -0,0 +1,37 @@
+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/vendor/rspec-0.8.2/lib/spec/deprecated.rb

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

data/vendor/rspec-0.8.2/lib/spec/expectations.rb

@@ -0,0 +1,59 @@
+require 'spec/deprecated'
+require 'spec/matchers'
+require 'spec/expectations/sugar'
+require 'spec/expectations/errors'
+require 'spec/expectations/extensions'
+require 'spec/expectations/should'
+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
+    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

data/vendor/rspec-0.8.2/lib/spec/expectations/differs/default.rb

@@ -0,0 +1,62 @@
+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 colour support
+      # TODO add some rdoc
+      class Default
+        def initialize(format=:unified,context_lines=nil,colour=nil)
+
+          context_lines ||= 3
+          colour        ||= false
+
+          @format,@context_lines,@colour = format,context_lines,colour
+        end
+
+        # This is snagged from diff/lcs/ldiff.rb (which is a commandline tool)
+        def diff_as_string(data_old, data_new)
+          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
+      end
+    end
+  end
+end

data/vendor/rspec-0.8.2/lib/spec/expectations/errors.rb

@@ -0,0 +1,6 @@
+module Spec
+  module Expectations
+    class ExpectationNotMetError < StandardError
+    end
+  end
+end

data/vendor/rspec-0.8.2/lib/spec/expectations/extensions.rb

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

data/vendor/rspec-0.8.2/lib/spec/expectations/extensions/object.rb

@@ -0,0 +1,109 @@
+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
+      #
+      #   receiver.should(matcher)
+      #     => Passes if matcher.matches?(receiver)
+      #
+      #   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)
+        return ExpectationMatcherHandler.handle_matcher(self, matcher, &block) if matcher
+        Should::Should.new(self)
+      end
+
+      # :call-seq:
+      #   should_not(matcher)
+      #   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 =~ regexp
+      #     => Passes unless (receiver =~ regexp)
+      #
+      # See Spec::Matchers for more information about matchers
+      def should_not(matcher=nil, &block)
+        return NegativeExpectationMatcherHandler.handle_matcher(self, matcher, &block) if matcher
+        should.not
+      end
+
+      deprecated do
+        # Deprecated: use should have(n).items (see Spec::Matchers)
+        # This will be removed in 0.9
+        def should_have(expected)
+          should.have(expected)
+        end
+        alias_method :should_have_exactly, :should_have
+
+        # Deprecated: use should have_at_least(n).items (see Spec::Matchers)
+        # This will be removed in 0.9
+        def should_have_at_least(expected)
+          should.have.at_least(expected)
+        end
+      
+        # Deprecated: use should have_at_most(n).items (see Spec::Matchers)
+        # This will be removed in 0.9
+        def should_have_at_most(expected)
+          should.have.at_most(expected)
+        end
+
+        # Deprecated: use should include(expected) (see Spec::Matchers)
+        # This will be removed in 0.9
+        def should_include(expected)
+          should.include(expected)
+        end
+
+        # Deprecated: use should_not include(expected) (see Spec::Matchers)
+        # This will be removed in 0.9
+        def should_not_include(expected)
+          should.not.include(expected)
+        end
+
+        # Deprecated: use should be(expected) (see Spec::Matchers)
+        # This will be removed in 0.9
+        def should_be(expected = :___no_arg)
+          should.be(expected)
+        end
+      
+        # Deprecated: use should_not be(expected) (see Spec::Matchers)
+        # This will be removed in 0.9
+        def should_not_be(expected = :___no_arg)
+          should_not.be(expected)
+        end
+      end
+    end
+  end
+end
+
+class Object
+  include Spec::Expectations::ObjectExpectations
+  deprecated do
+    include Spec::Expectations::UnderscoreSugar
+  end
+end
+
+deprecated do
+  Object.handle_underscores_for_rspec!
+end