rspec 0.7.5.1 → 0.8.0

data/lib/spec/mocks/mock.rb

@@ -1,10 +1,10 @@
 module Spec
   module Mocks
     class Mock
-      include MockMethods
+      include Methods
 
       # Creates a new mock with a +name+ (that will be used in error messages only)
-      # Options:
+      # == Options:
       # * <tt>:null_object</tt> - if true, the mock object acts as a forgiving null object allowing any message to be sent to it.
       def initialize(name, options={})
         @name = name

data/lib/spec/mocks/mock_handler.rb

@@ -1,6 +1,11 @@
 module Spec
   module Mocks
     class MockHandler
+      DEFAULT_OPTIONS = {
+        :null_object => false,
+        :auto_verify => true
+      }
+
       def initialize(target, name, options={})
         @target = target
         @name = name
@@ -9,15 +14,10 @@ module Spec
         @expectations = []
         @messages_received = []
         @stubs = []
-        @proxied_methods = {}
+        @proxied_methods = []
         @options = options ? DEFAULT_OPTIONS.dup.merge(options) : DEFAULT_OPTIONS
       end
 
-      DEFAULT_OPTIONS = {
-        :null_object => false,
-        :auto_verify => true
-      }
-
       def null_object?
         @options[:null_object]
       end
@@ -36,26 +36,8 @@ module Spec
 
       def add_stub(expected_from, sym)
         __add expected_from, sym, nil
-        @stubs << MethodStub.new(@error_generator, @expectation_ordering, expected_from, sym, nil)
-        @stubs.last
-      end
-
-      def __add expected_from, sym, block
-        current_spec = Runner::Specification.current
-        current_spec.after_teardown {verify} if current_spec && @options[:auto_verify]
-        define_expected_method(sym)
-      end
-
-      def define_expected_method(sym)
-        if @target.respond_to?(sym) && !@proxied_methods[sym]
-          @proxied_methods[sym] = @target.method(sym)
-        end
-
-        metaclass_eval %-
-          def #{sym}(*args, &block)
-            __mock_handler.message_received :#{sym}, *args, &block
-          end
-        -
+        @stubs.unshift MethodStub.new(@error_generator, @expectation_ordering, expected_from, sym, nil)
+        @stubs.first
       end
 
       def verify #:nodoc:
@@ -73,43 +55,98 @@ module Spec
         clear_proxied_methods
       end
 
-      def verify_expectations
-        @expectations.each do |expectation|
-          expectation.verify_messages_received
-        end
+      def received_message?(sym, *args, &block)
+        return true if @messages_received.find {|array| array == [sym, args, block]}
+        return false
       end
 
-      def reset_proxied_methods
-        @proxied_methods.each do |method_name, method_obj|
-          define_instance_method(method_name, method_obj)
+      def has_negative_expectation?(sym)
+        @expectations.detect {|expectation| expectation.negative_expectation_for?(sym)}
+      end
+
+      def message_received(sym, *args, &block)
+        if expectation = find_matching_expectation(sym, *args)
+          expectation.invoke(args, block)
+        elsif stub = find_matching_method_stub(sym)
+          stub.invoke([], block)
+        elsif expectation = find_almost_matching_expectation(sym, *args)
+          raise_unexpected_message_args_error(expectation, *args) unless has_negative_expectation?(sym) unless null_object?
+        else
+          @target.send :method_missing, sym, *args, &block
         end
       end
 
-      def define_instance_method(method_name, method_obj)
-        (class << @target; self; end).class_eval do
-          define_method method_name, &method_obj
+      def raise_unexpected_message_args_error(expectation, *args)
+        @error_generator.raise_unexpected_message_args_error expectation, *args
+      end
+
+      def raise_unexpected_message_error(sym, *args)
+        @error_generator.raise_unexpected_message_error sym, *args
+      end
+      
+      private
+
+      def __add(expected_from, sym, block)
+        # TODO - this is the only reference in the 'spec/mocks' to the Runner
+        current_spec = Runner::Specification.current
+        current_spec.after_teardown {verify} if current_spec && @options[:auto_verify]
+        define_expected_method(sym)
+      end
+      
+      def define_expected_method(sym)
+        if target_responds_to?(sym) && !@proxied_methods.include?(sym)
+          @proxied_methods << sym
+          metaclass.__send__(:alias_method, munge(sym), sym)
         end
+
+        metaclass_eval(<<-EOF, __FILE__, __LINE__)
+          def #{sym}(*args, &block)
+            __mock_handler.message_received :#{sym}, *args, &block
+          end
+        EOF
       end
 
