rspec 1.0.8 → 1.1.0

data/lib/spec/example/example_matcher.rb

@@ -0,0 +1,42 @@
+module Spec
+  module Example
+    class ExampleMatcher
+      def initialize(example_group_description, example_name)
+        @example_group_description = example_group_description
+        @example_name = example_name
+      end
+      
+      def matches?(specified_examples)
+        specified_examples.each do |specified_example|
+          return true if matches_literal_example?(specified_example) || matches_example_not_considering_modules?(specified_example)
+        end
+        false
+      end
+      
+      protected
+      def matches_literal_example?(specified_example)
+        specified_example =~ /(^#{example_group_regex} #{example_regexp}$|^#{example_group_regex}$|^#{example_group_with_before_all_regexp}$|^#{example_regexp}$)/
+      end
+
+      def matches_example_not_considering_modules?(specified_example)
+        specified_example =~ /(^#{example_group_regex_not_considering_modules} #{example_regexp}$|^#{example_group_regex_not_considering_modules}$|^#{example_regexp}$)/
+      end
+
+      def example_group_regex
+        Regexp.escape(@example_group_description)
+      end
+
+      def example_group_with_before_all_regexp
+        Regexp.escape("#{@example_group_description} before(:all)")
+      end
+
+      def example_group_regex_not_considering_modules
+        Regexp.escape(@example_group_description.split('::').last)
+      end
+
+      def example_regexp
+        Regexp.escape(@example_name)
+      end
+    end
+  end
+end

data/lib/spec/example/example_methods.rb

@@ -0,0 +1,101 @@
+module Spec
+  module Example
+    module ExampleMethods
+      extend ExampleGroupMethods
+      extend ModuleReopeningFix
+
+      PENDING_EXAMPLE_BLOCK = lambda {
+        raise Spec::Example::ExamplePendingError.new("Not Yet Implemented")
+      }
+
+      def execute(options, instance_variables)
+        options.reporter.example_started(self)
+        set_instance_variables_from_hash(instance_variables)
+        
+        execution_error = nil
+        Timeout.timeout(options.timeout) do
+          begin
+            before_example
+            run_with_description_capturing
+          rescue Exception => e
+            execution_error ||= e
+          end
+          begin
+            after_example
+          rescue Exception => e
+            execution_error ||= e
+          end
+        end
+
+        options.reporter.example_finished(self, execution_error)
+        success = execution_error.nil? || ExamplePendingError === execution_error
+      end
+
+      def instance_variable_hash
+        instance_variables.inject({}) do |variable_hash, variable_name|
+          variable_hash[variable_name] = instance_variable_get(variable_name)
+          variable_hash
+        end
+      end
+
+      def violated(message="")
+        raise Spec::Expectations::ExpectationNotMetError.new(message)
+      end
+
+      def eval_each_fail_fast(procs) #:nodoc:
+        procs.each do |proc|
+          instance_eval(&proc)
+        end
+      end
+
+      def eval_each_fail_slow(procs) #:nodoc:
+        first_exception = nil
+        procs.each do |proc|
+          begin
+            instance_eval(&proc)
+          rescue Exception => e
+            first_exception ||= e
+          end
+        end
+        raise first_exception if first_exception
+      end
+
+      def description
+        @_defined_description || @_matcher_description || "NO NAME"
+      end
+      
+      def set_instance_variables_from_hash(instance_variables)
+        instance_variables.each do |variable_name, value|
+          unless ['@_implementation', '@_defined_description', '@_matcher_description', '@method_name'].index(variable_name)
+            instance_variable_set variable_name, value
+          end
+        end
+      end
+
+      def run_with_description_capturing
+        return_value = nil
+        
+        @_matcher_description = Matchers.capture_generated_description do
+          return_value = instance_eval(&(@_implementation || PENDING_EXAMPLE_BLOCK))
+        end
+        return_value
+      end
+      
+      protected
+      include Matchers
+      include Pending
+      
+      def before_example
+        setup_mocks_for_rspec
+        self.class.run_before_each(self)
+      end
+
+      def after_example
+        self.class.run_after_each(self)
+        verify_mocks_for_rspec
+      ensure
+        teardown_mocks_for_rspec
+      end
+    end
+  end
+end

data/lib/spec/example/module_reopening_fix.rb

@@ -0,0 +1,21 @@
+module Spec
+  module Example
+    # This is a fix for ...Something in Ruby 1.8.6??... (Someone fill in here please - Aslak)
+    module ModuleReopeningFix
+      def child_modules
+        @child_modules ||= []
+      end
+
+      def included(mod)
+        child_modules << mod
+      end
+
+      def include(mod)
+        super
+        child_modules.each do |child_module|
+          child_module.__send__(:include, mod)
+        end
+      end
+    end
+  end
+end

data/lib/spec/example/pending.rb

@@ -0,0 +1,18 @@
+module Spec
+  module Example      
+    module Pending
+      def pending(message = "TODO")
+        if block_given?
+          begin
+            yield
+          rescue Exception => e
+            raise Spec::Example::ExamplePendingError.new(message)
+          end
+          raise Spec::Example::PendingExampleFixedError.new("Expected pending '#{message}' to fail. No Error was raised.")
+        else
+          raise Spec::Example::ExamplePendingError.new(message)
+        end
+      end
+    end
+  end
+end

data/lib/spec/example/shared_example_group.rb

@@ -0,0 +1,58 @@
+module Spec
+  module Example
+    class SharedExampleGroup < Module
+      class << self
+        def add_shared_example_group(new_example_group)
+          guard_against_redefining_existing_example_group(new_example_group)
+          shared_example_groups << new_example_group
+        end
+
+        def find_shared_example_group(example_group_description)
+          shared_example_groups.find do |b|
+            b.description == example_group_description
+          end
+        end
+
+        def shared_example_groups
+          # TODO - this needs to be global, or at least accessible from
+          # from subclasses of Example in a centralized place. I'm not loving
+          # this as a solution, but it works for now.
+          $shared_example_groups ||= []
+        end
+
+        private
+        def guard_against_redefining_existing_example_group(new_example_group)
+          existing_example_group = find_shared_example_group(new_example_group.description)
+          return unless existing_example_group
+          return if new_example_group.equal?(existing_example_group)
+          return if spec_path(new_example_group) == spec_path(existing_example_group)
+          raise ArgumentError.new("Shared Example '#{existing_example_group.description}' already exists")
+        end
+
+        def spec_path(example_group)
+          File.expand_path(example_group.spec_path)
+        end
+      end
+      include ExampleGroupMethods
+      public :include
+
+      def initialize(*args, &example_group_block)
+        describe(*args)
+        @example_group_block = example_group_block
+        self.class.add_shared_example_group(self)
+      end
+
+      def included(mod) # :nodoc:
+        mod.module_eval(&@example_group_block)
+      end
+
+      def execute_in_class_hierarchy(superclass_last=false)
+        classes = [self]
+        superclass_last ? classes << ExampleMethods : classes.unshift(ExampleMethods)
+        classes.each do |example_group|
+          yield example_group
+        end
+      end
+    end
+  end
+end

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

@@ -12,12 +12,8 @@ module Spec
 
       # TODO add some rdoc
       class Default
-        def initialize(format=:unified,context_lines=nil,colour=nil)
-
-          context_lines ||= 3
-          colour        ||= false
-
-          @format,@context_lines,@colour = format,context_lines,colour
+        def initialize(options)
+          @options = options
         end
 
         # This is snagged from diff/lcs/ldiff.rb (which is a commandline tool)
@@ -31,17 +27,17 @@ module Spec
           file_length_difference = 0
           diffs.each do |piece|
             begin
-              hunk = Diff::LCS::Hunk.new(data_old, data_new, piece, @context_lines,
+              hunk = Diff::LCS::Hunk.new(data_old, data_new, piece, context_lines,
                                          file_length_difference)
               file_length_difference = hunk.file_length_difference      
               next unless oldhunk      
               # Hunks may overlap, which is why we need to be careful when our
               # diff includes lines of context. Otherwise, we might print
               # redundant lines.
-              if (@context_lines > 0) and hunk.overlaps?(oldhunk)
+              if (context_lines > 0) and hunk.overlaps?(oldhunk)
                 hunk.unshift(oldhunk)
               else
-                output << oldhunk.diff(@format)
+                output << oldhunk.diff(format)
               end
             ensure
               oldhunk = hunk
@@ -49,12 +45,21 @@ module Spec
             end
           end  
           #Handle the last remaining hunk
-          output << oldhunk.diff(@format) << "\n"
+          output << oldhunk.diff(format) << "\n"
         end  
 
         def diff_as_object(target,expected)
           diff_as_string(PP.pp(target,""), PP.pp(expected,""))
         end
+
+        protected
+        def format
+          @options.diff_format
+        end
+
+        def context_lines
+          @options.context_lines
+        end
       end
     end
   end

data/lib/spec/expectations/errors.rb

@@ -1,6 +1,12 @@
 module Spec
   module Expectations
-    class ExpectationNotMetError < StandardError
+    # If Test::Unit is loaed, we'll use its error as baseclass, so that Test::Unit
+    # will report unmet RSpec expectations as failures rather than errors.
+    superclass = ['Test::Unit::AssertionFailedError', '::StandardError'].map do |c|
+      eval(c) rescue nil
+    end.compact.first
+    
+    class ExpectationNotMetError < superclass
     end
   end
 end

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

@@ -3,7 +3,6 @@ module Spec
     # rspec adds #should and #should_not to every Object (and,
     # implicitly, every Class).
     module ObjectExpectations
-
       # :call-seq:
       #   should(matcher)
       #   should == expected
@@ -28,9 +27,12 @@ module Spec
       #
       # NOTE that this does NOT support receiver.should != expected.
       # Instead, use receiver.should_not == expected
-      def should(matcher=nil, &block)
-        return ExpectationMatcherHandler.handle_matcher(self, matcher, &block) if matcher
-        Spec::Matchers::PositiveOperatorMatcher.new(self)
+      def should(matcher = :default_parameter, &block)
+        if :default_parameter == matcher
+          Spec::Matchers::PositiveOperatorMatcher.new(self)
+        else
+          ExpectationMatcherHandler.handle_matcher(self, matcher, &block)
+        end
       end
 
       # :call-seq:
@@ -52,9 +54,12 @@ module Spec
       #     => 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
-        Spec::Matchers::NegativeOperatorMatcher.new(self)
+      def should_not(matcher = :default_parameter, &block)
+        if :default_parameter == matcher
+          Spec::Matchers::NegativeOperatorMatcher.new(self)
+        else
+          NegativeExpectationMatcherHandler.handle_matcher(self, matcher, &block)
+        end
       end
 
     end

data/lib/spec/expectations/handler.rb

@@ -1,18 +1,23 @@
 module Spec
   module Expectations
+    class InvalidMatcherError < ArgumentError; end        
     
     module MatcherHandlerHelper
-      def describe(matcher)
+      def describe_matcher(matcher)
         matcher.respond_to?(:description) ? matcher.description : "[#{matcher.class.name} does not provide a description]"
       end
     end
     
-    class ExpectationMatcherHandler
+    class ExpectationMatcherHandler        
       class << self
         include MatcherHandlerHelper
         def handle_matcher(actual, matcher, &block)
+          unless matcher.respond_to?(:matches?)
+            raise InvalidMatcherError, "Expected a matcher, got #{matcher.inspect}."
+          end
+          
           match = matcher.matches?(actual, &block)
-          ::Spec::Matchers.generated_description = "should #{describe(matcher)}"
+          ::Spec::Matchers.generated_description = "should #{describe_matcher(matcher)}"
           Spec::Expectations.fail_with(matcher.failure_message) unless match
         end
       end
@@ -22,6 +27,10 @@ module Spec
       class << self
         include MatcherHandlerHelper
         def handle_matcher(actual, matcher, &block)
+          unless matcher.respond_to?(:matches?)
+            raise InvalidMatcherError, "Expected a matcher, got #{matcher.inspect}."
+          end
+
           unless matcher.respond_to?(:negative_failure_message)
             Spec::Expectations.fail_with(
 <<-EOF
@@ -32,7 +41,7 @@ EOF
 )
           end
           match = matcher.matches?(actual, &block)
-          ::Spec::Matchers.generated_description = "should not #{describe(matcher)}"
+          ::Spec::Matchers.generated_description = "should not #{describe_matcher(matcher)}"
           Spec::Expectations.fail_with(matcher.negative_failure_message) if match
         end
       end

data/lib/spec/extensions.rb

@@ -1 +1,3 @@
 require 'spec/extensions/object'
+require 'spec/extensions/class'
+require 'spec/extensions/main'

data/lib/spec/extensions/class.rb

@@ -0,0 +1,24 @@
+class Class
+  # Creates a new subclass of self, with a name "under" our own name.
+  # Example:
+  #
+  #   x = Foo::Bar.subclass('Zap'){}
+  #   x.name # => Foo::Bar::Zap_1
+  #   x.superclass.name # => Foo::Bar
+  def subclass(base_name, &body)
+    klass = Class.new(self)
+    class_name = "#{base_name}_#{class_count!}"
+    instance_eval do
+      const_set(class_name, klass)
+    end
+    klass.instance_eval(&body)
+    klass
+  end
+
+  private
+  def class_count!
+    @class_count ||= 0
+    @class_count += 1
+    @class_count
+  end
+end

data/lib/spec/extensions/main.rb

@@ -0,0 +1,54 @@
+module Spec
+  module Extensions
+    module Main
+      # Creates and returns a class that includes the ExampleGroupMethods
+      # module. The ExampleGroup sub-class depends on the directory of the file
+      # calling this method. For example, Spec::Rails will use different
+      # classes for specs living in <tt>spec/models</tt>,
+      # <tt>spec/helpers</tt>, <tt>spec/views</tt> and
+      # <tt>spec/controllers</tt>.
+      #
+      # It is also possible to override autodiscovery of the example group
+      # type with an options Hash as the last argument:
+      #
+      #   describe "name", :type => :something_special do ...
+      #
+      # The reason for using different behaviour classes is to have different
+      # matcher methods available from within the <tt>describe</tt> block.
+      #
+      # See Spec::Example::ExampleFactory#register for details about how to
+      # register special implementations.
+      #
+      def describe(*args, &block)
+        raise ArgumentError if args.empty?
+        raise ArgumentError unless block
+        args << {} unless Hash === args.last
+        args.last[:spec_path] = caller(0)[1]
+        Spec::Example::ExampleGroupFactory.create_example_group(*args, &block)
+      end
+      alias :context :describe
+      
+      # Shortcut for creating a shared example group
+      def shared_examples_for(name, &block)
+        describe(name, :shared => true, &block)
+      end
+
+    private
+    
+      def rspec_options
+        $rspec_options ||= begin; \
+          parser = ::Spec::Runner::OptionParser.new(STDERR, STDOUT); \
+          parser.order!(ARGV); \
+          $rspec_options = parser.options; \
+        end
+        $rspec_options
+      end
+      
+      def init_rspec_options(options)
+        $rspec_options = options if $rspec_options.nil?
+      end
+    end
+  end
+end
+
+include Spec::Extensions::Main