rspec-core 3.3.0 → 3.4.0

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

@@ -1,114 +1,141 @@
+RSpec::Support.require_rspec_core "source"
+
 module RSpec
   module Core
     module Formatters
-      # @api private
-      #
-      # Extracts code snippets by looking at the backtrace of the passed error
-      # and applies synax highlighting and line numbers using html.
+      # @private
       class SnippetExtractor
-        # @private
-        module NullConverter
-          def self.convert(code)
-            %Q(#{code}\n<span class="comment"># Install the coderay gem to get syntax highlighting</span>)
-          end
-        end
+        NoSuchFileError = Class.new(StandardError)
+        NoSuchLineError = Class.new(StandardError)
 
-        # @private
-        module CoderayConverter
-          def self.convert(code)
-            CodeRay.scan(code, :ruby).html(:line_numbers => false)
-          end
+        def self.extract_line_at(file_path, line_number)
+          source = source_from_file(file_path)
+          line = source.lines[line_number - 1]
+          raise NoSuchLineError unless line
+          line
         end
 
-        # rubocop:disable Style/ClassVars
-        @@converter = NullConverter
-        begin
-          require 'coderay'
-          @@converter = CoderayConverter
-          # rubocop:disable Lint/HandleExceptions
-        rescue LoadError
-          # it'll fall back to the NullConverter assigned above
-          # rubocop:enable Lint/HandleExceptions
+        def self.source_from_file(path)
+          raise NoSuchFileError unless File.exist?(path)
+          RSpec.world.source_cache.source_from_file(path)
         end
 
-        # rubocop:enable Style/ClassVars
-
-        # @api private
-        #
-        # Extract lines of code corresponding to  a backtrace.
-        #
-        # @param backtrace [String] the backtrace from a test failure
-        # @return [String] highlighted code snippet indicating where the test
-        #   failure occured
-        #
-        # @see #post_process
-        def snippet(backtrace)
-          raw_code, line = snippet_for(backtrace[0])
-          highlighted = @@converter.convert(raw_code)
-          post_process(highlighted, line)
-        end
-        # rubocop:enable Style/ClassVars
-
-        # @api private
-        #
-        # Create a snippet from a line of code.
-        #
-        # @param error_line [String] file name with line number (i.e.
-        #   'foo_spec.rb:12')
-        # @return [String] lines around the target line within the file
-        #
-        # @see #lines_around
-        def snippet_for(error_line)
-          if error_line =~ /(.*):(\d+)/
-            file = Regexp.last_match[1]
-            line = Regexp.last_match[2].to_i
-            [lines_around(file, line), line]
-          else
-            ["# Couldn't get snippet for #{error_line}", 1]
+        if RSpec::Support::RubyFeatures.ripper_supported?
+          NoExpressionAtLineError = Class.new(StandardError)
+
+          PAREN_TOKEN_TYPE_PAIRS = {
+            :on_lbracket    => :on_rbracket,
+            :on_lparen      => :on_rparen,
+            :on_lbrace      => :on_rbrace,
+            :on_heredoc_beg => :on_heredoc_end
+          }
+
+          attr_reader :source, :beginning_line_number, :max_line_count
+
+          def self.extract_expression_lines_at(file_path, beginning_line_number, max_line_count=nil)
+            if max_line_count == 1
+              [extract_line_at(file_path, beginning_line_number)]
+            else
+              source = source_from_file(file_path)
+              new(source, beginning_line_number, max_line_count).expression_lines
+            end
           end
-        end
 
-        # @api private
-        #
-        # Extract lines of code centered around a particular line within a
-        # source file.
-        #
-        # @param file [String] filename
-        # @param line [Fixnum] line number
-        # @return [String] lines around the target line within the file (2 above
-        #   and 1 below).
-        def lines_around(file, line)
-          if File.file?(file)
-            lines = File.read(file).split("\n")
-            min = [0, line - 3].max
-            max = [line + 1, lines.length - 1].min
-            selected_lines = []
-            selected_lines.join("\n")
-            lines[min..max].join("\n")
-          else
-            "# Couldn't get snippet for #{file}"
+          def initialize(source, beginning_line_number, max_line_count=nil)
+            @source = source
+            @beginning_line_number = beginning_line_number
+            @max_line_count = max_line_count
           end
-        rescue SecurityError
-          "# Couldn't get snippet for #{file}"
-        end
 
-        # @api private
-        #
-        # Adds line numbers to all lines and highlights the line where the
-        # failure occurred using html `span` tags.
-        #
-        # @param highlighted [String] syntax-highlighted snippet surrounding the
-        #   offending line of code
-        # @param offending_line [Fixnum] line where failure occured
-        # @return [String] completed snippet
-        def post_process(highlighted, offending_line)
-          new_lines = []
-          highlighted.split("\n").each_with_index do |line, i|
-            new_line = "<span class=\"linenum\">#{offending_line + i - 2}</span>#{line}"
-            new_line = "<span class=\"offending\">#{new_line}</span>" if i == 2
-            new_lines << new_line
+          def expression_lines
+            line_range = line_range_of_expression
+
+            if max_line_count && line_range.count > max_line_count
+              line_range = (line_range.begin)..(line_range.begin + max_line_count - 1)
+            end
+
+            source.lines[(line_range.begin - 1)..(line_range.end - 1)]
+          rescue SyntaxError, NoExpressionAtLineError
+            [self.class.extract_line_at(source.path, beginning_line_number)]
+          end
+
+          private
+
+          def line_range_of_expression
+            @line_range_of_expression ||= begin
+              line_range = line_range_of_location_nodes_in_expression
+              initial_unclosed_parens = unclosed_paren_tokens_in_line_range(line_range)
+              unclosed_parens = initial_unclosed_parens
+
+              until (initial_unclosed_parens & unclosed_parens).empty?
+                line_range = (line_range.begin)..(line_range.end + 1)
+                unclosed_parens = unclosed_paren_tokens_in_line_range(line_range)
+              end
+
+              line_range
+            end
           end
-          new_lines.join("\n")
+
+          def unclosed_paren_tokens_in_line_range(line_range)
+            tokens = FlatMap.flat_map(line_range) do |line_number|
+              source.tokens_by_line_number[line_number]
+            end
+
+            tokens.each_with_object([]) do |token, unclosed_tokens|
+              if PAREN_TOKEN_TYPE_PAIRS.keys.include?(token.type)
+                unclosed_tokens << token
+              else
+                index = unclosed_tokens.rindex do |unclosed_token|
+                  PAREN_TOKEN_TYPE_PAIRS[unclosed_token.type] == token.type
+                end
+                unclosed_tokens.delete_at(index) if index
+              end
+            end
+          end
+
+          def line_range_of_location_nodes_in_expression
+            line_numbers = expression_node.each_with_object(Set.new) do |node, set|
+              set << node.location.line if node.location
+            end
+
+            line_numbers.min..line_numbers.max
+          end
+
+          def expression_node
+            raise NoExpressionAtLineError if location_nodes_at_beginning_line.empty?
+
+            @expression_node ||= begin
+              common_ancestor_nodes = location_nodes_at_beginning_line.map do |node|
+                node.each_ancestor.to_a
+              end.reduce(:&)
+
+              common_ancestor_nodes.find { |node| expression_outmost_node?(node) }
+            end
+          end
+
+          def expression_outmost_node?(node)
+            return true unless node.parent
+            return false if node.type.to_s.start_with?('@')
+            ![node, node.parent].all? do |n|
+              # See `Ripper::PARSER_EVENTS` for the complete list of sexp types.
+              type = n.type.to_s
+              type.end_with?('call') || type.start_with?('method_add_')
+            end
+          end
+
+          def location_nodes_at_beginning_line
+            source.nodes_by_line_number[beginning_line_number]
+          end
+        else
+          # :nocov:
+          def self.extract_expression_lines_at(file_path, beginning_line_number, *)
+            [extract_line_at(file_path, beginning_line_number)]
+          end
+          # :nocov:
+        end
+
+        def self.least_indentation_from(lines)
+          lines.map { |line| line[/^[ \t]*/] }.min
         end
       end
     end

data/lib/rspec/core/formatters.rb

@@ -73,6 +73,7 @@ module RSpec::Core::Formatters
   autoload :ProfileFormatter,         'rspec/core/formatters/profile_formatter'
   autoload :JsonFormatter,            'rspec/core/formatters/json_formatter'
   autoload :BisectFormatter,          'rspec/core/formatters/bisect_formatter'
+  autoload :ExceptionPresenter,       'rspec/core/formatters/exception_presenter'
 
   # Register the formatter class
   # @param formatter_class [Class] formatter class to register
@@ -182,7 +183,7 @@ module RSpec::Core::Formatters
 
     def duplicate_formatter_exists?(new_formatter)
       @formatters.any? do |formatter|
-        formatter.class === new_formatter && formatter.output == new_formatter.output
+        formatter.class == new_formatter.class && formatter.output == new_formatter.output
       end
     end
 

data/lib/rspec/core/hooks.rb

@@ -362,7 +362,7 @@ module RSpec
       class AfterHook < Hook
         def run(example)
           example.instance_exec(example, &block)
-        rescue Exception => ex
+        rescue Support::AllExceptionsExceptOnesWeMustNotRescue => ex
           example.set_exception(ex)
         end
       end
@@ -371,7 +371,7 @@ module RSpec
       class AfterContextHook < Hook
         def run(example)
           example.instance_exec(example, &block)
-        rescue Exception => e
+        rescue Support::AllExceptionsExceptOnesWeMustNotRescue => e
           # TODO: Come up with a better solution for this.
           RSpec.configuration.reporter.message <<-EOS
 

data/lib/rspec/core/memoized_helpers.rb

@@ -1,4 +1,4 @@
-require 'rspec/core/reentrant_mutex'
+RSpec::Support.require_rspec_support 'reentrant_mutex'
 
 module RSpec
   module Core
@@ -148,7 +148,7 @@ module RSpec
       class ThreadsafeMemoized
         def initialize
           @memoized = {}
-          @mutex = ReentrantMutex.new
+          @mutex = Support::ReentrantMutex.new
         end
 
         def fetch_or_store(key)

data/lib/rspec/core/metadata.rb

@@ -147,12 +147,13 @@ module RSpec
                                    end
 
           relative_file_path            = Metadata.relative_path(file_path)
+          absolute_file_path            = File.expand_path(relative_file_path)
           metadata[:file_path]          = relative_file_path
           metadata[:line_number]        = line_number.to_i
           metadata[:location]           = "#{relative_file_path}:#{line_number}"
-          metadata[:absolute_file_path] = File.expand_path(relative_file_path)
+          metadata[:absolute_file_path] = absolute_file_path
           metadata[:rerun_file_path]  ||= relative_file_path
-          metadata[:scoped_id]          = build_scoped_id_for(relative_file_path)
+          metadata[:scoped_id]          = build_scoped_id_for(absolute_file_path)
         end
 
         def file_path_and_line_number_from(backtrace)

data/lib/rspec/core/metadata_filter.rb

@@ -15,22 +15,19 @@ module RSpec
         # @private
         def filter_applies?(key, value, metadata)
           silence_metadata_example_group_deprecations do
-            return filter_applies_to_any_value?(key, value, metadata) if Array === metadata[key] && !(Proc === value)
             return location_filter_applies?(value, metadata)          if key == :locations
             return id_filter_applies?(value, metadata)                if key == :ids
             return filters_apply?(key, value, metadata)               if Hash === value
 
             return false unless metadata.key?(key)
+            return true if TrueClass === value && !!metadata[key]
+            return filter_applies_to_any_value?(key, value, metadata) if Array === metadata[key] && !(Proc === value)
 
             case value
             when Regexp
               metadata[key] =~ value
             when Proc
-              case value.arity
-              when 0 then value.call
-              when 2 then value.call(metadata[key], metadata)
-              else value.call(metadata[key])
-              end
+              proc_filter_applies?(key, value, metadata)
             else
               metadata[key].to_s == value.to_s
             end
@@ -61,6 +58,14 @@ module RSpec
           !(relevant_line_numbers(metadata) & preceding_declaration_lines).empty?
         end
 
+        def proc_filter_applies?(key, proc, metadata)
+          case proc.arity
+          when 0 then proc.call
+          when 2 then proc.call(metadata[key], metadata)
+          else proc.call(metadata[key])
+          end
+        end
+
         def relevant_line_numbers(metadata)
           Metadata.ascend(metadata).map { |meta| meta[:line_number] }
         end

data/lib/rspec/core/notifications.rb

@@ -1,7 +1,6 @@
 RSpec::Support.require_rspec_core "formatters/exception_presenter"
 RSpec::Support.require_rspec_core "formatters/helpers"
 RSpec::Support.require_rspec_core "shell_escape"
-RSpec::Support.require_rspec_support "encoded_string"
 
 module RSpec::Core
   # Notifications are value objects passed to formatters to provide them
@@ -10,6 +9,7 @@ module RSpec::Core
     # @private
     module NullColorizer
       module_function
+
       def wrap(line, _code_or_symbol)
         line
       end
@@ -281,7 +281,8 @@ module RSpec::Core
     # @attr pending_examples [Array<RSpec::Core::Example>] the pending examples
     # @attr load_time [Float] the number of seconds taken to boot RSpec
     #                         and load the spec files
-    SummaryNotification = Struct.new(:duration, :examples, :failed_examples, :pending_examples, :load_time)
+    SummaryNotification = Struct.new(:duration, :examples, :failed_examples,
+                                     :pending_examples, :load_time)
     class SummaryNotification
       # @api
       # @return [Fixnum] the number of examples run

data/lib/rspec/core/option_parser.rb

@@ -34,6 +34,8 @@ module RSpec::Core
   private
 
     # rubocop:disable MethodLength
+    # rubocop:disable Metrics/AbcSize
+    # rubocop:disable CyclomaticComplexity
     def parser(options)
       OptionParser.new do |parser|
         parser.banner = "Usage: rspec [options] [files or directories]\n\n"
@@ -69,7 +71,18 @@ module RSpec::Core
           bisect_and_exit(argument)
         end
 
-        parser.on('--[no-]fail-fast', 'Abort the run on first failure.') do |value|
+        parser.on('--[no-]fail-fast[=COUNT]', 'Abort the run after a certain number of failures (1 by default).') do |argument|
+          if argument == true
+            value = 1
+          elsif argument == false || argument == 0
+            value = false
+          else
+            begin
+              value = Integer(argument)
+            rescue ArgumentError
+              RSpec.warning "Expected an integer value for `--fail-fast`, got: #{argument.inspect}", :call_site => nil
+            end
+          end
           set_fail_fast(options, value)
         end
 
@@ -174,12 +187,16 @@ FILTERING
         parser.on("--next-failure", "Apply `--only-failures` and abort after one failure.",
                   "  (Equivalent to `--only-failures --fail-fast --order defined`)") do
           configure_only_failures(options)
-          set_fail_fast(options, true)
+          set_fail_fast(options, 1)
           options[:order] ||= 'defined'
         end
 
         parser.on('-P', '--pattern PATTERN', 'Load files matching pattern (default: "spec/**/*_spec.rb").') do |o|
-          options[:pattern] = o
+          if options[:pattern]
+            options[:pattern] += ',' + o
+          else
+            options[:pattern] = o
+          end
         end
 
         parser.on('--exclude-pattern PATTERN',
@@ -246,10 +263,11 @@ FILTERING
             raise OptionParser::InvalidOption.new
           end
         end
-
       end
     end
+    # rubocop:enable Metrics/AbcSize
     # rubocop:enable MethodLength
+    # rubocop:enable CyclomaticComplexity
 
     def add_tag_filter(options, filter_type, tag_name, value=true)
       (options[filter_type] ||= {})[tag_name] = value

data/lib/rspec/core/project_initializer/spec/spec_helper.rb

@@ -57,9 +57,9 @@ RSpec.configure do |config|
 
   # Limits the available syntax to the non-monkey patched syntax that is
   # recommended. For more details, see:
-  #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+  #   - http://rspec.info/blog/2012/06/rspecs-new-expectation-syntax/
   #   - http://www.teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
-  #   - http://myronmars.to/n/dev-blog/2014/05/notable-changes-in-rspec-3#new__config_option_to_disable_rspeccore_monkey_patching
+  #   - http://rspec.info/blog/2014/05/notable-changes-in-rspec-3/#zero-monkey-patching-mode
   config.disable_monkey_patching!
 
   # This setting enables warnings. It's recommended, but in some cases may

data/lib/rspec/core/rake_task.rb

@@ -1,7 +1,16 @@
 require 'rake'
 require 'rake/tasklib'
-require 'rspec/support/ruby_features'
-require 'rspec/core/shell_escape'
+require 'rspec/support'
+
+RSpec::Support.require_rspec_support "ruby_features"
+
+# :nocov:
+unless RSpec::Support.respond_to?(:require_rspec_core)
+  RSpec::Support.define_optimized_require_for_rspec(:core) { |f| require_relative "../#{f}" }
+end
+# :nocov:
+
+RSpec::Support.require_rspec_core "shell_escape"
 
 module RSpec
   module Core
@@ -91,7 +100,7 @@ module RSpec
 
       def file_inclusion_specification
         if ENV['SPEC']
-          FileList[ ENV['SPEC']].sort
+          FileList[ENV['SPEC']].sort
         elsif String === pattern && !File.exist?(pattern)
           "--pattern #{escape pattern}"
         else

data/lib/rspec/core/reporter.rb

@@ -8,7 +8,7 @@ module RSpec::Core
         :close, :deprecation, :deprecation_summary, :dump_failures, :dump_pending,
         :dump_profile, :dump_summary, :example_failed, :example_group_finished,
         :example_group_started, :example_passed, :example_pending, :example_started,
-        :message, :seed, :start, :start_dump, :stop
+        :message, :seed, :start, :start_dump, :stop, :example_finished
       ])
 
     def initialize(configuration)
