jscop 0.1.2 → 0.1.3

data/vendor/cache/ruby/2.6.0/gems/rspec-core-3.9.1/lib/rspec/core/formatters/bisect_progress_formatter.rb

@@ -1,157 +0,0 @@
-RSpec::Support.require_rspec_core "formatters/base_text_formatter"
-
-module RSpec
-  module Core
-    module Formatters
-      # @private
-      # Produces progress output while bisecting.
-      class BisectProgressFormatter < BaseTextFormatter
-        def initialize(output, bisect_runner)
-          super(output)
-          @bisect_runner = bisect_runner
-        end
-
-        def bisect_starting(notification)
-          @round_count = 0
-          output.puts bisect_started_message(notification)
-          output.print "Running suite to find failures..."
-        end
-
-        def bisect_original_run_complete(notification)
-          failures     = Helpers.pluralize(notification.failed_example_ids.size, "failing example")
-          non_failures = Helpers.pluralize(notification.non_failing_example_ids.size, "non-failing example")
-
-          output.puts " (#{Helpers.format_duration(notification.duration)})"
-          output.puts "Starting bisect with #{failures} and #{non_failures}."
-        end
-
-        def bisect_dependency_check_started(_notification)
-          output.print "Checking that failure(s) are order-dependent.."
-        end
-
-        def bisect_dependency_check_passed(_notification)
-          output.puts " failure appears to be order-dependent"
-        end
-
-        def bisect_dependency_check_failed(_notification)
-          output.puts " failure(s) do not require any non-failures to run first"
-
-          if @bisect_runner == :fork
-            output.puts
-            output.puts "=" * 80
-            output.puts "NOTE: this bisect run used `config.bisect_runner = :fork`, which generally"
-            output.puts "provides significantly faster bisection runs than the old shell-based runner,"
-            output.puts "but may inaccurately report that no non-failures are required. If this result"
-            output.puts "is unexpected, consider setting `config.bisect_runner = :shell` and trying again."
-            output.puts "=" * 80
-          end
-        end
-
-        def bisect_round_started(notification, include_trailing_space=true)
-          @round_count += 1
-          range_desc = notification.candidate_range.description
-
-          output.print "\nRound #{@round_count}: bisecting over non-failing #{range_desc}"
-          output.print " " if include_trailing_space
-        end
-
-        def bisect_round_ignoring_ids(notification)
-          range_desc = notification.ignore_range.description
-
-          output.print " ignoring #{range_desc}"
-          output.print " (#{Helpers.format_duration(notification.duration)})"
-        end
-
-        def bisect_round_detected_multiple_culprits(notification)
-          output.print " multiple culprits detected - splitting candidates"
-          output.print " (#{Helpers.format_duration(notification.duration)})"
-        end
-
-        def bisect_individual_run_complete(_)
-          output.print '.'
-        end
-
-        def bisect_complete(notification)
-          output.puts "\nBisect complete! Reduced necessary non-failing examples " \
-                      "from #{notification.original_non_failing_count} to " \
-                      "#{notification.remaining_count} in " \
-                      "#{Helpers.format_duration(notification.duration)}."
-        end
-
-        def bisect_repro_command(notification)
-          output.puts "\nThe minimal reproduction command is:\n  #{notification.repro}"
-        end
-
-        def bisect_failed(notification)
-          output.puts "\nBisect failed! #{notification.failure_explanation}"
-        end
-
-        def bisect_aborted(notification)
-          output.puts "\n\nBisect aborted!"
-          output.puts "\nThe most minimal reproduction command discovered so far is:\n  #{notification.repro}"
-        end
-
-      private
-
-        def bisect_started_message(notification)
-          options = notification.original_cli_args.join(' ')
-          "Bisect started using options: #{options.inspect}"
-        end
-      end
-
-      # @private
-      # Produces detailed debug output while bisecting. Used when bisect is
-      # performed with `--bisect=verbose`. Designed to provide details for
-      # us when we need to troubleshoot bisect bugs.
-      class BisectDebugFormatter < BisectProgressFormatter
-        def bisect_original_run_complete(notification)
-          output.puts " (#{Helpers.format_duration(notification.duration)})"
-
-          output.puts " - #{describe_ids 'Failing examples', notification.failed_example_ids}"
-          output.puts " - #{describe_ids 'Non-failing examples', notification.non_failing_example_ids}"
-        end
-
-        def bisect_individual_run_start(notification)
-          output.print "\n - Running: #{notification.command}"
-        end
-
-        def bisect_individual_run_complete(notification)
-          output.print " (#{Helpers.format_duration(notification.duration)})"
-        end
-
-        def bisect_dependency_check_passed(_notification)
-          output.print "\n - Failure appears to be order-dependent"
-        end
-
-        def bisect_dependency_check_failed(_notification)
-          output.print "\n - Failure is not order-dependent"
-        end
-
-        def bisect_round_started(notification)
-          super(notification, false)
-        end
-
-        def bisect_round_ignoring_ids(notification)
-          output.print "\n - #{describe_ids 'Examples we can safely ignore', notification.ids_to_ignore}"
-          output.print "\n - #{describe_ids 'Remaining non-failing examples', notification.remaining_ids}"
-        end
-
-        def bisect_round_detected_multiple_culprits(_notification)
-          output.print "\n - Multiple culprits detected - splitting candidates"
-        end
-
-      private
-
-        def describe_ids(description, ids)
-          organized_ids = Formatters::Helpers.organize_ids(ids)
-          formatted_ids = organized_ids.map { |id| "    - #{id}" }.join("\n")
-          "#{description} (#{ids.size}):\n#{formatted_ids}"
-        end
-
-        def bisect_started_message(notification)
-          "#{super} and bisect runner: #{notification.bisect_runner.inspect}"
-        end
-      end
-    end
-  end
-end

