rspec-core 2.0.0.a1 → 2.0.0.a2

data/features/support/env.rb

@@ -1,12 +1,11 @@
-$:.unshift File.join(File.dirname(__FILE__), "/../../lib")
-$:.unshift File.join(File.dirname(__FILE__), "/../../../expectations/lib")
+require 'pathname'
+RSPEC_LIB = File.expand_path('../../../lib', __FILE__)
 
 require 'forwardable'
 require 'tempfile'
 require 'spec/ruby_forker'
 require 'features/support/matchers/smart_match'
 
-
 class RspecWorld
   include Rspec::Expectations
   include Rspec::Matchers
@@ -16,16 +15,12 @@ class RspecWorld
   def_delegators RspecWorld, :working_dir, :spec_command
   
   def self.working_dir
-    @working_dir ||= File.expand_path(File.join(File.dirname(__FILE__), "/../../tmp/cucumber-generated-files"))
+    @working_dir ||= File.expand_path('../../../tmp/cucumber-generated-files', __FILE__)
   end
 
   def self.spec_command
-    @spec_command ||= File.expand_path(File.join(File.dirname(__FILE__), "/../../bin/rspec"))
+    @spec_command ||= File.expand_path('../../../bin/rspec', __FILE__)
   end
-
-  RSPEC_LIB              = File.expand_path(File.join(working_dir, "/../../lib"))
-  RSPEC_EXPECTATIONS_LIB = File.expand_path(File.join(working_dir, "/../../../expectations/lib"))
-  RSPEC_MOCKS_LIB        = File.expand_path(File.join(working_dir, "/../../../mocks/lib"))
   
   def spec(args)
     ruby("#{spec_command} #{args}")
@@ -49,14 +44,7 @@ class RspecWorld
   end
   
   def rspec_libs
-    result = "-I #{RSPEC_LIB}"
-    if File.directory?(RSPEC_EXPECTATIONS_LIB)
-      result << " -I #{RSPEC_EXPECTATIONS_LIB}"
-    end
-    if File.directory?(RSPEC_MOCKS_LIB)
-      result << " -I #{RSPEC_MOCKS_LIB}"
-    end
-    result
+    "-I #{RSPEC_LIB} -I #{working_dir}"
   end
 
   # it seems like this, and the last_* methods, could be moved into RubyForker-- is that being used anywhere but the features?
@@ -64,7 +52,7 @@ class RspecWorld
     stderr_file = Tempfile.new('rspec')
     stderr_file.close
     Dir.chdir(working_dir) do
-      @stdout = super("#{rspec_libs} #{args}", stderr_file.path)
+      @stdout = super("-rrubygems #{rspec_libs} #{args}", stderr_file.path)
     end
     @stderr = IO.read(stderr_file.path)
     @exit_code = $?.to_i

data/lib/rspec/core.rb

@@ -1,3 +1,4 @@
+require 'rspec/core/load_path'
 require 'rspec/core/deprecation'
 require 'rspec/core/mocking/with_absolutely_nothing'
 require 'rspec/core/world'
@@ -5,6 +6,7 @@ require 'rspec/core/configuration'
 require 'rspec/core/command_line_options'
 require 'rspec/core/runner'
 require 'rspec/core/example'
+require 'rspec/core/metadata'
 require 'rspec/core/kernel_extensions'
 require 'rspec/core/shared_behaviour'
 require 'rspec/core/example_group_subject'
@@ -15,11 +17,9 @@ require 'rspec/core/version'
 
 module Rspec
   module Core
-    
+
     def self.install_directory
       @install_directory ||= File.expand_path(File.dirname(__FILE__))
-      puts "@install_directory => #{@install_directory}"
-      @install_directory
     end
 
     def self.configuration
@@ -29,10 +29,10 @@ module Rspec
     def self.configure
       yield configuration if block_given?
     end
-  
+
     def self.world
       @world ||= Rspec::Core::World.new
     end
-    
+
   end
 end

data/lib/rspec/core/advice.rb

