rspec-core 3.2.3 → 3.3.0

data/lib/rspec/core/example_status_persister.rb

@@ -0,0 +1,235 @@
+RSpec::Support.require_rspec_support "directory_maker"
+
+module RSpec
+  module Core
+    # Persists example ids and their statuses so that we can filter
+    # to just the ones that failed the last time they ran.
+    # @private
+    class ExampleStatusPersister
+      def self.load_from(file_name)
+        return [] unless File.exist?(file_name)
+        ExampleStatusParser.parse(File.read(file_name))
+      end
+
+      def self.persist(examples, file_name)
+        new(examples, file_name).persist
+      end
+
+      def initialize(examples, file_name)
+        @examples  = examples
+        @file_name = file_name
+      end
+
+      def persist
+        write dumped_statuses
+      end
+
+    private
+
+      def write(statuses)
+        RSpec::Support::DirectoryMaker.mkdir_p(File.dirname(@file_name))
+        File.open(@file_name, "w") { |f| f.write(statuses) }
+      end
+
+      def dumped_statuses
+        ExampleStatusDumper.dump(merged_statuses)
+      end
+
+      def merged_statuses
+        ExampleStatusMerger.merge(statuses_from_this_run, statuses_from_previous_runs)
+      end
+
+      def statuses_from_this_run
+        @examples.map do |ex|
+          result = ex.execution_result
+
+          {
+            :example_id => ex.id,
+            :status     => result.status ? result.status.to_s : Configuration::UNKNOWN_STATUS,
+            :run_time   => result.run_time ? Formatters::Helpers.format_duration(result.run_time) : ""
+          }
+        end
+      end
+
+      def statuses_from_previous_runs
+        self.class.load_from(@file_name)
+      end
+    end
+
+    # Merges together a list of example statuses from this run
+    # and a list from previous runs (presumably loaded from disk).
+    # Each example status object is expected to be a hash with
+    # at least an `:example_id` and a `:status` key. Examples that
+    # were loaded but not executed (due to filtering, `--fail-fast`
+    # or whatever) should have a `:status` of `UNKNOWN_STATUS`.
+    #
+    # This willl produce a new list that:
+    #   - Will be missing examples from previous runs that we know for sure
+    #     no longer exist.
+    #   - Will have the latest known status for any examples that either
+    #     definitively do exist or may still exist.
+    #   - Is sorted by file name and example definition order, so that
+    #     the saved file is easily scannable if users want to inspect it.
+    # @private
+    class ExampleStatusMerger
+      def self.merge(this_run, from_previous_runs)
+        new(this_run, from_previous_runs).merge
+      end
+
+      def initialize(this_run, from_previous_runs)
+        @this_run           = hash_from(this_run)
+        @from_previous_runs = hash_from(from_previous_runs)
+        @file_exists_cache  = Hash.new { |hash, file| hash[file] = File.exist?(file) }
+      end
+
+      def merge
+        delete_previous_examples_that_no_longer_exist
+
+        @this_run.merge(@from_previous_runs) do |_ex_id, new, old|
+          new.fetch(:status) == Configuration::UNKNOWN_STATUS ? old : new
+        end.values.sort_by(&method(:sort_value_from))
+      end
+
+    private
+
+      def hash_from(example_list)
+        example_list.inject({}) do |hash, example|
+          hash[example.fetch(:example_id)] = example
+          hash
+        end
+      end
+
+      def delete_previous_examples_that_no_longer_exist
+        @from_previous_runs.delete_if do |ex_id, _|
+          example_must_no_longer_exist?(ex_id)
+        end
+      end
+
+      def example_must_no_longer_exist?(ex_id)
+        # Obviously, it exists if it was loaded for this spec run...
+        return false if @this_run.key?(ex_id)
+
+        spec_file = spec_file_from(ex_id)
+
+        # `this_run` includes examples that were loaded but not executed.
+        # Given that, if the spec file for this example was loaded,
+        # but the id does not still exist, it's safe to assume that
+        # the example must no longer exist.
+        return true if loaded_spec_files.include?(spec_file)
+
+        # The example may still exist as long as the file exists...
+        !@file_exists_cache[spec_file]
+      end
+
+      def loaded_spec_files
+        @loaded_spec_files ||= Set.new(@this_run.keys.map(&method(:spec_file_from)))
+      end
+
+      def spec_file_from(ex_id)
+        ex_id.split("[").first
+      end
+
+      def sort_value_from(example)
+        file, scoped_id = example.fetch(:example_id).split(Configuration::ON_SQUARE_BRACKETS)
+        [file, *scoped_id.split(":").map(&method(:Integer))]
+      end
+    end
+
+    # Dumps a list of hashes in a pretty, human readable format
+    # for later parsing. The hashes are expected to have symbol
+    # keys and string values, and each hash should have the same
+    # set of keys.
+    # @private
+    class ExampleStatusDumper
+      def self.dump(examples)
+        new(examples).dump
+      end
+
+      def initialize(examples)
+        @examples = examples
+      end
+
+      def dump
+        return nil if @examples.empty?
+        (formatted_header_rows + formatted_value_rows).join("\n") << "\n"
+      end
+
+    private
+
+      def formatted_header_rows
+        @formatted_header_rows ||= begin
+          dividers = column_widths.map { |w| "-" * w }
+          [formatted_row_from(headers.map(&:to_s)), formatted_row_from(dividers)]
+        end
+      end
+
+      def formatted_value_rows
+        @foramtted_value_rows ||= rows.map do |row|
+          formatted_row_from(row)
+        end
+      end
+
+      def rows
+        @rows ||= @examples.map { |ex| ex.values_at(*headers) }
+      end
+
+      def formatted_row_from(row_values)
+        padded_values = row_values.each_with_index.map do |value, index|
+          value.ljust(column_widths[index])
+        end
+
+        padded_values.join(" | ") << " |"
+      end
+
+      def headers
+        @headers ||= @examples.first.keys
+      end
+
+      def column_widths
+        @column_widths ||= begin
+          value_sets = rows.transpose
+
+          headers.each_with_index.map do |header, index|
+            values = value_sets[index] << header.to_s
+            values.map(&:length).max
+          end
+        end
+      end
+    end
+
+    # Parses a string that has been previously dumped by ExampleStatusDumper.
+    # Note that this parser is a bit naive in that it does a simple split on
+    # "\n" and " | ", with no concern for handling escaping. For now, that's
+    # OK because the values we plan to persist (example id, status, and perhaps
+    # example duration) are highly unlikely to contain "\n" or " | " -- after
+    # all, who puts those in file names?
+    # @private
+    class ExampleStatusParser
+      def self.parse(string)
+        new(string).parse
+      end
+
+      def initialize(string)
+        @header_line, _, *@row_lines = string.lines.to_a
+      end
+
+      def parse
+        @row_lines.map { |line| parse_row(line) }
+      end
+
+    private
+
+      def parse_row(line)
+        Hash[headers.zip(split_line(line))]
+      end
+
+      def headers
+        @headers ||= split_line(@header_line).grep(/\S/).map(&:to_sym)
+      end
+
+      def split_line(line)
+        line.split(/\s+\|\s+?/, -1)
+      end
+    end
+  end
+end

