opal-rspec 0.8.0 → 1.0.0.alpha1

data/rspec-core/upstream/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
+        RSpec::Support::DirectoryMaker.mkdir_p(File.dirname(@file_name))
+        File.open(@file_name, File::RDWR | File::CREAT) do |f|
+          # lock the file while reading / persisting to avoid a race
+          # condition where parallel or unrelated spec runs race to
+          # update the same file
+          f.flock(File::LOCK_EX)
+          unparsed_previous_runs = f.read
+          f.rewind
+          f.write(dump_statuses(unparsed_previous_runs))
+          f.flush
+          f.truncate(f.pos)
+        end
+      end
+
+    private
+
+      def dump_statuses(unparsed_previous_runs)
+        statuses_from_previous_runs = ExampleStatusParser.parse(unparsed_previous_runs)
+        merged_statuses = ExampleStatusMerger.merge(statuses_from_this_run, statuses_from_previous_runs)
+        ExampleStatusDumper.dump(merged_statuses)
+      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
+    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.parse_id(example.fetch(:example_id))
+        [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/rspec-core/upstream/lib/rspec/core/filter_manager.rb

@@ -1,71 +1,6 @@
 module RSpec
   module Core
     # @private
-    # Manages the filtering of examples and groups by matching tags declared on
-    # the command line or options files, or filters declared via
-    # `RSpec.configure`, with hash key/values submitted within example group
-    # and/or example declarations. For example, given this declaration:
-    #
-    #     describe Thing, :awesome => true do
-    #       it "does something" do
-    #         # ...
-    #       end
-    #     end
-    #
-    # That group (or any other with `:awesome => true`) would be filtered in
-    # with any of the following commands:
-    #
-    #     rspec --tag awesome:true
-    #     rspec --tag awesome
-    #     rspec -t awesome:true
-    #     rspec -t awesome
-    #
-    # Prefixing the tag names with `~` negates the tags, thus excluding this group with
-    # any of:
-    #
-    #     rspec --tag ~awesome:true
-    #     rspec --tag ~awesome
-    #     rspec -t ~awesome:true
-    #     rspec -t ~awesome
-    #
-    # ## Options files and command line overrides
-    #
-    # Tag declarations can be stored in `.rspec`, `~/.rspec`, or a custom
-    # options file.  This is useful for storing defaults. For example, let's
-    # say you've got some slow specs that you want to suppress most of the
-    # time. You can tag them like this:
-    #
-    #     describe Something, :slow => true do
-    #
-    # And then store this in `.rspec`:
-    #
-    #     --tag ~slow:true
-    #
-    # Now when you run `rspec`, that group will be excluded.
-    #
-    # ## Overriding
-    #
-    # Of course, you probably want to run them sometimes, so you can override
-    # this tag on the command line like this:
-    #
-    #     rspec --tag slow:true
-    #
-    # ## RSpec.configure
-    #
-    # You can also store default tags with `RSpec.configure`. We use `tag` on
-    # the command line (and in options files like `.rspec`), but for historical
-    # reasons we use the term `filter` in `RSpec.configure:
-    #
-    #     RSpec.configure do |c|
-    #       c.filter_run_including :foo => :bar
-    #       c.filter_run_excluding :foo => :bar
-    #     end
-    #
-    # These declarations can also be overridden from the command line.
-    #
-    # @see RSpec.configure
-    # @see Configuration#filter_run_including
-    # @see Configuration#filter_run_excluding
     class FilterManager
       attr_reader :exclusions, :inclusions
 
@@ -81,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_location(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?
@@ -91,11 +32,25 @@ 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?
-          base_exclusions = ExclusionRules.new
-          examples.select { |e| !base_exclusions.include_example?(e) && include?(e) }
+          examples.select { |e| inclusions.include_example?(e) }
         else
-          examples.select { |e| !exclude?(e) && include?(e) }
+          locations, ids, non_scoped_inclusions = inclusions.split_file_scoped_rules
+
+          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
       end
 
@@ -111,10 +66,6 @@ module RSpec
         exclusions.add_with_low_priority(args.last)
       end
 
-      def exclude?(example)
-        exclusions.include_example?(example)
-      end
-
       def include(*args)
         inclusions.add(args.last)
       end
@@ -127,14 +78,42 @@ module RSpec
         inclusions.add_with_low_priority(args.last)
       end
 
-      def include?(example)
-        inclusions.include_example?(example)
+    private
+
+      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)
+        examples.reject do |ex|
+          meta = ex.metadata
+          !meta.fetch(:if, true) || meta[:unless]
+        end
+      end
+
+      # When a user specifies a particular spec location, that takes priority
+      # over any exclusion filters (such as if the spec is tagged with `:slow`
+      # 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 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
 
     # @private
     class FilterRules
-      PROC_HEX_NUMBER = /0x[0-9a-f]+@/
+      PROC_HEX_NUMBER = /0x[0-9a-f]+@?/
       PROJECT_DIR = File.expand_path('.')
 
       attr_accessor :opposite
@@ -148,8 +127,8 @@ module RSpec
         [exclusions, inclusions]
       end
 
-      def initialize(*args, &block)
-        @rules = Hash.new(*args, &block)
+      def initialize(rules={})
+        @rules = rules
       end
 
       def add(updated)
@@ -194,16 +173,17 @@ module RSpec
       def description
         rules.inspect.gsub(PROC_HEX_NUMBER, '').gsub(PROJECT_DIR, '.').gsub(' (lambda)', '')
       end
+
+      def include_example?(example)
+        MetadataFilter.apply?(:any?, @rules, example.metadata)
+      end
     end
 
     # @private
-    class InclusionRules < FilterRules
-      STANDALONE_FILTERS = [:locations, :full_description]
-
-      def add_location(locations)
-        replace_filters(:locations => locations)
-      end
+    ExclusionRules = FilterRules
 
+    # @private
+    class InclusionRules < FilterRules
       def add(*args)
         apply_standalone_filter(*args) || super
       end
@@ -212,18 +192,22 @@ module RSpec
         apply_standalone_filter(*args) || super
       end
 
-      def use(*args)
-        apply_standalone_filter(*args) || super
-      end
-
       def include_example?(example)
-        @rules.empty? ? true : example.any_apply?(@rules)
+        @rules.empty? || super
       end
 
       def standalone?
         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)