@@ -0,0 +1,49 @@
+module Rspec
+  module Core
+    module Advice
+      def before_blocks
+        @before_blocks ||= { :all => [], :each => [] }
+      end
+
+      def after_blocks
+        @after_blocks  ||= { :all => [], :each => [] }
+      end
+
+      def around_blocks
+        @around_blocks ||= { :each => [] }
+      end
+
+      def before_eachs
+        before_blocks[:each]
+      end
+
+      def before_alls
+        before_blocks[:all]
+      end
+
+      def before(type=:each, &block)
+        before_blocks[type] << block
+      end
+
+      def after_eachs
+        after_blocks[:each]
+      end
+
+      def after_alls
+        after_blocks[:all]
+      end
+
+      def after(type=:each, &block)
+        after_blocks[type] << block
+      end
+
+      def around_eachs
+        around_blocks[:each]
+      end
+
+      def around(type=:each, &block)
+        around_blocks[type] << block
+      end
+    end
+  end
+end

data/lib/rspec/core/command_line_options.rb

@@ -9,9 +9,7 @@ module Rspec
       attr_reader :args, :options
       
       def self.parse(args)
-        cli_options = new(args)
-        cli_options.parse
-        cli_options
+        new(args).parse
       end
 
       def initialize(args)
@@ -19,12 +17,8 @@ module Rspec
         @options = {}
       end
       
-      def files_to_run
-        options[:files_to_run]
-      end
-
       def parse
-        possible_files = OptionParser.new do |opts|
+        options[:files_or_directories_to_run] = OptionParser.new do |opts|
           opts.banner = "Usage: rspec [options] [files or directories]"
 
           opts.on('-c', '--[no-]color', '--[no-]colour', 'Enable color in the output') do |o|
@@ -44,10 +38,9 @@ module Rspec
           end
         end.parse!(@args)
 
-        options[:files_to_run] = possible_files
-        options
+        self 
       end
-      
+
       def apply(config)
         options.each do |key, value|
           config.send("#{key}=", value)

data/lib/rspec/core/configuration.rb

@@ -3,9 +3,9 @@ module Rspec
     class Configuration
       # Regex patterns to scrub backtrace with
       attr_reader :backtrace_clean_patterns
-      
-      # All of the defined before/after blocks setup in the configuration
-      attr_reader :before_and_afters
+
+      # All of the defined advice in the configuration (before/after/around)
+      attr_reader :advice
 
       # Allows you to control what examples are ran by filtering 
       attr_reader :filter
@@ -19,14 +19,14 @@ module Rspec
       # when using focused examples for instance.  Defaults to true
       attr_accessor :run_all_when_everything_filtered
 
-      # Enable verbose interal logging of the framework - defaults to false
-      attr_accessor :trace
-
       attr_reader :options
 
       def initialize
         @run_all_when_everything_filtered = true
-        @before_and_afters = { :before => { :each => [], :all => [], :suite => [] }, :after => { :each => [], :all => [], :suite => [] } }
+        @advice = { 
+          :before => { :each => [], :all => [], :suite => [] }, 
+          :after => { :each => [], :all => [], :suite => [] } 
+        }
         @include_or_extend_modules = []
         @filter, @exclusion_filter = nil, nil
         @options = default_options
@@ -46,9 +46,7 @@ module Rspec
                                         /vendor\/rails/, 
                                         /bin\/rspec/, 
                                         /bin\/spec/,
-                                        /lib\/rspec\/core/,
-                                        /lib\/rspec\/expectations/,
-                                        /lib\/rspec\/mocks/]
+                                        /lib\/rspec\/(core|expectations|matchers|mocks)/]
         }
       end
       
@@ -106,7 +104,7 @@ module Rspec
         options[:profile_examples]
       end
       
-      def profile_examples=(profile)
+      def profile_examples=(on_or_off)
         options[:profile_examples] = on_or_off
       end
      
@@ -116,7 +114,7 @@ module Rspec
      
       def formatter=(formatter_to_use)
         formatter_class = case formatter_to_use.to_s
-        when /doc/, 's'
+        when /doc/, 's', 'n'
           Rspec::Core::Formatters::DocumentationFormatter
         when 'progress' 
           Rspec::Core::Formatters::ProgressFormatter