@@ -124,6 +124,11 @@ module RSpec::Core
       notify :example_started, Notifications::ExampleNotification.for(example)
     end
 
+    # @private
+    def example_finished(example)
+      notify :example_finished, Notifications::ExampleNotification.for(example)
+    end
+
     # @private
     def example_passed(example)
       notify :example_passed, Notifications::ExampleNotification.for(example)
@@ -192,6 +197,17 @@ module RSpec::Core
       exit!(exit_status)
     end
 
+    # @private
+    def fail_fast_limit_met?
+      return false unless (fail_fast = @configuration.fail_fast)
+
+      if fail_fast == true
+        @failed_examples.any?
+      else
+        fail_fast <= @failed_examples.size
+      end
+    end
+
   private
 
     def close
@@ -201,7 +217,7 @@ module RSpec::Core
     def mute_profile_output?
       # Don't print out profiled info if there are failures and `--fail-fast` is
       # used, it just clutters the output.
-      !@configuration.profile_examples? || (@configuration.fail_fast? && @failed_examples.size > 0)
+      !@configuration.profile_examples? || fail_fast_limit_met?
     end
 
     def seed_used?

data/lib/rspec/core/ruby_project.rb

@@ -6,7 +6,7 @@ module RSpec
     # @private
     module RubyProject
       def add_to_load_path(*dirs)
