logstash-output-scalyr 0.1.3 → 0.1.8

data/vendor/bundle/jruby/2.5.0/gems/rspec-core-3.9.2/lib/rspec/core/backtrace_formatter.rb

@@ -1,65 +0,0 @@
-module RSpec
-  module Core
-    # @private
-    class BacktraceFormatter
-      # @private
-      attr_accessor :exclusion_patterns, :inclusion_patterns
-
-      def initialize
-        @full_backtrace = false
-
-        patterns = %w[ /lib\d*/ruby/ bin/ exe/rspec /lib/bundler/ /exe/bundle: ]
-        patterns << "org/jruby/" if RUBY_PLATFORM == 'java'
-        patterns.map! { |s| Regexp.new(s.gsub("/", File::SEPARATOR)) }
-
-        @exclusion_patterns = [Regexp.union(RSpec::CallerFilter::IGNORE_REGEX, *patterns)]
-        @inclusion_patterns = []
-
-        return unless matches?(@exclusion_patterns, File.join(Dir.getwd, "lib", "foo.rb:13"))
-        inclusion_patterns << Regexp.new(Dir.getwd)
-      end
-
-      attr_writer :full_backtrace
-
-      def full_backtrace?
-        @full_backtrace || exclusion_patterns.empty?
-      end
-
-      def filter_gem(gem_name)
-        sep = File::SEPARATOR
-        exclusion_patterns << /#{sep}#{gem_name}(-[^#{sep}]+)?#{sep}/
-      end
-
-      def format_backtrace(backtrace, options={})
-        return [] unless backtrace
-        return backtrace if options[:full_backtrace] || backtrace.empty?
-
-        backtrace.map { |l| backtrace_line(l) }.compact.
-          tap do |filtered|
-            if filtered.empty?
-              filtered.concat backtrace
-              filtered << ""
-              filtered << "  Showing full backtrace because every line was filtered out."
-              filtered << "  See docs for RSpec::Configuration#backtrace_exclusion_patterns and"
-              filtered << "  RSpec::Configuration#backtrace_inclusion_patterns for more information."
-            end
-          end
-      end
-
-      def backtrace_line(line)
-        Metadata.relative_path(line) unless exclude?(line)
-      end
-
-      def exclude?(line)
-        return false if @full_backtrace
-        matches?(exclusion_patterns, line) && !matches?(inclusion_patterns, line)
-      end
-
-    private
-
-      def matches?(patterns, line)
-        patterns.any? { |p| line =~ p }
-      end
-    end
-  end
-end

data/vendor/bundle/jruby/2.5.0/gems/rspec-core-3.9.2/lib/rspec/core/bisect/coordinator.rb

@@ -1,62 +0,0 @@
-RSpec::Support.require_rspec_core "bisect/shell_command"
-RSpec::Support.require_rspec_core "bisect/example_minimizer"
-RSpec::Support.require_rspec_core "bisect/utilities"
-RSpec::Support.require_rspec_core "formatters/bisect_progress_formatter"
-
-module RSpec
-  module Core
-    module Bisect
-      # The main entry point into the bisect logic. Coordinates among:
-      #   - Bisect::ShellCommand: Generates shell commands to run spec subsets
-      #   - Bisect::ExampleMinimizer: Contains the core bisect logic.
-      #   - A bisect runner: runs a set of examples and returns the results.
-      #   - A bisect formatter: provides progress updates to the user.
-      # @private
-      class Coordinator
-        def self.bisect_with(spec_runner, original_cli_args, formatter)
-          new(spec_runner, original_cli_args, formatter).bisect
-        end
-
-        def initialize(spec_runner, original_cli_args, formatter)
-          @spec_runner   = spec_runner
-          @shell_command = ShellCommand.new(original_cli_args)
-          @notifier      = Bisect::Notifier.new(formatter)
-        end
-
-        def bisect
-          repro = start_bisect_runner do |runner|
-            minimizer = ExampleMinimizer.new(@shell_command, runner, @notifier)
-
-            gracefully_abort_on_sigint(minimizer)
-            minimizer.find_minimal_repro
-            minimizer.repro_command_for_currently_needed_ids
-          end
-
-          @notifier.publish(:bisect_repro_command, :repro => repro)
-
-          true
-        rescue BisectFailedError => e
-          @notifier.publish(:bisect_failed, :failure_explanation => e.message)
-          false
-        ensure
-          @notifier.publish(:close)
-        end
-
-      private
-
-        def start_bisect_runner(&block)
-          klass = @spec_runner.configuration.bisect_runner_class
-          klass.start(@shell_command, @spec_runner, &block)
-        end
-
-        def gracefully_abort_on_sigint(minimizer)
-          trap('INT') do
-            repro = minimizer.repro_command_for_currently_needed_ids
-            @notifier.publish(:bisect_aborted, :repro => repro)
-            exit(1)
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/jruby/2.5.0/gems/rspec-core-3.9.2/lib/rspec/core/bisect/example_minimizer.rb

