rspec-legacy_formatters 1.0.0.rc1

data/lib/rspec/legacy_formatters/adaptor.rb

@@ -0,0 +1,230 @@
+module RSpec
+  module LegacyFormatters
+
+    # @private
+    # The `LegacyFormatter` is used to wrap older RSpec 2.x style formatters
+    # for the new 3.x implementation. It takes care of registering all the
+    # old notifications and translating them to the older formatter.
+    #
+    # @see RSpec::Core::Formatters::BaseFormatter
+    class Adaptor
+      NOTIFICATIONS = %W[start message example_group_started example_group_finished example_started
+                         example_passed example_failed example_pending start_dump dump_pending
+                         dump_failures dump_summary seed close stop deprecation deprecation_summary]
+
+      # @private
+      module LegacyColorSupport
+        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
+
+        # @private
+        module ConstantLookup
+          def const_missing(name)
+            base_name = "RSpec::Core::Formatters::BaseTextFormatter"
+            case name
+            when :VT100_COLORS then
+              RSpec.deprecate("#{base_name}::VT100_COLORS", :replacement => "RSpec::Core::Formatters::ConsoleCodes.code_for(code_or_symbol)")
+              RSpec::Core::Formatters::ConsoleCodes::VT100_CODES
+            when :VT100_COLOR_CODES then
+              RSpec.deprecate("#{base_name}::VT100_COLOR_CODES", :replacement => "RSpec::Core::Formatters::ConsoleCodes.code_for(code_or_symbol)")
+              RSpec::Core::Formatters::ConsoleCodes::VT100_CODE_VALUES
+            else
+              super
+            end
+          end
+        end
+
+        # These are part of the deprecated interface, so no individual deprecations
+        def color_code_for(code_or_symbol)
+          ::RSpec::Core::Formatters::ConsoleCodes.console_code_for(code_or_symbol)
+        end
+
+        def colorize(text, code_or_symbol)
+          ::RSpec::Core::Formatters::ConsoleCodes.wrap(text, code_or_symbol)
+        end
+
+        def colorize_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
+      end
+
+      # @api private
+      attr_reader :formatter
+
+      # @api private
+      def output
+        formatter.output
+      end
+
+      # @api public
+      #
+      # @param formatter_class [Class] formatter class to build
+      # @param args [Array<IO, Object>] arguments for the formatter, (usually IO but don't have to be)
+      def initialize(formatter_class, *args)
+        @formatter = formatter_class.new(*args)
+      end
+
+      # @api public
+      #
+      # This method is invoked during the setup phase to register
+      # a formatters with the reporter
+      #
+      # @return [Array] notifications the legacy formatter implements
+      def notifications
+        @notifications ||= NOTIFICATIONS.select { |m| @formatter.respond_to? m }
+      end
+
+      # @api public
+      #
+      # @param notification [NullNotification]
+      def start(notification)
+        @formatter.start notification.count
+      end
+
+      # @api public
+      #
+      # @param notification [GroupNotification] containing example_group subclass of `RSpec::Core::ExampleGroup`
+      def example_group_started(notification)
+        @formatter.example_group_started notification.group
+      end
+
+      # @api public
+      #
+      # @param notification [GroupNotification] containing example_group subclass of `RSpec::Core::ExampleGroup`
+      def example_group_finished(notification)
+        @formatter.example_group_finished notification.group
+      end
+
+      # @api public
+      #
+      # @param notification [ExampleNotification] containing example subclass of `RSpec::Core::Example`
+      def example_started(notification)
+        @formatter.example_started notification.example
+      end
+
+      # @api public
+      #
+      # @param notification [ExampleNotification] containing example subclass of `RSpec::Core::Example`
+      def example_passed(notification)
+        @formatter.example_passed notification.example
+      end
+
+      # @api public
+      #
+      # @param notification [ExampleNotification] containing example subclass of `RSpec::Core::Example`
+      def example_pending(notification)
+        @formatter.example_pending notification.example
+      end
+
+      # @api public
+      #
+      # @param notification [ExampleNotification] containing example subclass of `RSpec::Core::Example`
+      def example_failed(notification)
+        @formatter.example_failed notification.example
+      end
+
+      # @api public
+      #
+      # @param notification [MessageNotification] containing message
+      def message(notification)
+        @formatter.message notification.message
+      end
+
+      # @api public
+      #
+      # @param notification [NullNotification]
+      def stop(notification)
+        @formatter.stop
+      end
+
+      # @api public
+      #
+      # @param notification [NullNotification]
+      def start_dump(notification)
+        @formatter.start_dump
+      end
+
+      # @api public
+      #
+      # @param notification [NullNotification]
+      def dump_failures(notification)
+        @formatter.dump_failures
+      end
+
+      # @api public
+      #
+      # @param summary [Core::Notifications::SummaryNotification]
+      def dump_summary(summary)
+        @formatter.load_time = summary.load_time if @formatter.respond_to? :load_time
+        @formatter.dump_summary summary.duration, summary.example_count, summary.failure_count, summary.pending_count
+      end
+
+      # @api public
+      #
+      # @param notification [NullNotification]
+      def dump_pending(notification)
+        @formatter.dump_pending
+      end
+
+      # @api public
+      #
+      # @param notification [NullNotification]
+      def dump_profile(notification)
+        @formatter.dump_profile
+      end
+
+      # @api public
+      #
+      # @param notification [SeedNotification] containing the seed
+      def seed(notification)
+        @formatter.seed notification.seed
+      end
+
+      # @api public
+      #
+      # @param notification [NullNotification]
+      def close(notification)
+        @formatter.close
+      end
+
+    end
+  end
+end

