rspec-core 2.0.0.a1

data/lib/rspec/core/deprecation.rb

@@ -0,0 +1,47 @@
+module Rspec
+  module Core
+  
+    class << self
+      def deprecate(method, alternate_method=nil)
+         message = <<-NOTICE
+
+*****************************************************************
+DEPRECATION WARNING: you are using deprecated behaviour that will
+be removed from a future version of RSpec.
+
+#{caller(0)[2]}
+
+* #{method} is deprecated.
+NOTICE
+        if alternate_method
+          message << <<-ADDITIONAL
+* please use #{alternate_method} instead.
+ADDITIONAL
+        end
+
+        message << "*****************************************************************"
+        warn(message)
+      end
+
+      def warn(message)
+        Kernel.warn(message)
+      end
+
+    end
+
+    class HashWithDeprecationNotice < Hash
+    
+      def initialize(method, alternate_method=nil, &block)
+        @method, @alternate_method = method, alternate_method
+      end
+    
+      def []=(k,v)
+        Rspec.deprecate(@method, @alternate_method)
+        super
+      end
+    
+    end
+  
+  end
+  
+end

data/lib/rspec/core/example.rb

@@ -0,0 +1,113 @@
+module Rspec
+  module Core
+    class Example
+
+      attr_reader :behaviour, :description, :metadata, :example_block
+
+      def initialize(behaviour, desc, options, example_block=nil)
+        @behaviour, @description, @options, @example_block = behaviour, desc, options, example_block
+        @metadata = @behaviour.metadata.dup
+        @metadata[:description] = description
+        @metadata[:execution_result] = {}
+        @metadata[:caller] = options.delete(:caller)
+        if @metadata[:caller]
+          @metadata[:file_path] = @metadata[:caller].split(":")[0].strip 
+          @metadata[:line_number] = @metadata[:caller].split(":")[1].to_i
+        end
+        @metadata.update(options)
+      end
+      
+      def record_results(results={})
+        @metadata[:execution_result].update(results)
+      end
+
+      def execution_result
+        @metadata[:execution_result]
+      end
+
+      def file_path
+        @metadata[:file_path] || behaviour.file_path
+      end
+
+      def run_started
+        record_results :started_at => Time.now
+      end
+
+      def run_passed
+        run_finished 'passed'
+      end
+
+      def run_pending(message='Not yet implemented')
+        run_finished 'pending', :pending_message => message
+      end
+
+      def run_failed(exception)
+        run_finished 'failed', :exception_encountered => exception
+      end
+
+      def run_finished(status, results={})
+        record_results results.update(:status => status)
+        finish_time = Time.now
+        record_results :finished_at => finish_time, :run_time => (finish_time - execution_result[:started_at])
+        Rspec::Core.configuration.formatter.example_finished(self)
+      end
+
+      def run_before_each
+        @behaviour_instance._setup_mocks if @behaviour_instance.respond_to?(:_setup_mocks)
+        @behaviour.eval_before_eachs(@behaviour_instance)
+      end
+
+      def run_after_each
+        @behaviour.eval_after_eachs(@behaviour_instance)
+        @behaviour_instance._verify_mocks if @behaviour_instance.respond_to?(:_verify_mocks)
+      ensure
+        @behaviour_instance._teardown_mocks if @behaviour_instance.respond_to?(:_teardown_mocks)
+      end
+
+      def run(behaviour_instance)
+        @behaviour_instance = behaviour_instance
+        @behaviour_instance.running_example = self
+
+        run_started
+
+        all_systems_nominal = true
+        exception_encountered = nil
+
+        begin
+          run_before_each
+          @behaviour_instance.instance_eval(&example_block) if example_block
+        rescue Exception => e
+          exception_encountered = e
+          all_systems_nominal = false
+        end
+
+        begin
+          run_after_each
+        rescue Exception => e
+          exception_encountered ||= e
+          all_systems_nominal = false
+        ensure
+          @behaviour_instance.running_example = nil
+        end
+
+        if exception_encountered
+          run_failed(exception_encountered) 
+        else
+          example_block ? run_passed : run_pending
+        end
+
+        all_systems_nominal
+      end
+
+      def inspect
+        "#{@metadata[:behaviour][:name]} - #{@metadata[:description]}"
+      end
+
+      def to_s
+        inspect
+      end
+
+    end
+
+  end
+end

data/lib/rspec/core/example_group.rb

