rspec 0.8.2 → 0.9.0

data/lib/spec/mocks/{mock_handler.rb → proxy.rb}

@@ -1,9 +1,8 @@
 module Spec
   module Mocks
-    class MockHandler
+    class Proxy
       DEFAULT_OPTIONS = {
         :null_object => false,
-        :auto_verify => true
       }
 
       def initialize(target, name, options={})
@@ -84,12 +83,10 @@ module Spec
         @error_generator.raise_unexpected_message_error sym, *args
       end
       
-      private
+    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]
+        $rspec_mocks.add(@target)
         define_expected_method(sym)
       end
       
@@ -101,7 +98,7 @@ module Spec
 
         metaclass_eval(<<-EOF, __FILE__, __LINE__)
           def #{sym}(*args, &block)
-            __mock_handler.message_received :#{sym}, *args, &block
+            __mock_proxy.message_received :#{sym}, *args, &block
           end
         EOF
       end

data/lib/spec/mocks/space.rb

@@ -0,0 +1,28 @@
+module Spec
+  module Mocks
+    class Space
+      def add(obj)
+        mocks << obj unless mocks.include?(obj)
+      end
+
+      def verify_all
+        mocks.each do |mock|
+          mock.rspec_verify
+        end
+      end
+      
+      def reset_all
+        mocks.each do |mock|
+          mock.rspec_reset
+        end
+        mocks.clear
+      end
+      
+    private
+    
+      def mocks
+        @mocks ||= []
+      end
+    end
+  end
+end

data/lib/spec/mocks/spec_methods.rb

@@ -0,0 +1,30 @@
+module Spec
+  module Mocks
+    module SpecMethods
+      include Spec::Mocks::ArgumentConstraintMatchers
+
+      # Shortcut for creating an instance of Spec::Mocks::Mock.
+      def mock(name, options={})
+        Spec::Mocks::Mock.new(name, options)
+      end
+
+      # Shortcut for creating an instance of Spec::Mocks::Mock with
+      # predefined method stubs.
+      #
+      # == Examples
+      #
+      #   stub_thing = stub("thing", :a => "A")
+      #   stub_thing.a == "A" => true
+      #
+      #   stub_person = stub("thing", :name => "Joe", :email => "joe@domain.com")
+      #   stub_person.name => "Joe"
+      #   stub_person.email => "joe@domain.com"
+      def stub(name, stubs={})
+        object_stub = mock(name)
+        stubs.each { |key, value| object_stub.stub!(key).and_return(value) }
+        object_stub
+      end
+      
+    end
+  end
+end

data/lib/spec/rake/spectask.rb

@@ -41,6 +41,7 @@ module Spec
       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)
@@ -103,31 +104,32 @@ module Spec
         end
         task @name do
           RakeFileUtils.verbose(@verbose) do
-            ruby_opts = @ruby_opts.clone
-            ruby_opts.push( "-I\"#{lib_path}\"" )
-            ruby_opts.push( "-S rcov" ) if @rcov
-            ruby_opts.push( "-w" ) if @warning
-
-            redirect = @out.nil? ? "" : " > \"#{@out}\""
-
             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
-              begin
-                ruby(
-                  ruby_opts.join(" ") + " " + 
-                  rcov_option_list +
-                  (@rcov ? %[ -o "#{@rcov_dir}" ] : "") + 
-                  '"' + spec_script + '"' + " " +
-                  (@rcov ? "-- " : "") + 
-                  spec_file_list.collect { |fn| %["#{fn}"] }.join(' ') + " " + 
-                  spec_option_list + " " +
-                  redirect
-                )
-              rescue => e
-                 puts @failure_message if @failure_message
-                 raise e if @fail_on_error
+              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(" ")
+              cmd << " "
+              cmd << rcov_option_list
+              cmd << %[ -o "#{@rcov_dir}" ] if @rcov
+              cmd << %Q|"#{spec_script}"|
+              cmd << " "
+              cmd << "-- " if @rcov
+              cmd << spec_file_list.collect { |fn| %["#{fn}"] }.join(' ')
+              cmd << " "
+              cmd << spec_option_list
+              cmd << " "
+              cmd << %Q| > "#{@out}"| if @out
+
+              unless system(cmd)
+               puts @failure_message if @failure_message
+               raise("Command #{cmd} failed") if @fail_on_error
               end
             end
           end

data/lib/spec/rake/verify_rcov.rb

@@ -32,6 +32,7 @@ module RCov
       desc "Verify that rcov coverage is at least #{threshold}%"
       task @name do
         total_coverage = nil
