rspec 0.7.3 → 0.7.4

data/CHANGES

@@ -1,6 +1,28 @@
 = RSpec Changelog
 
-== Version 0.7.3 (In SVN)
+== Version 0.7.4
+
+This release features a complete redesign of the reports generated with --format html.
+As usual there are many bug fixes - mostly related to spec/rails.
+
+* Applied [#7010] Fixes :spacer_template does not work w/ view spec (patch from Shintaro Kakutani)
+* Applied [#6798] ensure two ':' in the first backtrace line for Emacs's 'next-error' command (patch from Kouhei Sutou)
+* Added Much nicer reports to generated website
+* Much nicer reports with --format --html (patch from Luke Redpath)
+* Applied [#6959] Calls to render and redirect in controllers should return true
+* Fixed [#6981] helper method is not available in partial template.
+* Added [#6978] mock should tell you the expected and actual args when receiving the right message with the wrong args
+* Added the possibility to tweak the output of the HtmlFormatter (by overriding extra_failure_content).
+* Fixed [#6936] View specs don't include ApplicationHelper by default
+* Fixed [#6903] Rendering a partial in a view makes the view spec blow up
+* Added callback library from Brian Takita
+* Added [#6925] support controller.should_render :action_name
+* Fixed [#6884] intermittent errors related to method binding
+* Fixed [#6870] rspec on edge rails spec:controller fixture loading fails
+* Using obj.inspect for all messages
+* Improved performance by getting rid of instance_exec (instance_eval is good enough because we never need to pass it args)
+
+== Version 0.7.3
 
 Almost normal bug fix/new feature release.
 

data/Rakefile

@@ -21,11 +21,9 @@ PKG_FILES = FileList[
   'lib/**/*.rb', 
   'test/**/*.rb', 
   'examples/**/*',
-  'vendor/watir/*.rb',
-  'vendor/watir/*.txt',
-  'vendor/selenium/*.rb',
-  'vendor/selenium/*.patch',
-  'vendor/selenium/*.txt'
+  'vendor/web_spec/**/*.rb',
+  'vendor/web_spec/**/*.txt',
+  'vendor/web_spec/**/*.patch'
 ]
 
 task :default => [:spec, :verify_rcov]
@@ -33,12 +31,18 @@ task :default => [:spec, :verify_rcov]
 desc "Run all specs"
 Spec::Rake::SpecTask.new do |t|
   t.spec_files = FileList['spec/**/*_spec.rb', 'vendor/RSpec.tmbundle/Support/spec/*_spec.rb']
-  t.spec_opts = ['--diff','--color','--backtrace']
+  t.spec_opts = ['--color','--backtrace']
   t.rcov = true
   t.rcov_dir = 'doc/output/coverage'
   t.rcov_opts = ['--exclude', 'spec\/spec,bin\/spec,bin\/drbspec,examples']
 end
 
+desc "Run all specs and store html output in doc/output/report.html"
+Spec::Rake::SpecTask.new('spec_html') do |t|
+  t.spec_files = FileList['spec/**/*_spec.rb', 'vendor/RSpec.tmbundle/Support/spec/*_spec.rb']
+  t.spec_opts = ['--diff','--format html','--backtrace','--out doc/output/report.html']
+end
+
 desc "Run all failing examples"
 Spec::Rake::SpecTask.new('failing_examples') do |t|
   t.spec_files = FileList['failing_examples/**/*_spec.rb']
@@ -203,7 +207,7 @@ task :commit_ok do |t|
 end
 
 desc "Build the website, but do not publish it"
-task :website => [:clobber, :verify_rcov, :webgen, :failing_examples_with_html, :spec, :examples_specdoc, :rdoc]
+task :website => [:clobber, :verify_rcov, :spec_html, :webgen, :failing_examples_with_html, :examples_specdoc, :rdoc]
 
 task :verify_user do
   raise "RUBYFORGE_USER environment variable not set!" unless ENV['RUBYFORGE_USER']
@@ -244,7 +248,6 @@ task :publish_packages => [:verify_user, :package] do
   Rake::XForge::Release.new(MetaProject::Project::XForge::RubyForge.new(PKG_NAME)) do |xf|
     # Never hardcode user name and password in the Rakefile!
     xf.user_name = ENV['RUBYFORGE_USER']
-    xf.password = ENV['RUBYFORGE_PASSWORD']
     xf.files = release_files.to_a
     xf.release_name = "RSpec #{PKG_VERSION}"
   end
@@ -257,6 +260,5 @@ task :publish_news => [:verify_user] do
   Rake::XForge::NewsPublisher.new(MetaProject::Project::XForge::RubyForge.new(PKG_NAME)) do |news|
     # Never hardcode user name and password in the Rakefile!
     news.user_name = ENV['RUBYFORGE_USER']
-    news.password = ENV['RUBYFORGE_PASSWORD']
   end
 end

data/bin/spec

@@ -1,5 +1,4 @@
 #!/usr/bin/env ruby
-# require File.expand_path(File.dirname(__FILE__) + "/../lib/spec")
 $LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__) + "/../lib"))
 require 'spec'
 ::Spec::Runner::CommandLine.run(ARGV, STDERR, STDOUT, true, true)

data/lib/spec.rb

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

data/lib/spec/callback.rb

@@ -0,0 +1,3 @@
+require 'spec/callback/callback_container'
+require 'spec/callback/extensions/module'
+require 'spec/callback/extensions/object'

data/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/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/lib/spec/callback/extensions/object.rb

@@ -0,0 +1,33 @@
+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
+
+    # The CallbackContainer for this object.
+    def callbacks
+      @callbacks ||= CallbackContainer.new
+    end
+  end
+end
+
+class Object
+  include Callback::InstanceMethods
+end

data/lib/spec/expectations/diff.rb

@@ -9,23 +9,19 @@ module Spec
           @@differ = differ
         end
 
-        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 != :no_expectation_specified
-              if expected.is_a?(String)
-                result << "\nDiff:" << @@differ.diff_as_string(@target.to_s, expected)
-              elsif ! @target.is_a? Proc
-                result << "\nDiff:" << @@differ.diff_as_object(@target,expected)
-              end
+        alias old_default_message default_message
+        def default_message(expectation, expected=:no_expectation_specified)
+          result = old_default_message(expectation, expected)
+          if expected != :no_expectation_specified
+            if expected.is_a?(String)
+              result << "\nDiff:" << @@differ.diff_as_string(@target.to_s, expected) unless @@differ.nil?
+            elsif ! @target.is_a? Proc
+              result << "\nDiff:" << @@differ.diff_as_object(@target, expected) unless @@differ.nil?
             end
-
-            result
           end
-        end
 
+          result
+        end
       end
     end
   end

data/lib/spec/expectations/extensions.rb

@@ -1,4 +1,2 @@
 require 'spec/expectations/extensions/object'
-require 'spec/expectations/extensions/numeric'
-require 'spec/expectations/extensions/symbol'
-require 'spec/expectations/extensions/inspect_for_expectation_not_met_error'
+require 'spec/expectations/extensions/numeric'

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

@@ -1,5 +1,10 @@
 class Numeric
-  def close?(other, precision)
+  def should_be_close(other, precision)
+    should.be._close_for_rspec(other, precision)
+  end
+  
+  private
+  def _close_for_rspec?(other, precision)
     (self - other).abs < precision
   end
 end

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

@@ -1,49 +1,103 @@
 module Spec
   module Expectations
+    # rspec adds all of these expectations to every Object (and,
+    # implicitly, every Class).
     module ObjectExpectations
+      
+      # Supports the following expectations:
+      #   receiver.should == expected #any value
+      #     Passes if (target == expected)
+      #
+      #   target.should =~ expected #a regexp
+      #     Passes if (target =~ expected), where expected
+      #     is a Regexp.
+      #
+      # NOTE that this does NOT support target.should != expected.
+      # Instead, use target.should_not == expected
       def should
         Should::Should.new self
       end
 
+      # Supports the following expectations:
+      #   target.should_not == expected #any value
+      #     Passes unless (target == expected)
+      #
+      #   target.should_not =~ expected #a regexp
+      #     Passes unless (target =~ expected), where expected
+      #     is a Regexp.
       def should_not
         should.not
       end
 
-      def should_equal(arg)
-        should.equal(arg)
+      # Passes if target.equal?(expected)
+      def should_equal(expected)
+        should.equal(expected)
       end
 
-      def should_not_equal(arg)
-        should.not.equal(arg)
+      # Passes unless target.equal?(expected)
+      def should_not_equal(expected)
+        should.not.equal(expected)
       end
 
-      def should_eql(arg)
-        should.eql(arg)
+      # Passes if target.eql?(expected)
+      def should_eql(expected)
+        should.eql(expected)
       end
 
-      def should_not_eql(arg)
-        should.not.eql(arg)
+      # Passes unless target.eql?(expected)
+      def should_not_eql(expected)
+        should.not.eql(expected)
       end
 
-      def should_have(arg)
-        should.have(arg)
+      # Specify that the receiver should have a
+      # specified number of items in a named collection. For example:
+      #
+      #   team.should_have(40).players
+      #
+      # Passes if team.players.size == 40.
+      #
+      # Works for collections with size() and/or length() methods.
+      def should_have(expected)
+        should.have(expected)
       end
       alias_method :should_have_exactly, :should_have
 
-      def should_have_at_least(arg)
-        should.have.at_least(arg)
+      # Specify that the receiver should have at least a
+      # specified number of items in a named collection. For example:
+      #
+      #   team.should_have_at_least(10).players
+      #
+      # Passes if team.players.size == 10 (or more)
+      #
+      # Fails if team.players.size == 9 (or less)
+      #
+      # Works for collections with size() and/or length() methods.
+      def should_have_at_least(expected)
+        should.have.at_least(expected)
       end
 
-      def should_have_at_most(arg)
-        should.have.at_most(arg)
+      # Specify that the receiver should have at most a
+      # specified number of items in a named collection. For example:
+      #
+      #   team.should_have_at_most(10).players
+      #
+      # Passes if team.players.size == 10 (or less)
+      #
+      # Fails if team.players.size == 11 (or more)
+      #
+      # Works for collections with size() and/or length() methods.
+      def should_have_at_most(expected)
+        should.have.at_most(expected)
       end
 
-      def should_include(arg)
-        should.include(arg)
+      # Passes if receiver.include?(expected)
+      def should_include(expected)
+        should.include(expected)
       end
 
-      def should_not_include(arg)
-        should.not.include(arg)
+      # Passes unless receiver.include?(expected)
+      def should_not_include(expected)
+        should.not.include(expected)
       end
       
       def should_change(receiver, message)

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

@@ -2,13 +2,35 @@ module Spec
   module Expectations
     module Should
       class Base
-
-        instance_methods.each { |m| undef_method m unless m =~ /^(__|\w)/ }
+        
+        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
+        
+        def >=(expected)
+          __delegate_method_missing_to_target ">=", ">=", expected
+        end
+        
+        def >(expected)
+          __delegate_method_missing_to_target ">", ">", expected
+        end
 
         def default_message(expectation, expected=:no_expectation_specified)
-          message = "#{@target.inspect_for_expectation_not_met_error} #{expectation}"
+          message = "#{@target.inspect} #{expectation}"
           if (expected != :no_expectation_specified)
-            message << " " << expected.inspect_for_expectation_not_met_error
+            message << " " << expected.inspect
           end
           message
          end
@@ -21,7 +43,7 @@ module Spec
           ["#{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}?"
+          return ["<","<=",">=",">","==","=~"].include?(original_sym) ? original_sym : "#{original_sym}?"
         end
 
         def method_missing(original_sym, *args, &block)