data/lib/rspec/legacy_formatters/base_formatter.rb

@@ -0,0 +1,248 @@
+require 'rspec/legacy_formatters/helpers'
+require 'stringio'
+
+module RSpec
+  module Core
+    module Formatters
+      remove_const :BaseFormatter
+
+      # RSpec's built-in formatters are all subclasses of RSpec::Core::Formatters::BaseTextFormatter,
+      # but the BaseTextFormatter documents all of the methods needed to be implemented by a formatter,
+      # as they are called from the reporter.
+      #
+      # @see RSpec::Core::Formatters::BaseTextFormatter
+      # @see RSpec::Core::Reporter
+      class BaseFormatter
+        include Helpers
+        attr_accessor :example_group
+        attr_reader :duration, :examples, :output
+        attr_reader :example_count, :pending_count, :failure_count
+        attr_reader :failed_examples, :pending_examples
+
+        # @api public
+        #
+        # @param output
+        def initialize(output)
+          @output = output || StringIO.new
+          @example_count = @pending_count = @failure_count = 0
+          @examples = []
+          @failed_examples = []
+          @pending_examples = []
+          @example_group = nil
+        end
+
+        # @api public
+        #
+        # This method is invoked before any examples are run, right after
+        # they have all been collected. This can be useful for special
+        # formatters that need to provide progress on feedback (graphical ones).
+        #
+        # This will only be invoked once, and the next one to be invoked
+        # is {#example_group_started}.
+        #
+        # @param example_count
+        def start(example_count)
+          start_sync_output
+          @example_count = example_count
+        end
+
+        # @api public
+        #
+        # This method is invoked at the beginning of the execution of each example group.
+        #
+        # @param example_group subclass of `RSpec::Core::ExampleGroup`
+        #
+        # The next method to be invoked after this is {#example_passed},
+        # {#example_pending}, or {#example_group_finished}.
+        #
+        # @param example_group
+        def example_group_started(example_group)
+          @example_group = example_group
+        end
+
+        # @api public
+        #
+        # Invoked at the end of the execution of each example group.
+        #
+        # @param example_group subclass of `RSpec::Core::ExampleGroup`
+        def example_group_finished(example_group)
+        end
+
+        # @api public
+        #
+        # Invoked at the beginning of the execution of each example.
+        #
+        # @param example instance of subclass of `RSpec::Core::ExampleGroup`
+        # @return [Array]
+        def example_started(example)
+          examples << example
+        end
+
+        # @api public
+        #
+        # Invoked when an example passes.
+        #
+        # @param example instance of subclass of `RSpec::Core::ExampleGroup`
+        def example_passed(example)
+        end
+
+        # Invoked when an example is pending.
+        #
+        # @param example instance of subclass of `RSpec::Core::ExampleGroup`
+        # @return [Array]
+        def example_pending(example)
+          @pending_examples << example
+        end
+
+        # @api public
+        #
+        # Invoked when an example fails.
+        #
+        # @param example instance of subclass of `RSpec::Core::ExampleGroup`
+        # @return [Array]
+        def example_failed(example)
+          @failed_examples << example
+        end
+
+        # @api public
+        #
+        # Used by the reporter to send messages to the output stream.
+        #
+        # @param [String] message
+        def message(message)
+        end
+
+        # @api public
+        #
+        # Invoked after all examples have executed, before dumping post-run reports.
+        #
+        # @return [nil]
+        def stop
+        end
+
+        # @api public
+        #
+        # This method is invoked after all of the examples have executed. The next method
+        # to be invoked after this one is {#dump_failures}
+        # (BaseTextFormatter then calls {#dump_failure} once for each failed example.)
+        #
+        # @return [nil]
+        def start_dump
+        end
+
+        # @api public
+        #
+        # Dumps detailed information about each example failure.
+        #
+        # @return [nil]
+        def dump_failures
+        end
+
+        # @api public
+        #
+        # This method is invoked after the dumping of examples and failures. Each parameter
+        # is assigned to a corresponding attribute.
+        #
+        # @param duration
+        # @param example_count
+        # @param failure_count
+        # @param pending_count
+        def dump_summary(duration, example_count, failure_count, pending_count)
+          @duration = duration
+          @example_count = example_count
+          @failure_count = failure_count
+          @pending_count = pending_count
+        end
+
+        # @api public
+        #
+        # Outputs a report of pending examples.  This gets invoked
+        # after the summary if option is set to do so.
+        #
+        # @return [nil]
+        def dump_pending
+        end
+
+        # @private not intended for use outside RSpec.
+        def seed(number)
+        end
+
+        # @api public
+        #
+        # Invoked at the very end, `close` allows the formatter to clean
+        # up resources, e.g. open streams, etc.
+        def close
+          restore_sync_output
+        end
+
+        # @api public
+        #
+        # Formats the given backtrace based on configuration and
+        # the metadata of the given example.
+        def format_backtrace(backtrace, example)
+          super(backtrace, example.metadata)
+        end
+
+      protected
+
+        def configuration
+          RSpec.configuration
+        end
+
+        def read_failed_line(exception, example)
+          unless matching_line = find_failed_line(exception.backtrace, example.file_path)
+            return "Unable to find matching line from backtrace"
+          end
+
+          file_path, line_number = matching_line.match(/(.+?):(\d+)(|:\d+)/)[1..2]
+
+          if File.exist?(file_path)
+            File.readlines(file_path)[line_number.to_i - 1] ||
+              "Unable to find matching line in #{file_path}"
+          else
+            "Unable to find #{file_path} to read failed line"
+          end
+        rescue SecurityError
+          "Unable to read failed line"
+        end
+
+        def find_failed_line(backtrace, path)
+          path = File.expand_path(path)
+          backtrace.detect { |line|
+            match = line.match(/(.+?):(\d+)(|:\d+)/)
+            match && match[1].downcase == path.downcase
+          }
+        end
+
+        def start_sync_output
+          @old_sync, output.sync = output.sync, true if output_supports_sync
+        end
+
+        def restore_sync_output
+          output.sync = @old_sync if output_supports_sync and !output.closed?
+        end
+
+        def output_supports_sync
+          output.respond_to?(:sync=)
+        end
+
+        def profile_examples?
+          configuration.profile_examples
+        end
+
+        def fail_fast?
+          configuration.fail_fast
+        end
+
+        def color_enabled?
+          configuration.color_enabled?(output)
+        end
+
+        def mute_profile_output?(failure_count)
+          # Don't print out profiled info if there are failures and `--fail-fast` is used, it just clutters the output
+          !profile_examples? || (fail_fast? && failure_count != 0)
+        end
+      end
+    end
+  end
+end