data/lib/rspec/core/filter_manager.rb

@@ -16,9 +16,15 @@ module RSpec
         # locations is a hash of expanded paths to arrays of line
         # numbers to match against. e.g.
         #   { "path/to/file.rb" => [37, 42] }
-        locations = inclusions.delete(:locations) || Hash.new { |h, k| h[k] = [] }
-        locations[File.expand_path(file_path)].push(*line_numbers)
-        inclusions.add(:locations => locations)
+        add_path_to_arrays_filter(:locations, File.expand_path(file_path), line_numbers)
+      end
+
+      def add_ids(rerun_path, scoped_ids)
+        # ids is a hash of relative paths to arrays of ids
+        # to match against. e.g.
+        #   { "./path/to/file.rb" => ["1:1", "2:4"] }
+        rerun_path = Metadata.relative_path(File.expand_path rerun_path)
+        add_path_to_arrays_filter(:ids, rerun_path, scoped_ids)
       end
 
       def empty?
@@ -26,16 +32,23 @@ module RSpec
       end
 
       def prune(examples)
+        # Semantically, this is unnecessary (the filtering below will return the empty
+        # array unmodified), but for perf reasons it's worth exiting early here. Users
+        # commonly have top-level examples groups that do not have any direct examples
+        # and instead have nested groups with examples. In that kind of situation,
+        # `examples` will be empty.
+        return examples if examples.empty?
+
         examples = prune_conditionally_filtered_examples(examples)
 
         if inclusions.standalone?