+
         File.open(index_html).each_line do |line|
           if line =~ /<tt.*>(\d+\.\d+)%<\/tt>&nbsp;<\/td>/
             total_coverage = eval($1)

data/lib/spec/runner.rb

@@ -1,42 +1,38 @@
 require 'spec/runner/formatter'
-require 'spec/runner/context'
-require 'spec/runner/context_eval'
-require 'spec/runner/specification'
-require 'spec/runner/execution_context'
-require 'spec/runner/context_runner'
+require 'spec/runner/behaviour_runner'
+require 'spec/runner/options'
 require 'spec/runner/option_parser'
 require 'spec/runner/command_line'
 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
+  # == Behaviours and Examples
   # 
-  # Rather than expressing examples in classes, RSpec uses a custom domain specific language to express
-  # examples using contexts and specifications.
+  # Rather than expressing examples in classes, RSpec uses a custom domain specific language to 
+  # describe Behaviours and Examples of those behaviours.
   # 
-  # A context is the equivalent of a fixture in xUnit-speak. It is a metaphor for the context
+  # A Behaviour 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.
+  # We begin be describing
   # 
-  #   context "A new account" do
+  #   describe Account do
   # 
-  #     setup do
+  #     before do
   #       @account = Account.new
   #     end
   # 
-  #     specify "should have a balance of $0" do
-  #       @account.balance.should_eql Money.new(0, :dollars)
+  #     it "should have a balance of $0" do
+  #       @account.balance.should == Money.new(0, :dollars)
   #     end
   # 
   #   end
   # 
-  # We use the setup block to set up the context (given), and then the specify method to
+  # We use the before block to set up the Behaviour (given), and then the #it method to
   # hold the example code that expresses the event (when) and the expected outcome (then).
   # 
   # == Helper Methods
@@ -51,51 +47,52 @@ module Spec
   # 
   # == Setup and Teardown
   # 
-  # You can use setup, teardown, context_setup and context_teardown within a context:
+  # You can use before and after within a Behaviour. Both methods take an optional
+  # scope argument so you can run the block before :each example or before :all examples
   # 
-  #   context "..." do
-  #     context_setup do
+  #   describe "..." do
+  #     before :all do
   #       ...
   #     end
   # 
-  #     setup do
+  #     before :each do
   #       ...
   #     end
   # 
-  #     specify "number one" do
+  #     it "should do something" do
   #       ...
   #     end
   # 
-  #     specify "number two" do
+  #     it "should do something else" do
   #       ...
   #     end
   # 
-  #     teardown do
+  #     after :each do
   #       ...
   #     end
   # 
-  #     context_teardown do
+  #     after :all 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.
+  # The <tt>before :each</tt> block will run before each of the examples, once for each example. Likewise,
+  # the <tt>after :each</tt> block will run after each of the examples.
   # 
-  # 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
+  # It is also possible to specify a <tt>before :all</tt> and <tt>after :all</tt>
+  # block that will run only once for each behaviour, respectively before the first <code>before :each</code>
+  # and after the last <code>after :each</code>. The use of these is generally discouraged, because it
+  # introduces dependencies between the examples. 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
+  #   describe "..." do
   #   
-  #     specify "..." do
+  #     it "..." do
   #       helper_method
   #     end
   # 
@@ -116,17 +113,73 @@ module Spec
   #     end
   #   end
   # 
-  #   context "A new account" do
+  #   describe "A new account" do
   #     include AccountExampleHelperMethods
-  #     setup do
+  #     before do
   #       @account = Account.new
   #     end
   # 
-  #     specify "should have a balance of $0" do
+  #     it "should have a balance of $0" do
   #       helper_method
   #       @account.balance.should eql(Money.new(0, :dollars))
   #     end
   #   end
+  # 
+  # == Shared behaviour
+  # 
+  # You can define a shared behaviour, that may be used on other behaviours
+  #
+  #  describe "All Editions", :shared => true do
+  #    it "all editions behaviour" ...
+  #  end
+  #
+  #  describe SmallEdition do
+  #    it_should_behave_like "All Editions"
+  #  
+  #    it "should do small edition stuff" do
+  #      ...
+  #    end
+  #  end
   module Runner