data/vendor/cache/ruby/2.6.0/gems/rspec-core-3.9.1/lib/rspec/core/formatters/console_codes.rb

@@ -1,68 +0,0 @@
-module RSpec
-  module Core
-    module Formatters
-      # ConsoleCodes provides helpers for formatting console output
-      # with ANSI codes, e.g. color's and bold.
-      module ConsoleCodes
-        # @private
-        VT100_CODES =
-          {
-            :black   => 30,
-            :red     => 31,
-            :green   => 32,
-            :yellow  => 33,
-            :blue    => 34,
-            :magenta => 35,
-            :cyan    => 36,
-            :white   => 37,
-            :bold    => 1,
-          }
-        # @private
-        VT100_CODE_VALUES = VT100_CODES.invert
-
-        module_function
-
-        # @private
-        def config_colors_to_methods
-          @config_colors_to_methods ||=
-            Configuration.instance_methods.grep(/_color\z/).inject({}) do |hash, method|
-              hash[method.to_s.sub(/_color\z/, '').to_sym] = method
-              hash
-            end
-        end
-
-        # Fetches the correct code for the supplied symbol, or checks
-        # that a code is valid. Defaults to white (37).
-        #
-        # @param code_or_symbol [Symbol, Fixnum] Symbol or code to check
-        # @return [Fixnum] a console code
-        def console_code_for(code_or_symbol)
-          if (config_method = config_colors_to_methods[code_or_symbol])
-            console_code_for RSpec.configuration.__send__(config_method)
-          elsif VT100_CODE_VALUES.key?(code_or_symbol)
-            code_or_symbol
-          else
-            VT100_CODES.fetch(code_or_symbol) do
-              console_code_for(:white)
-            end
-          end
-        end
-
-        # Wraps a piece of text in ANSI codes with the supplied code. Will
-        # only apply the control code if `RSpec.configuration.color_enabled?`
-        # returns true.
-        #
-        # @param text [String] the text to wrap
-        # @param code_or_symbol [Symbol, Fixnum] the desired control code
-        # @return [String] the wrapped text
-        def wrap(text, code_or_symbol)
-          if RSpec.configuration.color_enabled?
-            "\e[#{console_code_for(code_or_symbol)}m#{text}\e[0m"
-          else
-            text
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/cache/ruby/2.6.0/gems/rspec-core-3.9.1/lib/rspec/core/formatters/deprecation_formatter.rb