-          examples.select { |e| include?(e) }
+          examples.select { |e| inclusions.include_example?(e) }
         else
-          locations, other_inclusions = inclusions.partition_locations
+          locations, ids, non_scoped_inclusions = inclusions.split_file_scoped_rules
 
-          examples.select do |e|
-            priority_include?(e, locations) do
-              !exclude?(e) && other_inclusions.include_example?(e)
+          examples.select do |ex|
+            file_scoped_include?(ex.metadata, ids, locations) do
+              !exclusions.include_example?(ex) && non_scoped_inclusions.include_example?(ex)
             end
           end
         end
@@ -67,12 +80,10 @@ module RSpec
 
     private
 
-      def exclude?(example)
-        exclusions.include_example?(example)
-      end
-
-      def include?(example)
-        inclusions.include_example?(example)
+      def add_path_to_arrays_filter(filter_key, path, values)
+        filter = inclusions.delete(filter_key) || Hash.new { |h, k| h[k] = [] }
+        filter[path].concat(values)
+        inclusions.add(filter_key => filter)
       end
 
       def prune_conditionally_filtered_examples(examples)
@@ -87,9 +98,16 @@ module RSpec
       # and there is a `:slow => true` exclusion filter), but only for specs
       # defined in the same file as the location filters. Excluded specs in
       # other files should still be excluded.
-      def priority_include?(example, locations)
-        return yield if locations[example.metadata[:absolute_file_path]].empty?
-        MetadataFilter.filter_applies?(:locations, locations, example.metadata)
+      def file_scoped_include?(ex_metadata, ids, locations)
+        no_id_filters = ids[ex_metadata[:rerun_file_path]].empty?
+        no_location_filters = locations[
+          File.expand_path(ex_metadata[:rerun_file_path])
+        ].empty?
+
+        return yield if no_location_filters && no_id_filters
+
+        MetadataFilter.filter_applies?(:ids, ids, ex_metadata) ||
+        MetadataFilter.filter_applies?(:locations, locations, ex_metadata)
       end
     end
 
@@ -174,17 +192,6 @@ module RSpec
         apply_standalone_filter(*args) || super
       end
 
-      def use(*args)
-        apply_standalone_filter(*args) || super
-      end
-
-      def partition_locations
-        locations = @rules.fetch(:locations) { Hash.new([]) }
-        other_inclusions = self.class.new(@rules.dup.tap { |r| r.delete(:locations) })
-
-        return locations, other_inclusions
-      end
-
       def include_example?(example)
         @rules.empty? || super
       end
@@ -193,6 +200,14 @@ module RSpec
         is_standalone_filter?(@rules)
       end
 
+      def split_file_scoped_rules
+        rules_dup = @rules.dup
+        locations = rules_dup.delete(:locations) { Hash.new([]) }
+        ids       = rules_dup.delete(:ids)       { Hash.new([]) }
+
+        return locations, ids, self.class.new(rules_dup)
+      end
+
     private
 
       def apply_standalone_filter(updated)

data/lib/rspec/core/flat_map.rb

@@ -7,9 +7,11 @@ module RSpec
           array.flat_map(&block)
         end
       else # for 1.8.7
+        # :nocov:
         def flat_map(array, &block)
           array.map(&block).flatten(1)
         end
+        # :nocov:
       end
 
       module_function :flat_map

data/lib/rspec/core/formatters.rb

@@ -66,11 +66,13 @@ RSpec::Support.require_rspec_support "directory_maker"
 # @see RSpec::Core::Formatters::BaseTextFormatter
 # @see RSpec::Core::Reporter
 module RSpec::Core::Formatters
