rspec-core 2.6.4 → 2.7.0.rc1

data/lib/rspec/core/configuration_options.rb

@@ -9,9 +9,7 @@ module RSpec
       end
 
       def configure(config)
-        keys = options.keys
-        keys.unshift(:requires) if keys.delete(:requires)
-        keys.unshift(:libs)     if keys.delete(:libs)
+        keys = order(options.keys, :libs, :requires, :default_path, :pattern)
 
         formatters = options[:formatters] if keys.delete(:formatters)
 
@@ -31,7 +29,6 @@ module RSpec
         argv << "--backtrace"    if options[:full_backtrace]
         argv << "--tty"          if options[:tty]
         argv << "--fail-fast"    if options[:fail_fast]
-        argv << "--line_number"  << options[:line_number]             if options[:line_number]
         argv << "--options"      << options[:custom_options_file]     if options[:custom_options_file]
         if options[:full_description]
           # The argument to --example is regexp-escaped before being stuffed
@@ -40,6 +37,9 @@ module RSpec
           # backslashes, so we must remove them.
           argv << "--example" << options[:full_description].source.delete('\\')
         end
+        if options[:line_numbers]
+          argv += options[:line_numbers].inject([]){|a,l| a << "--line_number" << l}
+        end
         if options[:filter]
           options[:filter].each_pair do |k, v|
             argv << "--tag" << k.to_s
@@ -71,6 +71,13 @@ module RSpec
 
     private
 
+      def order(keys, *ordered)
+        ordered.reverse.each do |key|
+          keys.unshift(key) if keys.delete(key)
+        end
+        keys
+      end
+
       def file_options
         custom_options_file ? custom_options : global_options.merge(local_options)
       end

data/lib/rspec/core/example.rb

@@ -4,6 +4,10 @@ module RSpec
 
       attr_reader :metadata, :options, :example_group_instance
 
+      # Returns the first exception raised, if any, in the context of running
+      # this example.
+      attr_reader :exception
+
       def self.delegate_to_metadata(*keys)
         keys.each do |key|
           define_method(key) {@metadata[key]}
@@ -23,13 +27,12 @@ module RSpec
         @example_group_class
       end
 
-      def around_hooks
+      def around_hooks # :nodoc:
         @around_hooks ||= example_group.around_hooks_for(self)
       end
 
-      def apply?(predicate, filters)
-        @metadata.apply?(predicate, filters) ||
-        @example_group_class.apply?(predicate, filters)
+      def all_apply?(filters)
+        @metadata.all_apply?(filters) || @example_group_class.all_apply?(filters)
       end
 
       alias_method :pending?, :pending
@@ -106,7 +109,7 @@ module RSpec
         if around_hooks.empty?
           yield
         else
-          @example_group_class.eval_around_eachs(self, Example.procsy(metadata, &block)).call
+          @example_group_class.run_around_each_hooks(self, Example.procsy(metadata, &block)).call
         end
       end
 
@@ -142,11 +145,11 @@ module RSpec
 
       def run_before_each
         @example_group_instance.setup_mocks_for_rspec if @example_group_instance.respond_to?(:setup_mocks_for_rspec)
-        @example_group_class.eval_before_eachs(self)
+        @example_group_class.run_before_each_hooks(self)
       end
 
       def run_after_each
-        @example_group_class.eval_after_eachs(self)
+        @example_group_class.run_after_each_hooks(self)
         @example_group_instance.verify_mocks_for_rspec if @example_group_instance.respond_to?(:verify_mocks_for_rspec)
       ensure
         @example_group_instance.teardown_mocks_for_rspec if @example_group_instance.respond_to?(:teardown_mocks_for_rspec)

data/lib/rspec/core/example_group.rb

@@ -60,16 +60,20 @@ module RSpec
 
       alias_example_to :it
       alias_example_to :specify
