rspec 1.0.8 → 1.1.0

data/lib/spec/story/step_group.rb

@@ -0,0 +1,89 @@
+module Spec
+  module Story
+
+    class StepGroupHash < Hash
+      def initialize
+        super do |h,k|
+          h[k] = Spec::Story::StepGroup.new
+        end
+      end
+    end
+
+    class StepGroup
+      def self.steps(&block)
+        @step_group ||= StepGroup.new(false)
+        @step_group.instance_eval(&block) if block
+        @step_group
+      end
+      
+      def initialize(init_defaults=true, &block)
+        @hash_of_lists_of_steps = Hash.new {|h, k| h[k] = []}
+        if init_defaults
+          self.class.steps.add_to(self)
+        end
+        instance_eval(&block) if block
+      end
+      
+      def find(type, name)
+        @hash_of_lists_of_steps[type].each do |step|
+          return step if step.matches?(name)
+        end
+        return nil
+      end
+
+      def GivenScenario(name, &block)
+        create_matcher(:given_scenario, name, &block)
+      end
+      
+      def Given(name, &block)
+        create_matcher(:given, name, &block)
+      end
+      
+      def When(name, &block)
+        create_matcher(:when, name, &block)
+      end
+      
+      def Then(name, &block)
+        create_matcher(:then, name, &block)
+      end
+
+      alias :given_scenario :GivenScenario
+      alias :given :Given
+      alias :when :When
+      alias :then :Then
+      
+      def add(type, steps)
+        (@hash_of_lists_of_steps[type] << steps).flatten!
+      end
+      
+      def clear
+        @hash_of_lists_of_steps.clear
+      end
+      
+      def empty?
+        [:given_scenario, :given, :when, :then].each do |type|
+          return false unless @hash_of_lists_of_steps[type].empty?
+        end
+        return true
+      end
+      
+      def add_to(other_step_matchers)
+        [:given_scenario, :given, :when, :then].each do |type|
+          other_step_matchers.add(type, @hash_of_lists_of_steps[type])
+        end
+      end
+      
+      def <<(other_step_matchers)
+        other_step_matchers.add_to(self) if other_step_matchers.respond_to?(:add_to)
+      end
+      
+      # TODO - make me private
+      def create_matcher(type, name, &block)
+        matcher = Step.new(name, &block)
+        @hash_of_lists_of_steps[type] << matcher
+        matcher
+      end
+      
+    end
+  end
+end

data/lib/spec/story/step_mother.rb

@@ -0,0 +1,37 @@
+module Spec
+  module Story
+    class StepMother
+      def initialize
+        @steps = StepGroup.new
+      end
+      
+      def use(new_step_group)
+        @steps << new_step_group
+      end
+      
+      def store(type, step)
+        @steps.add(type, step)
+      end
+      
+      def find(type, name)
+        if @steps.find(type, name).nil?
+          @steps.add(type,
+          Step.new(name) do
+            raise Spec::Example::ExamplePendingError.new("Unimplemented step: #{name}")
+          end
+          )
+        end
+        @steps.find(type, name)
+      end
+      
+      def clear
+        @steps.clear
+      end
+      
+      def empty?
+        @steps.empty?
+      end
+      
+    end
+  end
+end

data/lib/spec/story/story.rb

@@ -0,0 +1,42 @@
+module Spec
+  module Story
+    class Story
+      attr_reader :title, :narrative
+      
+      def initialize(title, narrative, params = {}, &body)
+        @body = body
+        @title = title
+        @narrative = narrative
+        @params = params
+      end
+      
+      def [](key)
+        @params[key]
+      end
+      
+      def run_in(obj)
+        obj.instance_eval(&@body)
+      end
+      
+      def assign_steps_to(assignee)
+        if @params[:steps]
+          assignee.use(@params[:steps])
+        else
+          case keys = @params[:steps_for]
+          when Symbol
+            keys = [keys]
+          when nil
+            keys = []
+          end
+          keys.each do |key|
+            assignee.use(steps_for(key))
+          end
+        end
+      end
+      
+      def steps_for(key)
+        $rspec_story_steps[key]
+      end
+    end
+  end
+end

data/lib/spec/story/world.rb