@@ -1,223 +0,0 @@
-RSpec::Support.require_rspec_core "formatters/helpers"
-
-module RSpec
-  module Core
-    module Formatters
-      # @private
-      class DeprecationFormatter
-        Formatters.register self, :deprecation, :deprecation_summary
-
-        attr_reader :count, :deprecation_stream, :summary_stream
-
-        def initialize(deprecation_stream, summary_stream)
-          @deprecation_stream = deprecation_stream
-          @summary_stream = summary_stream
-          @seen_deprecations = Set.new
-          @count = 0
-        end
-        alias :output :deprecation_stream
-
-        def printer
-          @printer ||= case deprecation_stream
-                       when File
-                         ImmediatePrinter.new(FileStream.new(deprecation_stream),
-                                              summary_stream, self)
-                       when RaiseErrorStream
-                         ImmediatePrinter.new(deprecation_stream, summary_stream, self)
-                       else
-                         DelayedPrinter.new(deprecation_stream, summary_stream, self)
-                       end
-        end
-
-        def deprecation(notification)
-          return if @seen_deprecations.include? notification
-
-          @count += 1
-          printer.print_deprecation_message notification
-          @seen_deprecations << notification
-        end
-
-        def deprecation_summary(_notification)
-          printer.deprecation_summary
-        end
-
-        def deprecation_message_for(data)
-          if data.message
-            SpecifiedDeprecationMessage.new(data)
-          else
-            GeneratedDeprecationMessage.new(data)
-          end
-        end
-
-        RAISE_ERROR_CONFIG_NOTICE = <<-EOS.gsub(/^\s+\|/, '')
-          |
-          |If you need more of the backtrace for any of these deprecations to
-          |identify where to make the necessary changes, you can configure
-          |`config.raise_errors_for_deprecations!`, and it will turn the
-          |deprecation warnings into errors, giving you the full backtrace.
-        EOS
-
-        DEPRECATION_STREAM_NOTICE = "Pass `--deprecation-out` or set " \
-          "`config.deprecation_stream` to a file for full output."
-        TOO_MANY_WARNINGS_NOTICE  = "Too many similar deprecation messages " \
-          "reported, disregarding further reports. #{DEPRECATION_STREAM_NOTICE}"
-
-        # @private
-        SpecifiedDeprecationMessage = Struct.new(:type) do
-          def initialize(data)
-            @message = data.message
-            super deprecation_type_for(data)
-          end
-
-          def to_s
-            output_formatted @message
-          end
-
-          def too_many_warnings_message
-            TOO_MANY_WARNINGS_NOTICE
-          end
-
-          private
-
-          def output_formatted(str)
-            return str unless str.lines.count > 1
-            separator = '-' * 80
-            "#{separator}\n#{str.chomp}\n#{separator}"
-          end
-
-          def deprecation_type_for(data)
-            data.message.gsub(/(\w+\/)+\w+\.rb:\d+/, '')
-          end
-        end
-
-        # @private
-        GeneratedDeprecationMessage = Struct.new(:type) do
-          def initialize(data)
-            @data = data
-            super data.deprecated
-          end
-
-          def to_s
-            msg = String.new("#{@data.deprecated} is deprecated.")
-            msg << " Use #{@data.replacement} instead." if @data.replacement
-            msg << " Called from #{@data.call_site}."   if @data.call_site
-            msg
-          end
-
-          def too_many_warnings_message
-            "Too many uses of deprecated '#{type}'. #{DEPRECATION_STREAM_NOTICE}"
-          end
-        end
-
-        # @private
-        class ImmediatePrinter
-          attr_reader :deprecation_stream, :summary_stream, :deprecation_formatter
-
-          def initialize(deprecation_stream, summary_stream, deprecation_formatter)
-            @deprecation_stream = deprecation_stream
-
-            @summary_stream = summary_stream
-            @deprecation_formatter = deprecation_formatter
-          end
-
-          def print_deprecation_message(data)
-            deprecation_message = deprecation_formatter.deprecation_message_for(data)
-            deprecation_stream.puts deprecation_message.to_s
-          end
-
-          def deprecation_summary
-            return if deprecation_formatter.count.zero?
-            deprecation_stream.summarize(summary_stream, deprecation_formatter.count)
-          end
-        end
-
-        # @private
-        class DelayedPrinter
-          TOO_MANY_USES_LIMIT = 4
-
-          attr_reader :deprecation_stream, :summary_stream, :deprecation_formatter
-
-          def initialize(deprecation_stream, summary_stream, deprecation_formatter)
-            @deprecation_stream = deprecation_stream
-            @summary_stream = summary_stream
-            @deprecation_formatter = deprecation_formatter
-            @seen_deprecations = Hash.new { 0 }
-            @deprecation_messages = Hash.new { |h, k| h[k] = [] }
-          end
-
-          def print_deprecation_message(data)
-            deprecation_message = deprecation_formatter.deprecation_message_for(data)
-            @seen_deprecations[deprecation_message] += 1
-
-            stash_deprecation_message(deprecation_message)
-          end
-
-          def stash_deprecation_message(deprecation_message)
-            if @seen_deprecations[deprecation_message] < TOO_MANY_USES_LIMIT
-              @deprecation_messages[deprecation_message] << deprecation_message.to_s
-            elsif @seen_deprecations[deprecation_message] == TOO_MANY_USES_LIMIT
-              @deprecation_messages[deprecation_message] << deprecation_message.too_many_warnings_message
-            end
-          end
-
-          def deprecation_summary
-            return unless @deprecation_messages.any?
-
-            print_deferred_deprecation_warnings
-            deprecation_stream.puts RAISE_ERROR_CONFIG_NOTICE
-
-            summary_stream.puts "\n#{Helpers.pluralize(deprecation_formatter.count, 'deprecation warning')} total"
-          end
-
-          def print_deferred_deprecation_warnings
-            deprecation_stream.puts "\nDeprecation Warnings:\n\n"
-            @deprecation_messages.keys.sort_by(&:type).each do |deprecation|
-              messages = @deprecation_messages[deprecation]
-              messages.each { |msg| deprecation_stream.puts msg }
-              deprecation_stream.puts
-            end
-          end
-        end
-
-        # @private
-        # Not really a stream, but is usable in place of one.
-        class RaiseErrorStream
-          def puts(message)
-            raise DeprecationError, message
-          end
-
-          def summarize(summary_stream, deprecation_count)
-            summary_stream.puts "\n#{Helpers.pluralize(deprecation_count, 'deprecation')} found."
-          end
-        end
-
-        # @private
-        # Wraps a File object and provides file-specific operations.
-        class FileStream
-          def initialize(file)
-            @file = file
-
-            # In one of my test suites, I got lots of duplicate output in the
-            # deprecation file (e.g. 200 of the same deprecation, even though
-            # the `puts` below was only called 6 times). Setting `sync = true`
-            # fixes this (but we really have no idea why!).
-            @file.sync = true
-          end
-
-          def puts(*args)
-            @file.puts(*args)
-          end
-
-          def summarize(summary_stream, deprecation_count)
-            path = @file.respond_to?(:path) ? @file.path : @file.inspect
-            summary_stream.puts "\n#{Helpers.pluralize(deprecation_count, 'deprecation')} logged to #{path}"
-            puts RAISE_ERROR_CONFIG_NOTICE
-          end
-        end
-      end
-    end
-
-    # Deprecation Error.
-    DeprecationError = Class.new(StandardError)
-  end
-end