-      alias_example_to :focused, :focused => true, :focus => true
-      alias_example_to :focus,   :focused => true, :focus => true
-      alias_example_to :pending, :pending => true
-      alias_example_to :xit,     :pending => true
+
+      alias_example_to :pending,  :pending => true
+      alias_example_to :xexample, :pending => true
+      alias_example_to :xit,      :pending => true
+      alias_example_to :xspecify, :pending => true
+
+      alias_example_to :focused,  :focused => true, :focus => true
+      alias_example_to :focus,    :focused => true, :focus => true
 
       def self.define_nested_shared_group_method(new_name, report_label=nil)
         module_eval(<<-END_RUBY, __FILE__, __LINE__)
           def self.#{new_name}(name, *args, &customization_block)
-            shared_block = world.shared_example_groups[name]
-            raise "Could not find shared example group named \#{name.inspect}" unless shared_block
+            shared_block = find_shared("examples", name)
+            raise "Could not find shared examples \#{name.inspect}" unless shared_block
 
             group = describe("#{report_label || "it should behave like"} \#{name}") do
               module_eval_with_args(*args, &shared_block)
@@ -90,11 +94,19 @@ module RSpec
       alias_it_should_behave_like_to :it_behaves_like, "behaves like"
 
       def self.include_context(name)
-        module_eval(&world.shared_example_groups[name])
+        module_eval(&find_shared("context", name))
       end
 
-      class << self
-        alias_method :include_examples, :include_context
+      def self.include_examples(name)
+        module_eval(&find_shared("examples", name))
+      end
+
+      def self.find_shared(label, name)
+        if world.shared_example_groups.has_key?(name)
+          world.shared_example_groups[name]
+        else
+          raise ArgumentError, "Could not find shared #{label} #{name.inspect}"
+        end          
       end
 
       def self.examples
@@ -200,7 +212,7 @@ module RSpec
         ivars.each { |ivar, val| example_group_instance.instance_variable_set(ivar, val) }
       end
 
-      def self.eval_before_alls(example_group_instance)
+      def self.run_before_all_hooks(example_group_instance)
         return if descendant_filtered_examples.empty?
         assign_before_all_ivars(superclass.before_all_ivars, example_group_instance)
         world.run_hook_filtered(:before, :all, self, example_group_instance)
@@ -208,7 +220,7 @@ module RSpec
         store_before_all_ivars(example_group_instance)
       end
 
-      def self.eval_around_eachs(example, initial_procsy)
+      def self.run_around_each_hooks(example, initial_procsy)
         example.around_hooks.reverse.inject(initial_procsy) do |procsy, around_hook|
           Example.procsy(procsy.metadata) do
             example.example_group_instance.instance_eval_with_args(procsy, &around_hook)
@@ -216,17 +228,17 @@ module RSpec
         end
       end
 
-      def self.eval_before_eachs(example)
+      def self.run_before_each_hooks(example)
         world.run_hook_filtered(:before, :each, self, example.example_group_instance, example)
         ancestors.reverse.each { |ancestor| ancestor.run_hook(:before, :each, example.example_group_instance) }
       end
 
-      def self.eval_after_eachs(example)
+      def self.run_after_each_hooks(example)
         ancestors.each { |ancestor| ancestor.run_hook(:after, :each, example.example_group_instance) }
         world.run_hook_filtered(:after, :each, self, example.example_group_instance, example)
       end
 
-      def self.eval_after_alls(example_group_instance)
+      def self.run_after_all_hooks(example_group_instance)
         return if descendant_filtered_examples.empty?
         assign_before_all_ivars(before_all_ivars, example_group_instance)
 
@@ -258,14 +270,14 @@ An error occurred in an after(:all) hook.
         reporter.example_group_started(self)
 
         begin
-          eval_before_alls(new)
+          run_before_all_hooks(new)
           result_for_this_group = run_examples(reporter)
           results_for_descendants = children.map {|child| child.run(reporter)}.all?
           result_for_this_group && results_for_descendants
         rescue Exception => ex
           fail_filtered_examples(ex, reporter)
         ensure
-          eval_after_alls(new)
+          run_after_all_hooks(new)
           before_all_ivars.clear
           reporter.example_group_finished(self)
         end