@@ -1,173 +0,0 @@
-RSpec::Support.require_rspec_core "bisect/utilities"
-
-module RSpec
-  module Core
-    module Bisect
-      # @private
-      # Contains the core bisect logic. Searches for examples we can ignore by
-      # repeatedly running different subsets of the suite.
-      class ExampleMinimizer
-        attr_reader :shell_command, :runner, :all_example_ids, :failed_example_ids
-        attr_accessor :remaining_ids
-
-        def initialize(shell_command, runner, notifier)
-          @shell_command = shell_command
-          @runner        = runner
-          @notifier      = notifier
-        end
-
-        def find_minimal_repro
-          prep
-
-          _, duration = track_duration do
-            bisect(non_failing_example_ids)
-          end
-
-          notify(:bisect_complete, :duration => duration,
-                                   :original_non_failing_count => non_failing_example_ids.size,
-                                   :remaining_count => remaining_ids.size)
-
-          remaining_ids + failed_example_ids
-        end
-
-        def bisect(candidate_ids)
-          notify(:bisect_dependency_check_started)
-          if get_expected_failures_for?([])
-            notify(:bisect_dependency_check_failed)
-            self.remaining_ids = []
-            return
-          end
-          notify(:bisect_dependency_check_passed)
-
-          bisect_over(candidate_ids)
-        end
-
-        def bisect_over(candidate_ids)
-          return if candidate_ids.one?
-
-          notify(
-            :bisect_round_started,
-            :candidate_range => example_range(candidate_ids),
-            :candidates_count => candidate_ids.size
-          )
-
-          slice_size = (candidate_ids.length / 2.0).ceil
-          lhs, rhs = candidate_ids.each_slice(slice_size).to_a
-
-          ids_to_ignore, duration = track_duration do
-            [lhs, rhs].find do |ids|
-              get_expected_failures_for?(remaining_ids - ids)
-            end
-          end
-
-          if ids_to_ignore
-            self.remaining_ids -= ids_to_ignore
-            notify(
-              :bisect_round_ignoring_ids,
-              :ids_to_ignore => ids_to_ignore,
-              :ignore_range => example_range(ids_to_ignore),
-              :remaining_ids => remaining_ids,
-              :duration => duration
-            )
-            bisect_over(candidate_ids - ids_to_ignore)
-          else
-            notify(
-              :bisect_round_detected_multiple_culprits,
-              :duration => duration
-            )
-            bisect_over(lhs)
-            bisect_over(rhs)
-          end
-        end
-
-        def currently_needed_ids
-          remaining_ids + failed_example_ids
-        end
-
-        def repro_command_for_currently_needed_ids
-          return shell_command.repro_command_from(currently_needed_ids) if remaining_ids
-          "(Not yet enough information to provide any repro command)"
-        end
-
-        # @private
-        # Convenience class for describing a subset of the candidate examples
-        ExampleRange = Struct.new(:start, :finish) do
-          def description
-            if start == finish
-              "example #{start}"
-            else
-              "examples #{start}-#{finish}"
-            end
-          end
-        end
-
-      private
-
-        def example_range(ids)
-          ExampleRange.new(
-            non_failing_example_ids.find_index(ids.first) + 1,
-            non_failing_example_ids.find_index(ids.last) + 1
-          )
-        end
-
-        def prep
-          notify(:bisect_starting, :original_cli_args => shell_command.original_cli_args,
-                                   :bisect_runner => runner.class.name)
-
-          _, duration = track_duration do
-            original_results    = runner.original_results
-            @all_example_ids    = original_results.all_example_ids
-            @failed_example_ids = original_results.failed_example_ids
-            @remaining_ids      = non_failing_example_ids
-          end
-
-          if @failed_example_ids.empty?
-            raise BisectFailedError, "\n\nNo failures found. Bisect only works " \
-                  "in the presence of one or more failing examples."
-          else
-            notify(:bisect_original_run_complete, :failed_example_ids => failed_example_ids,
-                                                  :non_failing_example_ids => non_failing_example_ids,
-                                                  :duration => duration)
-          end
-        end
-
-        def non_failing_example_ids
-          @non_failing_example_ids ||= all_example_ids - failed_example_ids
-        end
-
-        def get_expected_failures_for?(ids)
-          ids_to_run = ids + failed_example_ids
-          notify(
-            :bisect_individual_run_start,
-            :command => shell_command.repro_command_from(ids_to_run),
-            :ids_to_run => ids_to_run
-          )
-
-          results, duration = track_duration { runner.run(ids_to_run) }
-          notify(:bisect_individual_run_complete, :duration => duration, :results => results)
-
-          abort_if_ordering_inconsistent(results)
-          (failed_example_ids & results.failed_example_ids) == failed_example_ids
-        end
-
-        def track_duration
-          start = ::RSpec::Core::Time.now
-          [yield, ::RSpec::Core::Time.now - start]
-        end
-
-        def abort_if_ordering_inconsistent(results)
-          expected_order = all_example_ids & results.all_example_ids
-          return if expected_order == results.all_example_ids
-
-          raise BisectFailedError, "\n\nThe example ordering is inconsistent. " \
-                "`--bisect` relies upon consistent ordering (e.g. by passing " \
-                "`--seed` if you're using random ordering) to work properly."
-        end
-
-        def notify(*args)
-          @notifier.publish(*args)
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/jruby/2.5.0/gems/rspec-core-3.9.2/lib/rspec/core/bisect/fork_runner.rb