@@ -240,19 +224,7 @@ module RSpec
       end
 
       def is_standalone_filter?(rules)
-        STANDALONE_FILTERS.any? { |key| rules.key?(key) }
-      end
-    end
-
-    # @private
-    class ExclusionRules < FilterRules
-      CONDITIONAL_FILTERS = {
-        :if     => lambda { |value| !value },
-        :unless => lambda { |value| value }
-      }.freeze
-
-      def include_example?(example)
-        example.any_apply?(@rules) || example.any_apply?(CONDITIONAL_FILTERS)
+        rules.key?(:full_description)
       end
     end
   end

data/rspec-core/upstream/lib/rspec/core/flat_map.rb

@@ -3,13 +3,15 @@ module RSpec
     # @private
     module FlatMap
       if [].respond_to?(:flat_map)
-        def flat_map(array)
-          array.flat_map { |item| yield item }
+        def flat_map(array, &block)
+          array.flat_map(&block)
         end
       else # for 1.8.7
-        def flat_map(array)
-          array.map { |item| yield item }.flatten
+        # :nocov:
+        def flat_map(array, &block)
+          array.map(&block).flatten(1)
         end
+        # :nocov:
       end
 
       module_function :flat_map

data/rspec-core/upstream/lib/rspec/core/formatters/base_bisect_formatter.rb

@@ -0,0 +1,45 @@
+RSpec::Support.require_rspec_core "bisect/utilities"
+
+module RSpec
+  module Core
+    module Formatters
+      # Contains common logic for formatters used by `--bisect` to communicate results
+      # back to the bisect runner.
+      #
+      # Subclasses must define a `notify_results(all_example_ids, failed_example_ids)`
+      # method.
+      # @private
+      class BaseBisectFormatter
+        def self.inherited(formatter)
+          Formatters.register formatter, :start_dump, :example_failed, :example_finished
+        end
+
+        def initialize(expected_failures)
+          @all_example_ids = []
+          @failed_example_ids = []
+          @remaining_failures = expected_failures
+        end
+
+        def example_failed(notification)
+          @failed_example_ids << notification.example.id
+        end
+
+        def example_finished(notification)
+          @all_example_ids << notification.example.id
+          return unless @remaining_failures.include?(notification.example.id)
+          @remaining_failures.delete(notification.example.id)
+
+          status = notification.example.execution_result.status
+          return if status == :failed && !@remaining_failures.empty?
+          RSpec.world.wants_to_quit = true
+        end
+
+        def start_dump(_notification)
+          # `notify_results` is defined in the subclass
+          notify_results(Bisect::ExampleSetDescriptor.new(
+            @all_example_ids, @failed_example_ids))
+        end
+      end
+    end
+  end
+end

data/rspec-core/upstream/lib/rspec/core/formatters/base_formatter.rb

@@ -4,13 +4,15 @@ require 'stringio'
 module RSpec
   module Core
     module Formatters
-      # RSpec's built-in formatters are all subclasses of RSpec::Core::Formatters::BaseTextFormatter.
+      # RSpec's built-in formatters are all subclasses of
+      # RSpec::Core::Formatters::BaseFormatter.
       #
       # @see RSpec::Core::Formatters::BaseTextFormatter
       # @see RSpec::Core::Reporter
       # @see RSpec::Core::Formatters::Protocol
       class BaseFormatter