@@ -297,8 +309,12 @@ An error occurred in an after(:all) hook.
         end.all?
       end
 
-      def self.apply?(predicate, filters)
-        metadata.apply?(predicate, filters)
+      def self.any_apply?(filters)
+        metadata.any_apply?(filters)
+      end
+
+      def self.all_apply?(filters)
+        metadata.all_apply?(filters)
       end
 
       def self.declaration_line_numbers

data/lib/rspec/core/formatters/base_text_formatter.rb

@@ -77,6 +77,11 @@ module RSpec
               output.puts yellow("  #{pending_example.full_description}")
               output.puts cyan("    # #{pending_example.execution_result[:pending_message]}")
               output.puts cyan("    # #{format_caller(pending_example.location)}")
+              if pending_example.execution_result[:exception] \
+                && RSpec.configuration.show_failures_in_pending_blocks?
+                dump_failure_info(pending_example)
+                dump_backtrace(pending_example)
+              end
             end
           end
         end
@@ -156,8 +161,12 @@ module RSpec
         end
 
         def dump_failure(example, index)
-          exception = example.execution_result[:exception]
           output.puts "#{short_padding}#{index.next}) #{example.full_description}"
+          dump_failure_info(example)
+        end
+
+        def dump_failure_info(example)
+          exception = example.execution_result[:exception]
           output.puts "#{long_padding}#{red("Failure/Error:")} #{red(read_failed_line(exception, example).strip)}"
           output.puts "#{long_padding}#{red(exception.class.name << ":")}" unless exception.class.name =~ /RSpec/
           exception.message.split("\n").each { |line| output.puts "#{long_padding}  #{red(line)}" } if exception.message
@@ -170,7 +179,6 @@ module RSpec
             end
           end
         end
-
       end
     end
   end

data/lib/rspec/core/formatters/html_formatter.rb

@@ -108,8 +108,10 @@ module RSpec
         #
         def extra_failure_content(exception)
           require 'rspec/core/formatters/snippet_extractor'
+          backtrace = exception.backtrace.map {|line| backtrace_line(line)}
+          backtrace.compact!
           @snippet_extractor ||= SnippetExtractor.new
-          "    <pre class=\"ruby\"><code>#{@snippet_extractor.snippet(exception)}</code></pre>"
+          "    <pre class=\"ruby\"><code>#{@snippet_extractor.snippet(backtrace)}</code></pre>"
         end
 
         def move_progress

data/lib/rspec/core/formatters/snippet_extractor.rb

@@ -4,10 +4,16 @@ module RSpec
       # This class extracts code snippets by looking at the backtrace of the passed error
       class SnippetExtractor #:nodoc:
         class NullConverter; def convert(code, pre); code; end; end #:nodoc:
-        begin; require 'syntax/convertors/html'; @@converter = Syntax::Convertors::HTML.for_syntax "ruby"; rescue LoadError => e; @@converter = NullConverter.new; end
+        
+        begin
+          require 'syntax/convertors/html'
+          @@converter = Syntax::Convertors::HTML.for_syntax "ruby"
+        rescue LoadError => e
+          @@converter = NullConverter.new
+        end
 
-        def snippet(error)
-          raw_code, line = snippet_for(error.backtrace[0])
+        def snippet(backtrace)
+          raw_code, line = snippet_for(backtrace[0])
           highlighted = @@converter.convert(raw_code, false)
           highlighted << "\n<span class=\"comment\"># gem install syntax to get syntax highlighting</span>" if @@converter.is_a?(NullConverter)
           post_process(highlighted, line)

data/lib/rspec/core/formatters/text_mate_formatter.rb

@@ -1,3 +1,4 @@
+require 'cgi'
 require 'rspec/core/formatters/html_formatter'
 
 module RSpec
@@ -5,15 +6,28 @@ module RSpec
     module Formatters
       # Formats backtraces so they're clickable by TextMate
       class TextMateFormatter < HtmlFormatter