@@ -0,0 +1,124 @@
+require 'rubygems'
+require 'spec/expectations'
+require 'spec/matchers'
+require 'spec/example/pending'
+
+module Spec
+  module Story
+=begin
+  A World represents the actual instance a scenario will run in.
+  
+  The runner ensures any instance variables and methods defined anywhere
+  in a story block are available to all the scenarios. This includes
+  variables that are created or referenced inside Given, When and Then
+  blocks.
+=end
+    module World
+      include ::Spec::Example::Pending
+      include ::Spec::Matchers
+      # store steps and listeners in the singleton metaclass.
+      # This serves both to keep them out of the way of runtime Worlds
+      # and to make them available to all instances.
+      class << self
+        def create(cls = Object, *args)
+          cls.new(*args).extend(World)
+        end
+        
+        def listeners
+          @listeners ||= []
+        end
+        
+        def add_listener(listener)
+          listeners() << listener
+        end
+        
+        def step_mother
+          @step_mother ||= StepMother.new
+        end
+                
+        def use(steps)
+          step_mother.use(steps)
+        end
+        
+        def step_names
+          @step_names ||= []
+        end
+
+        def run_given_scenario_with_suspended_listeners(world, type, name, scenario)
+          current_listeners = Array.new(listeners)
+          begin
+            listeners.each { |l| l.found_scenario(type, name) }
+            @listeners.clear
+            scenario.perform(world, name) unless ::Spec::Story::Runner.dry_run
+          ensure
+            @listeners.replace(current_listeners)
+          end
+        end
+        
+        def store_and_call(world, type, name, *args, &block)
+          if block_given?
+            step_mother.store(type, Step.new(name, &block))
+          end
+          step = step_mother.find(type, name)
+
+          step_name = step.name
+          step_names << step_name
+          
+          # It's important to have access to the parsed args here, so
+          # we can give them to the listeners. The HTML reporter needs
+          # the args so it can style them. See the generated output in
+          # story_server/prototype/rspec_stories.html (generated by rake stories)
+          args = step.parse_args(name) if args.empty?
+          begin
+            step.perform(world, *args) unless ::Spec::Story::Runner.dry_run
+            listeners.each { |l| l.step_succeeded(type, step_name, *args) }
+          rescue Exception => e
+            case e
+            when Spec::Example::ExamplePendingError
+              @listeners.each { |l| l.step_pending(type, step_name, *args) }
+            else
+              @listeners.each { |l| l.step_failed(type, step_name, *args) }
+            end
+            errors << e
+          end
+        end
+        
+        def errors
+          @errors ||= []
+        end
+      end # end of class << self
+      
+      def start_collecting_errors
+        errors.clear
+      end
+      
+      def errors
+        World.errors
+      end
+      
+      def GivenScenario(name)
+        World.run_given_scenario_with_suspended_listeners(self, :'given scenario', name, GivenScenario.new(name))
+        @__previous_step = :given
+      end
+      
+      def Given(name, *args, &block)
+        World.store_and_call self, :given, name, *args, &block
+        @__previous_step = :given
+      end
+      
+      def When(name, *args, &block)
+        World.store_and_call self, :when, name, *args, &block
+        @__previous_step = :when
+      end
+      
+      def Then(name, *args, &block)
+        World.store_and_call self, :then, name, *args, &block
+        @__previous_step = :then
+      end
+      
+      def And(name, *args, &block)
+        World.store_and_call self, @__previous_step, name, *args, &block
+      end
+    end
+  end
+end

data/lib/spec/version.rb

@@ -2,16 +2,15 @@ module Spec
   module VERSION
     unless defined? MAJOR
       MAJOR  = 1
-      MINOR  = 0
-      TINY   = 8
+      MINOR  = 1
+      TINY   = 0
       RELEASE_CANDIDATE = nil
 
-      # RANDOM_TOKEN: 0.510454315029681
-      REV = "$LastChangedRevision: 2338 $".match(/LastChangedRevision: (\d+)/)[1]
+      BUILD_TIME_UTC = 20071214045307
 
       STRING = [MAJOR, MINOR, TINY].join('.')
       TAG = "REL_#{[MAJOR, MINOR, TINY, RELEASE_CANDIDATE].compact.join('_')}".upcase.gsub(/\.|-/, '_')
-      FULL_VERSION = "#{[MAJOR, MINOR, TINY, RELEASE_CANDIDATE].compact.join('.')} (r#{REV})"
+      FULL_VERSION = "#{[MAJOR, MINOR, TINY, RELEASE_CANDIDATE].compact.join('.')} (build #{BUILD_TIME_UTC})"
 
       NAME   = "RSpec"
       URL    = "http://rspec.rubyforge.org/"  

