rspec 0.8.2 → 0.9.0

data/lib/spec/dsl/behaviour_factory.rb

@@ -0,0 +1,32 @@
+module Spec
+  module DSL
+    class BehaviourFactory
+
+      class << self
+
+        BEHAVIOUR_CLASSES = {:default => Spec::DSL::Behaviour}
+        
+        def add_behaviour_class(key, value)
+          BEHAVIOUR_CLASSES[key] = value
+        end
+
+        def remove_behaviour_class(key)
+          BEHAVIOUR_CLASSES.delete(key)
+        end
+
+        def create(*args, &block)
+          return BEHAVIOUR_CLASSES[behaviour_type(*args)].new(*args, &block)
+        end
+        
+      private
+      
+        def behaviour_type(*args)
+          opts = Hash === args.last ? args.last : {}
+          opts[:behaviour_type] ? opts[:behaviour_type] : :default
+        end
+        
+      end
+      
+    end
+  end
+end

data/lib/spec/dsl/composite_proc_builder.rb

@@ -0,0 +1,28 @@
+module Spec
+  module DSL
+    class CompositeProcBuilder < Array
+      def initialize(callbacks=[])
+        push(*callbacks)
+      end
+
+      def proc(&error_handler)
+        parts = self
+        Proc.new do
+          parts.collect do |part|
+            begin
+              if part.is_a?(UnboundMethod)
+                part.bind(self).call
+              else
+                instance_eval(&part)
+              end
+            rescue Exception => e
+              raise e unless error_handler
+              error_handler.call(e)
+              e
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/spec/dsl/configuration.rb

@@ -0,0 +1,38 @@
+module Spec
+  module DSL
+    class Configuration
+      
+      def mock_with(mock_framework)
+        @mock_framework = case mock_framework
+        when Symbol
+          mock_framework_path(mock_framework.to_s)
+        else
+          mock_framework
+        end
+      end
+      
+      def mock_framework
+        @mock_framework ||= mock_framework_path("rspec")
+      end
+      
+      def include(mod)
+        included_modules << mod
+      end
+      
+      def included_modules
+        @included_modules ||= []
+      end
+      
+      def predicate_matchers
+        @predicate_matchers ||= {}
+      end
+      
+    private
+    
+      def mock_framework_path(framework_name)
+        File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "..", "plugins", "mock_frameworks", framework_name))
+      end
+      
+    end
+  end
+end

data/lib/spec/dsl/description.rb

@@ -0,0 +1,34 @@
+module Spec
+  module DSL
+    class Description
+      attr_reader :description, :described_type
+      
+      def initialize(*args)
+        args, @options = args_and_options(*args)
+        @described_type = args.first unless args.first.is_a?(String)
+        @description = args.shift.to_s
+        @description << args.shift.to_s unless args.empty?
+      end
+  
+      def [](key)
+        @options[key]
+      end
+      
+      def []=(key, value)
+        @options[key] = value
+      end
+      
+      def to_s; @description; end
+      
+      def ==(value)
+        case value
+        when Description
+          @description == value.description
+        else
+          @description == value
+        end
+      end
+
+    end
+  end
+end

data/lib/spec/dsl/example.rb