-        def backtrace_line(line)
-          if line = super(line)
-            line.sub!(/([^:]*\.e?rb):(\d*)/) do
-              "<a href=\"txmt://open?url=file://#{File.expand_path($1)}&line=#{$2}\">#{$1}:#{$2}</a> "
-            end
+        def backtrace_line(line, skip_textmate_conversion=false)
+          if skip_textmate_conversion
+            super(line)
+          else
+            format_backtrace_line_for_textmate(super(line))
+          end
+        end
 
-            line
+        def format_backtrace_line_for_textmate(line)
+          return nil unless line
+          CGI.escapeHTML(line).sub(/([^:]*\.e?rb):(\d*)/) do
+            "<a href=\"txmt://open?url=file://#{File.expand_path($1)}&line=#{$2}\">#{$1}:#{$2}</a> "
           end
         end
+
+        def extra_failure_content(exception)
+          require 'rspec/core/formatters/snippet_extractor'
+          backtrace = exception.backtrace.map {|line| backtrace_line(line, :skip_textmate_conversion)}
+          backtrace.compact!
+          @snippet_extractor ||= SnippetExtractor.new
+          "    <pre class=\"ruby\"><code>#{@snippet_extractor.snippet(backtrace)}</code></pre>"
+        end
       end
     end
   end

data/lib/rspec/core/hooks.rb

@@ -13,7 +13,7 @@ module RSpec
         end
 
         def options_apply?(example_or_group)
-          !example_or_group || example_or_group.apply?(:all?, options)
+          example_or_group.all_apply?(options)
         end
 
         def to_proc
@@ -77,7 +77,7 @@ module RSpec
 
       class AfterHooks < HookCollection
         def run_all(example_group_instance)
-          reverse.each {|h| h.run_in(example_group_instance) } unless empty?
+          reverse.each {|h| h.run_in(example_group_instance) } 
         end
 
         def run_all!(example_group_instance)

data/lib/rspec/core/let.rb

@@ -21,7 +21,7 @@ module RSpec
         #  end
         def let(name, &block)
           define_method(name) do
-            __memoized[name] ||= instance_eval(&block)
+            __memoized.fetch(name) {|k| __memoized[k] = instance_eval(&block) }
           end
         end
 
@@ -57,12 +57,12 @@ module RSpec
         #      let(:thing) { Thing.new }
         #
         #      it "is not invoked implicitly" do
-        #        Thing.count.should == 0
+        #        Thing.count.should eq(0)
         #      end
         #
         #      it "can be invoked explicitly" do
         #        thing
-        #        Thing.count.should == 1
+        #        Thing.count.should eq(1)
         #      end
         #    end
         #
@@ -70,12 +70,12 @@ module RSpec
         #      let!(:thing) { Thing.new }
         #
         #      it "is invoked implicitly" do
-        #        Thing.count.should == 1
+        #        Thing.count.should eq(1)
         #      end
         #
         #      it "returns memoized version on first invocation" do
         #        thing
-        #        Thing.count.should == 1
+        #        Thing.count.should eq(1)
         #      end
         #    end
         #  end

data/lib/rspec/core/metadata.rb

@@ -2,7 +2,9 @@ module RSpec
   module Core
     class Metadata < Hash
 
-      module LocationKeys
+      # Used to extend metadata Hashes to support lazy evaluation of locations
+      # and descriptions.
+      module MetadataHash
         def [](key)
           return super if has_key?(key)
           case key
@@ -12,12 +14,22 @@ module RSpec
             file_path, line_number = file_and_line_number
             store(:file_path, file_path)
             store(:line_number, line_number)
-            self[key]
+            super
+          when :execution_result
+            store(:execution_result, {})
+          when :describes
+            store(:describes, described_class_for(self))
+          when :full_description
+            store(:full_description, full_description_for(self))
+          when :description
+            store(:description, build_description_from(*self[:description_args]))
           else
             super
           end
         end
 
+      private
+
         def location
           "#{self[:file_path]}:#{self[:line_number]}"
         end
