opal-rspec 0.4.3 → 0.5.0.beta1

data/rspec-core/lib/rspec/core/formatters/protocol.rb

@@ -0,0 +1,163 @@
+module RSpec
+  module Core
+    module Formatters
+      # This class isn't loaded at runtime but serves to document all of the
+      # notifications implemented as part of the standard interface. The
+      # reporter will issue these during a normal test suite run, but a
+      # formatter will only receive those notifications it has registered
+      # itself to receive. To register a formatter call:
+      #
+      # `::RSpec::Core::Formatters.register class, :list, :of, :notifications`
+      #
+      # e.g.
+      #
+      # `::RSpec::Core::Formatters.register self, :start, :example_started`
+      #
+      # @see RSpec::Core::Formatters::BaseFormatter
+      # @see RSpec::Core::Formatters::BaseTextFormatter
+      # @see RSpec::Core::Reporter
+      class Protocol
+        # @method initialize
+        # @api public
+        #
+        # @param output [IO] the formatter output
+
+        # @method start
+        # @api public
+        # @group Suite Notifications
+        #
+        # 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 notification [StartNotification]
+
+        # @method example_group_started
+        # @api public
+        # @group Group Notifications
+        #
+        # This method is invoked at the beginning of the execution of each example group.
+        #
+        # The next method to be invoked after this is {#example_passed},
+        # {#example_pending}, or {#example_group_finished}.
+        #
+        # @param notification [GroupNotification] containing example_group subclass of `RSpec::Core::ExampleGroup`
+
+        # @method example_group_finished
+        # @api public
+        # @group Group Notifications
+        #
+        # Invoked at the end of the execution of each example group.
+        #
+        # @param notification [GroupNotification] containing example_group subclass of `RSpec::Core::ExampleGroup`
+
+        # @method example_started
+        # @api public
+        # @group Example Notifications
+        #
+        # Invoked at the beginning of the execution of each example.
+        #
+        # @param notification [ExampleNotification] containing example subclass of `RSpec::Core::Example`
+
+        # @method example_passed
+        # @api public
+        # @group Example Notifications
+        #
+        # Invoked when an example passes.
+        #
+        # @param notification [ExampleNotification] containing example subclass of `RSpec::Core::Example`
+
+        # @method example_pending
+        # @api public
+        # @group Example Notifications
+        #
+        # Invoked when an example is pending.
+        #
+        # @param notification [ExampleNotification] containing example subclass of `RSpec::Core::Example`
+
+        # @method example_failed
+        # @api public
+        # @group Example Notifications
+        #
+        # Invoked when an example fails.
+        #
+        # @param notification [ExampleNotification] containing example subclass of `RSpec::Core::Example`
+
+        # @method message
+        # @api public
+        # @group Suite Notifications
+        #
+        # Used by the reporter to send messages to the output stream.
+        #
+        # @param notification [MessageNotification] containing message
+
+        # @method stop
+        # @api public
+        # @group Suite Notifications
+        #
+        # Invoked after all examples have executed, before dumping post-run reports.
+        #
+        # @param notification [NullNotification]
+
+        # @method start_dump
+        # @api public
+        # @group Suite Notifications
+        #
+        # 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.)
+        #
+        # @param notification [NullNotification]
+
+        # @method dump_failures
+        # @api public
+        # @group Suite Notifications
+        #
+        # Dumps detailed information about each example failure.
+        #
+        # @param notification [NullNotification]
+
+        # @method dump_summary
+        # @api public
+        # @group Suite Notifications
+        #
+        # This method is invoked after the dumping of examples and failures. Each parameter
+        # is assigned to a corresponding attribute.
+        #
+        # @param summary [SummaryNotification] containing duration, example_count,
+        #                                      failure_count and pending_count
+
+        # @method dump_profile
+        # @api public
+        # @group Suite Notifications
+        #
+        # This method is invoked after the dumping the summary if profiling is
+        # enabled.
+        #
+        # @param profile [ProfileNotification] containing duration, slowest_examples
+        #                                      and slowest_example_groups
+
+        # @method dump_pending
+        # @api public
+        # @group Suite Notifications
+        #
+        # Outputs a report of pending examples.  This gets invoked
+        # after the summary if option is set to do so.
+        #
+        # @param notification [NullNotification]
+
+        # @method close
+        # @api public
+        # @group Suite Notifications
+        #
+        # Invoked at the very end, `close` allows the formatter to clean
+        # up resources, e.g. open streams, etc.
+        #
+        # @param notification [NullNotification]
+      end
+    end
+  end
+end