@@ -1,135 +0,0 @@
-require 'stringio'
-RSpec::Support.require_rspec_core "formatters/base_bisect_formatter"
-RSpec::Support.require_rspec_core "bisect/utilities"
-
-module RSpec
-  module Core
-    module Bisect
-      # A Bisect runner that runs requested subsets of the suite by forking
-      # sub-processes. The master process bootstraps RSpec and the application
-      # environment (including preloading files specified via `--require`) so
-      # that the individual spec runs do not have to re-pay that cost.  Each
-      # spec run happens in a forked process, ensuring that the spec files are
-      # not loaded in the main process.
-      #
-      # For most projects, bisections that use `ForkRunner` instead of
-      # `ShellRunner` will finish significantly faster, because the `ShellRunner`
-      # pays the cost of booting RSpec and the app environment on _every_ run of
-      # a subset. In contrast, `ForkRunner` pays that cost only once.
-      #
-      # However, not all projects can use `ForkRunner`. Obviously, on platforms
-      # that do not support forking (e.g. Windows), it cannot be used. In addition,
-      # it can cause problems for some projects that put side-effectful spec
-      # bootstrapping logic that should run on every spec run directly at the top
-      # level in a file loaded by `--require`, rather than in a `before(:suite)`
-      # hook. For example, consider a project that relies on some top-level logic
-      # in `spec_helper` to boot a Redis server for the test suite, intending the
-      # Redis bootstrapping to happen on every spec run. With `ShellRunner`, the
-      # bootstrapping logic will happen for each run of any subset of the suite,
-      # but for `ForkRunner`, such logic will only get run once, when the
-      # `RunDispatcher` boots the application environment. This might cause
-      # problems. The solution is for users to move the bootstrapping logic into
-      # a `before(:suite)` hook, or use the slower `ShellRunner`.
-      #
-      # @private
-      class ForkRunner
-        def self.start(shell_command, spec_runner)
-          instance = new(shell_command, spec_runner)
-          yield instance
-        ensure
-          instance.shutdown
-        end
-
-        def self.name
-          :fork
-        end
-
-        def initialize(shell_command, spec_runner)
-          @shell_command = shell_command
-          @channel = Channel.new
-          @run_dispatcher = RunDispatcher.new(spec_runner, @channel)
-        end
-
-        def run(locations)
-          run_descriptor = ExampleSetDescriptor.new(locations, original_results.failed_example_ids)
-          dispatch_run(run_descriptor)
-        end
-
-        def original_results
-          @original_results ||= dispatch_run(ExampleSetDescriptor.new(
-            @shell_command.original_locations, []))
-        end
-
-        def shutdown
-          @channel.close
-        end
-
-      private
-
-        def dispatch_run(run_descriptor)
-          @run_dispatcher.dispatch_specs(run_descriptor)
-          @channel.receive.tap do |result|
-            if result.is_a?(String)
-              raise BisectFailedError.for_failed_spec_run(result)
-            end
-          end
-        end
-
-        # @private
-        class RunDispatcher
-          def initialize(runner, channel)
-            @runner = runner
-            @channel = channel
-
-            @spec_output = StringIO.new
-
-            runner.configuration.tap do |c|
-              c.reset_reporter
-              c.output_stream = @spec_output
-              c.error_stream = @spec_output
-            end
-          end
-
-          def dispatch_specs(run_descriptor)
-            fork { run_specs(run_descriptor) }
-            # We don't use Process.waitpid here as it was causing bisects to
-            # block due to the file descriptor limit on OSX / Linux.
-          end
-
-        private
-
-          def run_specs(run_descriptor)
-            $stdout = $stderr = @spec_output
-            formatter = CaptureFormatter.new(run_descriptor.failed_example_ids)
-
-            @runner.configuration.tap do |c|
-              c.files_or_directories_to_run = run_descriptor.all_example_ids
-              c.formatter = formatter
-              c.load_spec_files
-            end
-
-            # `announce_filters` has the side effect of implementing the logic
-            # that honors `config.run_all_when_everything_filtered` so we need
-            # to call it here. When we remove `run_all_when_everything_filtered`
-            # (slated for RSpec 4), we can remove this call to `announce_filters`.
-            @runner.world.announce_filters
-
-            @runner.run_specs(@runner.world.ordered_example_groups)
-            latest_run_results = formatter.results
-
-            if latest_run_results.nil? || latest_run_results.all_example_ids.empty?
-              @channel.send(@spec_output.string)
-            else
-              @channel.send(latest_run_results)
-            end
-          end
-        end
-
-        class CaptureFormatter < Formatters::BaseBisectFormatter
-          attr_accessor :results
-          alias_method :notify_results, :results=
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/jruby/2.5.0/gems/rspec-core-3.9.2/lib/rspec/core/bisect/server.rb