@@ -30,97 +42,105 @@ module RSpec
         def first_caller_from_outside_rspec
           self[:caller].detect {|l| l !~ /\/lib\/rspec\/core/}
         end
+
+        def described_class_for(m)
+          m[:example_group][:describes]
+        end
+
+        def full_description_for(m)
+          build_description_from(m[:example_group][:full_description], *m[:description_args])
+        end
+
+        def build_description_from(*parts)
+          parts.map {|p| p.to_s}.reduce do |desc, p|
+            p =~ /^(#|::|\.)/ ? "#{desc}#{p}" : "#{desc} #{p}"
+          end || ""
+        end
       end
 
-      def initialize(superclass_metadata=nil)
-        @superclass_metadata = superclass_metadata
-        if @superclass_metadata
-          update(@superclass_metadata)
-          example_group = {:example_group => @superclass_metadata[:example_group]}
+      module GroupMetadataHash
+        include MetadataHash
+
+        def described_class_for(*)
+          ancestors.each do |g|
+            return g[:describes] if g.has_key?(:describes)
+          end
+
+          ancestors.reverse.each do |g|
+            candidate = g[:description_args].first
+            return candidate unless String === candidate || Symbol === candidate
+          end
+
+          nil
+        end
+
+        def full_description_for(*)
+          build_description_from(*ancestors.reverse.map do |a|
+            a.has_key?(:full_description) ? a[:full_description] : a[:description_args]
+          end.flatten)
+        end
+
+      private
+
+        def ancestors
+          @ancestors ||= begin
+                           groups = [group = self]
+                           while group.has_key?(:example_group)
+                             groups << group[:example_group]
+                             group = group[:example_group]
+                           end
+                           groups
+                         end
+        end
+      end
+
+      def initialize(parent_group_metadata=nil)
+        if parent_group_metadata
+          update(parent_group_metadata)
+          store(:example_group, {:example_group => parent_group_metadata[:example_group]}.extend(GroupMetadataHash))
         else
-          example_group = {}
+          store(:example_group, {}.extend(GroupMetadataHash))
         end
 
-        store(:example_group, example_group.extend(LocationKeys))
         yield self if block_given?
       end
 
-      RESERVED_KEYS = [
-        :description,
-        :example_group,
-        :execution_result,
-        :file_path,
-        :full_description,
-        :line_number,
-        :location
-      ]
-
       def process(*args)
         user_metadata = args.last.is_a?(Hash) ? args.pop : {}
         ensure_valid_keys(user_metadata)
 
+        self[:example_group].store(:description_args, args)
         self[:example_group].store(:caller, user_metadata.delete(:caller) || caller)
-        self[:example_group].store(:describes, described_class_from(*args))
-        self[:example_group].store(:description, description_from(*args))
-        self[:example_group].store(:full_description, full_description_from(*args))
-        self[:example_group].store(:block, user_metadata.delete(:example_group_block))
 
         update(user_metadata)
       end
 
-      def ensure_valid_keys(user_metadata)
-        RESERVED_KEYS.each do |key|
-          if user_metadata.keys.include?(key)
-            raise <<-EOM
-#{"*"*50}
-:#{key} is not allowed
-
-RSpec reserves some hash keys for its own internal use,
-including :#{key}, which is used on:
-
-  #{caller(0)[4]}.
-
-Here are all of RSpec's reserved hash keys:
-
-  #{RESERVED_KEYS.join("\n  ")}
-#{"*"*50}
-EOM
-            raise ":#{key} is not allowed"
-          end
-        end
-      end
-
       def for_example(description, user_metadata)
-        dup.extend(LocationKeys).configure_for_example(description, user_metadata)
+        dup.extend(MetadataHash).configure_for_example(description, user_metadata)
       end
 
-      def configure_for_example(description, user_metadata)
-        store(:description, description.to_s)
-        store(:full_description, "#{self[:example_group][:full_description]} #{self[:description]}")
-        store(:execution_result, {})
-        store(:caller, user_metadata.delete(:caller) || caller)
-        update(user_metadata)
-      end
-
-      def apply?(predicate, filters)
-        filters.send(predicate) do |key, value|
-          apply_condition(key, value)
-        end
+      def any_apply?(filters)
+        filters.any? {|k,v| filter_applies?(k,v)}
       end
 
-      def relevant_line_numbers(metadata)
-        line_numbers = [metadata[:line_number]]
-        if metadata[:example_group]
-          line_numbers + relevant_line_numbers(metadata[:example_group])
-        else
-          line_numbers
-        end
+      def all_apply?(filters)
+        filters.all? {|k,v| filter_applies?(k,v)}
       end
 
-      def apply_condition(key, value, metadata=self)
+      def filter_applies?(key, value, metadata=self)
         case value
         when Hash
-          value.all? { |k, v| apply_condition(k, v, metadata[key]) }
+          if key == :locations
+            file_path     = (self[:example_group] || {})[:file_path]
+            expanded_path = file_path && File.expand_path( file_path )
+            if expanded_path && line_numbers = value[expanded_path]
+              filter_applies?(:line_numbers, line_numbers)
+            else
+              true
+            end
+          else
+            value.all? { |k, v| filter_applies?(k, v, metadata[key]) }
+          end
         when Regexp
           metadata[key] =~ value
         when Proc
@@ -135,9 +155,12 @@ EOM
           else
             value.call(metadata[key]) rescue false
           end
-        when Fixnum
-          if key == :line_number
-            relevant_line_numbers(metadata).include?(world.preceding_declaration_line(value))
+        when String
+          metadata[key].to_s == value.to_s
+        when Enumerable
+          if key == :line_numbers
+            preceding_declaration_lines = value.map{|v| world.preceding_declaration_line(v)}
+            !(relevant_line_numbers(metadata) & preceding_declaration_lines).empty?
           else
             metadata[key] == value
           end
@@ -146,42 +169,61 @@ EOM
         end
       end
 
-    private
+    protected
 
-      def world
-        RSpec.world
+      def configure_for_example(description, user_metadata)
+        store(:description_args, [description])
+        store(:caller, user_metadata.delete(:caller) || caller)
+        update(user_metadata)
       end
 
-      def superclass_metadata
-        @superclass_metadata ||= { :example_group => {} }
-      end
+    private
 
-      def description_from(*args)
-        args.inject("") do |result, a|
-          a = a.to_s.strip
-          if result == ""
-            a
-          elsif a =~ /^(#|::|\.)/
-            "#{result}#{a}"
-          else
-            "#{result} #{a}"
+      RESERVED_KEYS = [
+        :description,
+        :example_group,
+        :execution_result,
+        :file_path,
+        :full_description,
+        :line_number,
+        :location
+      ]
+
+      def ensure_valid_keys(user_metadata)
+        RESERVED_KEYS.each do |key|
+          if user_metadata.keys.include?(key)
+            raise <<-EOM
+#{"*"*50}
+:#{key} is not allowed
+
+RSpec reserves some hash keys for its own internal use,
+including :#{key}, which is used on:
+
+  #{caller(0)[4]}.
+
+Here are all of RSpec's reserved hash keys:
+
+  #{RESERVED_KEYS.join("\n  ")}
+#{"*"*50}
+EOM
+            raise ":#{key} is not allowed"
           end
         end
       end
 
-      def full_description_from(*args)
-        if superclass_metadata[:example_group][:full_description]
-          description_from(superclass_metadata[:example_group][:full_description], *args)
-        else
-          description_from(*args)
-        end
+      def world
+        RSpec.world
       end
 
-      def described_class_from(*args)
-        superclass_metadata[:example_group][:describes] || begin
-          args.first unless args.first.is_a?(String) || args.first.is_a?(Symbol)
+      def relevant_line_numbers(metadata)
+        line_numbers = [metadata[:line_number]]
+        if metadata[:example_group]
+          line_numbers + relevant_line_numbers(metadata[:example_group])
+        else
+          line_numbers
         end
       end
+
     end
   end
 end