@@ -134,23 +132,17 @@ module Rspec
         options[:files_to_run]
       end
       
-      def files_to_run=(*files)
-        files.flatten!
-
-        result = []
-        files.each do |file|
+      def files_or_directories_to_run=(*files)
+        options[:files_to_run] = files.flatten.inject([]) do |result, file|
           if File.directory?(file)
             filename_pattern.split(",").each do |pattern|
               result += Dir[File.expand_path("#{file}/#{pattern.strip}")]
             end
-          elsif File.file?(file)
-            result << file
           else
-            raise "File or directory not found: #{file}"
+            result << file
           end
+          result
         end
-
-        options[:files_to_run] = result
       end
 
       # E.g. alias_example_to :crazy_slow, :speed => 'crazy_slow' defines
@@ -194,25 +186,21 @@ module Rspec
 
       def find_modules(group)
         include_or_extend_modules.select do |include_or_extend, mod, options|
-          options.all? do |filter_on, filter|
-            Rspec::Core.world.apply_condition(filter_on, filter, group.metadata)
-          end
+          Rspec::Core.world.all_apply?(group, options)
         end
       end
 
       def before(each_or_all=:each, options={}, &block)
-        before_and_afters[:before][each_or_all] << [options, block]
+        advice[:before][each_or_all] << [options, block]
       end
 
       def after(each_or_all=:each, options={}, &block)
-        before_and_afters[:after][each_or_all] << [options, block]
+        advice[:after][each_or_all] << [options, block]
       end
 
-      def find_before_or_after(desired_before_or_after, desired_each_or_all, group)
-        before_and_afters[desired_before_or_after][desired_each_or_all].select do |options, block|
-          options.all? do |filter_on, filter|
-            Rspec::Core.world.apply_condition(filter_on, filter, group.metadata)
-          end
+      def find_advice(desired_advice_type, desired_each_or_all, group)
+        advice[desired_advice_type][desired_each_or_all].select do |options, block|
+          Rspec::Core.world.all_apply?(group, options)
         end.map { |options, block| block }
       end
 

data/lib/rspec/core/example.rb

@@ -2,12 +2,12 @@ module Rspec
   module Core
     class Example
 
-      attr_reader :behaviour, :description, :metadata, :example_block
+      attr_reader :behaviour, :metadata, :example_block
 
       def initialize(behaviour, desc, options, example_block=nil)
-        @behaviour, @description, @options, @example_block = behaviour, desc, options, example_block
+        @behaviour, @options, @example_block = behaviour, options, example_block
         @metadata = @behaviour.metadata.dup
-        @metadata[:description] = description
+        @metadata[:description] = desc.to_s
         @metadata[:execution_result] = {}
         @metadata[:caller] = options.delete(:caller)
         if @metadata[:caller]
@@ -16,6 +16,10 @@ module Rspec
         end
         @metadata.update(options)
       end
+
+      def description
+        @metadata[:description]
+      end
       
       def record_results(results={})
         @metadata[:execution_result].update(results)
@@ -53,20 +57,43 @@ module Rspec
       end
 
       def run_before_each
-        @behaviour_instance._setup_mocks if @behaviour_instance.respond_to?(:_setup_mocks)
-        @behaviour.eval_before_eachs(@behaviour_instance)
+        @example_group_instance._setup_mocks if @example_group_instance.respond_to?(:_setup_mocks)
+        @behaviour.eval_before_eachs(@example_group_instance)
       end
 
       def run_after_each
-        @behaviour.eval_after_eachs(@behaviour_instance)
-        @behaviour_instance._verify_mocks if @behaviour_instance.respond_to?(:_verify_mocks)
+        @behaviour.eval_after_eachs(@example_group_instance)
+        @example_group_instance._verify_mocks if @example_group_instance.respond_to?(:_verify_mocks)
       ensure
-        @behaviour_instance._teardown_mocks if @behaviour_instance.respond_to?(:_teardown_mocks)
+        @example_group_instance._teardown_mocks if @example_group_instance.respond_to?(:_teardown_mocks)
       end
 