data/plugins/mock_frameworks/rspec.rb

@@ -3,7 +3,7 @@ require File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "lib", "s
 module Spec
   module Plugins
     module MockFramework
-      include Spec::Mocks::SpecMethods
+      include Spec::Mocks::ExampleMethods
       def setup_mocks_for_rspec
         $rspec_mocks ||= Spec::Mocks::Space.new
       end

data/spec/autotest/rspec_spec.rb

@@ -39,7 +39,10 @@ HERE
 
   describe Rspec, "rspec_commands" do
     it "should contain the various commands, ordered by preference" do
-      Rspec.new.spec_commands.should == ["bin/spec", "#{Config::CONFIG['bindir']}/spec"]
+      Rspec.new.spec_commands.should == [
+        File.expand_path("#{File.dirname(__FILE__)}/../../bin/spec"),
+        "#{Config::CONFIG['bindir']}/spec"
+      ]
     end
   end
   
@@ -54,8 +57,9 @@ HERE
     it "should try to find the spec command if it exists in ./bin and use it above everything else" do
       File.stub!(:exists?).and_return true
 
-      File.should_receive(:exists?).with("bin/spec").and_return true
-      @rspec_autotest.spec_command.should == "bin/spec"
+      spec_path = File.expand_path("#{File.dirname(__FILE__)}/../../bin/spec")
+      File.should_receive(:exists?).with(spec_path).and_return true
+      @rspec_autotest.spec_command.should == spec_path
     end
 
     it "should otherwise select the default spec command in gem_dir/bin/spec" do
@@ -85,15 +89,17 @@ HERE
     
     it "should use the ALT_SEPARATOR if it is non-nil" do
       @rspec_autotest = Rspec.new(@kernel, @posix_separator, @windows_alt_separator)
-      @rspec_autotest.stub!(:spec_commands).and_return [File.join('bin', 'spec')]
-      @rspec_autotest.spec_command.should == "bin\\spec"
+      spec_command = File.expand_path("#{File.dirname(__FILE__)}/../../bin/spec")
+      @rspec_autotest.stub!(:spec_commands).and_return [spec_command]
+      @rspec_autotest.spec_command.should == spec_command.gsub('/', '\\')
     end
     
     it "should not use the ALT_SEPATOR if it is nil" do
       @windows_alt_separator = nil
       @rspec_autotest = Rspec.new(@kernel, @posix_separator, @windows_alt_separator)
-      @rspec_autotest.stub!(:spec_commands).and_return [File.join('bin', 'spec')]
-      @rspec_autotest.spec_command.should == "bin/spec"
+      spec_command = File.expand_path("#{File.dirname(__FILE__)}/../../bin/spec")
+      @rspec_autotest.stub!(:spec_commands).and_return [spec_command]
+      @rspec_autotest.spec_command.should == spec_command
     end
   end
 

data/spec/autotest_helper.rb

@@ -1,4 +1,5 @@
+require "rubygems"
 require 'autotest'
-require File.dirname(__FILE__) + "/../lib/autotest/rspec"
-
-
+dir = File.dirname(__FILE__)
+require "#{dir}/spec_helper"
+require File.expand_path("#{dir}/../lib/autotest/rspec")

data/spec/rspec_suite.rb

@@ -0,0 +1,7 @@
+if __FILE__ == $0
+  dir = File.dirname(__FILE__)
+  Dir["#{dir}/**/*_spec.rb"].each do |file|
+#    puts "require '#{file}'"
+    require file
+  end
+end

data/spec/ruby_forker.rb

@@ -0,0 +1,13 @@
+require 'rbconfig'
+
+module RubyForker
+  # Forks a ruby interpreter with same type as ourself.
+  # juby will fork jruby, ruby will fork ruby etc.
+  def ruby(args, stderr=nil)
+    config       = ::Config::CONFIG
+    interpreter  = File::join(config['bindir'], config['ruby_install_name']) + config['EXEEXT']
+    cmd = "#{interpreter} #{args}"
+    cmd << " 2> #{stderr}" unless stderr.nil?
+    `#{cmd}`
+  end
+end

data/spec/spec/example/configuration_spec.rb

