rspec 0.6.3 → 0.6.4

data/CHANGES

@@ -1,5 +1,30 @@
 = RSpec Changelog
 
+== Version 0.6.4
+
+In addition to a number of bug fixes and patches, this release begins to formalize the support for
+RSpec on Rails.
+
+* Fixed [#5909], once again supporting multi_word_predicates
+* Applied [#5873] - response.should_have_rjs (initial patch from Jake Howerton, based on ARTS by Kevin Clark)
+* Added generation of view specs for rspec_on_rails
+* Applied [#5815] active_record_subclass.should_have(3).records
+* Added support in "rake stats" for view specs (in spec/views)
+* Applied [#5801] QuickRef.pdf should say RSpec, not rSpec
+* Applied [#5728] rails_spec_runner fails on Windows (Patch from Lindsay Evans).
+* Applied [#5708] RSpec Rails plugin rspec_controller generator makes specs that do not parse.
+* Cleaned up RSpec on Rails so it doesn't pollute as much during bootstrapping.
+* Added support for response.should_have_tag and response.should_not_have_tag (works just like assert_tag in rails)
+* Added new -c, --colour, --color option for colourful (red/green) output. Inspired from Pat Eyler's Redgreen gem.
+* Added examples for Watir and Selenium under the gem's vendor directory.
+* Renamed rails_spec_runner to rails_spec_server (as referred to in the docs)
+* Added support for trying a plural for arbitrary predicates.  E.g. Album.should_exist(:name => "Hey Jude") will call Album.exists?(:name => "Hey Jude")
+* Added support for should_have to work with methods taking args returning a collection.  E.g. @dave.should_have(3).albums_i_have_that_this_guy_doesnt(@aslak)
+* Added [#5570] should_not_receive(:msg).with(:specific, "args")
+* Applied [#5065] to support using define_method rather than method_missing to capture expected messages on mocks. Thanks to Eero Saynatkari for the tip that made it work.
+* Restructured directories and Modules in order to separate rspec into three distinct Modules: Spec::Expectations, Spec::Runner and Spec::Mocks. This will allow us to more easily integrate other mock frameworks and/or allow test/unit users to take advantage of the expectation API.
+* Applied [#5620] support any boolean method and arbitrary comparisons (5.should_be < 6) (Patch from Mike Williams)
+ 
 == Version 0.6.3
 
 This release fixes some minor bugs related to RSpec on Rails
@@ -8,7 +33,7 @@ you should remove your lib/tasks/rspec.rake if it exists.
 
 * Backtraces from drb (and other standard ruby libraries) are now stripped from backtraces.
 * Applied [#5557] Put rspec.rake into the task directory of the RSpec on Rails plugin (Patch from Daniel Siemssen)
-* Applied [#5556] rails_spec_runner loads environment.rb twice (Patch from Daniel Siemssen)
+* Applied [#5556] rails_spec_server loads environment.rb twice (Patch from Daniel Siemssen)
 
 == Version 0.6.2
 This release fixes a couple of regressions with the rake task that were introduced in the previous version (0.6.1)
@@ -29,7 +54,7 @@ Things that may break backwards compatibility:
 * Fixed [#5224] Move 'require diff-lcs' from test_helper.rb to diff_test.rb (Tip from Chris Roos)
 * Applied [#5449] Rake stats for specs (Patch from Nick Sieger)
 * Applied [#5468, #5058] Fix spec runner to correctly run controller specs (Patch from Daniel Siemssen)
-* Applied fixes to rails_spec_runner to improve its ability to run several times. (Patch from Daniel Siemssen)
+* Applied fixes to rails_spec_server to improve its ability to run several times. (Patch from Daniel Siemssen)
 * Changed RCov::VerifyTask to fail if the coverage is above the threshold. This is to ensure it gets bumped when coverage improves.
 
 == Version 0.6.0
@@ -67,7 +92,7 @@ a experimental support for faster rails specs.
 * Methods can now be defined alongside specs. This obsoletes the need for defining methods in setup. (Patch #5002 from Brian Takita)
 * Sugar (underscores) now works correctly with should_be_a_kind_of and should_be_an_instance_of
 * Added support for include and inherit in contexts. (Patch #4971 from Brian Takita)
-* Added rails_spec and rails_spec_runner for faster specs on rails (still buggy - help needed)
+* Added rails_spec and rails_spec_server for faster specs on rails (still buggy - help needed)
 * Fixed bug that caused should_render to break if given a :symbol (in Rails)
 * Added support for comparing exception message in should_raise and should_not_raise
 

data/EXAMPLES.rd

@@ -1,21 +1,10 @@
-# Airport at home
-# * should always work
-# * not need cables
-# * not need electricity
-# BDD framework
-# * should be adopted quickly
-# * should be intuitive
-# Rspec allow you to define custom methods
-# * Rspec should allow you to define methods
-# Rspec allow you to define custom methods
-# * Rspec should allow you to define methods
 # A FileAccessor
 # * should open a file and pass it to the processor's process method
+# Rspec
+# * should allow you to define helper methods
 # An IoProcessor
 # * should raise nothing when the file is exactly 32 bytes
 # * should raise an exception when the file length is less than 32 bytes
-# A consumer of a mock
-# * should be able to send messages to the mock
 # A stack (in general)
 # * should add to the top when sent 'push'
 # * should return the top item when sent 'peek'
@@ -39,9 +28,6 @@
 # * should remain full after 'peek'
 # * should no longer be full after 'pop'
 # * should complain on 'push'
-# Underscore sugar
-# * should be available for regular objects
-# * should be available for mocks
 # Rspec should integrate with Test::Unit::TestCase
 # * TestCase#setup should be called.
 # * Rspec should be able to access TestCase methods

data/README

@@ -1,5 +1,4 @@
-In order to run RSpec's tests and generate the gem and the website, you must have RubyGems.
-Then you must install the following gems:
+In order to run RSpec's full test suite (rake pre_commit) you must install the following gems:
 
 * rake
 * rcov
@@ -9,6 +8,10 @@ Then you must install the following gems:
 * RedCloth
 * syntax
 * diff-lcs
+* meta_project
+* sqlite3-ruby
+
+You must also install SQLite - which is needed to test the Rails plugin.
 
 Note that RSpec itself - once built - doesn't have any dependencies outside the Ruby core 
 and stdlib - with a few exceptions:

data/Rakefile

@@ -22,7 +22,11 @@ PKG_FILES = FileList[
   '[A-Z]*',
   'lib/**/*.rb', 
   'test/**/*.rb', 
-  'examples/**/*'
+  'examples/**/*',
+  'vendor/watir/*.rb',
+  'vendor/watir/*.txt',
+  'vendor/selenium/*.rb',
+  'vendor/selenium/*.txt'
 ]
 
 task :default => :test
@@ -39,7 +43,7 @@ Rake::TestTask.new do |t|
   tests.exclude 'test/spec/test_to_spec/*.rb' if windows
   t.test_files = tests
   t.verbose = true
-  t.warning = true
+#  t.warning = true
 end
 
 Rcov::RcovTask.new do |t|
@@ -178,8 +182,8 @@ task :pre_commit => [:verify_warnings, :website, :examples, :failing_examples_wi
 
 task :rails_pre_commit do
   Dir.chdir 'vendor/rspec_on_rails' do    
-    `rake pre_commit --verbose`
-    raise "RSpec on Rails pre_commit failed\ncd to vendor/rspec_on_rails and run rake pre_commit for more details" if $? != 0
+    `rake pre_commit --verbose`    
+    raise "RSpec on Rails pre_commit failed\n(cd to vendor/rspec_on_rails and run rake pre_commit for more details)" if $? != 0
   end
 end
 

data/bin/spec

@@ -1,4 +1,5 @@
 #!/usr/bin/env ruby
+$LOAD_PATH.push File.dirname(__FILE__) + "/../lib"
 require File.expand_path(File.dirname(__FILE__) + "/../lib/spec") # better stack traces this way
 
 $context_runner = ::Spec::Runner::OptionParser.create_context_runner(ARGV, false, STDERR, STDOUT)

data/examples/custom_formatter.rb

@@ -2,12 +2,13 @@ require 'spec/runner/formatter/base_text_formatter'
 
 # Example of a custom formatter. Run me with:
 # bin/spec examples -r examples/custom_formatter.rb -f CustomFormatter
+# bin/spec failing_examples -r examples/custom_formatter.rb -f CustomFormatter
 class CustomFormatter < Spec::Runner::Formatter::BaseTextFormatter
   def add_context(name, first)
     @output << "\n" if first
   end
   
-  def spec_failed(name, counter)
+  def spec_failed(name, counter, failure)
     @output << 'X'
   end
   

data/examples/helper_method_spec.rb

@@ -0,0 +1,12 @@
+require File.dirname(__FILE__)  + '/../lib/spec'
+
+context "Rspec" do
+  specify "should allow you to define helper methods" do
+    a_method
+    @a_method_called.should_be true
+  end
+
+  def a_method
+    @a_method_called = true
+  end
+end

data/examples/stubbing_example.rb

@@ -0,0 +1,28 @@
+require File.dirname(__FILE__) + '/../lib/spec'
+
+context "A consumer of a stub" do
+
+  specify "should be able to stub objects" do
+    obj = Object.new
+    stub(obj).method(:foobar).with {:return_value}
+    obj.foobar.should_equal :return_value
+  end
+
+end
+
+class StubbableClass
+  def self.find id
+    return :original_return
+  end
+end
+
+context "A stub" do
+  specify "should work at the class level" do
+    stub(StubbableClass).method(:find).with {:stub_return}
+    StubbableClass.find(1).should_equal :stub_return
+  end
+  
+  specify "should revert to the original after each spec" do
+    StubbableClass.find(1).should_equal :original_return
+  end
+end

data/lib/spec.rb

@@ -1,4 +1,5 @@
 require 'spec/version'
-require 'spec/api'
+require 'spec/expectations'
+require 'spec/mocks'
 require 'spec/runner'
 require 'spec/runner/kernel_ext'

data/lib/spec/expectations.rb

@@ -0,0 +1,7 @@
+require 'spec/expectations/exceptions'
+require 'spec/expectations/expectations'
+require 'spec/expectations/should_base'
+require 'spec/expectations/have_helper'
+require 'spec/expectations/should_helper'
+require 'spec/expectations/should_negator'
+require 'spec/expectations/sugar'

data/lib/spec/expectations/diff.rb

@@ -0,0 +1,56 @@
+begin
+  require 'rubygems'
+  require 'diff/lcs' #necessary to do 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
+
+module Spec
+  module Expectations
+    class ShouldBase
+      unless defined?(RSPEC_TESTING)
+        alias old_default_message default_message
+        def default_message(expectation, expected=:no_expectation_specified)
+          result = old_default_message(expectation, expected)
+          if expected.is_a?(String)
+            result << "\nDiff:" << diff_as_string(@target.to_s, expected)
+          end
+          result
+        end
+      end
+
+      # This is snagged from diff/lcs/ldiff.rb (which is a commandline tool)
+      def diff_as_string(data_old, data_new, format=:unified, context_lines=3)
+        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  
+    end
+  end
+end

data/lib/spec/expectations/exceptions.rb

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

data/lib/spec/expectations/expectations.rb

@@ -0,0 +1,19 @@
+module Spec
+  module Expectations
+    module ObjectExpectations
+      def should
+        ShouldHelper.new self
+      end
+    end
+  end
+end
+
+class Object
+  include Spec::Expectations::ObjectExpectations
+end
+
+class Numeric
+  def close?(other, precision)
+    (self - other).abs < precision
+  end
+end

data/lib/spec/expectations/have_helper.rb

@@ -0,0 +1,41 @@
+module Spec
+  module Expectations
+    class HaveHelper < ShouldBase
+
+      def initialize(target, relativity=:exactly, expected=nil)
+        @target = target
+        @expected = expected == :no ? 0 : expected
+        @at_least = (relativity == :at_least)
+        @at_most = (relativity == :at_most)
+      end
+    
+      def method_missing(sym, *args)
+        fail_with_message(build_message(sym, args)) unless as_specified?(sym, args)
+      end
+    
+      def collection(sym, args)
+        @target.send(sym, *args)
+      end
+    
+      def actual_size(collection)
+        return collection.length if collection.respond_to? :length
+        return collection.size if collection.respond_to? :size
+      end
+    
+      def build_message(sym, args)
+        message = "#{@target.inspect_for_expectation_not_met_error} should have"
+        message += " at least" if @at_least
+        message += " at most" if @at_most
+        message += " #{@expected} #{sym} (has #{actual_size(collection(sym, args))})"
+      end
+    
+      def as_specified?(sym, args)
+        return actual_size(collection(sym, args)) >= @expected if @at_least
+        return actual_size(collection(sym, args)) <= @expected if @at_most
+        return actual_size(collection(sym, args)) == @expected
+      end
+
+    end
+  end
+
+end

data/lib/spec/expectations/helper.rb

@@ -0,0 +1,4 @@
+require 'spec/expectations/helper/should_base'
+require 'spec/expectations/helper/have_helper'
+require 'spec/expectations/helper/should_helper'
+require 'spec/expectations/helper/should_negator'

data/lib/spec/expectations/should_base.rb

@@ -0,0 +1,52 @@
+class Symbol
+  def supported_by_rspec?
+    return ["<","<=",">=",">","==","=~"].include?(to_s)
+  end
+end
+class Object
+  def inspect_for_expectation_not_met_error
+    return "#{inspect}" if inspect.include? "<"
+    return "<#{inspect}>" unless inspect.include? "<"
+  end
+end
+class TrueClass; def inspect_for_expectation_not_met_error; "true" end end
+class FalseClass; def inspect_for_expectation_not_met_error; "false" end end
+class NilClass; def inspect_for_expectation_not_met_error; "nil" end end
+class Class; def inspect_for_expectation_not_met_error; "<#{name}>" end end
+class Proc; def inspect_for_expectation_not_met_error; "<Proc>" end end
+class Array; def inspect_for_expectation_not_met_error; inspect end end
+class String; def inspect_for_expectation_not_met_error; inspect end end
+class Numeric; def inspect_for_expectation_not_met_error; inspect end end
+
+module Spec
+  module Expectations
+    class ShouldBase
+
+      instance_methods.each { |m| undef_method m unless m =~ /^(__|\w)/ }
+
+      def default_message(expectation, expected=:no_expectation_specified)
+        message = "#{@target.inspect_for_expectation_not_met_error} #{expectation}"
+        if (expected != :no_expectation_specified)
+          message << " " << expected.inspect_for_expectation_not_met_error
+        end
+        message
+       end
+
+      def fail_with_message(message)
+        Kernel::raise(Spec::Expectations::ExpectationNotMetError.new(message))
+      end
+    
+      def respond_to? sym
+        return true if super
+        return true if @target.respond_to? "#{sym.to_s}?"
+      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
+        return original_sym.supported_by_rspec? ? original_sym : "#{original_sym}?"
+      end
+    end
+  end
+end

data/lib/spec/expectations/should_helper.rb

@@ -0,0 +1,93 @@
+module Spec
+  module Expectations
+    class ShouldHelper < ShouldBase
+
+      def initialize(target)
+        @target = target
+        @be_seen = false
+      end
+  
+      def not
+        ShouldNegator.new(@target)
+      end
+  
+      def have(expected_number=nil)
+        HaveHelper.new(@target, :exactly, expected_number)
+      end
+
+      def have_exactly(expected_number=nil)
+        HaveHelper.new(@target, :exactly, expected_number)
+      end
+
+      def have_at_least(expected_number=nil)
+        HaveHelper.new(@target, :at_least, expected_number)
+      end
+
+      def have_at_most(expected_number=nil)
+        HaveHelper.new(@target, :at_most, expected_number)
+      end
+
+      def satisfy(&block)
+        return if block.call(@target)
+        fail_with_message "Supplied expectation was not satisfied"
+      end
+      
+      def equal(expected)
+        fail_with_message(default_message("should equal", expected)) unless (@target == expected)
+      end
+
+      def be(expected = :___no_arg)
+        @be_seen = true
+        return self if (expected == :___no_arg)
+        return if (expected == false and @target.nil?)
+        return if (expected == true and (!@target.nil?) and (@target != false))
+        fail_with_message(default_message("should be", expected)) unless (@target.equal?(expected))
+      end
+
+      def an_instance_of expected_class
+        fail_with_message(default_message("should be an instance of", expected_class)) unless @target.instance_of? expected_class
+      end
+  
+      def a_kind_of expected_class
+        fail_with_message(default_message("should be a kind of", expected_class)) unless @target.kind_of? expected_class
+      end
+  
+      def respond_to message
+        fail_with_message(default_message("should respond to", message)) unless @target.respond_to? message
+      end
+  
+      def method_missing(original_sym, *args)
+        actual_sym = find_supported_sym(original_sym)      
+        return if @target.send(actual_sym, *args)
+        fail_with_message(default_message("should#{@be_seen ? ' be' : ''} #{original_sym}" + (args.empty? ? '' : (' ' + args.join(', ')))))
+      end
+  
+      def match(expected)
+         fail_with_message(default_message("should match", expected)) unless (@target =~ expected)
+      end
+
+      def raise(exception=Exception, message=nil)
+        begin
+          @target.call
+        rescue exception => e
+          e.message.should_equal message unless message.nil?
+          return
+        rescue => e
+          fail_with_message("#{default_message("should raise", exception)} but raised #{e.inspect}")
+        end
+        fail_with_message("#{default_message("should raise", exception)} but raised nothing")
+      end
+  
+      def throw(symbol)
+        begin
+          catch symbol do
+            @target.call
+            fail_with_message(default_message("should throw", symbol.inspect))
+          end
+        rescue NameError
+          fail_with_message(default_message("should throw", symbol.inspect))
+        end
+      end
+    end
+  end
+end