-        dirs.map { |dir| add_dir_to_load_path(File.join(root, dir)) }
+        dirs.each { |dir| add_dir_to_load_path(File.join(root, dir)) }
       end
 
       def add_dir_to_load_path(dir)

data/lib/rspec/core/shared_example_group.rb

@@ -96,6 +96,7 @@ module RSpec
       # Shared examples top level DSL.
       module TopLevelDSL
         # @private
+        # rubocop:disable Lint/NestedMethodDefinition
         def self.definitions
           proc do
             def shared_examples(name, *args, &block)
@@ -105,6 +106,7 @@ module RSpec
             alias shared_examples_for shared_examples
           end
         end
+        # rubocop:enable Lint/NestedMethodDefinition
 
         # @private
         def self.exposed_globally?

data/lib/rspec/core/source/location.rb

@@ -0,0 +1,13 @@
+module RSpec
+  module Core
+    class Source
+      # @private
+      # Represents a source location of node or token.
+      Location = Struct.new(:line, :column) do
+        def self.location?(array)
+          array.is_a?(Array) && array.size == 2 && array.all? { |e| e.is_a?(Integer) }
+        end
+      end
+    end
+  end
+end

data/lib/rspec/core/source/node.rb

@@ -0,0 +1,93 @@
+RSpec::Support.require_rspec_core "source/location"
+
+module RSpec
+  module Core
+    class Source
+      # @private
+      # A wrapper for Ripper AST node which is generated with `Ripper.sexp`.
+      class Node
+        include Enumerable
+
+        attr_reader :sexp, :parent
+
+        def self.sexp?(array)
+          array.is_a?(Array) && array.first.is_a?(Symbol)
+        end
+
+        def initialize(ripper_sexp, parent=nil)
+          @sexp = ripper_sexp.freeze
+          @parent = parent
+        end
+
+        def type
+          sexp[0]
+        end
+
+        def args
+          @args ||= raw_args.map do |raw_arg|
+            if Node.sexp?(raw_arg)
+              Node.new(raw_arg, self)
+            elsif Location.location?(raw_arg)
+              Location.new(*raw_arg)
+            elsif raw_arg.is_a?(Array)
+              GroupNode.new(raw_arg, self)
+            else
+              raw_arg
+            end
+          end.freeze
+        end
+
+        def children
+          @children ||= args.select { |arg| arg.is_a?(Node) }.freeze
+        end
+
+        def location
+          @location ||= args.find { |arg| arg.is_a?(Location) }
+        end
+
+        def each(&block)
+          return to_enum(__method__) unless block_given?
+
+          yield self
+
+          children.each do |child|
+            child.each(&block)
+          end
+        end
+
+        def each_ancestor
+          return to_enum(__method__) unless block_given?
+
+          current_node = self
+
+          while (current_node = current_node.parent)
+            yield current_node
+          end
+        end
+
+        def inspect
+          "#<#{self.class} #{type}>"
+        end
+
+      private
+
+        def raw_args
+          sexp[1..-1] || []
+        end
+      end
+
+      # @private
+      class GroupNode < Node
+        def type
+          :group
+        end
+
+      private
+
+        def raw_args
+          sexp
+        end
+      end
+    end
+  end
+end