opal-rspec 0.4.3 → 0.5.0.beta1

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

@@ -1,307 +0,0 @@
-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/documentation_formatter.rb

@@ -1,67 +0,0 @@
-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/json_formatter.rb

@@ -1,99 +0,0 @@
-require 'rspec/core/formatters/base_formatter'
-require 'json'
-
-module RSpec
-  module Core
-    module Formatters
-
-      class JsonFormatter < BaseFormatter
-
-        attr_reader :output_hash
-
-        def initialize(output)
-          super
-          @output_hash = {}
-        end
-
-        def message(message)
-          (@output_hash[:messages] ||= []) << message
-        end
-
-        def dump_summary(duration, example_count, failure_count, pending_count)
-          super(duration, example_count, failure_count, pending_count)
-          @output_hash[:summary] = {
-            :duration => duration,
-            :example_count => example_count,
-            :failure_count => failure_count,
-            :pending_count => pending_count
-          }
-          @output_hash[:summary_line] = summary_line(example_count, failure_count, pending_count)
-
-          dump_profile unless mute_profile_output?(failure_count)
-        end
-
-        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 stop
-          super
-          @output_hash[:examples] = examples.map do |example|
-            format_example(example).tap do |hash|
-              if e=example.exception
-                hash[:exception] =  {
-                  :class => e.class.name,
-                  :message => e.message,
-                  :backtrace => e.backtrace,
-                }
-              end
-            end
-          end
-        end
-
-        def close
-          output.write @output_hash.to_json
-          output.close if IO === output && output != $stdout
-        end
-
-        def dump_profile
-          @output_hash[:profile] = {}
-          dump_profile_slowest_examples
-          dump_profile_slowest_example_groups
-        end
-
-        def dump_profile_slowest_examples
-          @output_hash[:profile] = {}
-          sorted_examples = slowest_examples
-          @output_hash[:profile][:examples] = sorted_examples[:examples].map do |example|
-            format_example(example).tap do |hash|
-              hash[:run_time] = example.execution_result[:run_time]
-            end
-          end
-          @output_hash[:profile][:slowest] = sorted_examples[:slows]
-          @output_hash[:profile][:total] = sorted_examples[:total]
-        end
-
-        def dump_profile_slowest_example_groups
-          @output_hash[:profile] ||= {}
-          @output_hash[:profile][:groups] = slowest_groups.map do |loc, hash|
-            hash.update(:location => loc)
-          end
-        end
-
-      private
-        def format_example(example)
-          {
-            :description => example.description,
-            :full_description => example.full_description,
-            :status => example.execution_result[:status],
-            :file_path => example.metadata[:file_path],
-            :line_number  => example.metadata[:line_number]
-          }
-        end
-      end
-    end
-  end
-end

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

@@ -1,32 +0,0 @@
-require 'rspec/core/formatters/base_text_formatter'
-module RSpec
-  module Core
-    module Formatters
-
-      class ProgressFormatter < BaseTextFormatter
-
-        def example_passed(example)
-          super(example)
-          output.print success_color('.')
-        end
-
-        def example_pending(example)
-          super(example)
-          output.print pending_color('*')
-        end
-
-        def example_failed(example)
-          super(example)
-          output.print failure_color('F')
-        end
-
-        def start_dump
-          super()
-          output.puts
-        end
-
-      end
-
-    end
-  end
-end

data/vendor_lib/rspec/core/formatters.rb

@@ -1,54 +0,0 @@
-# ## Built-in Formatters
-#
-# * progress (default) - prints dots for passing examples, `F` for failures, `*` for pending
-# * documentation - prints the docstrings passed to `describe` and `it` methods (and their aliases)
-# * html
-# * json - useful for archiving data for subsequent analysis
-#
-# The progress formatter is the default, but you can choose any one or more of
-# the other formatters by passing with the `--format` (or `-f` for short)
-# command-line option, e.g.
-#
-#     rspec --format documentation
-#
-# You can also send the output of multiple formatters to different streams, e.g.
-#
-#     rspec --format documentation --format html --out results.html
-#
-# This example sends the output of the documentation formatter to `$stdout`, and
-# the output of the html formatter to results.html.
-#
-# ## Custom Formatters
-#
-# You can tell RSpec to use a custom formatter by passing its path and name to
-# the `rspec` commmand. For example, if you define MyCustomFormatter in
-# path/to/my_custom_formatter.rb, you would type this command:
-#
-#     rspec --require path/to/my_custom_formatter.rb --format MyCustomFormatter
-#
-# The reporter calls every formatter with this protocol:
-#
-# * `start(expected_example_count)`
-# * zero or more of the following
-#   * `example_group_started(group)`
-#   * `example_started(example)`
-#   * `example_passed(example)`
-#   * `example_failed(example)`
-#   * `example_pending(example)`
-#   * `message(string)`
-# * `stop`
-# * `start_dump`
-# * `dump_pending`
-# * `dump_failures`
-# * `dump_summary(duration, example_count, failure_count, pending_count)`
-# * `seed(value)`
-# * `close`
-#
-# You can either implement all of those methods or subclass
-# `RSpec::Core::Formatters::BaseTextFormatter` and override the methods you want
-# to enhance.
-#
-# @see RSpec::Core::Formatters::BaseTextFormatter
-# @see RSpec::Core::Reporter
-module RSpec::Core::Formatters
-end