svix 0.53.1 → 0.53.2

data/vendor/bundle/ruby/2.7.0/gems/rspec-core-3.10.1/lib/rspec/core/example_status_persister.rb

@@ -1,235 +0,0 @@
-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/vendor/bundle/ruby/2.7.0/gems/rspec-core-3.10.1/lib/rspec/core/filter_manager.rb

@@ -1,231 +0,0 @@
-module RSpec
-  module Core
-    # @private
-    class FilterManager
-      attr_reader :exclusions, :inclusions
-
-      def initialize
-        @exclusions, @inclusions = FilterRules.build
-      end
-
-      # @api private
-      #
-      # @param file_path [String]
-      # @param line_numbers [Array]
-      def add_location(file_path, line_numbers)
-        # locations is a hash of expanded paths to arrays of line
-        # numbers to match against. e.g.
-        #   { "path/to/file.rb" => [37, 42] }
-        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?
-        inclusions.empty? && exclusions.empty?
-      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| inclusions.include_example?(e) }
-        else
-          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
-
-      def exclude(*args)
-        exclusions.add(args.last)
-      end
-
-      def exclude_only(*args)
-        exclusions.use_only(args.last)
-      end
-
-      def exclude_with_low_priority(*args)
-        exclusions.add_with_low_priority(args.last)
-      end
-
-      def include(*args)
-        inclusions.add(args.last)
-      end
-
-      def include_only(*args)
-        inclusions.use_only(args.last)
-      end
-
-      def include_with_low_priority(*args)
-        inclusions.add_with_low_priority(args.last)
-      end
-
-    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]+@?/
-      PROJECT_DIR = File.expand_path('.')
-
-      attr_accessor :opposite
-      attr_reader :rules
-
-      def self.build
-        exclusions = ExclusionRules.new
-        inclusions = InclusionRules.new
-        exclusions.opposite = inclusions
-        inclusions.opposite = exclusions
-        [exclusions, inclusions]
-      end
-
-      def initialize(rules={})
-        @rules = rules
-      end
-
-      def add(updated)
-        @rules.merge!(updated).each_key { |k| opposite.delete(k) }
-      end
-
-      def add_with_low_priority(updated)
-        updated = updated.merge(@rules)
-        opposite.each_pair { |k, v| updated.delete(k) if updated[k] == v }
-        @rules.replace(updated)
-      end
-
-      def use_only(updated)
-        updated.each_key { |k| opposite.delete(k) }
-        @rules.replace(updated)
-      end
-
-      def clear
-        @rules.clear
-      end
-
-      def delete(key)
-        @rules.delete(key)
-      end
-
-      def fetch(*args, &block)
-        @rules.fetch(*args, &block)
-      end
-
-      def [](key)
-        @rules[key]
-      end
-
-      def empty?
-        rules.empty?
-      end
-
-      def each_pair(&block)
-        @rules.each_pair(&block)
-      end
-
-      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
-    ExclusionRules = FilterRules
-
-    # @private
-    class InclusionRules < FilterRules
-      def add(*args)
-        apply_standalone_filter(*args) || super
-      end
-
-      def add_with_low_priority(*args)
-        apply_standalone_filter(*args) || super
-      end
-
-      def include_example?(example)
-        @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)
-        return true if standalone?
-        return nil unless is_standalone_filter?(updated)
-
-        replace_filters(updated)
-        true
-      end
-
-      def replace_filters(new_rules)
-        @rules.replace(new_rules)
-        opposite.clear
-      end
-
-      def is_standalone_filter?(rules)
-        rules.key?(:full_description)
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.7.0/gems/rspec-core-3.10.1/lib/rspec/core/flat_map.rb

@@ -1,20 +0,0 @@
-module RSpec
-  module Core
-    # @private
-    module FlatMap
-      if [].respond_to?(:flat_map)
-        def flat_map(array, &block)
-          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
-    end
-  end
-end

data/vendor/bundle/ruby/2.7.0/gems/rspec-core-3.10.1/lib/rspec/core/formatters/base_bisect_formatter.rb

@@ -1,45 +0,0 @@
-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/vendor/bundle/ruby/2.7.0/gems/rspec-core-3.10.1/lib/rspec/core/formatters/base_formatter.rb

@@ -1,70 +0,0 @@
-RSpec::Support.require_rspec_core "formatters/helpers"
-require 'stringio'
-
-module RSpec
-  module Core
-    module Formatters
-      # 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.
-        Formatters.register self, :start, :example_group_started, :close
-        attr_accessor :example_group
-        attr_reader :output
-
-        # @api public
-        # @param output [IO] the formatter output
-        # @see RSpec::Core::Formatters::Protocol#initialize
-        def initialize(output)
-          @output = output || StringIO.new
-          @example_group = nil
-        end
-
-        # @api public
-        #
-        # @param notification [StartNotification]
-        # @see RSpec::Core::Formatters::Protocol#start
-        def start(notification)
-          start_sync_output
-          @example_count = notification.count
-        end
-
-        # @api public
-        #
-        # @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
-        end
-
-        # @api public
-        #
-        # @param _notification [NullNotification] (Ignored)
-        # @see RSpec::Core::Formatters::Protocol#close
-        def close(_notification)
-          restore_sync_output
-        end
-
-      private
-
-        def start_sync_output
-          @old_sync, output.sync = output.sync, true if output_supports_sync
-        end
-
-        def restore_sync_output
-          output.sync = @old_sync if output_supports_sync && !output.closed?
-        end
-
-        def output_supports_sync
-          output.respond_to?(:sync=)
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.7.0/gems/rspec-core-3.10.1/lib/rspec/core/formatters/base_text_formatter.rb

@@ -1,75 +0,0 @@
-RSpec::Support.require_rspec_core "formatters/base_formatter"
-
-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.
-      #
-      # @see RSpec::Core::Formatters::BaseFormatter
-      # @see RSpec::Core::Reporter
-      class BaseTextFormatter < BaseFormatter
-        Formatters.register self,
-                            :message, :dump_summary, :dump_failures, :dump_pending, :seed
-
-        # @api public
-        #
-        # Used by the reporter to send messages to the output stream.
-        #
-        # @param notification [MessageNotification] containing message
-        def message(notification)
-          output.puts notification.message
-        end
-
-        # @api public
-        #
-        # Dumps detailed information about each example failure.
-        #
-        # @param notification [NullNotification]
-        def dump_failures(notification)
-          return if notification.failure_notifications.empty?
-          output.puts notification.fully_formatted_failed_examples
-        end
-
-        # @api public
-        #
-        # 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
-        def dump_summary(summary)
-          output.puts summary.fully_formatted
-        end
-
-        # @private
-        def dump_pending(notification)
-          return if notification.pending_examples.empty?
-          output.puts notification.fully_formatted_pending_examples
-        end
-
-        # @private
-        def seed(notification)
-          return unless notification.seed_used?
-          output.puts notification.fully_formatted
-        end
-
-        # @api public
-        #
-        # 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] (Ignored)
-        def close(_notification)
-          return if output.closed?
-
-          output.puts
-
-          output.flush
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.7.0/gems/rspec-core-3.10.1/lib/rspec/core/formatters/bisect_drb_formatter.rb

@@ -1,29 +0,0 @@
-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