-        # all formatters inheriting from this formatter will receive these notifications
+        # All formatters inheriting from this formatter will receive these
+        # notifications.
         Formatters.register self, :start, :example_group_started, :close
         attr_accessor :example_group
         attr_reader :output
@@ -34,7 +36,8 @@ module RSpec
 
         # @api public
         #
-        # @param notification [GroupNotification] containing example_group subclass of `RSpec::Core::ExampleGroup`
+        # @param notification [GroupNotification] containing example_group
+        #   subclass of `RSpec::Core::ExampleGroup`
         # @see RSpec::Core::Formatters::Protocol#example_group_started
         def example_group_started(notification)
           @example_group = notification.group
@@ -42,7 +45,7 @@ module RSpec
 
         # @api public
         #
-        # @param notification [NullNotification]
+        # @param _notification [NullNotification] (Ignored)
         # @see RSpec::Core::Formatters::Protocol#close
         def close(_notification)
           restore_sync_output

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

@@ -1,11 +1,11 @@
 RSpec::Support.require_rspec_core "formatters/base_formatter"
-RSpec::Support.require_rspec_core "formatters/console_codes"
 
 module RSpec
   module Core
     module Formatters
-      # Base for all of RSpec's built-in formatters. See RSpec::Core::Formatters::BaseFormatter
-      # to learn more about all of the methods called by the reporter.
+      # Base for all of RSpec's built-in formatters. See
+      # RSpec::Core::Formatters::BaseFormatter to learn more about all of the
+      # methods called by the reporter.
       #
       # @see RSpec::Core::Formatters::BaseFormatter
       # @see RSpec::Core::Reporter
@@ -13,7 +13,6 @@ module RSpec
         Formatters.register self,
                             :message, :dump_summary, :dump_failures, :dump_pending, :seed
 
-        # @method message
         # @api public
         #
         # Used by the reporter to send messages to the output stream.
@@ -23,7 +22,6 @@ module RSpec
           output.puts notification.message
         end
 
-        # @method dump_failures
         # @api public
         #
         # Dumps detailed information about each example failure.
@@ -34,14 +32,13 @@ module RSpec
           output.puts notification.fully_formatted_failed_examples
         end
 
-        # @method dump_summary
         # @api public
         #
-        # This method is invoked after the dumping of examples and failures. Each parameter
-        # is assigned to a corresponding attribute.
+        # This method is invoked after the dumping of examples and failures.
+        # Each parameter is assigned to a corresponding attribute.
         #
-        # @param summary [SummaryNotification] containing duration, example_count,
-        #                                      failure_count and pending_count
+        # @param summary [SummaryNotification] containing duration,
+        #   example_count, failure_count and pending_count
         def dump_summary(summary)
           output.puts summary.fully_formatted
         end
@@ -60,15 +57,17 @@ module RSpec
 
         # @api public
         #
-        # Invoked at the very end, `close` allows the formatter to clean
-        # up resources, e.g. open streams, etc.
+        # Invoked at the end of a suite run. Allows the formatter to do any
+        # tidying up, but be aware that formatter output streams may be used
+        # elsewhere so don't actually close them.
         #
-        # @param notification [NullNotification]
+        # @param _notification [NullNotification] (Ignored)
         def close(_notification)
-          return unless IO === output
-          return if output.closed? || output == $stdout
+          return if output.closed?
+
+          output.puts
 
-          output.close
+          output.flush
         end
       end
     end

data/rspec-core/upstream/lib/rspec/core/formatters/bisect_drb_formatter.rb

@@ -0,0 +1,29 @@
+require 'drb/drb'
+RSpec::Support.require_rspec_core "formatters/base_bisect_formatter"
+
+module RSpec
+  module Core
+    module Formatters
+      # Used by `--bisect`. When it shells out and runs a portion of the suite, it uses
+      # this formatter as a means to have the status reported back to it, via DRb.
+      #
+      # Note that since DRb calls carry considerable overhead compared to normal
+      # method calls, we try to minimize the number of DRb calls for perf reasons,
+      # opting to communicate only at the start and the end of the run, rather than
+      # after each example.
+      # @private
+      class BisectDRbFormatter < BaseBisectFormatter
+        def initialize(_output)
+          drb_uri = "druby://localhost:#{RSpec.configuration.drb_port}"
+          @bisect_server = DRbObject.new_with_uri(drb_uri)
+          RSpec.configuration.files_or_directories_to_run = @bisect_server.files_or_directories_to_run
+          super(Set.new(@bisect_server.expected_failures))
+        end
+
+        def notify_results(results)
+          @bisect_server.latest_run_results = results
+        end
+      end
+    end
+  end
+end