opal-rspec 0.4.0.beta3 → 0.4.0.beta4

data/vendor_lib/rspec/core/formatters/base_text_formatter.rb

@@ -0,0 +1,307 @@
+require 'rspec/core/formatters/base_formatter'
+require 'set'
+
+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
+        def message(message)
+          output.puts message
+        end
+
+        def dump_failures
+          return if failed_examples.empty?
+          output.puts
+          output.puts "Failures:"
+          failed_examples.each_with_index do |example, index|
+            output.puts
+            pending_fixed?(example) ? dump_pending_fixed(example, index) : dump_failure(example, index)
+            dump_backtrace(example)
+          end
+        end
+
+        # @api public
+        #
+        # Colorizes the output red for failure, yellow for
+        # pending, and green otherwise.
+        #
+        # @param [String] string
+        def colorise_summary(summary)
+          if failure_count > 0
+            color(summary, RSpec.configuration.failure_color)
+          elsif pending_count > 0
+            color(summary, RSpec.configuration.pending_color)
+          else
+            color(summary, RSpec.configuration.success_color)
+          end
+        end
+
+        def dump_summary(duration, example_count, failure_count, pending_count)
+          super(duration, example_count, failure_count, pending_count)
+          dump_profile unless mute_profile_output?(failure_count)
+          output.puts "\nFinished in #{format_duration(duration)}\n"
+          output.puts colorise_summary(summary_line(example_count, failure_count, pending_count))
+          dump_commands_to_rerun_failed_examples
+        end
+
+        # @api public
+        #
+        # Outputs commands which can be used to re-run failed examples.
+        #
+        def dump_commands_to_rerun_failed_examples
+          return if failed_examples.empty?
+          output.puts
+          output.puts("Failed examples:")
+          output.puts
+
+          failed_examples.each do |example|
+            output.puts(failure_color("rspec #{RSpec::Core::Metadata::relative_path(example.location)}") + " " + detail_color("# #{example.full_description}"))
+          end
+        end
+
+        # @api public
+        #
+        # Outputs the slowest examples and example groups in a report when using `--profile COUNT` (default 10).
+        #
+        def dump_profile
+          dump_profile_slowest_examples
+          dump_profile_slowest_example_groups
+        end
+
+        def dump_profile_slowest_examples
+          sorted_examples = slowest_examples
+
+          time_taken = sorted_examples[:slows] / sorted_examples[:total]
+          percentage = '%.1f' % ((time_taken.nan? ? 0.0 : time_taken) * 100)
+
+          output.puts "\nTop #{sorted_examples[:examples].size} slowest examples (#{format_seconds(sorted_examples[:slows])} seconds, #{percentage}% of total time):\n"
+
+          sorted_examples[:examples].each do |example|
+            output.puts "  #{example.full_description}"
+            output.puts "    #{bold(format_seconds(example.execution_result[:run_time]))} #{bold("seconds")} #{format_caller(example.location)}"
+          end
+        end
+
+        def dump_profile_slowest_example_groups
+
+          sorted_groups = slowest_groups
+          return if sorted_groups.empty?
+
+          output.puts "\nTop #{sorted_groups.size} slowest example groups:"
+          slowest_groups.each do |loc, hash|
+            average = "#{bold(format_seconds(hash[:average]))} #{bold("seconds")} average"
+            total   = "#{format_seconds(hash[:total_time])} seconds"
+            count   = pluralize(hash[:count], "example")
+            output.puts "  #{hash[:description]}"
+            output.puts "    #{average} (#{total} / #{count}) #{loc}"
+          end
+        end
+
+        # @api public
+        #
+        # Outputs summary with number of examples, failures and pending.
+        #
+        def summary_line(example_count, failure_count, pending_count)
+          summary = pluralize(example_count, "example")
+          summary << ", " << pluralize(failure_count, "failure")
+          summary << ", #{pending_count} pending" if pending_count > 0
+          summary
+        end
+
+        def dump_pending
+          unless pending_examples.empty?
+            output.puts
+            output.puts "Pending:"
+            pending_examples.each do |pending_example|
+              output.puts pending_color("  #{pending_example.full_description}")
+              output.puts detail_color("    # #{pending_example.execution_result[:pending_message]}")
+              output.puts detail_color("    # #{format_caller(pending_example.location)}")
+              if pending_example.execution_result[:exception] \
+                && RSpec.configuration.show_failures_in_pending_blocks?
+                dump_failure_info(pending_example)
+                dump_backtrace(pending_example)
+              end
+            end
+          end
+        end
+
+        def seed(number)
+          output.puts
+          output.puts "Randomized with seed #{number}"
+          output.puts
+        end
+
+        def close
+          output.close if IO === output && output != $stdout
+        end
+
+        VT100_COLORS = {
+          :black => 30,
+          :red => 31,
+          :green => 32,
+          :yellow => 33,
+          :blue => 34,
+          :magenta => 35,
+          :cyan => 36,
+          :white => 37
+        }
+
+        VT100_COLOR_CODES = VT100_COLORS.values.to_set
+
+        def color_code_for(code_or_symbol)
+          if VT100_COLOR_CODES.include?(code_or_symbol)
+            code_or_symbol
+          else
+            VT100_COLORS.fetch(code_or_symbol) do
+              color_code_for(:white)
+            end
+          end
+        end
+
+        def colorize(text, code_or_symbol)
+          "\e[#{color_code_for(code_or_symbol)}m#{text}\e[0m"
+        end
+
+      protected
+
+        def bold(text)
+          color_enabled? ? "\e[1m#{text}\e[0m" : text
+        end
+
+        def color(text, color_code)
+          color_enabled? ? colorize(text, color_code) : text
+        end
+
+        def failure_color(text)
+          color(text, RSpec.configuration.failure_color)
+        end
+
+        def success_color(text)
+          color(text, RSpec.configuration.success_color)
+        end
+
+        def pending_color(text)
+          color(text, RSpec.configuration.pending_color)
+        end
+
+        def fixed_color(text)
+          color(text, RSpec.configuration.fixed_color)
+        end
+
+        def detail_color(text)
+          color(text, RSpec.configuration.detail_color)
+        end
+
+        def default_color(text)
+          color(text, RSpec.configuration.default_color)
+        end
+
+        def red(text)
+          RSpec.deprecate("RSpec::Core::Formatters::BaseTextFormatter#red", :replacement => "#failure_color")
+          color(text, :red)
+        end
+
+        def green(text)
+          RSpec.deprecate("RSpec::Core::Formatters::BaseTextFormatter#green", :replacement => "#success_color")
+          color(text, :green)
+        end
+
+        def yellow(text)
+          RSpec.deprecate("RSpec::Core::Formatters::BaseTextFormatter#yellow", :replacement => "#pending_color")
+          color(text, :yellow)
+        end
+
+        def blue(text)
+          RSpec.deprecate("RSpec::Core::Formatters::BaseTextFormatter#blue", :replacement => "#fixed_color")
+          color(text, :blue)
+        end
+
+        def magenta(text)
+          RSpec.deprecate("RSpec::Core::Formatters::BaseTextFormatter#magenta")
+          color(text, :magenta)
+        end
+
+        def cyan(text)
+          RSpec.deprecate("RSpec::Core::Formatters::BaseTextFormatter#cyan", :replacement => "#detail_color")
+          color(text, :cyan)
+        end
+
+        def white(text)
+          RSpec.deprecate("RSpec::Core::Formatters::BaseTextFormatter#white", :replacement => "#default_color")
+          color(text, :white)
+        end
+
+        def short_padding
+          '  '
+        end
+
+        def long_padding
+          '     '
+        end
+
+      private
+
+        def format_caller(caller_info)
+          configuration.backtrace_formatter.backtrace_line(caller_info.to_s.split(':in `block').first)
+        end
+
+        def dump_backtrace(example)
+          format_backtrace(example.execution_result[:exception].backtrace, example).each do |backtrace_info|
+            output.puts detail_color("#{long_padding}# #{backtrace_info}")
+          end
+        end
+
+        def dump_pending_fixed(example, index)
+          output.puts "#{short_padding}#{index.next}) #{example.full_description} FIXED"
+          output.puts fixed_color("#{long_padding}Expected pending '#{example.metadata[:execution_result][:pending_message]}' to fail. No Error was raised.")
+        end
+
+        def pending_fixed?(example)
+          example.execution_result[:pending_fixed]
+        end
+
+        def dump_failure(example, index)
+          output.puts "#{short_padding}#{index.next}) #{example.full_description}"
+          dump_failure_info(example)
+        end
+
+        def dump_failure_info(example)
+          exception = example.execution_result[:exception]
+          exception_class_name = exception_class_name_for(exception)
+          output.puts "#{long_padding}#{failure_color("Failure/Error:")} #{failure_color(read_failed_line(exception, example).strip)}"
+          output.puts "#{long_padding}#{failure_color(exception_class_name)}:" unless exception_class_name =~ /RSpec/
+          exception.message.to_s.split("\n").each { |line| output.puts "#{long_padding}  #{failure_color(line)}" } if exception.message
+
+          if shared_group = find_shared_group(example)
+            dump_shared_failure_info(shared_group)
+          end
+        end
+
+        def exception_class_name_for(exception)
+          name = exception.class.name.to_s
+          name ="(anonymous error class)" if name == ''
+          name
+        end
+
+        def dump_shared_failure_info(group)
+          output.puts "#{long_padding}Shared Example Group: \"#{group.metadata[:shared_group_name]}\" called from " +
+            "#{configuration.backtrace_formatter.backtrace_line(group.metadata[:example_group][:location])}"
+        end
+
+        def find_shared_group(example)
+          group_and_parent_groups(example).find {|group| group.metadata[:shared_group_name]}
+        end
+
+        def group_and_parent_groups(example)
+          example.example_group.parent_groups + [example.example_group]
+        end
+      end
+    end
+  end
+end