-      def run(behaviour_instance)
-        @behaviour_instance = behaviour_instance
-        @behaviour_instance.running_example = self
+      def assign_auto_description
+        if description.empty?
+          metadata[:description] = Rspec::Matchers.generated_description 
+          Rspec::Matchers.clear_generated_description
+        end
+      end
+
+      class AroundProxy
+        def initialize(example_group_instance, &example_block)
+          @example_group_instance, @example_block = example_group_instance, example_block
+        end
+
+        def run
+          @example_group_instance.instance_eval(&@example_block)
+        end
+      end
+
+      def runnable?
+        ![example_block.nil?,
+          metadata[:disabled] == true,
+          metadata[:pending] == true ].any?
+      end
+
+      def run(example_group_instance)
+        @example_group_instance = example_group_instance
+        @example_group_instance.running_example = self
 
         run_started
 
@@ -75,25 +102,31 @@ module Rspec
 
         begin
           run_before_each
-          @behaviour_instance.instance_eval(&example_block) if example_block
+          if @behaviour.around_eachs.empty?
+            @example_group_instance.instance_eval(&example_block) if runnable?
+          else
+            @behaviour.around_eachs.first.call(AroundProxy.new(self, &example_block))
+          end
         rescue Exception => e
           exception_encountered = e
           all_systems_nominal = false
         end
 
+        assign_auto_description
+
         begin
           run_after_each
         rescue Exception => e
           exception_encountered ||= e
           all_systems_nominal = false
         ensure
-          @behaviour_instance.running_example = nil
+          @example_group_instance.running_example = nil
         end
 
         if exception_encountered
           run_failed(exception_encountered) 
         else
-          example_block ? run_passed : run_pending
+          runnable? ? run_passed : run_pending
         end
 
         all_systems_nominal
@@ -110,4 +143,4 @@ module Rspec
     end
 
   end
-end
+end

data/lib/rspec/core/example_group.rb

@@ -1,63 +1,35 @@
+require 'rspec/core/advice'
+require 'rspec/core/example_group_subject'
+require 'rspec/core/metadata'
+
 module Rspec
   module Core
     class ExampleGroup
+      extend Advice
       include ExampleGroupSubject
-    
+
       attr_accessor :running_example, :reporter
-    
+
       def self.inherited(klass)
         super
         Rspec::Core.configuration.autorun!
         Rspec::Core.world.behaviours << klass
       end
-    
+
       def self.extended_modules #:nodoc:
         ancestors = class << self; ancestors end
         ancestors.select { |mod| mod.class == Module } - [ Object, Kernel ]
       end
 
-      def self.befores
-        @_befores ||= { :all => [], :each => [] }
-      end
-
-      def self.before_eachs
-        befores[:each]
-      end
-
-      def self.before_alls
-        befores[:all]
-      end
-
-      def self.before(type=:each, &block)
-        befores[type] << block
-      end
-
-      def self.afters
-        @_afters ||= { :all => [], :each => [] }
-      end
-
-      def self.after_eachs
-        afters[:each]
-      end
-
-      def self.after_alls
-        afters[:all]
-      end
-
-      def self.after(type=:each, &block)
-        afters[type] << block
-      end
-
       def self.example(desc=nil, options={}, &block)
         examples << Rspec::Core::Example.new(self, desc, options.update(:caller => caller[0]), block)
       end
