dirwatch 0.0.1 → 0.0.2

data/vendor/bundle/ruby/2.3.0/gems/rspec-core-3.6.0/lib/rspec/core/formatters/exception_presenter.rb

@@ -0,0 +1,496 @@
+# encoding: utf-8
+RSpec::Support.require_rspec_core "formatters/console_codes"
+RSpec::Support.require_rspec_core "formatters/snippet_extractor"
+RSpec::Support.require_rspec_core 'formatters/syntax_highlighter'
+RSpec::Support.require_rspec_support "encoded_string"
+
+module RSpec
+  module Core
+    module Formatters
+      # @private
+      class ExceptionPresenter
+        attr_reader :exception, :example, :description, :message_color,
+                    :detail_formatter, :extra_detail_formatter, :backtrace_formatter
+        private :message_color, :detail_formatter, :extra_detail_formatter, :backtrace_formatter
+
+        def initialize(exception, example, options={})
+          @exception               = exception
+          @example                 = example
+          @message_color           = options.fetch(:message_color)          { RSpec.configuration.failure_color }
+          @description             = options.fetch(:description)            { example.full_description }
+          @detail_formatter        = options.fetch(:detail_formatter)       { Proc.new {} }
+          @extra_detail_formatter  = options.fetch(:extra_detail_formatter) { Proc.new {} }
+          @backtrace_formatter     = options.fetch(:backtrace_formatter)    { RSpec.configuration.backtrace_formatter }
+          @indentation             = options.fetch(:indentation, 2)
+          @skip_shared_group_trace = options.fetch(:skip_shared_group_trace, false)
+          @failure_lines           = options[:failure_lines]
+        end
+
+        def message_lines
+          add_shared_group_lines(failure_lines, Notifications::NullColorizer)
+        end
+
+        def colorized_message_lines(colorizer=::RSpec::Core::Formatters::ConsoleCodes)
+          add_shared_group_lines(failure_lines, colorizer).map do |line|
+            colorizer.wrap line, message_color
+          end
+        end
+
+        def formatted_backtrace(exception=@exception)
+          backtrace_formatter.format_backtrace(exception.backtrace, example.metadata) +
+            formatted_cause(exception)
+        end
+
+        if RSpec::Support::RubyFeatures.supports_exception_cause?
+          def formatted_cause(exception)
+            last_cause = final_exception(exception)
+            cause = []
+
+            if exception.cause
+              cause << '------------------'
+              cause << '--- Caused by: ---'
+              cause << "#{exception_class_name(last_cause)}:" unless exception_class_name(last_cause) =~ /RSpec/
+
+              encoded_string(last_cause.message.to_s).split("\n").each do |line|
+                cause << "  #{line}"
+              end
+
+              cause << ("  #{backtrace_formatter.format_backtrace(last_cause.backtrace, example.metadata).first}")
+            end
+
+            cause
+          end
+        else
+          # :nocov:
+          def formatted_cause(_)
+            []
+          end
+          # :nocov:
+        end
+
+        def colorized_formatted_backtrace(colorizer=::RSpec::Core::Formatters::ConsoleCodes)
+          formatted_backtrace.map do |backtrace_info|
+            colorizer.wrap "# #{backtrace_info}", RSpec.configuration.detail_color
+          end
+        end
+
+        def fully_formatted(failure_number, colorizer=::RSpec::Core::Formatters::ConsoleCodes)
+          lines = fully_formatted_lines(failure_number, colorizer)
+          lines.join("\n") << "\n"
+        end
+
+        def fully_formatted_lines(failure_number, colorizer)
+          lines = [
+            description,
+            detail_formatter.call(example, colorizer),
+            formatted_message_and_backtrace(colorizer),
+            extra_detail_formatter.call(failure_number, colorizer),
+          ].compact.flatten
+
+          lines = indent_lines(lines, failure_number)
+          lines.unshift("")
+          lines
+        end
+
+      private
+
+        def final_exception(exception, previous=[])
+          cause = exception.cause
+          if cause && !previous.include?(cause)
+            previous << cause
+            final_exception(cause, previous)
+          else
+            exception
+          end
+        end
+
+        if String.method_defined?(:encoding)
+          def encoding_of(string)
+            string.encoding
+          end
+
+          def encoded_string(string)
+            RSpec::Support::EncodedString.new(string, Encoding.default_external)
+          end
+        else # for 1.8.7
+          # :nocov:
+          def encoding_of(_string)
+          end
+
+          def encoded_string(string)
+            RSpec::Support::EncodedString.new(string)
+          end
+          # :nocov:
+        end
+
+        def indent_lines(lines, failure_number)
+          alignment_basis = ' ' * @indentation
+          alignment_basis <<  "#{failure_number}) " if failure_number
+          indentation = ' ' * alignment_basis.length
+
+          lines.each_with_index.map do |line, index|
+            if index == 0
+              "#{alignment_basis}#{line}"
+            elsif line.empty?
+              line
+            else
+              "#{indentation}#{line}"
+            end
+          end
+        end
+
+        def exception_class_name(exception=@exception)
+          name = exception.class.name.to_s
+          name = "(anonymous error class)" if name == ''
+          name
+        end
+
+        def failure_lines
+          @failure_lines ||= [].tap do |lines|
+            lines.concat(failure_slash_error_lines)
+
+            sections = [failure_slash_error_lines, exception_lines]
+            if sections.any? { |section| section.size > 1 } && !exception_lines.first.empty?
+              lines << ''
+            end
+
+            lines.concat(exception_lines)
+            lines.concat(extra_failure_lines)
+          end
+        end
+
+        def failure_slash_error_lines
+          lines = read_failed_lines
+          if lines.count == 1
+            lines[0] = "Failure/Error: #{lines[0].strip}"
+          else
+            least_indentation = SnippetExtractor.least_indentation_from(lines)
+            lines = lines.map { |line| line.sub(/^#{least_indentation}/, '  ') }
+            lines.unshift('Failure/Error:')
+          end
+          lines
+        end
+
+        def exception_lines
+          lines = []
+          lines << "#{exception_class_name}:" unless exception_class_name =~ /RSpec/
+          encoded_string(exception.message.to_s).split("\n").each do |line|
+            lines << (line.empty? ? line : "  #{line}")
+          end
+          lines
+        end
+
+        def extra_failure_lines
+          @extra_failure_lines ||= begin
+            lines = Array(example.metadata[:extra_failure_lines])
+            unless lines.empty?
+              lines.unshift('')
+              lines.push('')
+            end
+            lines
+          end
+        end
+
+        def add_shared_group_lines(lines, colorizer)
+          return lines if @skip_shared_group_trace
+
+          example.metadata[:shared_group_inclusion_backtrace].each do |frame|
+            lines << colorizer.wrap(frame.description, RSpec.configuration.default_color)
+          end
+
+          lines
+        end
+
+        def read_failed_lines
+          matching_line = find_failed_line
+          unless matching_line
+            return ["Unable to find matching line from backtrace"]
+          end
+
+          file_and_line_number = matching_line.match(/(.+?):(\d+)(|:\d+)/)
+
+          unless file_and_line_number
+            return ["Unable to infer file and line number from backtrace"]
+          end
+
+          file_path, line_number = file_and_line_number[1..2]
+          max_line_count = RSpec.configuration.max_displayed_failure_line_count
+          lines = SnippetExtractor.extract_expression_lines_at(file_path, line_number.to_i, max_line_count)
+          RSpec.world.syntax_highlighter.highlight(lines)
+        rescue SnippetExtractor::NoSuchFileError
+          ["Unable to find #{file_path} to read failed line"]
+        rescue SnippetExtractor::NoSuchLineError
+          ["Unable to find matching line in #{file_path}"]
+        rescue SecurityError
+          ["Unable to read failed line"]
+        end
+
+        def find_failed_line
+          line_regex = RSpec.configuration.in_project_source_dir_regex
+          loaded_spec_files = RSpec.configuration.loaded_spec_files
+
+          exception_backtrace.find do |line|
+            next unless (line_path = line[/(.+?):(\d+)(|:\d+)/, 1])
+            path = File.expand_path(line_path)
+            loaded_spec_files.include?(path) || path =~ line_regex
+          end || exception_backtrace.first
+        end
+
+        def formatted_message_and_backtrace(colorizer)
+          lines = colorized_message_lines(colorizer) + colorized_formatted_backtrace(colorizer)
+          encoding = encoding_of("")
+          lines.map do |line|
+            RSpec::Support::EncodedString.new(line, encoding)
+          end
+        end
+
+        def exception_backtrace
+          exception.backtrace || []
+        end
+
+        # @private
+        # Configuring the `ExceptionPresenter` with the right set of options to handle
+        # pending vs failed vs skipped and aggregated (or not) failures is not simple.
+        # This class takes care of building an appropriate `ExceptionPresenter` for the
+        # provided example.
+        class Factory
+          def build
+            ExceptionPresenter.new(@exception, @example, options)
+          end
+
+        private
+
+          def initialize(example)
+            @example          = example
+            @execution_result = example.execution_result
+            @exception        = if @execution_result.status == :pending
+                                  @execution_result.pending_exception
+                                else
+                                  @execution_result.exception
+                                end
+          end
+
+          def options
+            with_multiple_error_options_as_needed(@exception, pending_options || {})
+          end
+
+          def pending_options
+            if @execution_result.pending_fixed?
+              {
+                :description   => "#{@example.full_description} FIXED",
+                :message_color => RSpec.configuration.fixed_color,
+                :failure_lines => [
+                  "Expected pending '#{@execution_result.pending_message}' to fail. No error was raised."
+                ]
+              }
+            elsif @execution_result.status == :pending
+              {
+                :message_color    => RSpec.configuration.pending_color,
+                :detail_formatter => PENDING_DETAIL_FORMATTER
+              }
+            end
+          end
+
+          def with_multiple_error_options_as_needed(exception, options)
+            return options unless multiple_exceptions_error?(exception)
+
+            options = options.merge(
+              :failure_lines          => [],
+              :extra_detail_formatter => sub_failure_list_formatter(exception, options[:message_color]),
+              :detail_formatter       => multiple_exception_summarizer(exception,
+                                                                       options[:detail_formatter],
+                                                                       options[:message_color])
+            )
+
+            return options unless exception.aggregation_metadata[:hide_backtrace]
+            options[:backtrace_formatter] = EmptyBacktraceFormatter
+            options
+          end
+
+          def multiple_exceptions_error?(exception)
+            MultipleExceptionError::InterfaceTag === exception
+          end
+
+          def multiple_exception_summarizer(exception, prior_detail_formatter, color)
+            lambda do |example, colorizer|
+              summary = if exception.aggregation_metadata[:hide_backtrace]
+                          # Since the backtrace is hidden, the subfailures will come
+                          # immediately after this, and using `:` will read well.
+                          "Got #{exception.exception_count_description}:"
+                        else
+                          # The backtrace comes after this, so using a `:` doesn't make sense
+                          # since the failures may be many lines below.
+                          "#{exception.summary}."
+                        end
+
+              summary = colorizer.wrap(summary, color || RSpec.configuration.failure_color)
+              return summary unless prior_detail_formatter
+              [
+                prior_detail_formatter.call(example, colorizer),
+                summary
+              ]
+            end
+          end
+
+          def sub_failure_list_formatter(exception, message_color)
+            common_backtrace_truncater = CommonBacktraceTruncater.new(exception)
+
+            lambda do |failure_number, colorizer|
+              FlatMap.flat_map(exception.all_exceptions.each_with_index) do |failure, index|
+                options = with_multiple_error_options_as_needed(
+                  failure,
+                  :description             => nil,
+                  :indentation             => 0,
+                  :message_color           => message_color || RSpec.configuration.failure_color,
+                  :skip_shared_group_trace => true
+                )
+
+                failure   = common_backtrace_truncater.with_truncated_backtrace(failure)
+                presenter = ExceptionPresenter.new(failure, @example, options)
+                presenter.fully_formatted_lines(
+                  "#{failure_number ? "#{failure_number}." : ''}#{index + 1}",
+                  colorizer
+                )
+              end
+            end
+          end
+
+          # @private
+          # Used to prevent a confusing backtrace from showing up from the `aggregate_failures`
+          # block declared for `:aggregate_failures` metadata.
+          module EmptyBacktraceFormatter
+            def self.format_backtrace(*)
+              []
+            end
+          end
+
+          # @private
+          class CommonBacktraceTruncater
+            def initialize(parent)
+              @parent = parent
+            end
+
+            def with_truncated_backtrace(child)
+              child_bt  = child.backtrace
+              parent_bt = @parent.backtrace
+              return child if child_bt.nil? || child_bt.empty? || parent_bt.nil?
+
+              index_before_first_common_frame = -1.downto(-child_bt.size).find do |index|
+                parent_bt[index] != child_bt[index]
+              end
+
+              return child if index_before_first_common_frame == -1
+
+              child = child.dup
+              child.set_backtrace(child_bt[0..index_before_first_common_frame])
+              child
+            end
+          end
+        end
+
+        # @private
+        PENDING_DETAIL_FORMATTER = Proc.new do |example, colorizer|
+          colorizer.wrap("# #{example.execution_result.pending_message}", :detail)
+        end
+      end
+    end
+
+    # Provides a single exception instance that provides access to
+    # multiple sub-exceptions. This is used in situations where a single
+    # individual spec has multiple exceptions, such as one in the `it` block
+    # and one in an `after` block.
+    class MultipleExceptionError < StandardError
+      # @private
+      # Used so there is a common module in the ancestor chain of this class
+      # and `RSpec::Expectations::MultipleExpectationsNotMetError`, which allows
+      # code to detect exceptions that are instances of either, without first
+      # checking to see if rspec-expectations is loaded.
+      module InterfaceTag
+        # Appends the provided exception to the list.
+        # @param exception [Exception] Exception to append to the list.
+        # @private
+        def add(exception)
+          # `PendingExampleFixedError` can be assigned to an example that initially has no
+          # failures, but when the `aggregate_failures` around hook completes, it notifies of
+          # a failure. If we do not ignore `PendingExampleFixedError` it would be surfaced to
+          # the user as part of a multiple exception error, which is undesirable. While it's
+          # pretty weird we handle this here, it's the best solution I've been able to come
+          # up with, and `PendingExampleFixedError` always represents the _lack_ of any exception
+          # so clearly when we are transitioning to a `MultipleExceptionError`, it makes sense to
+          # ignore it.
+          return if Pending::PendingExampleFixedError === exception
+
+          return if exception == self
+
+          all_exceptions << exception
+
+          if exception.class.name =~ /RSpec/
+            failures << exception
+          else
+            other_errors << exception
+          end
+        end
+
+        # Provides a way to force `ex` to be something that satisfies the multiple
+        # exception error interface. If it already satisfies it, it will be returned;
+        # otherwise it will wrap it in a `MultipleExceptionError`.
+        # @private
+        def self.for(ex)
+          return ex if self === ex
+          MultipleExceptionError.new(ex)
+        end
+      end
+
+      include InterfaceTag
+
+      # @return [Array<Exception>] The list of failures.
+      attr_reader :failures
+
+      # @return [Array<Exception>] The list of other errors.
+      attr_reader :other_errors
+
+      # @return [Array<Exception>] The list of failures and other exceptions, combined.
+      attr_reader :all_exceptions
+
+      # @return [Hash] Metadata used by RSpec for formatting purposes.
+      attr_reader :aggregation_metadata
+
+      # @return [nil] Provided only for interface compatibility with
+      #   `RSpec::Expectations::MultipleExpectationsNotMetError`.
+      attr_reader :aggregation_block_label
+
+      # @param exceptions [Array<Exception>] The initial list of exceptions.
+      def initialize(*exceptions)
+        super()
+
+        @failures                = []
+        @other_errors            = []
+        @all_exceptions          = []
+        @aggregation_metadata    = { :hide_backtrace => true }
+        @aggregation_block_label = nil
+
+        exceptions.each { |e| add e }
+      end
+
+      # @return [String] Combines all the exception messages into a single string.
+      # @note RSpec does not actually use this -- instead it formats each exception
+      #   individually.
+      def message
+        all_exceptions.map(&:message).join("\n\n")
+      end
+
+      # @return [String] A summary of the failure, including the block label and a count of failures.
+      def summary
+        "Got #{exception_count_description}"
+      end
+
+      # return [String] A description of the failure/error counts.
+      def exception_count_description
+        failure_count = Formatters::Helpers.pluralize(failures.size, "failure")
+        return failure_count if other_errors.empty?
+        error_count = Formatters::Helpers.pluralize(other_errors.size, "other error")
+        "#{failure_count} and #{error_count}"
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/gems/rspec-core-3.6.0/lib/rspec/core/formatters/fallback_message_formatter.rb

@@ -0,0 +1,28 @@
+module RSpec
+  module Core
+    module Formatters
+      # @api private
+      # Formatter for providing message output as a fallback when no other
+      # profiler implements #message
+      class FallbackMessageFormatter
+        Formatters.register self, :message
+
+        def initialize(output)
+          @output = output
+        end
+
+        # @private
+        attr_reader :output
+
+        # @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
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/gems/rspec-core-3.6.0/lib/rspec/core/formatters/helpers.rb

@@ -0,0 +1,110 @@
+RSpec::Support.require_rspec_core "shell_escape"
+
+module RSpec
+  module Core
+    module Formatters
+      # Formatters helpers.
+      module Helpers
+        # @private
+        SUB_SECOND_PRECISION = 5
+
+        # @private
+        DEFAULT_PRECISION = 2
+
+        # @api private
+        #
+        # Formats seconds into a human-readable string.
+        #
+        # @param duration [Float, Fixnum] in seconds
+        # @return [String] human-readable time
+        #
+        # @example
+        #    format_duration(1) #=>  "1 minute 1 second"
+        #    format_duration(135.14) #=> "2 minutes 15.14 seconds"
+        def self.format_duration(duration)
+          precision = case
+                      when duration < 1 then    SUB_SECOND_PRECISION
+                      when duration < 120 then  DEFAULT_PRECISION
+                      when duration < 300 then  1
+                      else                  0
+                      end
+
+          if duration > 60
+            minutes = (duration.round / 60).to_i
+            seconds = (duration - minutes * 60)
+
+            "#{pluralize(minutes, 'minute')} #{pluralize(format_seconds(seconds, precision), 'second')}"
+          else
+            pluralize(format_seconds(duration, precision), 'second')
+          end
+        end
+
+        # @api private
+        #
+        # Formats seconds to have 5 digits of precision with trailing zeros
+        # removed if the number is less than 1 or with 2 digits of precision if
+        # the number is greater than zero.
+        #
+        # @param float [Float]
+        # @return [String] formatted float
+        #
+        # @example
+        #    format_seconds(0.000006) #=> "0.00001"
+        #    format_seconds(0.020000) #=> "0.02"
+        #    format_seconds(1.00000000001) #=> "1"
+        #
+        # The precision used is set in {Helpers::SUB_SECOND_PRECISION} and
+        # {Helpers::DEFAULT_PRECISION}.
+        #
+        # @see #strip_trailing_zeroes
+        def self.format_seconds(float, precision=nil)
+          return '0' if float < 0
+          precision ||= (float < 1) ? SUB_SECOND_PRECISION : DEFAULT_PRECISION
+          formatted = "%.#{precision}f" % float
+          strip_trailing_zeroes(formatted)
+        end
+
+        # @api private
+        #
+        # Remove trailing zeros from a string.
+        #
+        # Only remove trailing zeros after a decimal place.
+        # see: http://rubular.com/r/ojtTydOgpn
+        #
+        # @param string [String] string with trailing zeros
+        # @return [String] string with trailing zeros removed
+        def self.strip_trailing_zeroes(string)
+          string.sub(/(?:(\..*[^0])0+|\.0+)$/, '\1')
+        end
+        private_class_method :strip_trailing_zeroes
+
+        # @api private
+        #
+        # Pluralize a word based on a count.
+        #
+        # @param count [Fixnum] number of objects
+        # @param string [String] word to be pluralized
+        # @return [String] pluralized word
+        def self.pluralize(count, string)
+          "#{count} #{string}#{'s' unless count.to_f == 1}"
+        end
+
+        # @api private
+        # Given a list of example ids, organizes them into a compact, ordered list.
+        def self.organize_ids(ids)
+          grouped = ids.inject(Hash.new { |h, k| h[k] = [] }) do |hash, id|
+            file, id = Example.parse_id(id)
+            hash[file] << id
+            hash
+          end
+
+          grouped.sort_by(&:first).map do |file, grouped_ids|
+            grouped_ids = grouped_ids.sort_by { |id| id.split(':').map(&:to_i) }
+            id = Metadata.id_from(:rerun_file_path => file, :scoped_id => grouped_ids.join(','))
+            ShellEscape.conditionally_quote(id)
+          end
+        end
+      end
+    end
+  end
+end