data/vendor_lib/rspec/core/formatters/deprecation_formatter.rb

@@ -0,0 +1,193 @@
+require 'rspec/core/formatters/helpers'
+require 'set'
+
+module RSpec
+  module Core
+    module Formatters
+      class DeprecationFormatter
+        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
+
+        def printer
+          @printer ||= case deprecation_stream
+                       when File, RaiseErrorStream
+                         ImmediatePrinter.new(deprecation_stream, summary_stream, self)
+                       else
+                         DelayedPrinter.new(deprecation_stream, summary_stream, self)
+                       end
+        end
+
+        def deprecation(data)
+          return if @seen_deprecations.include?(data)
+
+          @count += 1
+          printer.print_deprecation_message data
+          @seen_deprecations << data
+        end
+
+        def deprecation_summary
+          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
+
+        SpecifiedDeprecationMessage = Struct.new(:type) do
+          def initialize(data)
+            @message = data[:message]
+            super deprecation_type_for(data)
+          end
+
+          def to_s
+            @message
+          end
+
+          def too_many_warnings_message
+            msg = "Too many similar deprecation messages reported, disregarding further reports."
+            msg << " Set config.deprecation_stream to a File for full output."
+            msg
+          end
+
+          private
+
+          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 << " Set config.deprecation_stream to a File for full output."
+            msg
+          end
+        end
+
+        class ImmediatePrinter
+          include ::RSpec::Core::Formatters::Helpers
+
+          attr_reader :deprecation_stream, :summary_stream, :deprecation_formatter
+
+          def initialize(deprecation_stream, summary_stream, deprecation_formatter)
+            @deprecation_stream = deprecation_stream
+
+            # 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!).
+            @deprecation_stream.sync = true
+
+            @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
+            if deprecation_formatter.count > 0
+              summary_stream.puts "\n#{pluralize(deprecation_formatter.count, 'deprecation')} logged to #{deprecation_stream.path}"
+              deprecation_stream.puts RAISE_ERROR_CONFIG_NOTICE
+            end
+          end
+        end
+
+        class DelayedPrinter
+          TOO_MANY_USES_LIMIT = 4
+
+          include ::RSpec::Core::Formatters::Helpers
+
+          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#{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
+
+        # Not really a stream, but is usable in place of one.
+        class RaiseErrorStream
+          def puts(message)
+            raise DeprecationError, message
+          end
+
+          def sync=(value)
+            # no-op
+          end
+        end
+
+      end
+    end
+
+    DeprecationError = Class.new(StandardError)
+  end
+end