-      def clear_expectations #:nodoc:
+      def target_responds_to?(sym)
+        return @target.send(munge(:respond_to?),sym) if @already_proxied_respond_to
+        return @already_proxied_respond_to = true if sym == :respond_to?
+        return @target.respond_to?(sym)
+      end
+
+      def munge(sym)
+        "proxied_by_rspec__#{sym.to_s}".to_sym
+      end
+
+      def clear_expectations
         @expectations.clear
       end
 
-      def clear_stubs #:nodoc:
+      def clear_stubs
         @stubs.clear
       end
 
-      def clear_proxied_methods #:nodoc:
+      def clear_proxied_methods
         @proxied_methods.clear
       end
 
-      def metaclass_eval(str)
-        (class << @target; self; end).class_eval str
+      def metaclass_eval(str, filename, lineno)
+        metaclass.class_eval(str, filename, lineno)
+      end
+      
+      def metaclass
+        (class << @target; self; end)
       end
 
-      def received_message?(sym, *args, &block)
-        return true if @messages_received.find {|array| array == [sym, args, block]}
-        return false
+      def verify_expectations
+        @expectations.each do |expectation|
+          expectation.verify_messages_received
+        end
+      end
+
+      def reset_proxied_methods
+        @proxied_methods.each do |sym|
+          metaclass.__send__(:alias_method, sym, munge(sym))
+          metaclass.__send__(:undef_method, munge(sym))
+        end
       end
 
       def find_matching_expectation(sym, *args)
@@ -124,30 +161,6 @@ module Spec
         @stubs.find {|stub| stub.matches(sym, [])}
       end
 
-      def has_negative_expectation?(sym)
-        @expectations.detect {|expectation| expectation.negative_expectation_for?(sym)}
-      end
-
-      def message_received(sym, *args, &block)
-        if expectation = find_matching_expectation(sym, *args)
-          expectation.invoke(args, block)
-        elsif stub = find_matching_method_stub(sym)
-          stub.invoke([], block)
-        elsif expectation = find_almost_matching_expectation(sym, *args)
-          raise_unexpected_message_args_error(expectation, *args) unless has_negative_expectation?(sym) unless null_object?
-        else
-          @target.send :method_missing, sym, *args, &block
-        end
-      end
-
-      def raise_unexpected_message_args_error(expectation, *args)
-        @error_generator.raise_unexpected_message_args_error expectation, *args
-      end
-
-      def raise_unexpected_message_error(sym, *args)
-        @error_generator.raise_unexpected_message_error sym, *args
-      end
-
     end
   end
 end

data/lib/spec/rake/spectask.rb

@@ -34,7 +34,7 @@ module Spec
       # E.g. warning=true implies "ruby -w" used to run the specs. Defaults to false.
       attr_accessor :warning
 
-      # Glob pattern to match spec files. (default is 'spec/spec*.rb')
+      # Glob pattern to match spec files. (default is 'spec/**/*_spec.rb')
       attr_accessor :pattern
 
       # Array of commandline options to pass to RSpec. Defaults to [].
@@ -64,11 +64,6 @@ module Spec
 
       # A message to print to stdout when there are failures.
       attr_accessor :failure_message
-      
-      # Whether or not to run specs via DRb. Setting this to true may
-      # run specs faster, especially in a Rails environment.
-      # Defaults to false
-      attr_accessor :drb
 
       # Explicitly define the list of spec files to be included in a
       # spec.  +list+ is expected to be an array of file names (a
@@ -90,7 +85,7 @@ module Spec
         @out = nil
         @fail_on_error = true
         @rcov = false
-        @rcov_opts = ['--exclude', 'lib\/spec,bin\/spec']
+        @rcov_opts = ['--exclude', 'lib\/spec,bin\/spec,config\/boot.rb']
         @rcov_dir = "coverage"
 
         yield self if block_given?
@@ -99,7 +94,7 @@ module Spec
       end
 
       def define
-        spec_script = File.expand_path(File.dirname(__FILE__) + '/../../../bin/' + (drb ? 'drbspec' : 'spec'))
+        spec_script = File.expand_path(File.dirname(__FILE__) + '/../../../bin/spec')
 
         lib_path = @libs.join(File::PATH_SEPARATOR)
         actual_name = Hash === name ? name.keys.first : name
@@ -113,9 +108,9 @@ module Spec
             ruby_opts.push( "-S rcov" ) if @rcov
             ruby_opts.push( "-w" ) if @warning
 
-            redirect = @out.nil? ? "" : " > #{@out}"
+            redirect = @out.nil? ? "" : " > \"#{@out}\""
 
-            unless file_list.empty?
+            unless spec_file_list.empty?
               # ruby [ruby_opts] -Ilib -S rcov [rcov_opts] bin/spec -- [spec_opts] examples
               # or
               # ruby [ruby_opts] -Ilib bin/spec [spec_opts] examples