-  autoload :DocumentationFormatter, 'rspec/core/formatters/documentation_formatter'
-  autoload :HtmlFormatter,          'rspec/core/formatters/html_formatter'
-  autoload :ProgressFormatter,      'rspec/core/formatters/progress_formatter'
-  autoload :ProfileFormatter,       'rspec/core/formatters/profile_formatter'
-  autoload :JsonFormatter,          'rspec/core/formatters/json_formatter'
+  autoload :DocumentationFormatter,   'rspec/core/formatters/documentation_formatter'
+  autoload :HtmlFormatter,            'rspec/core/formatters/html_formatter'
+  autoload :FallbackMessageFormatter, 'rspec/core/formatters/fallback_message_formatter'
+  autoload :ProgressFormatter,        'rspec/core/formatters/progress_formatter'
+  autoload :ProfileFormatter,         'rspec/core/formatters/profile_formatter'
+  autoload :JsonFormatter,            'rspec/core/formatters/json_formatter'
+  autoload :BisectFormatter,          'rspec/core/formatters/bisect_formatter'
 
   # Register the formatter class
   # @param formatter_class [Class] formatter class to register
@@ -120,7 +122,15 @@ module RSpec::Core::Formatters
         add DeprecationFormatter, deprecation_stream, output_stream
       end
 
-      return unless RSpec.configuration.profile_examples? && !existing_formatter_implements?(:dump_profile)
+      unless existing_formatter_implements?(:message)
+        add FallbackMessageFormatter, output_stream
+      end
+
+      return unless RSpec.configuration.profile_examples?
+
+      @reporter.setup_profiler
+
+      return if existing_formatter_implements?(:dump_profile)
 
       add RSpec::Core::Formatters::ProfileFormatter, output_stream
     end
@@ -133,18 +143,12 @@ module RSpec::Core::Formatters
 
       if !Loader.formatters[formatter_class].nil?
         formatter = formatter_class.new(*args)
-        @reporter.register_listener formatter, *notifications_for(formatter_class)
+        register formatter, notifications_for(formatter_class)
       elsif defined?(RSpec::LegacyFormatters)
         formatter = RSpec::LegacyFormatters.load_formatter formatter_class, *args
-        @reporter.register_listener formatter, *formatter.notifications
+        register formatter, formatter.notifications
       else
-        line = ::RSpec::CallerFilter.first_non_rspec_line
-        if line
-          call_site = "Formatter added at: #{line}"
-        else
-          call_site = "The formatter was added via command line flag or your "\
-                      "`.rspec` file."
-        end
+        call_site = "Formatter added at: #{::RSpec::CallerFilter.first_non_rspec_line}"
 
         RSpec.warn_deprecation <<-WARNING.gsub(/\s*\|/, ' ')
           |The #{formatter_class} formatter uses the deprecated formatter
@@ -157,10 +161,7 @@ module RSpec::Core::Formatters
           |
           |#{call_site}
         WARNING
-        return
       end
-      @formatters << formatter unless duplicate_formatter_exists?(formatter)
-      formatter
     end
 
   private
@@ -172,6 +173,13 @@ module RSpec::Core::Formatters
                             "maybe you meant 'documentation' or 'progress'?.")
     end
 
+    def register(formatter, notifications)
+      return if duplicate_formatter_exists?(formatter)
+      @reporter.register_listener formatter, *notifications
+      @formatters << formatter
+      formatter
+    end
+
     def duplicate_formatter_exists?(new_formatter)
       @formatters.any? do |formatter|
         formatter.class === new_formatter && formatter.output == new_formatter.output
@@ -192,12 +200,14 @@ module RSpec::Core::Formatters
         ProgressFormatter
       when 'j', 'json'
         JsonFormatter
+      when 'bisect'
+        BisectFormatter
       end
     end
 
     def notifications_for(formatter_class)
-      formatter_class.ancestors.inject(Set.new) do |notifications, klass|
-        notifications + Loader.formatters.fetch(klass) { Set.new }
+      formatter_class.ancestors.inject(::RSpec::Core::Set.new) do |notifications, klass|
+        notifications.merge Loader.formatters.fetch(klass) { ::RSpec::Core::Set.new }
       end
     end