@@ -0,0 +1,114 @@
+require 'timeout'
+
+module Spec
+  module DSL
+    class Example
+      def initialize(description, options={}, &example_block)
+        @from = caller(0)[3]
+        @options = options
+        @example_block = example_block
+        @description = description
+        @description_generated_proc = lambda { |desc| @generated_description = desc }
+      end
+      
+      def run(reporter, before_each_block, after_each_block, dry_run, execution_context, timeout=nil)
+        reporter.example_started(description)
+        return reporter.example_finished(description) if dry_run
+
+        errors = []
+        location = nil
+        Timeout.timeout(timeout) do
+          before_each_ok = setup_example(execution_context, errors, &before_each_block)
+          example_ok = run_example(execution_context, errors) if before_each_ok
+          after_each_ok = teardown_example(execution_context, errors, &after_each_block)
+          location = failure_location(before_each_ok, example_ok, after_each_ok)
+        end
+
+        ExampleShouldRaiseHandler.new(@from, @options).handle(errors)
+        reporter.example_finished(description, errors.first, location) if reporter
+      end
+      
+      def matches?(matcher, specified_examples)
+        matcher.example_desc = description
+        matcher.matches?(specified_examples)
+      end
+      
+    private
+      def description
+        @description == :__generate_description ? generated_description : @description
+      end
+      
+      def generated_description
+        @generated_description || "NAME NOT GENERATED"
+      end
+      
+      def setup_example(execution_context, errors, &behaviour_before_block)
+        setup_mocks(execution_context)
+        Spec::Matchers.description_generated(&@description_generated_proc)
+        
+        builder = CompositeProcBuilder.new
+        before_proc = builder.proc(&append_errors(errors))
+        execution_context.instance_eval(&before_proc)
+        
+        execution_context.instance_eval(&behaviour_before_block) if behaviour_before_block
+        return errors.empty?
+      rescue => e
+        errors << e
+        return false
+      end
+
+      def run_example(execution_context, errors)
+        begin
+          execution_context.instance_eval(&@example_block)
+          return true
+        rescue Exception => e
+          errors << e
+          return false
+        end
+      end
+
+      def teardown_example(execution_context, errors, &behaviour_after_each)
+        execution_context.instance_eval(&behaviour_after_each) if behaviour_after_each
+
+        begin
+          verify_mocks(execution_context)
+        ensure
+          teardown_mocks(execution_context)
+        end
+
+        Spec::Matchers.unregister_description_generated(@description_generated_proc)
+
+        builder = CompositeProcBuilder.new
+        after_proc = builder.proc(&append_errors(errors))
+        execution_context.instance_eval(&after_proc)
+
+        return errors.empty?
+      rescue => e
+        errors << e
+        return false
+      end
+      
+      def setup_mocks(execution_context)
+        execution_context.setup_mocks_for_rspec if execution_context.respond_to?(:setup_mocks_for_rspec)
+      end
+      
+      def verify_mocks(execution_context)
+        execution_context.verify_mocks_for_rspec if execution_context.respond_to?(:verify_mocks_for_rspec)
+      end
+      
+      def teardown_mocks(execution_context)
+        execution_context.teardown_mocks_for_rspec if execution_context.respond_to?(:teardown_mocks_for_rspec)
+      end
+      
+      def append_errors(errors)
+        proc {|error| errors << error}
+      end
+      
+      def failure_location(before_each_ok, example_ok, after_each_ok)
+        return 'before(:each)' unless before_each_ok
+        return description unless example_ok
+        return 'after(:each)' unless after_each_ok
+      end
+    end
+  end
+end

data/lib/spec/dsl/example_matcher.rb