@@ -0,0 +1,290 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+module Spec
+  module Example
+    ConfigurationSpec =
+      describe Configuration, :shared => true do
+        before(:each) do
+          @config = Configuration.new
+          @example_group = mock("example_group")
+        end
+      end
+    
+    describe Configuration, "#mock_with" do
+      include ConfigurationSpec
+      it "should default mock framework to rspec" do
+        @config.mock_framework.should =~ /\/plugins\/mock_frameworks\/rspec$/
+      end
+
+      it "should let you set rspec mocking explicitly" do
+        @config.mock_with(:rspec)
+        @config.mock_framework.should =~ /\/plugins\/mock_frameworks\/rspec$/
+      end
+
+      it "should let you set mocha" do
+        @config.mock_with(:mocha)
+        @config.mock_framework.should =~ /\/plugins\/mock_frameworks\/mocha$/
+      end
+
+      it "should let you set flexmock" do
+        @config.mock_with(:flexmock)
+        @config.mock_framework.should =~ /\/plugins\/mock_frameworks\/flexmock$/
+      end
+
+      it "should let you set rr" do
+        @config.mock_with(:rr)
+        @config.mock_framework.should =~ /\/plugins\/mock_frameworks\/rr$/
+      end
+
+      it "should let you set an arbitrary adapter module" do
+        adapter = Module.new
+        @config.mock_with(adapter)
+        @config.mock_framework.should == adapter
+      end
+    end
+
+    describe Configuration, "#include" do
+      include ConfigurationSpec
+
+      before do
+        @original_configuration = Spec::Runner.configuration
+        spec_configuration = @config
+        Spec::Runner.instance_eval {@configuration = spec_configuration}
+        @example_group_class = Class.new(ExampleGroup) do
+          class << self
+            def this_class_has_special_methods
+            end
+          end
+        end
+        ExampleGroupFactory.register(:foobar, @example_group_class)
+      end
+
+      after do
+        original_configuration = @original_configuration
+        Spec::Runner.instance_eval {@configuration = original_configuration}
+        ExampleGroupFactory.reset
+      end
+
+      it "should include the submitted module in ExampleGroup subclasses" do
+        mod = Module.new
+        @config.include mod
+        Class.new(@example_group_class).included_modules.should include(mod)
+      end
+
+      it "should let you define modules to be included for a specific type" do
+        mod = Module.new
+        @config.include mod, :type => :foobar
+        Class.new(@example_group_class).included_modules.should include(mod)
+      end
+
+      it "should not include modules in a type they are not intended for" do
+        mod = Module.new
+        @other_example_group_class = Class.new(ExampleGroup)
+        ExampleGroupFactory.register(:baz, @other_example_group_class)
+
+        @config.include mod, :type => :foobar
+
+        Class.new(@other_example_group_class).included_modules.should_not include(mod)
+      end
+      
+      it "should not extend the ExampleGroup baseclass (to enable the included hook to work properly)" do
+        pending("need to figure out how to best express this one")
+      end
+    end
+
+    ConfigurationCallbacksSpec =
+      describe Configuration, "callbacks", :shared => true do
+        before do
+          @config = Configuration.new
+          @special_example_group = Class.new(ExampleGroup)
+          @special_child_example_group = Class.new(@special_example_group)
+          @nonspecial_example_group = Class.new(ExampleGroup)
+          ExampleGroupFactory.register(:special, @special_example_group)
+          ExampleGroupFactory.register(:special_child, @special_child_example_group)
+          ExampleGroupFactory.register(:non_special, @nonspecial_example_group)
+          @example_group = @special_child_example_group.describe "Special Example Group"
+          @unselected_example_group = Class.new(@nonspecial_example_group).describe "Non Special Example Group"
+        end
+
+        after do
+          ExampleGroupFactory.reset
+        end
+      end
+
+    describe Configuration, "#prepend_before" do
+      include ConfigurationCallbacksSpec
+
+      it "prepends the before block on all instances of the passed in type" do
+        order = []
+        @config.prepend_before(:all) do
+          order << :prepend__before_all
+        end
+        @config.prepend_before(:all, :type => :special) do
+          order << :special_prepend__before_all
+        end
+        @config.prepend_before(:all, :type => :special_child) do
+          order << :special_child_prepend__before_all
+        end
+        @config.prepend_before(:each) do
+          order << :prepend__before_each
+        end
+        @config.prepend_before(:each, :type => :special) do
+          order << :special_prepend__before_each
+        end
+        @config.prepend_before(:each, :type => :special_child) do
+          order << :special_child_prepend__before_each
+        end
+        @config.prepend_before(:all, :type => :non_special) do
+          order << :special_prepend__before_all
+        end
+        @config.prepend_before(:each, :type => :non_special) do
+          order << :special_prepend__before_each
+        end
+        @example_group.it "calls prepend_before" do
+        end
+        
+        @example_group.run
+        order.should == [
+          :prepend__before_all,
+          :special_prepend__before_all,
+          :special_child_prepend__before_all,
+          :prepend__before_each,
+          :special_prepend__before_each,
+          :special_child_prepend__before_each
+        ]
+      end
+    end
+
+    describe Configuration, "#append_before" do
+      include ConfigurationCallbacksSpec
+
+      it "calls append_before on the type" do
+        order = []
+        @config.append_before(:all) do
+          order << :append_before_all
+        end
+        @config.append_before(:all, :type => :special) do
+          order << :special_append_before_all
+        end
+        @config.append_before(:all, :type => :special_child) do
+          order << :special_child_append_before_all
+        end
+        @config.append_before(:each) do
+          order << :append_before_each
+        end
+        @config.append_before(:each, :type => :special) do
+          order << :special_append_before_each
+        end
+        @config.append_before(:each, :type => :special_child) do
+          order << :special_child_append_before_each
+        end
+        @config.append_before(:all, :type => :non_special) do
+          order << :special_append_before_all
+        end
+        @config.append_before(:each, :type => :non_special) do
+          order << :special_append_before_each
+        end
+        @example_group.it "calls append_before" do
+        end
+
+        @example_group.run
+        order.should == [
+          :append_before_all,
+          :special_append_before_all,
+          :special_child_append_before_all,
+          :append_before_each,
+          :special_append_before_each,
+          :special_child_append_before_each
+        ]
+      end
+    end
+
+    describe Configuration, "#prepend_after" do
+      include ConfigurationCallbacksSpec
+
+      it "prepends the after block on all instances of the passed in type" do
+        order = []
+        @config.prepend_after(:all) do
+          order << :prepend__after_all
+        end
+        @config.prepend_after(:all, :type => :special) do
+          order << :special_prepend__after_all
+        end
+        @config.prepend_after(:all, :type => :special) do
+          order << :special_child_prepend__after_all
+        end
+        @config.prepend_after(:each) do
+          order << :prepend__after_each
+        end
+        @config.prepend_after(:each, :type => :special) do
+          order << :special_prepend__after_each
+        end
+        @config.prepend_after(:each, :type => :special) do
+          order << :special_child_prepend__after_each
+        end
+        @config.prepend_after(:all, :type => :non_special) do
+          order << :special_prepend__after_all
+        end
+        @config.prepend_after(:each, :type => :non_special) do
+          order << :special_prepend__after_each
+        end
+        @example_group.it "calls prepend_after" do
+        end
+
+        @example_group.run
+        order.should == [
+          :special_child_prepend__after_each,
+          :special_prepend__after_each,
+          :prepend__after_each,
+          :special_child_prepend__after_all,
+          :special_prepend__after_all,
+          :prepend__after_all
+        ]
+      end
+    end
+
+    describe Configuration, "#append_after" do
+      include ConfigurationCallbacksSpec
+
+      it "calls append_after on the type" do
+        order = []
+        @config.append_after(:all) do
+          order << :append__after_all
+        end
+        @config.append_after(:all, :type => :special) do
+          order << :special_append__after_all
+        end
+        @config.append_after(:all, :type => :special_child) do
+          order << :special_child_append__after_all
+        end
+        @config.append_after(:each) do
+          order << :append__after_each
+        end
+        @config.append_after(:each, :type => :special) do
+          order << :special_append__after_each
+        end
+        @config.append_after(:each, :type => :special_child) do
+          order << :special_child_append__after_each
+        end
+        @config.append_after(:all, :type => :non_special) do
+          order << :non_special_append_after_all
+        end
+        @config.append_after(:each, :type => :non_special) do
+          order << :non_special_append_after_each
+        end
+        @example_group.it "calls append_after" do
+        end
+
+        @example_group.run
+        order.should == [
+          :special_child_append__after_each,
+          :special_append__after_each,
+          :append__after_each,
+          :special_child_append__after_all,
+          :special_append__after_all,
+          :append__after_all
+        ]
+      end
+    end
+  end
+end