@@ -0,0 +1,239 @@
+module Rspec
+  module Core
+    class ExampleGroup
+      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
+        module_eval(new_alias, __FILE__, __LINE__)
+      end
+
+      alias_example_to :it
+      alias_example_to :specify
+      alias_example_to :focused, :focused => true
+      alias_example_to :disabled, :disabled => true
+      alias_example_to :pending, :pending => true
+
+      def self.it_should_behave_like(*names)
+        Rspec::Core.world.shared_behaviours.each do |name, block|
+          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|                                                                                                                                                                               
+          if include_or_extend == :extend
+            send(:extend, mod) unless extended_modules.include?(mod)                                                                                                                                                                                                    
+          else
+            send(:include, mod) unless included_modules.include?(mod)
+          end
+        end
+      end
+
+      def self.metadata
+        @metadata ||= { :behaviour => {} }
+      end
+
+      def self.name(friendly=true)
+        friendly ? metadata[:behaviour][:name] : super
+      end
+
+      def self.describes
+        metadata[:behaviour][:describes]
+      end
+      
+      def self.described_class
+        describes || description
+      end
+
+      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)
+          set_it_up(*args)
+          module_eval(&behaviour_block)
+        end
+      end
+
+      def self.ancestors(superclass_last=false)
+        classes = []
+        current_class = self
+
+        while current_class < Rspec::Core::ExampleGroup
+          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
+
+      def self.before_all_ivars
+        @before_all_ivars ||= {}
+      end
+
+      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) }
+      
+        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) }
+        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) }
+        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) }
+      end
+
+      def self.run(reporter)
+        behaviour_instance = new
+        reporter.add_behaviour(self)
+        eval_before_alls(behaviour_instance)
+        success = run_examples(behaviour_instance, reporter)
+        eval_after_alls(behaviour_instance)
+      
+        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?
+      end
+
+      def self.subclass(base_name, &body) # :nodoc:
+        @_sub_class_count ||= 0
+        @_sub_class_count += 1
+        klass = Class.new(self)
+        class_name = "#{base_name}_#{@_sub_class_count}"
+        const_set(class_name, klass)
+        klass.instance_eval(&body)
+        klass
+      end
+
+      def self.to_s
+        self == Rspec::Core::ExampleGroup ? 'Rspec::Core::ExampleGroup' : name
+      end
+   
+    end
+  end
+end

data/lib/rspec/core/example_group_subject.rb

@@ -0,0 +1,77 @@
+module Rspec
+  module Core
+    module ExampleGroupSubject
+      
+      def self.included(kls)
+        kls.extend ClassMethods
+        kls.send :alias_method, :__should_for_example_group__,     :should
+        kls.send :alias_method, :__should_not_for_example_group__, :should_not
+      end
+      
+      def subject
+        @subject ||= self.class.subject.call
+      end
+      
+      # When +should+ is called with no explicit receiver, the call is
+      # delegated to the object returned by +subject+. Combined with
+      # an implicit subject (see +subject+), this supports very concise
+      # expressions.
+      #
+      # == Examples
+      #
+      #   describe Person do
+      #     it { should be_eligible_to_vote }
+      #   end
+      def should(matcher=nil, message=nil)
+        self == subject ? self.__should_for_example_group__(matcher) : subject.should(matcher,message)
+      end
+
+      # Just like +should+, +should_not+ delegates to the subject (implicit or
+      # explicit) of the example group.
+      #
+      # == Examples
+      #
+      #   describe Person do
+      #     it { should_not be_eligible_to_vote }
+      #   end
+      def should_not(matcher=nil, message=nil)
+        self == subject ? self.__should_not_for_example_group__(matcher) : subject.should_not(matcher,message)
+      end
+      
+      module ClassMethods
+        # Defines an explicit subject for an example group which can then be the
+        # implicit receiver (through delegation) of calls to +should+.
+        #
+        # == Examples
+        #
+        #   describe CheckingAccount, "with $50" do
+        #     subject { CheckingAccount.new(:amount => 50, :currency => :USD) }
+        #     it { should have_a_balance_of(50, :USD) }
+        #     it { should_not be_overdrawn }
+        #   end
+        #
+        # See +ExampleMethods#should+ for more information about this approach.
+        def subject(&block)
+          block.nil? ?
+          explicit_subject || implicit_subject : @explicit_subject_block = block
+        end
+      
+        attr_reader :explicit_subject_block # :nodoc:
+
+        private
+
+        def explicit_subject
+          group = self
+          while group.respond_to?(:explicit_subject_block)
+            return group.explicit_subject_block if group.explicit_subject_block
+            group = group.superclass
+          end
+        end
+
+        def implicit_subject
+          described_class.is_a?(Class) ? lambda { described_class.new } : lambda { described_class }
+        end
+      end
+    end
+  end
+end