data/vendor_lib/rspec/core/formatters/documentation_formatter.rb

@@ -0,0 +1,67 @@
+require 'rspec/core/formatters/base_text_formatter'
+
+module RSpec
+  module Core
+    module Formatters
+      class DocumentationFormatter < BaseTextFormatter
+        def initialize(output)
+          super(output)
+          @group_level = 0
+        end
+
+        def example_group_started(example_group)
+          super(example_group)
+
+          output.puts if @group_level == 0
+          output.puts "#{current_indentation}#{example_group.description.strip}"
+
+          @group_level += 1
+        end
+
+        def example_group_finished(example_group)
+          @group_level -= 1
+        end
+
+        def example_passed(example)
+          super(example)
+          output.puts passed_output(example)
+        end
+
+        def example_pending(example)
+          super(example)
+          output.puts pending_output(example, example.execution_result[:pending_message])
+        end
+
+        def example_failed(example)
+          super(example)
+          output.puts failure_output(example, example.execution_result[:exception])
+        end
+
+        def failure_output(example, exception)
+          failure_color("#{current_indentation}#{example.description.strip} (FAILED - #{next_failure_index})")
+        end
+
+        def next_failure_index
+          @next_failure_index ||= 0
+          @next_failure_index += 1
+        end
+
+        def passed_output(example)
+          success_color("#{current_indentation}#{example.description.strip}")
+        end
+
+        def pending_output(example, message)
+          pending_color("#{current_indentation}#{example.description.strip} (PENDING: #{message})")
+        end
+
+        def current_indentation
+          '  ' * @group_level
+        end
+
+        def example_group_chain
+          example_group.parent_groups.reverse
+        end
+      end
+    end
+  end
+end