-        
+
       def self.alias_example_to(new_alias, extra_options={})
         new_alias = <<-END_RUBY
                       def self.#{new_alias}(desc=nil, options={}, &block)
                         updated_options = options.update(:caller => caller[0])
                         updated_options.update(#{extra_options.inspect})
-                        block = nil if updated_options[:pending] == true || updated_options[:disabled] == true
                         examples << Rspec::Core::Example.new(self, desc, updated_options, block)
                       end
                     END_RUBY
@@ -75,44 +47,21 @@ module Rspec
           module_eval(&block) if names.include?(name)
         end
       end
-    
+
       def self.examples
         @_examples ||= []
       end
-    
+
       def self.examples_to_run
         @_examples_to_run ||= []
       end
 
-      def self.generate_name(options, metadata)
-        if superclass.metadata[:behaviour][:name]
-          metadata[:behaviour][:name] = "#{self.superclass.metadata[:behaviour][:name]} #{description} "
-        else
-          metadata[:behaviour][:name] = "#{describes} #{description} "
-        end
-        metadata[:behaviour][:name].strip!
-      end
-
       def self.set_it_up(*args)
-        @metadata = { }
-        extra_metadata = args.last.is_a?(Hash) ? args.pop : {}
-        extra_metadata.delete(:behaviour) # Remove it when present to prevent it clobbering the one we setup
-        @metadata.update(self.superclass.metadata) 
-        @metadata[:behaviour] = {}
-        @metadata[:behaviour][:describes] = args.shift unless args.first.is_a?(String)
-        @metadata[:behaviour][:describes] ||= self.superclass.metadata && self.superclass.metadata[:behaviour][:describes]
-        @metadata[:behaviour][:description] = args.shift || ''
-        @metadata[:behaviour][:name] = generate_name(args, metadata)
-        @metadata[:behaviour][:block] = extra_metadata.delete(:behaviour_block)
-        @metadata[:behaviour][:caller] = extra_metadata.delete(:caller) || caller(1)
-        @metadata[:behaviour][:file_path] = extra_metadata.delete(:file_path) || @metadata[:behaviour][:caller][4].split(":")[0].strip
-        @metadata[:behaviour][:line_number] = extra_metadata.delete(:line_number) || @metadata[:behaviour][:caller][4].split(":")[1].to_i
-      
-        @metadata.update(extra_metadata)
-      
-        Rspec::Core.configuration.find_modules(self).each do |include_or_extend, mod, opts|                                                                                                                                                                               
+        @metadata = Rspec::Core::Metadata.process(self.superclass.metadata, *args)
+
+        Rspec::Core.configuration.find_modules(self).each do |include_or_extend, mod, opts|
           if include_or_extend == :extend
-            send(:extend, mod) unless extended_modules.include?(mod)                                                                                                                                                                                                    
+            send(:extend, mod) unless extended_modules.include?(mod)
           else
             send(:include, mod) unless included_modules.include?(mod)
           end
@@ -120,7 +69,7 @@ module Rspec
       end
 
       def self.metadata
-        @metadata ||= { :behaviour => {} }
+        @metadata 
       end
 
       def self.name(friendly=true)
@@ -130,7 +79,7 @@ module Rspec
       def self.describes
         metadata[:behaviour][:describes]
       end
-      
+
       def self.described_class
         describes || description
       end
@@ -138,25 +87,29 @@ module Rspec
       def self.description
         metadata[:behaviour][:description]
       end
-    
+
       def self.file_path
         metadata[:behaviour][:file_path]
       end
-   
+
       def self.describe(*args, &behaviour_block)
         raise(ArgumentError, "No arguments given.  You must a least supply a type or description") if args.empty? 
         raise(ArgumentError, "You must supply a block when calling describe") if behaviour_block.nil?
-        
+
         # TODO: Pull out the below into a metadata object, that we can defer the subclassing if necessary
         # describe 'foo', :shared => true will need this to be completed first
         subclass('NestedLevel') do
           args << {} unless args.last.is_a?(Hash)
-          args.last.update(:behaviour_block => behaviour_block)
+          args.last.update(:behaviour_block => behaviour_block, :caller => caller(2))
           set_it_up(*args)
           module_eval(&behaviour_block)
         end
       end
 
+      class << self
+        alias_method :context, :describe
+      end
+
       def self.ancestors(superclass_last=false)
         classes = []
         current_class = self
@@ -165,14 +118,14 @@ module Rspec
           superclass_last ? classes << current_class : classes.unshift(current_class)
           current_class = current_class.superclass
         end
-      
+
         classes
       end
-    
+
       def self.before_ancestors
         @_before_ancestors ||= ancestors 
       end
-    
+
       def self.after_ancestors
         @_after_ancestors ||= ancestors(true)
       end
@@ -183,48 +136,54 @@ module Rspec
 
       def self.eval_before_alls(running_behaviour)
         superclass.before_all_ivars.each { |ivar, val| running_behaviour.instance_variable_set(ivar, val) }
-        Rspec::Core.configuration.find_before_or_after(:before, :all, self).each { |blk| running_behaviour.instance_eval(&blk) }
-      
+        Rspec::Core.configuration.find_advice(:before, :all, self).each { |blk| running_behaviour.instance_eval(&blk) }
+
         before_alls.each { |blk| running_behaviour.instance_eval(&blk) }
         running_behaviour.instance_variables.each { |ivar| before_all_ivars[ivar] = running_behaviour.instance_variable_get(ivar) }
       end
-        
+
       def self.eval_before_eachs(running_behaviour)
-        Rspec::Core.configuration.find_before_or_after(:before, :each, self).each { |blk| running_behaviour.instance_eval(&blk) }
+        Rspec::Core.configuration.find_advice(:before, :each, self).each { |blk| running_behaviour.instance_eval(&blk) }
         before_ancestors.each { |ancestor| ancestor.before_eachs.each { |blk| running_behaviour.instance_eval(&blk) } }
       end
 
       def self.eval_after_alls(running_behaviour)
         after_alls.each { |blk| running_behaviour.instance_eval(&blk) }
-        Rspec::Core.configuration.find_before_or_after(:after, :all, self).each { |blk| running_behaviour.instance_eval(&blk) }
+        Rspec::Core.configuration.find_advice(:after, :all, self).each { |blk| running_behaviour.instance_eval(&blk) }
         before_all_ivars.keys.each { |ivar| before_all_ivars[ivar] = running_behaviour.instance_variable_get(ivar) }
       end
 
       def self.eval_after_eachs(running_behaviour)
         after_ancestors.each { |ancestor| ancestor.after_eachs.each { |blk| running_behaviour.instance_eval(&blk) } }
-        Rspec::Core.configuration.find_before_or_after(:after, :each, self).each { |blk| running_behaviour.instance_eval(&blk) }
+        Rspec::Core.configuration.find_advice(:after, :each, self).each { |blk| running_behaviour.instance_eval(&blk) }
       end
 
       def self.run(reporter)
-        behaviour_instance = new
+        example_world = new
         reporter.add_behaviour(self)
-        eval_before_alls(behaviour_instance)
-        success = run_examples(behaviour_instance, reporter)
-        eval_after_alls(behaviour_instance)
-      
+        eval_before_alls(example_world)
+        success = run_examples(example_world, reporter)
+        eval_after_alls(example_world)
+
         success
       end
-    
+
       # Runs all examples, returning true only if all of them pass
-      def self.run_examples(behaviour_instance, reporter)
-        examples_to_run.map { |ex| ex.run(behaviour_instance) }.all?
+      def self.run_examples(example_world, reporter)
+        examples_to_run.map do |ex| 
+          result = ex.run(example_world) 
+          example_world.__reset__
+          before_all_ivars.each { |k, v| example_world.instance_variable_set(k, v) } 
+          result
+        end.all?
       end
 
+
       def self.subclass(base_name, &body) # :nodoc:
-        @_sub_class_count ||= 0
-        @_sub_class_count += 1
+        @_subclass_count ||= 0
+        @_subclass_count += 1
         klass = Class.new(self)
-        class_name = "#{base_name}_#{@_sub_class_count}"
+        class_name = "#{base_name}_#{@_subclass_count}"
         const_set(class_name, klass)
         klass.instance_eval(&body)
         klass
@@ -233,7 +192,23 @@ module Rspec
       def self.to_s
         self == Rspec::Core::ExampleGroup ? 'Rspec::Core::ExampleGroup' : name
       end
-   
+
+      def self.let(name, &block)
+        # Should we block defining method names already defined?
+        define_method(name) do
+          assignments[name] ||= instance_eval(&block)
+        end
+      end
+
+      def assignments
+        @assignments ||= {}
+      end
+
+      def __reset__
+        instance_variables.each { |ivar| remove_instance_variable(ivar) }
+        assignments.clear
+      end
+
     end
   end
 end