rspec 1.0.5 → 1.0.6

data/lib/spec/dsl/behaviour_factory.rb

@@ -28,8 +28,8 @@ module Spec
             behaviour_type = :default
           elsif opts[:behaviour_type]
             behaviour_type = opts[:behaviour_type]
-          elsif opts[:spec_path] =~ /spec\/(#{BEHAVIOUR_CLASSES.keys.join('|')})/
-            behaviour_type = $1.to_sym
+          elsif opts[:spec_path] =~ /spec(\\|\/)(#{BEHAVIOUR_CLASSES.keys.join('|')})/
+            behaviour_type = $2.to_sym
           else
             behaviour_type = :default
           end

data/lib/spec/dsl/composite_proc_builder.rb

@@ -7,8 +7,9 @@ module Spec
 
       def proc(&error_handler)
         parts = self
+        errors = []
         Proc.new do
-          parts.collect do |part|
+          result = parts.collect do |part|
             begin
               if part.is_a?(UnboundMethod)
                 part.bind(self).call
@@ -16,11 +17,15 @@ module Spec
                 instance_eval(&part)
               end
             rescue Exception => e
-              raise e unless error_handler
-              error_handler.call(e)
-              e
+              if error_handler
+                error_handler.call(e)
+              else
+                errors << e
+              end
             end
           end
+          raise errors.first unless errors.empty?
+          result
         end
       end
     end

data/lib/spec/dsl/configuration.rb

@@ -5,7 +5,7 @@ module Spec
       # Chooses what mock framework to use. Example:
       #
       #   Spec::Runner.configure do |config|
-      #     config.mock_with :rspec # or :mocha, or :flexmock
+      #     config.mock_with :rspec, :mocha, :flexmock, or :rr
       #   end
       #
       # To use any other mock framework, you'll have to provide
@@ -56,11 +56,27 @@ module Spec
       #   end
       #
       def include(*args)
-        included_modules.push(*args)
+        args << {} unless Hash === args.last
+        modules, options = args_and_options(*args)
+        required_behaviour_type = options[:behaviour_type]
+        required_behaviour_type = required_behaviour_type.to_sym unless required_behaviour_type.nil?
+        @modules ||= {}
+        @modules[required_behaviour_type] ||= []
+        @modules[required_behaviour_type] += modules
+      end
+
+      def modules_for(required_behaviour_type) #:nodoc:
+        @modules ||= {}
+        modules = @modules[nil] || [] # general ones
+        modules << @modules[required_behaviour_type.to_sym] unless required_behaviour_type.nil?
+        modules.uniq.compact
       end
       
-      def included_modules # :nodoc:
-        @included_modules ||= []
+      # This is just for cleanup in RSpec's own examples
+      def exclude(*modules) #:nodoc:
+        @modules.each do |behaviour_type, mods|
+          modules.each{|m| mods.delete(m)}
+        end
       end
       
       # Defines global predicate matchers. Example:

data/lib/spec/dsl/description.rb

@@ -19,6 +19,7 @@ module Spec
       def initialize(*args)
         args, @options = args_and_options(*args)
         init_behaviour_type(@options)
+        init_spec_path(@options)
         init_described_type(args)
         init_description(*args)
       end
@@ -52,6 +53,12 @@ module Spec
         end
       end
       
+      def init_spec_path(options)
+        if options.has_key?(:spec_path)
+          options[:spec_path] = File.expand_path(@options[:spec_path])
+        end
+      end
+      
       def init_description(*args)
         @description = self.class.generate_description(*args)
       end

data/lib/spec/dsl/errors.rb

@@ -0,0 +1,9 @@
+module Spec
+  module DSL
+    class ExamplePendingError < StandardError
+    end
+
+    class PendingFixedError < StandardError
+    end
+  end
+end

data/lib/spec/dsl/example.rb

@@ -3,6 +3,9 @@ require 'timeout'
 module Spec
   module DSL
     class Example
+      # The global sequence number of this example
+      attr_accessor :number
+      
       def initialize(description, options={}, &example_block)
         @from = caller(0)[3]
         @options = options
@@ -13,20 +16,20 @@ module Spec
       
       def run(reporter, before_each_block, after_each_block, dry_run, execution_context, timeout=nil)
         @dry_run = dry_run
-        reporter.example_started(description)
-        return reporter.example_finished(description) if dry_run
+        reporter.example_started(self)
+        return reporter.example_finished(self) if dry_run
 
         errors = []
         location = nil
         Timeout.timeout(timeout) do
-          before_each_ok = setup_example(execution_context, errors, &before_each_block)
+          before_each_ok = before_example(execution_context, errors, &before_each_block)
           example_ok = run_example(execution_context, errors) if before_each_ok
-          after_each_ok = teardown_example(execution_context, errors, &after_each_block)
+          after_each_ok = after_example(execution_context, errors, &after_each_block)
           location = failure_location(before_each_ok, example_ok, after_each_ok)
         end
 
         ExampleShouldRaiseHandler.new(@from, @options).handle(errors)
-        reporter.example_finished(description, errors.first, location, @example_block.nil?) if reporter
+        reporter.example_finished(self, errors.first, location, @example_block.nil?) if reporter
       end
       
       def matches?(matcher, specified_examples)
@@ -34,11 +37,16 @@ module Spec
         matcher.matches?(specified_examples)
       end
       
-    private
       def description
         @description == :__generate_description ? generated_description : @description
       end
       
+      def to_s
+        description
+      end
+
+    private
+      
       def generated_description
         return @generated_description if @generated_description
         if @dry_run
@@ -52,7 +60,7 @@ module Spec
         end
       end
       
-      def setup_example(execution_context, errors, &behaviour_before_block)
+      def before_example(execution_context, errors, &behaviour_before_block)
         setup_mocks(execution_context)
         Spec::Matchers.description_generated(@description_generated_proc)
         
@@ -62,7 +70,7 @@ module Spec
         
         execution_context.instance_eval(&behaviour_before_block) if behaviour_before_block
         return errors.empty?
-      rescue => e
+      rescue Exception => e
         @failed = true
         errors << e
         return false
@@ -79,7 +87,7 @@ module Spec
         end
       end
 
-      def teardown_example(execution_context, errors, &behaviour_after_each)
+      def after_example(execution_context, errors, &behaviour_after_each)
         execution_context.instance_eval(&behaviour_after_each) if behaviour_after_each
 
         begin
@@ -95,7 +103,7 @@ module Spec
         execution_context.instance_eval(&after_proc)
 
         return errors.empty?
-      rescue => e
+      rescue Exception => e
         @failed = true
         errors << e
         return false

data/lib/spec/matchers/have.rb

@@ -23,12 +23,12 @@ module Spec
       end
     
       def matches?(collection_owner)
-        if collection_owner.respond_to?(collection_name)
-          collection = collection_owner.send(collection_name, *@args, &@block)
+        if collection_owner.respond_to?(@collection_name)
+          collection = collection_owner.send(@collection_name, *@args, &@block)
         elsif (collection_owner.respond_to?(:length) || collection_owner.respond_to?(:size))
           collection = collection_owner
         else
-          collection_owner.send(collection_name, *@args, &@block)
+          collection_owner.send(@collection_name, *@args, &@block)
         end
         @actual = collection.size if collection.respond_to?(:size)
         @actual = collection.length if collection.respond_to?(:length)
@@ -43,39 +43,36 @@ module Spec
       end
     
       def failure_message
-        "expected #{relative_expectation} #{collection_name}, got #{@actual}"
+        "expected #{relative_expectation} #{@collection_name}, got #{@actual}"
       end
 
       def negative_failure_message
         if @relativity == :exactly
-          return "expected target not to have #{@expected} #{collection_name}, got #{@actual}"
+          return "expected target not to have #{@expected} #{@collection_name}, got #{@actual}"
         elsif @relativity == :at_most
           return <<-EOF
 Isn't life confusing enough?
 Instead of having to figure out the meaning of this:
-  should_not have_at_most(#{@expected}).#{collection_name}
+  should_not have_at_most(#{@expected}).#{@collection_name}
 We recommend that you use this instead:
-  should have_at_least(#{@expected + 1}).#{collection_name}
+  should have_at_least(#{@expected + 1}).#{@collection_name}
 EOF
         elsif @relativity == :at_least
           return <<-EOF
 Isn't life confusing enough?
 Instead of having to figure out the meaning of this:
-  should_not have_at_least(#{@expected}).#{collection_name}
+  should_not have_at_least(#{@expected}).#{@collection_name}
 We recommend that you use this instead:
-  should have_at_most(#{@expected - 1}).#{collection_name}
+  should have_at_most(#{@expected - 1}).#{@collection_name}
 EOF
         end
       end
       
       def description
-        "have #{relative_expectation} #{collection_name}"
+        "have #{relative_expectation} #{@collection_name}"
       end
       
       private
-      def collection_name
-        @collection_name
-      end
       
       def relative_expectation
         "#{relativities[@relativity]}#{@expected}"

data/lib/spec/matchers/operator_matcher.rb

@@ -52,8 +52,8 @@ module Spec
       def __delegate_method_missing_to_target(operator, expected)
         ::Spec::Matchers.generated_description = "should #{operator} #{expected.inspect}"
         return if @target.send(operator, expected)
-        return fail_with_message("expected #{expected.inspect}, got #{@target.inspect} (using #{operator})") if ['==','==='].include?(operator)
-        return fail_with_message("expected #{operator} #{expected.inspect}, got #{@target.inspect}")
+        return fail_with_message("expected: #{expected.inspect},\n     got: #{@target.inspect} (using #{operator})") if ['==','===', '=~'].include?(operator)
+        return fail_with_message("expected: #{operator} #{expected.inspect},\n     got: #{operator.gsub(/./, ' ')} #{@target.inspect}")
       end
 
     end
@@ -63,7 +63,7 @@ module Spec
       def __delegate_method_missing_to_target(operator, expected)
         ::Spec::Matchers.generated_description = "should not #{operator} #{expected.inspect}"
         return unless @target.send(operator, expected)
-        return fail_with_message("expected not #{operator} #{expected.inspect}, got #{@target.inspect}")
+        return fail_with_message("expected not: #{operator} #{expected.inspect},\n         got: #{operator.gsub(/./, ' ')} #{@target.inspect}")
       end
 
     end

data/lib/spec/matchers/raise_error.rb

@@ -2,9 +2,14 @@ module Spec
   module Matchers
     
     class RaiseError #:nodoc:
-      def initialize(exception=Exception, message=nil)
-        @expected_error = exception
-        @expected_message = message
+      def initialize(error_or_message=Exception, message=nil)
+        if String === error_or_message
+          @expected_error = Exception
+          @expected_message = error_or_message
+        else
+          @expected_error = error_or_message
+          @expected_message = message
+        end
       end
       
       def matches?(proc)

data/lib/spec/mocks/error_generator.rb

@@ -44,7 +44,7 @@ module Spec
       
       private
       def intro
-        @name ? "Mock '#{@name}'" : @target.to_s
+        @name ? "Mock '#{@name}'" : @target.inspect
       end
       
       def __raise(message)

data/lib/spec/mocks/message_expectation.rb

@@ -42,6 +42,17 @@ module Spec
         @return_block = block_given? ? return_block : lambda { value }
       end
       
+      # :call-seq:
+      #   and_raise()
+      #   and_raise(Exception) #any exception class
+      #   and_raise(exception) #any exception object
+      #
+      # == Warning
+      #
+      # When you pass an exception class, the MessageExpectation will
+      # raise an instance of it, creating it with +new+. If the exception
+      # class initializer requires any parameters, you must pass in an
+      # instance and not the class.
       def and_raise(exception=Exception)
         @exception_to_raise = exception
       end

data/lib/spec/mocks/methods.rb

@@ -2,19 +2,19 @@ module Spec
   module Mocks
     module Methods
       def should_receive(sym, opts={}, &block)
-        __mock_proxy.add_message_expectation(opts[:expected_from] || caller(1)[0], sym, opts, &block)
+        __mock_proxy.add_message_expectation(opts[:expected_from] || caller(1)[0], sym.to_sym, opts, &block)
       end
 
       def should_not_receive(sym, &block)
-        __mock_proxy.add_negative_message_expectation(caller(1)[0], sym, &block)
+        __mock_proxy.add_negative_message_expectation(caller(1)[0], sym.to_sym, &block)
       end
       
       def stub!(sym)
-        __mock_proxy.add_stub(caller(1)[0], sym)
+        __mock_proxy.add_stub(caller(1)[0], sym.to_sym)
       end
       
       def received_message?(sym, *args, &block) #:nodoc:
-        __mock_proxy.received_message?(sym, *args, &block)
+        __mock_proxy.received_message?(sym.to_sym, *args, &block)
       end
       
       def rspec_verify #:nodoc:
@@ -28,7 +28,11 @@ module Spec
     private
 
       def __mock_proxy
-        @mock_proxy ||= Proxy.new(self, @name, @options)
+        if Mock === self
+          @mock_proxy ||= Proxy.new(self, @name, @options)
+        else
+          @mock_proxy ||= Proxy.new(self, self.class.name)
+        end
       end
     end
   end

data/lib/spec/mocks/proxy.rb

@@ -22,19 +22,19 @@ module Spec
       end
 
       def add_message_expectation(expected_from, sym, opts={}, &block)
-        __add expected_from, sym, block
+        __add sym, block
         @expectations << MessageExpectation.new(@error_generator, @expectation_ordering, expected_from, sym, block_given? ? block : nil, 1, opts)
         @expectations.last
       end
 
       def add_negative_message_expectation(expected_from, sym, &block)
-        __add expected_from, sym, block
+        __add sym, block
         @expectations << NegativeMessageExpectation.new(@error_generator, @expectation_ordering, expected_from, sym, block_given? ? block : nil)
         @expectations.last
       end
 
       def add_stub(expected_from, sym)
-        __add expected_from, sym, nil
+        __add sym, nil
         @stubs.unshift MethodStub.new(@error_generator, @expectation_ordering, expected_from, sym, nil)
         @stubs.first
       end
@@ -85,17 +85,17 @@ module Spec
       
     private
 
-      def __add(expected_from, sym, block)
-        $rspec_mocks.add(@target)
+      def __add(sym, block)
+        $rspec_mocks.add(@target) unless $rspec_mocks.nil?
         define_expected_method(sym)
       end
       
       def define_expected_method(sym)
         if target_responds_to?(sym) && !@proxied_methods.include?(sym)
+          metaclass.__send__(:alias_method, munge(sym), sym) if metaclass.instance_methods.include?(sym.to_s)
           @proxied_methods << sym
-          metaclass.__send__(:alias_method, munge(sym), sym)
         end
-
+        
         metaclass_eval(<<-EOF, __FILE__, __LINE__)
           def #{sym}(*args, &block)
             __mock_proxy.message_received :#{sym}, *args, &block
@@ -141,8 +141,12 @@ module Spec
 
       def reset_proxied_methods
         @proxied_methods.each do |sym|
-          metaclass.__send__(:alias_method, sym, munge(sym))
-          metaclass.__send__(:undef_method, munge(sym))
+          if metaclass.instance_methods.include?(munge(sym).to_s)
+            metaclass.__send__(:alias_method, sym, munge(sym))
+            metaclass.__send__(:undef_method, munge(sym))
+          else
+            metaclass.__send__(:undef_method, sym)
+          end
         end
       end
 

data/lib/spec/rake/spectask.rb

@@ -21,7 +21,38 @@ module Spec
     #
     #   rake spec
     #
+    # If rake is invoked with a "SPEC=filename" command line option,
+    # then the list of spec files will be overridden to include only the
+    # filename specified on the command line.  This provides an easy way
+    # to run just one spec.
+    #
+    # If rake is invoked with a "SPEC_OPTS=options" command line option,
+    # then the given options will override the value of the +spec_opts+
+    # attribute.
+    #
+    # If rake is invoked with a "RCOV_OPTS=options" command line option,
+    # then the given options will override the value of the +rcov_opts+
+    # attribute.
+    #
+    # Examples:
+    #
+    #   rake spec                                      # run specs normally
+    #   rake spec SPEC=just_one_file.rb                # run just one spec file.
+    #   rake spec SPEC_OPTS="--diff"                   # enable diffing
+    #   rake spec RCOV_OPTS="--aggregate myfile.txt"   # see rcov --help for details
+    #
+    # Each attribute of this task may be a proc. This allows for lazy evaluation,
+    # which is sometimes handy if you want to defer the evaluation of an attribute value
+    # until the task is run (as opposed to when it is defined).
     class SpecTask < ::Rake::TaskLib
+      class << self
+        def attr_accessor(*names)
+          super(*names)
+          names.each do |name|
+            module_eval "def #{name}() evaluate(@#{name}) end" # Allows use of procs
+          end
+        end
+      end
 
       # Name of spec task. (default is :spec)
       attr_accessor :name
@@ -35,21 +66,20 @@ module Spec
       attr_accessor :warning
 
       # Glob pattern to match spec files. (default is 'spec/**/*_spec.rb')
+      # Setting the SPEC environment variable overrides this.
       attr_accessor :pattern
 
       # Array of commandline options to pass to RSpec. Defaults to [].
+      # Setting the SPEC_OPTS environment variable overrides this.
       attr_accessor :spec_opts
 
-      # Where RSpec's output is written. Defaults to STDOUT.
-      # DEPRECATED. Use --format FORMAT:WHERE in spec_opts.
-      attr_accessor :out
-
       # Whether or not to use RCov (default is false)
       # See http://eigenclass.org/hiki.rb?rcov
       attr_accessor :rcov
       
       # Array of commandline options to pass to RCov. Defaults to ['--exclude', 'lib\/spec,bin\/spec'].
       # Ignored if rcov=false
+      # Setting the RCOV_OPTS environment variable overrides this.
       attr_accessor :rcov_opts
 
       # Directory where the RCov report is written. Defaults to "coverage"
@@ -63,18 +93,21 @@ module Spec
       # Defaults to true.
       attr_accessor :fail_on_error
 
-      # A message to print to stdout when there are failures.
+      # A message to print to stderr when there are failures.
       attr_accessor :failure_message
 
+      # Where RSpec's output is written. Defaults to STDOUT.
+      # DEPRECATED. Use --format FORMAT:WHERE in spec_opts.
+      attr_accessor :out
+
       # Explicitly define the list of spec files to be included in a
-      # spec.  +list+ is expected to be an array of file names (a
+      # spec.  +spec_files+ is expected to be an array of file names (a
       # FileList is acceptable).  If both +pattern+ and +spec_files+ are
       # used, then the list of spec files is the union of the two.
-      def spec_files=(list)
-        @spec_files = list
-      end
+      # Setting the SPEC environment variable overrides this.
+      attr_accessor :spec_files
 
-      # Create a specing task.
+      # Defines a new task, using the name +name+.
       def initialize(name=:spec)
         @name = name
         @libs = [File.expand_path(File.dirname(__FILE__) + '/../../../lib')]
@@ -83,62 +116,63 @@ module Spec
         @spec_opts = []
         @warning = false
         @ruby_opts = []
-        @out = nil
         @fail_on_error = true
         @rcov = false
         @rcov_opts = ['--exclude', 'lib\/spec,bin\/spec,config\/boot.rb']
         @rcov_dir = "coverage"
 
         yield self if block_given?
-        @pattern = 'spec/**/*_spec.rb' if @pattern.nil? && @spec_files.nil?
+        @pattern = 'spec/**/*_spec.rb' if pattern.nil? && spec_files.nil?
         define
       end
 
-      def define
+      def define # :nodoc:
         spec_script = File.expand_path(File.dirname(__FILE__) + '/../../../bin/spec')
 
-        lib_path = @libs.join(File::PATH_SEPARATOR)
+        lib_path = libs.join(File::PATH_SEPARATOR)
         actual_name = Hash === name ? name.keys.first : name
         unless ::Rake.application.last_comment
-          desc "Run RSpec for #{actual_name}" + (@rcov ? " using RCov" : "")
+          desc "Run specs" + (rcov ? " using RCov" : "")
         end
-        task @name do
-          RakeFileUtils.verbose(@verbose) do
+        task name do
+          RakeFileUtils.verbose(verbose) do
             unless spec_file_list.empty?
-              # ruby [ruby_opts] -Ilib -S rcov [rcov_opts] bin/spec -- [spec_opts] examples
+              # ruby [ruby_opts] -Ilib -S rcov [rcov_opts] bin/spec -- examples [spec_opts]
               # or
-              # ruby [ruby_opts] -Ilib bin/spec [spec_opts] examples
+              # ruby [ruby_opts] -Ilib bin/spec examples [spec_opts]
               cmd = "ruby "
 
-              ruby_opts = @ruby_opts.clone
-              ruby_opts << "-I\"#{lib_path}\""
-              ruby_opts << "-S rcov" if @rcov
-              ruby_opts << "-w" if @warning
-              cmd << ruby_opts.join(" ")
+              rb_opts = ruby_opts.clone
+              rb_opts << "-I\"#{lib_path}\""
+              rb_opts << "-S rcov" if rcov
+              rb_opts << "-w" if warning
+              cmd << rb_opts.join(" ")
               cmd << " "
               cmd << rcov_option_list
-              cmd << %[ -o "#{@rcov_dir}" ] if @rcov
+              cmd << %[ -o "#{rcov_dir}" ] if rcov
               cmd << %Q|"#{spec_script}"|
               cmd << " "
-              cmd << "-- " if @rcov
+              cmd << "-- " if rcov
               cmd << spec_file_list.collect { |fn| %["#{fn}"] }.join(' ')
               cmd << " "
               cmd << spec_option_list
-              cmd << " "
-              cmd << %Q| > "#{@out}"| if @out
-
+              if out
+                cmd << " "
+                cmd << %Q| > "#{out}"|
+                STDERR.puts "The Spec::Rake::SpecTask#out attribute is DEPRECATED and will be removed in a future version. Use --format FORMAT:WHERE instead."
+              end
               unless system(cmd)
-               puts @failure_message if @failure_message
-               raise("Command #{cmd} failed") if @fail_on_error
+                STDERR.puts failure_message if failure_message
+                raise("Command #{cmd} failed") if fail_on_error
               end
             end
           end
         end
 
-        if @rcov
+        if rcov
           desc "Remove rcov products for #{actual_name}"
           task paste("clobber_", actual_name) do
-            rm_r @rcov_dir rescue nil
+            rm_r rcov_dir rescue nil
           end
 
           clobber_task = paste("clobber_", actual_name)
@@ -150,12 +184,20 @@ module Spec
       end
 
       def rcov_option_list # :nodoc:
-        return "" unless @rcov
-        ENV['RCOVOPTS'] || @rcov_opts.join(" ") || ""
+        return "" unless rcov
+        ENV['RCOV_OPTS'] || rcov_opts.join(" ") || ""
       end
 
       def spec_option_list # :nodoc:
-        ENV['RSPECOPTS'] || @spec_opts.join(" ") || ""
+        STDERR.puts "RSPECOPTS is DEPRECATED and will be removed in a future version. Use SPEC_OPTS instead." if ENV['RSPECOPTS']
+        ENV['SPEC_OPTS'] || ENV['RSPECOPTS'] || spec_opts.join(" ") || ""
+      end
+      
+      def evaluate(o) # :nodoc:
+        case o
+          when Proc then o.call
+          else o
+        end
       end
 
       def spec_file_list # :nodoc:
@@ -163,8 +205,8 @@ module Spec
           FileList[ ENV['SPEC'] ]
         else
           result = []
-          result += @spec_files.to_a if @spec_files
-          result += FileList[ @pattern ].to_a if @pattern
+          result += spec_files.to_a if spec_files
+          result += FileList[ pattern ].to_a if pattern
           FileList[result]
         end
       end