+    class << self
+      def configuration # :nodoc:
+        @configuration ||= Spec::DSL::Configuration.new
+      end
+      
+      # Use this to configure various configurable aspects of
+      # RSpec. For example, to choose a mock framework from
+      # RSpec, mocha and flexmock, you can do this:
+      #
+      #   Spec::Runner.configure do |config|
+      #     config.mock_with :rspec #or :mocha, or :flexmock
+      #   end
+      #
+      # To use any other mock framework, you'll have to provide
+      # your own adapter. This is simply a module that responds to
+      # setup_mocks_for_rspec, verify_mocks_for_rspec and teardown_mocks_for_rspec.
+      # These are your hooks into the lifecycle of a given example. RSpec will
+      # call setup_mocks_for_rspec before running anything else in each Example.
+      # After executing the #after methods, RSpec will then call verify_mocks_for_rspec
+      # and teardown_mocks_for_rspec (this is guaranteed to run even if there are
+      # failures in verify_mocks_for_rspec).
+      #
+      # Once you've defined this module, you can pass that to mock_with:
+      #
+      #   Spec::Runner.configure do |config|
+      #     config.mock_with MyMockFrameworkAdapter
+      #   end
+      #
+      # You can also configure the following items:
+      #
+      #   # include SomeModule in every Behaviour
+      #   config.include SomeModule
+      #
+      #   # generate a do_something predicate_matcher for every Behaviour
+      #   # - See Spec::DSL::Behaviour#predicate_matchers
+      #   config.predicate_matchers[:does_something?] = :do_something
+      def configure
+        yield configuration
+      end
+    end
   end
 end

data/lib/spec/runner/backtrace_tweaker.rb

@@ -32,7 +32,8 @@ module Spec
           # TextMate's Ruby and RSpec plugins
           /Ruby\.tmbundle\/Support\/tmruby.rb:/,
           /RSpec\.tmbundle\/Support\/lib/,
-          /temp_textmate\./
+          /temp_textmate\./,
+          /mock_frameworks\/rspec/
         ]
       end
       

data/lib/spec/runner/behaviour_runner.rb

@@ -0,0 +1,102 @@
+module Spec
+  module Runner
+    class BehaviourRunner
+      
+      def initialize(options)
+        @behaviours = []
+        @options = options
+      end
+    
+      def add_behaviour(behaviour)
+        unless specified_examples.nil? || specified_examples.empty? #|| behaviour.matches?(specified_examples)
+          behaviour.retain_examples_matching!(specified_examples) #if behaviour.matches?(specified_examples)
+        end
+        @behaviours << behaviour unless behaviour.number_of_examples == 0
+      end
+      
+      # Runs all contexts and returns the number of failures.
+      def run(paths, exit_when_done)
+        unless paths.nil? # It's nil when running single specs with ruby
+          paths = find_paths(paths)
+          sorted_paths = sort_paths(paths)
+          load_specs(sorted_paths) 
+        end
+        @options.reporter.start(number_of_examples)
+        behaviours = @options.reverse ? @behaviours.reverse : @behaviours
+        begin
+          run_behaviours(behaviours)
+        rescue Interrupt
+        ensure
+          @options.reporter.end
+        end
+        failure_count = @options.reporter.dump
+        
+        heckle if(failure_count == 0 && !@options.heckle_runner.nil?)
+        
+        if(exit_when_done)
+          exit_code = (failure_count == 0) ? 0 : 1
+          exit(exit_code)
+        end
+        failure_count
+      end
+
+      def run_behaviours(behaviours)
+        behaviours.each do |behaviour|
+          behaviour.run(@options.reporter, @options.dry_run, @options.reverse)
+        end
+      end
+    
+      def number_of_examples
+        @behaviours.inject(0) {|sum, behaviour| sum + behaviour.number_of_examples}
+      end
+      
+      FILE_SORTERS = {
+        'mtime' => lambda {|file_a, file_b| File.mtime(file_b) <=> File.mtime(file_a)}
+      }
+      
+      def sorter(paths)
+        FILE_SORTERS[@options.loadby]
+      end
+      
+      def sort_paths(paths)
+        sorter = sorter(paths)
+        paths = paths.sort(&sorter) unless sorter.nil?
+        paths
+      end
+
+    private
+      
+      def find_paths(paths)
+        result = []
+        paths.each do |path|
+          if File.directory?(path)
+            result += Dir["#{path}/**/*.rb"]
+          elsif File.file?(path)
+            result << path
+          else
+            raise "File or directory not found: #{path}"
+          end
+        end
+        result
+      end
+      
+      def load_specs(paths)
+        paths.each do |path|
+          load path
+        end
+      end
+      
+      def specified_examples
+        @options.examples
+      end
+      
+      def heckle
+        heckle_runner = @options.heckle_runner
+        @options.heckle_runner = nil
+        behaviour_runner = self.class.new(@options)
+        behaviour_runner.instance_variable_set(:@behaviours, @behaviours)
+        heckle_runner.heckle_with(behaviour_runner)
+      end
+    end
+  end
+end