rspec 0.8.2 → 0.9.0

data/lib/spec/runner/context_eval.rb

@@ -1,142 +0,0 @@
-module Spec
-  module Runner
-    module ContextEval
-      module ModuleMethods
-        def inherit(klass)
-          @context_superclass = klass
-          derive_execution_context_class_from_context_superclass
-        end
-
-        def include(mod)
-          context_modules << mod
-          mod.send :included, self
-        end
-        
-        def context_setup(&block)
-          context_setup_parts << block
-        end
-
-        def context_teardown(&block)
-          context_teardown_parts << block
-        end
-
-        def setup(&block)
-          setup_parts << block
-        end
-
-        def teardown(&block)
-          teardown_parts << block
-        end
-
-        def specify(spec_name=:__generate_description, opts={}, &block)
-          specifications << Specification.new(spec_name, opts, &block)
-        end
-
-        def methods
-          my_methods = super
-          my_methods |= context_superclass.methods
-          my_methods
-        end
-      
-      protected
-
-        def method_missing(method_name, *args)
-          if context_superclass.respond_to?(method_name)
-            return execution_context_class.send(method_name, *args)
-          end
-          super
-        end
-
-      private
-
-        def context_setup_block
-          parts = context_setup_parts.dup
-          add_context_superclass_method(:context_setup, parts)
-          create_block_from_parts(parts)
-        end
-
-        def context_teardown_block
-          parts = context_teardown_parts.dup
-          add_context_superclass_method(:context_teardown, parts)
-          create_block_from_parts(parts)
-        end
-
-        def setup_block
-          parts = setup_parts.dup
-          add_context_superclass_method(:setup, parts)
-          create_block_from_parts(parts)
-        end
-        
-        def teardown_block
-          parts = teardown_parts.dup
-          add_context_superclass_method(:teardown, parts)
-          create_block_from_parts(parts)
-        end
-
-        def execution_context_class
-          @execution_context_class ||= derive_execution_context_class_from_context_superclass
-        end
-
-        def derive_execution_context_class_from_context_superclass
-          @execution_context_class = Class.new(context_superclass)
-          @execution_context_class.class_eval do
-            include ::Spec::Runner::ExecutionContext::InstanceMethods
-          end
-        end
-
-        def context_superclass
-          @context_superclass ||= Object
-        end
-
-        def context_modules
-          @context_modules ||= [Spec::Matchers, Spec::Mocks]
-        end
-        
-        def specifications
-          @specifications ||= []
-        end
-
-        def context_setup_parts
-          @context_setup_parts ||= []
-        end
-
-        def context_teardown_parts
-          @context_teardown_parts ||= []
-        end
-
-        def setup_parts
-          @setup_parts ||= []
-        end
-
-        def teardown_parts
-          @teardown_parts ||= []
-        end
-
-        def add_context_superclass_method sym, parts
-          superclass_method = begin
-            context_superclass.instance_method(sym)
-          rescue
-            nil
-          end
-          parts.unshift superclass_method if superclass_method
-        end
-
-        def create_block_from_parts(parts)
-          proc do
-            parts.each do |part|
-              if part.is_a?(UnboundMethod)
-                part.bind(self).call
-              else
-                instance_eval(&part)
-              end
-            end
-          end
-        end
-      end
-
-      module InstanceMethods
-      end
-      
-    end
-  end
-end

data/lib/spec/runner/context_runner.rb

@@ -1,55 +0,0 @@
-module Spec
-  module Runner
-    class ContextRunner
-      
-      def initialize(options)
-        @contexts = []
-        @options = options
-      end
-    
-      def add_context(context)
-        return unless spec_description.nil? || context.matches?(spec_description)
-        context.run_single_spec(spec_description) if context.matches?(spec_description)
-        @contexts << context
-      end
-      
-      # Runs all contexts and returns the number of failures.
-      def run(exit_when_done)
-        @options.reporter.start(number_of_specs)
-        begin
-          @contexts.each do |context|
-            context.run(@options.reporter, @options.dry_run)
-          end
-        rescue Interrupt
-        ensure
-          @options.reporter.end
-        end
-        failure_count = @options.reporter.dump
-        
-        if(failure_count == 0 && !@options.heckle_runner.nil?)
-          heckle_runner = @options.heckle_runner
-          @options.heckle_runner = nil
-          context_runner = self.class.new(@options)
-          context_runner.instance_variable_set(:@contexts, @contexts)
-          heckle_runner.heckle_with(context_runner)
-        end
-        
-        if(exit_when_done)
-          exit_code = (failure_count == 0) ? 0 : 1
-          exit(exit_code)
-        end
-        failure_count
-      end
-    
-      def number_of_specs
-        @contexts.inject(0) {|sum, context| sum + context.number_of_specs}
-      end
-      
-      private
-      def spec_description
-        @options.spec_name
-      end
-      
-    end
-  end
-end