data/vendor_lib/rspec/core/formatters/helpers.rb

@@ -0,0 +1,82 @@
+module RSpec
+  module Core
+    module Formatters
+      module Helpers
+        SUB_SECOND_PRECISION = 5
+        DEFAULT_PRECISION = 2
+
+        # @api private
+        #
+        # Formats seconds into a human-readable string.
+        #
+        # @param [Float, Fixnum] duration 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 format_duration(duration)
+          precision = case
+                      when duration < 1;    SUB_SECOND_PRECISION
+                      when duration < 120;  DEFAULT_PRECISION
+                      when duration < 300;  1
+                      else                  0
+                      end
+
+          if duration > 60
+            minutes = (duration.to_i / 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 format_seconds(float, precision = nil)
+          precision ||= (float < 1) ? SUB_SECOND_PRECISION : DEFAULT_PRECISION
+          formatted = sprintf("%.#{precision}f", float)
+          strip_trailing_zeroes(formatted)
+        end
+
+        # @api private
+        #
+        # Remove trailing zeros from a string.
+        #
+        # @param [String] string string with trailing zeros
+        # @return [String] string with trailing zeros removed
+        def strip_trailing_zeroes(string)
+          stripped = string.sub(/[^1-9]+$/, '')
+          stripped.empty? ? "0" : stripped
+        end
+
+        # @api private
+        #
+        # Pluralize a word based on a count.
+        #
+        # @param [Fixnum] count number of objects
+        # @param [String] string word to be pluralized
+        # @return [String] pluralized word
+        def pluralize(count, string)
+          "#{count} #{string}#{'s' unless count.to_f == 1}"
+        end
+      end
+    end
+  end
+end