data/vendor/cache/ruby/2.6.0/gems/rspec-core-3.9.1/lib/rspec/core/formatters/documentation_formatter.rb

@@ -1,102 +0,0 @@
-RSpec::Support.require_rspec_core "formatters/base_text_formatter"
-RSpec::Support.require_rspec_core "formatters/console_codes"
-
-module RSpec
-  module Core
-    module Formatters
-      # @private
-      class DocumentationFormatter < BaseTextFormatter
-        Formatters.register self, :example_started, :example_group_started, :example_group_finished,
-                            :example_passed, :example_pending, :example_failed
-
-        def initialize(output)
-          super
-          @group_level = 0
-
-          @example_running = false
-          @messages = []
-        end
-
-        def example_started(_notification)
-          @example_running = true
-        end
-
-        def example_group_started(notification)
-          output.puts if @group_level == 0
-          output.puts "#{current_indentation}#{notification.group.description.strip}"
-
-          @group_level += 1
-        end
-
-        def example_group_finished(_notification)
-          @group_level -= 1 if @group_level > 0
-        end
-
-        def example_passed(passed)
-          output.puts passed_output(passed.example)
-
-          flush_messages
-          @example_running = false
-        end
-
-        def example_pending(pending)
-          output.puts pending_output(pending.example,
-                                     pending.example.execution_result.pending_message)
-
-          flush_messages
-          @example_running = false
-        end
-
-        def example_failed(failure)
-          output.puts failure_output(failure.example)
-
-          flush_messages
-          @example_running = false
-        end
-
-        def message(notification)
-          if @example_running
-            @messages << notification.message
-          else
-            output.puts "#{current_indentation}#{notification.message}"
-          end
-        end
-
-      private
-
-        def flush_messages
-          @messages.each do |message|
-            output.puts "#{current_indentation(1)}#{message}"
-          end
-
-          @messages.clear
-        end
-
-        def passed_output(example)
-          ConsoleCodes.wrap("#{current_indentation}#{example.description.strip}", :success)
-        end
-
-        def pending_output(example, message)
-          ConsoleCodes.wrap("#{current_indentation}#{example.description.strip} " \
-                            "(PENDING: #{message})",
-                            :pending)
-        end
-
-        def failure_output(example)
-          ConsoleCodes.wrap("#{current_indentation}#{example.description.strip} " \
-                            "(FAILED - #{next_failure_index})",
-                            :failure)
-        end
-
-        def next_failure_index
-          @next_failure_index ||= 0
-          @next_failure_index += 1
-        end
-
-        def current_indentation(offset=0)
-          '  ' * (@group_level + offset)
-        end
-      end
-    end
-  end
-end