sublimetheme 1.0.0

data/path/gems/rspec-core-3.3.2/lib/rspec/core/formatters/bisect_progress_formatter.rb

@@ -0,0 +1,115 @@
+RSpec::Support.require_rspec_core "formatters/base_text_formatter"
+
+module RSpec
+  module Core
+    module Formatters
+      # @private
+      # Produces progress output while bisecting.
+      class BisectProgressFormatter < BaseTextFormatter
+        # We've named all events with a `bisect_` prefix to prevent naming collisions.
+        Formatters.register self, :bisect_starting, :bisect_original_run_complete,
+                            :bisect_round_started, :bisect_individual_run_complete,
+                            :bisect_round_finished, :bisect_complete, :bisect_repro_command,
+                            :bisect_failed, :bisect_aborted
+
+        def bisect_starting(notification)
+          options = notification.original_cli_args.join(' ')
+          output.puts "Bisect started using options: #{options.inspect}"
+          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_round_started(notification, include_trailing_space=true)
+          search_desc = Helpers.pluralize(
+            notification.subset_size, "non-failing example"
+          )
+
+          output.print "\nRound #{notification.round}: searching for #{search_desc}" \
+                       " (of #{notification.remaining_count}) to ignore:"
+          output.print " " if include_trailing_space
+        end
+
+        def bisect_round_finished(notification)
+          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
+      end
+
+      # @private
+      # Produces detailed debug output while bisecting. Used when
+      # bisect is performed while the `DEBUG_RSPEC_BISECT` ENV var is used.
+      # Designed to provide details for us when we need to troubleshoot bisect bugs.
+      class BisectDebugFormatter < BisectProgressFormatter
+        Formatters.register self, :bisect_original_run_complete, :bisect_individual_run_start,
+                            :bisect_individual_run_complete, :bisect_round_finished, :bisect_ignoring_ids
+
+        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_round_started(notification)
+          super(notification, false)
+        end
+
+        def bisect_round_finished(notification)
+          output.print "\n - Round finished"
+          super
+        end
+
+        def bisect_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
+
+      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
+      end
+    end
+  end
+end

data/path/gems/rspec-core-3.3.2/lib/rspec/core/formatters/console_codes.rb

@@ -0,0 +1,65 @@
+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
+        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
+
+        # 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/path/gems/rspec-core-3.3.2/lib/rspec/core/formatters/deprecation_formatter.rb

@@ -0,0 +1,223 @@
+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."
+
+        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
+            msg = "Too many similar deprecation messages reported, disregarding further reports. "
+            msg << DEPRECATION_STREAM_NOTICE
+            msg
+          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
+
+        GeneratedDeprecationMessage = Struct.new(:type) do
+          def initialize(data)
+            @data = data
+            super data.deprecated
+          end
+
+          def to_s
+            msg =  "#{@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
+            msg = "Too many uses of deprecated '#{type}'. "
+            msg << DEPRECATION_STREAM_NOTICE
+            msg
+          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/path/gems/rspec-core-3.3.2/lib/rspec/core/formatters/documentation_formatter.rb

@@ -0,0 +1,70 @@
+RSpec::Support.require_rspec_core "formatters/base_text_formatter"
+
+module RSpec
+  module Core
+    module Formatters
+      # @private
+      class DocumentationFormatter < BaseTextFormatter
+        Formatters.register self, :example_group_started, :example_group_finished,
+                            :example_passed, :example_pending, :example_failed
+
+        def initialize(output)
+          super
+          @group_level = 0
+        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
+        end
+
+        def example_passed(passed)
+          output.puts passed_output(passed.example)
+        end
+
+        def example_pending(pending)
+          output.puts pending_output(pending.example,
+                                     pending.example.execution_result.pending_message)
+        end
+
+        def example_failed(failure)
+          output.puts failure_output(failure.example,
+                                     failure.example.execution_result.exception)
+        end
+
+      private
+
+        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, _exception)
+          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
+          '  ' * @group_level
+        end
+      end
+    end
+  end
+end