data/{vendor_lib → rspec-core/lib}/rspec/core/formatters/snippet_extractor.rb

@@ -5,12 +5,14 @@ module RSpec
       #
       # Extracts code snippets by looking at the backtrace of the passed error and applies synax highlighting and line numbers using html.
       class SnippetExtractor
+        # @private
         class NullConverter
           def convert(code)
             %Q(#{code}\n<span class="comment"># Install the coderay gem to get syntax highlighting</span>)
           end
         end
 
+        # @private
         class CoderayConverter
           def convert(code)
             CodeRay.scan(code, :ruby).html(:line_numbers => false)
@@ -19,16 +21,18 @@ module RSpec
 
         begin
           require 'coderay'
+          # rubocop:disable Style/ClassVars
           @@converter = CoderayConverter.new
         rescue LoadError
           @@converter = NullConverter.new
         end
+        # rubocop:enable Style/ClassVars
 
         # @api private
         #
         # Extract lines of code corresponding to  a backtrace.
         #
-        # @param [String] backtrace the backtrace from a test failure
+        # @param backtrace [String] the backtrace from a test failure
         # @return [String] highlighted code snippet indicating where the test failure occured
         #
         # @see #post_process
@@ -42,14 +46,14 @@ module RSpec
         #
         # Create a snippet from a line of code.
         #
-        # @param [String] error_line file name with line number (i.e. 'foo_spec.rb:12')
+        # @param error_line [String] file name with line number (i.e. 'foo_spec.rb:12')
         # @return [String] lines around the target line within the file
         #
         # @see #lines_around
         def snippet_for(error_line)
           if error_line =~ /(.*):(\d+)/
-            file = $1
-            line = $2.to_i
+            file = Regexp.last_match[1]
+            line = Regexp.last_match[2].to_i
             [lines_around(file, line), line]
           else
             ["# Couldn't get snippet for #{error_line}", 1]
@@ -60,14 +64,14 @@ module RSpec
         #
         # Extract lines of code centered around a particular line within a source file.
         #
-        # @param [String] file filename
-        # @param [Fixnum] line line number
+        # @param file [String] filename
+        # @param line [Fixnum] line number
         # @return [String] lines around the target line within the file (2 above and 1 below).
         def lines_around(file, line)
           if File.file?(file)
             lines = File.read(file).split("\n")
-            min = [0, line-3].max
-            max = [line+1, lines.length-1].min
+            min = [0, line - 3].max
+            max = [line + 1, lines.length - 1].min
             selected_lines = []
             selected_lines.join("\n")
             lines[min..max].join("\n")
@@ -82,19 +86,18 @@ module RSpec
         #
         # Adds line numbers to all lines and highlights the line where the failure occurred using html `span` tags.
         #
-        # @param [String] highlighted syntax-highlighted snippet surrounding the offending line of code
-        # @param [Fixnum] offending_line line where failure occured
+        # @param highlighted [String] syntax-highlighted snippet surrounding the offending line of code
+        # @param offending_line [Fixnum] line where failure occured
         # @return [String] completed snippet
         def post_process(highlighted, offending_line)
           new_lines = []
           highlighted.split("\n").each_with_index do |line, i|
-            new_line = "<span class=\"linenum\">#{offending_line+i-2}</span>#{line}"
+            new_line = "<span class=\"linenum\">#{offending_line + i - 2}</span>#{line}"
             new_line = "<span class=\"offending\">#{new_line}</span>" if i == 2
             new_lines << new_line
           end
           new_lines.join("\n")
         end
-
       end
     end
   end

data/rspec-core/lib/rspec/core/formatters.rb

@@ -0,0 +1,240 @@
+RSpec::Support.require_rspec_support "directory_maker"
+# ## 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:
+#
+# * To start
+#   * `start(StartNotification)`
+# * Once per example group
+#   * `example_group_started(GroupNotification)`
+# * Once per example
+#   * `example_started(ExampleNotification)`
+# * One of these per example, depending on outcome
+#   * `example_passed(ExampleNotification)`
+#   * `example_failed(FailedExampleNotification)`
+#   * `example_pending(ExampleNotification)`
+# * Optionally at any time
+#   * `message(MessageNotification)`
+# * At the end of the suite
+#   * `stop(ExamplesNotification)`
+#   * `start_dump(NullNotification)`
+#   * `dump_pending(ExamplesNotification)`
+#   * `dump_failures(ExamplesNotification)`
+#   * `dump_summary(SummaryNotification)`
+#   * `seed(SeedNotification)`
+#   * `close(NullNotification)`
+#
+# Only the notifications to which you subscribe your formatter will be called
+# on your formatter. To subscribe your formatter use:
+# `RSpec::Core::Formatters#register` e.g.
+#
+# `RSpec::Core::Formatters.register FormatterClassName, :example_passed, :example_failed`
+#
+# We recommend you implement the methods yourself; for simplicity we provide the
+# default formatter output via our notification objects but if you prefer you
+# can subclass `RSpec::Core::Formatters::BaseTextFormatter` and override the
+# methods you wish to enhance.
+#
+# @see RSpec::Core::Formatters::BaseTextFormatter
+# @see RSpec::Core::Reporter
+module RSpec::Core::Formatters
+  autoload :DocumentationFormatter, 'rspec/core/formatters/documentation_formatter'
+  autoload :HtmlFormatter,          'rspec/core/formatters/html_formatter'
+  autoload :ProgressFormatter,      'rspec/core/formatters/progress_formatter'
+  autoload :ProfileFormatter,       'rspec/core/formatters/profile_formatter'
+  autoload :JsonFormatter,          'rspec/core/formatters/json_formatter'
+
+  # Register the formatter class
+  # @param formatter_class [Class] formatter class to register
+  # @param notifications [Symbol, ...] one or more notifications to be registered to the specified formatter
+  #
+  # @see RSpec::Core::Formatters::BaseFormatter
+  def self.register(formatter_class, *notifications)
+    Loader.formatters[formatter_class] = notifications
+  end
+
+  # @api private
+  #
+  # `RSpec::Core::Formatters::Loader` is an internal class for
+  # managing formatters used by a particular configuration. It is
+  # not expected to be used directly, but only through the configuration
+  # interface.
+  class Loader
+    # @api private
+    #
+    # Internal formatters are stored here when loaded
+    def self.formatters
+      @formatters ||= {}
+    end
+
+    # @api private
+    def initialize(reporter)
+      @formatters = []
+      @reporter = reporter
+      self.default_formatter = 'progress'
+    end
+
+    # @return [Array] the loaded formatters
+    attr_reader :formatters
+
+    # @return [Reporter] the reporter
+    attr_reader :reporter
+
+    # @return [String] the default formatter to setup, defaults to `progress`
+    attr_accessor :default_formatter
+
+    # @private
+    def setup_default(output_stream, deprecation_stream)
+      add default_formatter, output_stream if @formatters.empty?
+
+      unless @formatters.any? { |formatter| DeprecationFormatter === formatter }
+        add DeprecationFormatter, deprecation_stream, output_stream
+      end
+
+      return unless RSpec.configuration.profile_examples? && !existing_formatter_implements?(:dump_profile)
+
+      add RSpec::Core::Formatters::ProfileFormatter, output_stream
+    end
+
+    # @private
+    def add(formatter_to_use, *paths)
+      formatter_class = find_formatter(formatter_to_use)
+
+      args = paths.map { |p| p.respond_to?(:puts) ? p : file_at(p) }
+
+      if !Loader.formatters[formatter_class].nil?
+        formatter = formatter_class.new(*args)
+        @reporter.register_listener formatter, *notifications_for(formatter_class)
+      elsif defined?(RSpec::LegacyFormatters)
+        formatter = RSpec::LegacyFormatters.load_formatter formatter_class, *args
+        @reporter.register_listener formatter, *formatter.notifications
+      else
+        line = ::RSpec::CallerFilter.first_non_rspec_line
+        if line
+          call_site = "Formatter added at: #{line}"
+        else
+          call_site = "The formatter was added via command line flag or your "\
+                      "`.rspec` file."
+        end
+
+        RSpec.warn_deprecation <<-WARNING.gsub(/\s*\|/, ' ')
+          |The #{formatter_class} formatter uses the deprecated formatter
+          |interface not supported directly by RSpec 3.
+          |
+          |To continue to use this formatter you must install the
+          |`rspec-legacy_formatters` gem, which provides support
+          |for legacy formatters or upgrade the formatter to a
+          |compatible version.
+          |
+          |#{call_site}
+        WARNING
+        return
+      end
+      @formatters << formatter unless duplicate_formatter_exists?(formatter)
+      formatter
+    end
+
+  private
+
+    def find_formatter(formatter_to_use)
+      built_in_formatter(formatter_to_use) ||
+      custom_formatter(formatter_to_use)   ||
+      (raise ArgumentError, "Formatter '#{formatter_to_use}' unknown - maybe you meant 'documentation' or 'progress'?.")
+    end
+
+    def duplicate_formatter_exists?(new_formatter)
+      @formatters.any? do |formatter|
+        formatter.class === new_formatter && formatter.output == new_formatter.output
+      end
+    end
+
+    def existing_formatter_implements?(notification)
+      @reporter.registered_listeners(notification).any?
+    end
+
+    def built_in_formatter(key)
+      case key.to_s
+      when 'd', 'doc', 'documentation'
+        DocumentationFormatter
+      when 'h', 'html'
+        HtmlFormatter
+      when 'p', 'progress'
+        ProgressFormatter
+      when 'j', 'json'
+        JsonFormatter
+      end
+    end
+
+    def notifications_for(formatter_class)
+      formatter_class.ancestors.inject(Set.new) do |notifications, klass|
+        notifications + Loader.formatters.fetch(klass) { Set.new }
+      end
+    end
+
+    def custom_formatter(formatter_ref)
+      if Class === formatter_ref
+        formatter_ref
+      elsif string_const?(formatter_ref)
+        begin
+          formatter_ref.gsub(/^::/, '').split('::').inject(Object) { |a, e| a.const_get e }
+        rescue NameError
+          require(path_for(formatter_ref)) ? retry : raise
+        end
+      end
+    end
+
+    def string_const?(str)
+      str.is_a?(String) && /\A[A-Z][a-zA-Z0-9_:]*\z/ =~ str
+    end
+
+    def path_for(const_ref)
+      underscore_with_fix_for_non_standard_rspec_naming(const_ref)
+    end
+
+    def underscore_with_fix_for_non_standard_rspec_naming(string)
+      underscore(string).sub(%r{(^|/)r_spec($|/)}, '\\1rspec\\2')
+    end
+
+    # activesupport/lib/active_support/inflector/methods.rb, line 48
+    def underscore(camel_cased_word)
+      word = camel_cased_word.to_s.dup
+      word.gsub!(/::/, '/')
+      word.gsub!(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+      word.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
+      word.tr!("-", "_")
+      word.downcase!
+      word
+    end
+
+    def file_at(path)
+      RSpec::Support::DirectoryMaker.mkdir_p(File.dirname(path))
+      File.new(path, 'w')
+    end
+  end
+end