@@ -0,0 +1,28 @@
+module Spec
+  module DSL
+    class ExampleMatcher
+
+      attr_writer :example_desc
+      def initialize(context_desc, example_desc=nil)
+        @context_desc = context_desc
+        @example_desc = example_desc
+      end
+      
+      def matches?(specified_examples)
+        specified_examples.each do |specified_example|
+          return true if specified_example =~ /(^#{context_regexp} #{example_regexp}$|^#{context_regexp}$|^#{example_regexp}$)/
+        end
+        false
+      end
+      
+      private
+        def context_regexp
+          Regexp.escape(@context_desc.split('::').last)
+        end
+        
+        def example_regexp
+          Regexp.escape(@example_desc)
+        end
+    end
+  end
+end

data/lib/spec/{runner/spec_should_raise_handler.rb → dsl/example_should_raise_handler.rb}

@@ -1,6 +1,6 @@
 module Spec
-  module Runner
-    class SpecShouldRaiseHandler
+  module DSL
+    class ExampleShouldRaiseHandler
       def initialize(file_and_line_number, opts)
         @file_and_line_number = file_and_line_number
         @options = opts
@@ -31,9 +31,9 @@ module Spec
   
       def build_message(exception=nil)
         if @expected_error_message.nil?
-          message = "specify block expected #{@expected_error_class.to_s}"
+          message = "example block expected #{@expected_error_class.to_s}"
         else
-          message = "specify block expected #{@expected_error_class.new(@expected_error_message.to_s).inspect}"
+          message = "example block expected #{@expected_error_class.new(@expected_error_message.to_s).inspect}"
         end
         message << " but raised #{exception.inspect}" if exception
         message << " but nothing was raised" unless exception

data/lib/spec/expectations.rb

@@ -1,9 +1,6 @@
-require 'spec/deprecated'
 require 'spec/matchers'
-require 'spec/expectations/sugar'
 require 'spec/expectations/errors'
 require 'spec/expectations/extensions'
-require 'spec/expectations/should'
 require 'spec/expectations/handler'
 
 module Spec

data/lib/spec/expectations/differs/default.rb

@@ -10,7 +10,6 @@ module Spec
   module Expectations
     module Differs
 
-      # TODO add colour support
       # TODO add some rdoc
       class Default
         def initialize(format=:unified,context_lines=nil,colour=nil)

data/lib/spec/expectations/extensions.rb

@@ -1,3 +1,2 @@
 require 'spec/expectations/extensions/object'
-require 'spec/expectations/extensions/proc'
 require 'spec/expectations/extensions/string_and_symbol'

data/lib/spec/expectations/extensions/object.rb

@@ -7,6 +7,7 @@ module Spec
       # :call-seq:
       #   should(matcher)
       #   should == expected
+      #   should === expected
       #   should =~ expected
       #
       #   receiver.should(matcher)
@@ -15,6 +16,9 @@ module Spec
       #   receiver.should == expected #any value
       #     => Passes if (receiver == expected)
       #
+      #   receiver.should === expected #any value
+      #     => Passes if (receiver === expected)
+      #
       #   receiver.should =~ regexp
       #     => Passes if (receiver =~ regexp)
       #
@@ -26,12 +30,13 @@ module Spec
       # Instead, use receiver.should_not == expected
       def should(matcher=nil, &block)
         return ExpectationMatcherHandler.handle_matcher(self, matcher, &block) if matcher
-        Should::Should.new(self)
+        Spec::Matchers::PositiveOperatorMatcher.new(self)
       end
 
       # :call-seq:
       #   should_not(matcher)
       #   should_not == expected
+      #   should_not === expected
       #   should_not =~ expected
       #
       #   receiver.should_not(matcher)
@@ -40,70 +45,22 @@ module Spec
       #   receiver.should_not == expected
       #     => Passes unless (receiver == expected)
       #
+      #   receiver.should_not === expected
+      #     => Passes unless (receiver === expected)
+      #
       #   receiver.should_not =~ regexp
       #     => Passes unless (receiver =~ regexp)
       #
       # See Spec::Matchers for more information about matchers
       def should_not(matcher=nil, &block)
         return NegativeExpectationMatcherHandler.handle_matcher(self, matcher, &block) if matcher
-        should.not
+        Spec::Matchers::NegativeOperatorMatcher.new(self)
       end
 
-      deprecated do
-        # Deprecated: use should have(n).items (see Spec::Matchers)
-        # This will be removed in 0.9
-        def should_have(expected)
-          should.have(expected)
-        end
-        alias_method :should_have_exactly, :should_have
-
-        # Deprecated: use should have_at_least(n).items (see Spec::Matchers)
-        # This will be removed in 0.9
-        def should_have_at_least(expected)
-          should.have.at_least(expected)
-        end
-      
-        # Deprecated: use should have_at_most(n).items (see Spec::Matchers)
-        # This will be removed in 0.9
-        def should_have_at_most(expected)
-          should.have.at_most(expected)
-        end
-
-        # Deprecated: use should include(expected) (see Spec::Matchers)
-        # This will be removed in 0.9
-        def should_include(expected)
-          should.include(expected)
-        end
-
-        # Deprecated: use should_not include(expected) (see Spec::Matchers)
-        # This will be removed in 0.9
-        def should_not_include(expected)
-          should.not.include(expected)
-        end
-
-        # Deprecated: use should be(expected) (see Spec::Matchers)
-        # This will be removed in 0.9
-        def should_be(expected = :___no_arg)
-          should.be(expected)
-        end
-      
-        # Deprecated: use should_not be(expected) (see Spec::Matchers)
-        # This will be removed in 0.9
-        def should_not_be(expected = :___no_arg)
-          should_not.be(expected)
-        end
-      end
     end
   end
 end
 
 class Object
   include Spec::Expectations::ObjectExpectations
-  deprecated do
-    include Spec::Expectations::UnderscoreSugar
-  end
 end
-
-deprecated do
-  Object.handle_underscores_for_rspec!
-end

data/lib/spec/expectations/handler.rb

@@ -11,11 +11,9 @@ module Spec
       class << self
         include MatcherHandlerHelper
         def handle_matcher(actual, matcher, &block)
-          unless matcher.nil?
-            match = matcher.matches?(actual, &block)
-            ::Spec::Matchers.generated_description = "should #{describe(matcher)}"
-            Spec::Expectations.fail_with(matcher.failure_message) unless match
-          end
+          match = matcher.matches?(actual, &block)
+          ::Spec::Matchers.generated_description = "should #{describe(matcher)}"
+          Spec::Expectations.fail_with(matcher.failure_message) unless match
         end
       end
     end
@@ -24,20 +22,18 @@ module Spec
       class << self
         include MatcherHandlerHelper
         def handle_matcher(actual, matcher, &block)
-          unless matcher.nil?
-            unless matcher.respond_to?(:negative_failure_message)
-              Spec::Expectations.fail_with(
-  <<-EOF
-  Matcher does not support should_not.
-  See Spec::Matchers for more information
-  about matchers.
-  EOF
-  )
-            end
-            match = matcher.matches?(actual, &block)
-            ::Spec::Matchers.generated_description = "should not #{describe(matcher)}"
-            Spec::Expectations.fail_with(matcher.negative_failure_message) if match
+          unless matcher.respond_to?(:negative_failure_message)
+            Spec::Expectations.fail_with(
+<<-EOF
+Matcher does not support should_not.
+See Spec::Matchers for more information
+about matchers.
+EOF
+)
           end
+          match = matcher.matches?(actual, &block)
+          ::Spec::Matchers.generated_description = "should not #{describe(matcher)}"
+          Spec::Expectations.fail_with(matcher.negative_failure_message) if match
         end
       end
     end