@@ -126,7 +121,7 @@ module Spec
                   (@rcov ? %[ -o "#{@rcov_dir}" ] : "") + 
                   '"' + spec_script + '"' + " " +
                   (@rcov ? "-- " : "") + 
-                  file_list.collect { |fn| %["#{fn}"] }.join(' ') + " " + 
+                  spec_file_list.collect { |fn| %["#{fn}"] }.join(' ') + " " + 
                   spec_option_list + " " +
                   redirect
                 )
@@ -161,7 +156,7 @@ module Spec
         ENV['RSPECOPTS'] || @spec_opts.join(" ") || ""
       end
 
-      def file_list # :nodoc:
+      def spec_file_list # :nodoc:
         if ENV['SPEC']
           FileList[ ENV['SPEC'] ]
         else

data/lib/spec/rake/verify_rcov.rb

@@ -33,7 +33,7 @@ module RCov
       task @name do
         total_coverage = nil
         File.open(index_html).each_line do |line|
-          if line =~ /<tt>(\d+\.\d+)%<\/tt>&nbsp;<\/td>/
+          if line =~ /<tt.*>(\d+\.\d+)%<\/tt>&nbsp;<\/td>/
             total_coverage = eval($1)
             break
           end

data/lib/spec/runner.rb

@@ -10,6 +10,123 @@ require 'spec/runner/drb_command_line'
 require 'spec/runner/backtrace_tweaker'
 require 'spec/runner/reporter'
 require 'spec/runner/spec_matcher'
+require 'spec/runner/extensions/object'
 require 'spec/runner/extensions/kernel'
 require 'spec/runner/spec_should_raise_handler'
 require 'spec/runner/spec_parser'
+
+module Spec
+  # == Contexts and Specifications
+  # 
+  # Rather than expressing examples in classes, RSpec uses a custom domain specific language to express
+  # examples using contexts and specifications.
+  # 
+  # A context is the equivalent of a fixture in xUnit-speak. It is a metaphor for the context
+  # in which you will run your executable example - a set of known objects in a known starting state.
+  # 
+  #   context "A new account" do
+  # 
+  #     setup do
+  #       @account = Account.new
+  #     end
+  # 
+  #     specify "should have a balance of $0" do
+  #       @account.balance.should_eql Money.new(0, :dollars)
+  #     end
+  # 
+  #   end
+  # 
+  # We use the setup block to set up the context (given), and then the specify method to
+  # hold the example code that expresses the event (when) and the expected outcome (then).
+  # 
+  # == Helper Methods
+  # 
+  # A primary goal of RSpec is to keep the examples clear. We therefore prefer
+  # less indirection than you might see in xUnit examples and in well factored, DRY production code. We feel
+  # that duplication is OK if removing it makes it harder to understand an example without
+  # having to look elsewhere to understand its context.
+  # 
+  # That said, RSpec does support some level of encapsulating common code in helper
+  # methods that can exist within a context or within an included module.
+  # 
+  # == Setup and Teardown
+  # 
+  # You can use setup, teardown, context_setup and context_teardown within a context:
+  # 
+  #   context "..." do
+  #     context_setup do
+  #       ...
+  #     end
+  # 
+  #     setup do
+  #       ...
+  #     end
+  # 
+  #     specify "number one" do
+  #       ...
+  #     end
+  # 
+  #     specify "number two" do
+  #       ...
+  #     end
+  # 
+  #     teardown do
+  #       ...
+  #     end
+  # 
+  #     context_teardown do
+  #       ...
+  #     end
+  # 
+  #   end
+  # 
+  # The <tt>setup</tt> block will run before each of the specs, once for each spec. Likewise,
+  # the <tt>teardown</tt> block will run after each of the specs.
+  # 
+  # It is also possible to specify a <tt>context_setup</tt> and <tt>context_teardown</tt>
+  # block that will run only once for each context, respectively before the first <code>setup</code>
+  # and after the last <code>teardown</code>. The use of these is generally discouraged, because it
+  # introduces dependencies between the specs. Still, it might prove useful for very expensive operations
+  # if you know what you are doing.
+  # 
+  # == Local helper methods
+  # 
+  # You can include local helper methods by simply expressing them within a context:
+  # 
+  #   context "..." do
+  #   
+  #     specify "..." do
+  #       helper_method
+  #     end
+  # 
+  #     def helper_method
+  #       ...
+  #     end
+  # 
+  #   end
+  # 
+  # == Included helper methods
+  # 
+  # You can include helper methods in multiple contexts by expressing them within
+  # a module, and then including that module in your context:
+  # 
+  #   module AccountExampleHelperMethods
+  #     def helper_method
+  #       ...
+  #     end
+  #   end
+  # 
+  #   context "A new account" do
+  #     include AccountExampleHelperMethods
+  #     setup do
+  #       @account = Account.new
+  #     end
+  # 
+  #     specify "should have a balance of $0" do
+  #       helper_method
+  #       @account.balance.should eql(Money.new(0, :dollars))
+  #     end
+  #   end
+  module Runner
+  end
+end