@@ -1,61 +0,0 @@
-require 'drb/drb'
-require 'drb/acl'
-RSpec::Support.require_rspec_core "bisect/utilities"
-
-module RSpec
-  module Core
-    # @private
-    module Bisect
-      # @private
-      # A DRb server that receives run results from a separate RSpec process
-      # started by the bisect process.
-      class Server
-        def self.run
-          server = new
-          server.start
-          yield server
-        ensure
-          server.stop
-        end
-
-        def capture_run_results(files_or_directories_to_run=[], expected_failures=[])
-          self.expected_failures  = expected_failures
-          self.files_or_directories_to_run = files_or_directories_to_run
-          self.latest_run_results = nil
-          run_output = yield
-
-          if latest_run_results.nil? || latest_run_results.all_example_ids.empty?
-            raise BisectFailedError.for_failed_spec_run(run_output)
-          end
-
-          latest_run_results
-        end
-
-        def start
-          # Only allow remote DRb requests from this machine.
-          DRb.install_acl ACL.new(%w[ deny all allow localhost allow 127.0.0.1 allow ::1 ])
-
-          # We pass `nil` as the first arg to allow it to pick a DRb port.
-          @drb = DRb.start_service(nil, self)
-        end
-
-        def stop
-          @drb.stop_service
-        end
-
-        def drb_port
-          @drb_port ||= Integer(@drb.uri[/\d+$/])
-        end
-
-        # Fetched via DRb by the BisectDRbFormatter to determine when to abort.
-        attr_accessor :expected_failures
-
-        # Set via DRb by the BisectDRbFormatter with the results of the run.
-        attr_accessor :latest_run_results
-
-        # Fetched via DRb to tell clients which files to run
-        attr_accessor :files_or_directories_to_run
-      end
-    end
-  end
-end