data/lib/spec/runner/execution_context.rb

@@ -1,17 +0,0 @@
-module Spec
-  module Runner
-    class ExecutionContext
-      module InstanceMethods
-        def initialize(*args) #:nodoc:
-          #necessary for RSpec's own specs
-        end
-        
-        def violated(message="")
-          raise Spec::Expectations::ExpectationNotMetError.new(message)
-        end
-
-      end
-      include InstanceMethods
-    end
-  end
-end

data/lib/spec/runner/spec_matcher.rb

@@ -1,25 +0,0 @@
-module Spec
-  module Runner
-    class SpecMatcher
-
-      attr_writer :spec_desc
-      def initialize(context_desc, spec_desc=nil)
-        @context_desc = context_desc
-        @spec_desc = spec_desc
-      end
-      
-      def matches?(desc)
-        desc =~ /(^#{context_regexp} #{spec_regexp}$|^#{context_regexp}$|^#{spec_regexp}$)/
-      end
-      
-      private
-        def context_regexp
-          Regexp.escape(@context_desc)
-        end
-        
-        def spec_regexp
-          Regexp.escape(@spec_desc)
-        end
-    end
-  end
-end

data/lib/spec/runner/specification.rb

@@ -1,114 +0,0 @@
-module Spec
-  module Runner
-    class Specification
-
-      class << self
-        attr_accessor :current, :generated_description
-        protected :current=
-
-        callback_events :before_setup, :after_teardown
-      end
-
-      attr_reader :spec_block
-      callback_events :before_setup, :after_teardown
-
-      def initialize(name, opts={}, &spec_block)
-        @from = caller(0)[3]
-        @description = name
-        @options = opts
-        @spec_block = spec_block
-        @description_generated_callback = lambda { |desc| @generated_description = desc }
-      end
-
-      def run(reporter, setup_block, teardown_block, dry_run, execution_context)
-        reporter.spec_started(name) if reporter
-        return reporter.spec_finished(name) if dry_run
-
-        errors = []
-        begin
-          set_current
-          setup_ok = setup_spec(execution_context, errors, &setup_block)
-          spec_ok = execute_spec(execution_context, errors) if setup_ok
-          teardown_ok = teardown_spec(execution_context, errors, &teardown_block)
-        ensure
-          clear_current
-        end
-
-        SpecShouldRaiseHandler.new(@from, @options).handle(errors)
-        reporter.spec_finished(name, errors.first, failure_location(setup_ok, spec_ok, teardown_ok)) if reporter
-      end
-      
-      def matches?(matcher, description)
-        matcher.spec_desc = name
-        matcher.matches?(description)
-      end
-      
-      private
-      def name
-        @description == :__generate_description ? generated_description : @description
-      end
-      
-      def generated_description
-        @generated_description || "NAME NOT GENERATED"
-      end
-      
-      def setup_spec(execution_context, errors, &setup_block)
-        notify_before_setup(errors)
-        execution_context.instance_eval(&setup_block) if setup_block
-        return errors.empty?
-      rescue => e
-        errors << e
-        return false
-      end
-
-      def execute_spec(execution_context, errors)
-        begin
-          execution_context.instance_eval(&spec_block)
-          return true
-        rescue Exception => e
-          errors << e
-          return false
-        end
-      end
-
-      def teardown_spec(execution_context, errors, &teardown_block)
-        execution_context.instance_eval(&teardown_block) if teardown_block
-        notify_after_teardown(errors)
-        return errors.empty?
-      rescue => e
-        errors << e
-        return false
-      end
-
-      def notify_before_setup(errors)
-        notify_class_callbacks(:before_setup, self, &append_errors(errors))
-        notify_callbacks(:before_setup, self, &append_errors(errors))
-      end
-      
-      def notify_after_teardown(errors)
-        notify_callbacks(:after_teardown, self, &append_errors(errors))
-        notify_class_callbacks(:after_teardown, self, &append_errors(errors))
-      end
-      
-      def append_errors(errors)
-        proc {|error| errors << error}
-      end
-      
-      def set_current
-        Spec::Matchers.description_generated(&@description_generated_callback)
-        self.class.send(:current=, self)
-      end
-
-      def clear_current
-        Spec::Matchers.unregister_callback(:description_generated, @description_generated_callback)
-        self.class.send(:current=, nil)
-      end
-
-      def failure_location(setup_ok, spec_ok, teardown_ok)
-        return 'setup' unless setup_ok
-        return name unless spec_ok
-        return 'teardown' unless teardown_ok
-      end
-    end
-  end
-end

data/spec/spec/callback/callback_container_spec.rb

@@ -1,27 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-context "A CallbackContainer instance" do
-  setup do
-    @container = Callback::CallbackContainer.new
-  end
-
-  specify "should define and call callbacks" do
-    @container.define(:foo) {:bar}
-    @container.define(:foo) {:baz}
-    @container.notify(:foo).should == [:bar, :baz]
-  end
-
-  specify "should undefine callbacks" do
-    callback_to_undefine = @container.define(:foo) {:bar}
-    @container.define(:foo) {:baz}
-    @container.undefine(:foo, callback_to_undefine)
-    @container.notify(:foo).should == [:baz]
-  end
-  
-  specify "should clear all callbacks" do
-    @container.define(:foo) {:bar}
-    @container.define(:baz) {1}
-    @container.clear
-    @container.notify(:foo).should == []
-  end
-end

data/spec/spec/callback/module_spec.rb

@@ -1,37 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-context "A Module" do
-  specify "should provide callback_events and notify_callbacks methods" do
-    the_class = Class.new do
-      callback_events :foo
-    end
-
-    the_obj = the_class.new
-    the_obj.foo { :bar }
-    the_obj.notify_callbacks(:foo).should == [:bar]
-  end
-
-  specify "should support defining multiple callback_events with one call to callback_events" do
-    the_class = Class.new do
-      callback_events :foo, :bar
-    end
-
-    the_obj = the_class.new
-    the_obj.foo { 1 }
-    the_obj.bar { 2 }
-    the_obj.notify_callbacks(:foo).should == [1]
-    the_obj.notify_callbacks(:bar).should == [2]
-  end
-
-  specify "should provide unregister_callback method" do
-    the_class = Class.new do
-      callback_events :foo
-    end
-
-    the_obj = the_class.new
-    bar_proc = proc {:bar}
-    the_obj.foo &bar_proc
-    the_obj.unregister_callback(:foo, bar_proc)
-    the_obj.notify_callbacks(:foo).should == []
-  end
-end

data/spec/spec/callback/object_spec.rb

@@ -1,90 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-context "An Object" do
-  setup do
-    @callback_object = Object.new
-  end
-
-  specify "should be defined as a block and notified" do
-    specify_registration_and_notification do |callback_key, expected_callback|
-      @callback_object.register_callback(callback_key, &expected_callback)
-    end
-  end
-
-  specify "should be defined as a proc and notified" do
-    specify_registration_and_notification do |callback_key, expected_callback|
-      @callback_object.register_callback(callback_key, expected_callback)
-    end
-  end
-
-  specify "define should require callback with the call method" do
-    proc do
-      specify_registration_and_notification do |callback_key, expected_callback|
-        @callback_object.register_callback(callback_key)
-      end
-    end.should_raise(RuntimeError, "You must define the callback that accepts the call method.")
-  end
-
-  specify "should undefine a proc" do
-    specify_unregistration do |callback_key, callback|
-      @callback_object.unregister_callback callback_key, callback
-    end
-  end
-
-  specify "undefine should require callback with the call method" do
-    proc do
-      specify_unregistration do |callback_key, expected_callback|
-        @callback_object.unregister_callback(callback_key, nil)
-      end
-    end.should_raise(RuntimeError, "You may only undefine callbacks that use the call method.")
-  end
-  
-  specify "should handle errors" do
-    @callback_object.register_callback(:error_callback) do
-      raise "First Error"
-    end
-
-    @callback_object.register_callback(:error_callback) do
-      raise "Second Error"
-    end
-
-    error_messages = []
-    @callback_object.notify_callbacks(:error_callback) do |e|
-      error_messages << e.message
-    end
-
-    error_messages.should_eql ["First Error", "Second Error"]
-  end
-
-  specify "should not fail with nothing to notify" do
-    @callback_object.notify_callbacks(:foobar, :argument)
-  end
-
-  protected
-  def specify_registration_and_notification
-    callback_key = :create
-    passed_callback_argument = nil
-    expected_callback = proc do |callback_argument|
-      passed_callback_argument = callback_argument
-    end
-
-    returned_callback = yield(callback_key, expected_callback)
-    returned_callback.should_equal expected_callback
-
-    expected_argument = Object.new
-    @callback_object.notify_callbacks(callback_key, expected_argument)
-    passed_callback_argument.should_equal expected_argument
-  end
-
-  def specify_unregistration
-    callback_key = :create
-    callback_called = false
-    callback = @callback_object.register_callback(callback_key) do
-      callback_called = true
-    end
-
-    yield(callback_key, callback)
-    @callback_object.notify_callbacks(callback_key)
-    callback_called.should_equal false
-  end
-end