data/lib/spec/runner/command_line.rb

@@ -1,15 +1,18 @@
+require 'spec/runner/option_parser'
+
 module Spec
   module Runner
     # Facade to run specs without having to fork a new ruby process (using `spec ...`)
     class CommandLine
-      # Runs specs. +argv+ is the commandline args as per the spec commandline API, +stderr+ 
-      # and +stdiout+ are the streams output will be written to, +exit+ tells whether or
+      # Runs specs. +argv+ is the commandline args as per the spec commandline API, +err+ 
+      # and +out+ are the streams output will be written to. +exit+ tells whether or
       # not a system exit should be called after the specs are run and
       # +warn_if_no_files+ tells whether or not a warning (the help message)
-      # should be printed to +stderr+ in case no files are specified.
-      def self.run(argv, stderr, stdout, exit=false, warn_if_no_files=true)
+      # should be printed to +err+ in case no files are specified.
+      def self.run(argv, err, out, exit=true, warn_if_no_files=true)
         old_context_runner = defined?($context_runner) ? $context_runner : nil
-        $context_runner = OptionParser.new.create_context_runner(argv, stderr, stdout, warn_if_no_files)
+        $context_runner = OptionParser.new.create_context_runner(argv, err, out, warn_if_no_files)
+        return if $context_runner.nil? # This is the case if we use --drb
 
         # If ARGV is a glob, it will actually each over each one of the matching files.
         argv.each do |file_or_dir|

data/lib/spec/runner/context.rb

@@ -4,8 +4,8 @@ module Spec
     end
     class Context
       module InstanceMethods
-        def initialize(name, &context_block)
-          @name = name
+        def initialize(description, &context_block)
+          @description = description
 
           @context_eval_module = ContextEvalModule.new
           @context_eval_module.extend ContextEval::ModuleMethods
@@ -17,43 +17,19 @@ module Spec
         def before_context_eval
         end
 
-        def inherit(klass)
+        #this is here for Spec::Rails
+        def inherit_context_eval_module_from(klass)
           @context_eval_module.inherit klass
         end
-        alias :inherit_context_eval_module_from :inherit
-
-        def include(mod)
-          @context_eval_module.include mod
-        end
-
-        def context_setup(&block)
-          @context_eval_module.context_setup(&block)
-        end
-
-        def context_teardown(&block)
-          @context_eval_module.context_teardown(&block)
-        end
-
-        def setup(&block)
-          @context_eval_module.setup(&block)
-        end
-
-        def teardown(&block)
-          @context_eval_module.teardown(&block)
-        end
-
-        def specify(spec_name, opts={}, &block)
-          @context_eval_module.specify(spec_name, opts, &block)
-        end
 
         def run(reporter, dry_run=false)
-          reporter.add_context(@name)
+          reporter.add_context(@description)
           prepare_execution_context_class
           errors = run_context_setup(reporter, dry_run)
 
           specifications.each do |specification|
             specification_execution_context = execution_context(specification)
-            specification_execution_context.copy_instance_variables_from(@once_only_execution_context_instance, [:@spec]) unless context_setup_block.nil?
+            specification_execution_context.copy_instance_variables_from(@once_only_execution_context_instance, []) unless context_setup_block.nil?
             specification.run(reporter, setup_block, teardown_block, dry_run, specification_execution_context)
           end unless errors.length > 0
           
@@ -64,19 +40,19 @@ module Spec
           specifications.length
         end
 
-        def matches? name, matcher=nil
-          matcher ||= SpecMatcher.new name, @name
+        def matches?(full_description)
+          matcher ||= SpecMatcher.new(@description)
           specifications.each do |spec|
-            return true if spec.matches_matcher? matcher
+            return true if spec.matches?(matcher, full_description)
           end
           return false
         end
 
-        def run_single_spec name
-          return if @name == name
-          matcher = SpecMatcher.new name, @name
+        def run_single_spec(full_description)
+          return if @description == full_description
+          matcher = SpecMatcher.new(@description)
           specifications.reject! do |spec|
-            !spec.matches_matcher? matcher
+            !spec.matches?(matcher, full_description)
           end
         end