rspec-legacy_formatters 1.0.0.rc1

data/lib/rspec/legacy_formatters/json_formatter.rb

@@ -0,0 +1,71 @@
+require 'rspec/legacy_formatters/base_formatter'
+require 'json'
+
+module RSpec
+  module Core
+    module Formatters
+      remove_const :JsonFormatter
+
+      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)
+        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|
+            {
+              :description => example.description,
+              :full_description => example.full_description,
+              :status => example.execution_result.status,
+              # :example_group,
+              # :execution_result,
+              :file_path => example.metadata[:file_path],
+              :line_number  => example.metadata[:line_number],
+            }.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
+
+      end
+    end
+  end
+end

data/lib/rspec/legacy_formatters/progress_formatter.rb

@@ -0,0 +1,31 @@
+require 'rspec/legacy_formatters/base_text_formatter'
+
+module RSpec
+  module Core
+    module Formatters
+      remove_const :ProgressFormatter
+
+      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/lib/rspec/legacy_formatters/snippet_extractor.rb

@@ -0,0 +1,92 @@
+module RSpec
+  module Core
+    module Formatters
+      # @api private
+      #
+      # Extracts code snippets by looking at the backtrace of the passed error and applies synax highlighting and line numbers using html.
+      class SnippetExtractor
+        class NullConverter; def convert(code, pre); code; end; end
+
+        begin
+          require 'syntax/convertors/html'
+          @@converter = Syntax::Convertors::HTML.for_syntax "ruby"
+        rescue LoadError
+          @@converter = NullConverter.new
+        end
+
+        # @api private
+        #
+        # Extract lines of code corresponding to  a backtrace.
+        #
+        # @param [String] backtrace the backtrace from a test failure
+        # @return [String] highlighted code snippet indicating where the test failure occured
+        #
+        # @see #post_process
+        def snippet(backtrace)
+          raw_code, line = snippet_for(backtrace[0])
+          highlighted = @@converter.convert(raw_code, false)
+          highlighted << "\n<span class=\"comment\"># gem install syntax to get syntax highlighting</span>" if @@converter.is_a?(NullConverter)
+          post_process(highlighted, line)
+        end
+
+        # @api private
+        #
+        # Create a snippet from a line of code.
+        #
+        # @param [String] error_line 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
+            [lines_around(file, line), line]
+          else
+            ["# Couldn't get snippet for #{error_line}", 1]
+          end
+        end
+
+        # @api private
+        #
+        # Extract lines of code centered around a particular line within a source file.
+        #
+        # @param [String] file filename
+        # @param [Fixnum] line 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
+            selected_lines = []
+            selected_lines.join("\n")
+            lines[min..max].join("\n")
+          else
+            "# Couldn't get snippet for #{file}"
+          end
+        rescue SecurityError
+          "# Couldn't get snippet for #{file}"
+        end
+
+        # @api private
+        #
+        # 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
+        # @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=\"offending\">#{new_line}</span>" if i == 2
+            new_lines << new_line
+          end
+          new_lines.join("\n")
+        end
+
+      end
+    end
+  end
+end

data/lib/rspec/legacy_formatters/version.rb

@@ -0,0 +1,9 @@
+module RSpec
+  module LegacyFormatters
+    # Version information for RSpec LegacyFormatters.
+    module Version
+      # Current version of RSpec LegacyFormatters, in semantic versioning format.
+      STRING = '1.0.0.rc1'
+    end
+  end
+end

data/maintenance-branch

@@ -0,0 +1 @@
+master

data/rspec-legacy_formatters.gemspec

@@ -0,0 +1,43 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rspec/legacy_formatters/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "rspec-legacy_formatters"
+  spec.version       = RSpec::LegacyFormatters::Version::STRING
+  spec.authors       = ["Jon Rowe"]
+  spec.email         = ["hello@jonrowe.co.uk"]
+  spec.email         = "rspec@googlegroups.com"
+  spec.homepage      = "http://github.com/rspec/rspec-legacy_formatters"
+  spec.summary       = "rspec-legacy_formatters-#{RSpec::LegacyFormatters::Version::STRING}"
+  spec.description   = %q{Support for RSpec 2.x formatters on 3.x}
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.test_files    = []
+  spec.rdoc_options  = ["--charset=UTF-8"]
+  spec.require_paths = ["lib"]
+
+  spec.required_ruby_version = '>= 1.8.7'
+
+  private_key = File.expand_path('~/.gem/rspec-gem-private_key.pem')
+  if File.exist?(private_key)
+    spec.signing_key = private_key
+    spec.cert_chain = [File.expand_path('~/.gem/rspec-gem-public_cert.pem')]
+  end
+
+  spec.add_runtime_dependency     "rspec-core",    ">= 3.0.0.beta2"
+  spec.add_runtime_dependency     "rspec-support", ">= 3.0.0.beta2"
+
+  spec.add_development_dependency "cucumber", "~> 1.3"
+  spec.add_development_dependency "aruba",    "~> 0.5"
+  spec.add_development_dependency "rake",     "~> 10.0.0"
+
+  # For legacy custom formatter regression tests
+  spec.add_development_dependency "fuubar",                 "1.3.2"
+  spec.add_development_dependency "nyan-cat-formatter",     "0.5.2"
+  spec.add_development_dependency "rspec-instafail",        "0.2.4"
+  spec.add_development_dependency "rspec-extra-formatters", "1.0.0"
+  spec.add_development_dependency "fivemat",                "1.2.1"
+end

data/script/functions.sh

@@ -0,0 +1,144 @@
+# This file was generated on 2014-03-30T13:16:22-07:00 from the rspec-dev repo.
+# DO NOT modify it by hand as your changes will get lost the next time it is generated.
+
+# idea taken from: http://blog.headius.com/2010/03/jruby-startup-time-tips.html
+export JRUBY_OPTS='-X-C' # disable JIT since these processes are so short lived
+SPECS_HAVE_RUN_FILE=specs.out
+MAINTENANCE_BRANCH=`cat maintenance-branch`
+
+# Taken from:
+# https://github.com/travis-ci/travis-build/blob/e9314616e182a23e6a280199cd9070bfc7cae548/lib/travis/build/script/templates/header.sh#L34-L53
+travis_retry() {
+  local result=0
+  local count=1
+  while [ $count -le 3 ]; do
+    [ $result -ne 0 ] && {
+      echo -e "\n\033[33;1mThe command \"$@\" failed. Retrying, $count of 3.\033[0m\n" >&2
+    }
+    "$@"
+    result=$?
+    [ $result -eq 0 ] && break
+    count=$(($count + 1))
+    sleep 1
+  done
+
+  [ $count -eq 3 ] && {
+    echo "\n\033[33;1mThe command \"$@\" failed 3 times.\033[0m\n" >&2
+  }
+
+  return $result
+}
+
+function is_mri {
+  if ruby -e "exit(!defined?(RUBY_ENGINE) || RUBY_ENGINE == 'ruby')"; then
+    # RUBY_ENGINE only returns 'ruby' on MRI.
+    # MRI 1.8.7 lacks the constant but all other rubies have it (including JRuby in 1.8 mode)
+    return 0
+  else
+    return 1
+  fi;
+}
+
+function is_mri_192 {
+  if is_mri; then
+    if ruby -e "exit(RUBY_VERSION == '1.9.2')"; then
+      return 0
+    else
+      return 1
+    fi
+  else
+    return 1
+  fi
+}
+
+function rspec_support_compatible {
+  if [ "$MAINTENANCE_BRANCH" != "2-99-maintenance" ] && [ "$MAINTENANCE_BRANCH" != "2-14-maintenance" ]; then
+    return 0
+  else
+    return 1
+  fi
+}
+
+function documentation_enforced {
+  if [ -x ./bin/yard ]; then
+    return 0
+  else
+    return 1
+  fi
+}
+
+function clone_repo {
+  if [ ! -d $1 ]; then # don't clone if the dir is already there
+    travis_retry git clone git://github.com/rspec/$1 --depth 1 --branch $MAINTENANCE_BRANCH
+  fi;
+}
+
+function run_specs_and_record_done {
+  local rspec_bin=bin/rspec
+
+  # rspec-core needs to run with a special script that loads simplecov first,
+  # so that it can instrument rspec-core's code before rspec-core has been loaded.
+  if [ -f script/rspec_with_simplecov ]; then
+    rspec_bin=script/rspec_with_simplecov
+  fi;
+
+  $rspec_bin spec --backtrace --format progress --profile --format progress --out $SPECS_HAVE_RUN_FILE
+}
+
+function run_cukes {
+  if [ -d features ]; then
+    # force jRuby to use client mode JVM or a compilation mode thats as close as possible,
+    # idea taken from https://github.com/jruby/jruby/wiki/Improving-startup-time
+    #
+    # Note that we delay setting this until we run the cukes because we've seen
+    # spec failures in our spec suite due to problems with this mode.
+    export JAVA_OPTS='-client -XX:+TieredCompilation -XX:TieredStopAtLevel=1'
+
+    if is_mri_192; then
+      # For some reason we get SystemStackError on 1.9.2 when using
+      # the bin/cucumber approach below. That approach is faster
+      # (as it avoids the bundler tax), so we use it on rubies where we can.
+      bundle exec cucumber --strict
+    else
+      # Prepare RUBYOPT for scenarios that are shelling out to ruby,
+      # and PATH for those that are using `rspec` or `rake`.
+      RUBYOPT="-I${PWD}/../bundle -rbundler/setup" \
+         PATH="${PWD}/bin:$PATH" \
+         bin/cucumber --strict
+    fi
+  fi
+}
+
+function run_specs_one_by_one {
+  for file in `find spec -iname '*_spec.rb'`; do
+    bin/rspec $file -b --format progress
+  done
+}
+
+function run_spec_suite_for {
+  if [ ! -f ../$1/$SPECS_HAVE_RUN_FILE ]; then # don't rerun specs that have already run
+    pushd ../$1
+    echo
+    echo "Running specs for $1"
+    echo
+    unset BUNDLE_GEMFILE
+    bundle_install_flags=`cat .travis.yml | grep bundler_args | tr -d '"' | grep -o " .*"`
+    travis_retry bundle install $bundle_install_flags
+    run_specs_and_record_done
+    popd
+  fi;
+}
+
+function check_documentation_coverage {
+  bin/yard stats --list-undoc | ruby -e "
+    while line = gets
+      coverage ||= line[/([\d\.]+)% documented/, 1]
+      puts line
+    end
+
+    unless Float(coverage) == 100
+      puts \"\n\nMissing documentation coverage (currently at #{coverage}%)\"
+      exit(1)
+    end
+  "
+}

data/script/run_build

@@ -0,0 +1,13 @@
+#!/bin/bash
+# This file was generated on 2014-03-30T13:16:22-07:00 from the rspec-dev repo.
+# DO NOT modify it by hand as your changes will get lost the next time it is generated.
+
+set -e -x
+source script/functions.sh
+
+run_specs_and_record_done
+run_cukes
+
+if documentation_enforced; then
+  check_documentation_coverage
+fi

data/spec/rspec/legacy_formatters_spec.rb

@@ -0,0 +1,184 @@
+require 'rspec/core/formatters/console_codes'
+require 'rspec/legacy_formatters'
+
+RSpec.describe RSpec::LegacyFormatters do
+  include FormatterSupport
+
+  it 'can access attributes provided by base class accessors in #initialize' do
+    klass = Class.new(LegacyFormatterUsingSubClassing) do
+      def initialize(*args)
+        examples
+        super
+      end
+    end
+
+    config.add_formatter klass
+    expect(config.formatters.first).to be_a(RSpec::LegacyFormatters::Adaptor)
+    expect(config.formatters.first.formatter).to be_a(klass)
+  end
+
+  [OldStyleFormatterExample, LegacyFormatterUsingSubClassing].each do |klass|
+
+    describe "#{klass}" do
+      let(:described_class) { klass }
+
+      describe "#start" do
+        it "notifies formatter of start" do
+          send_notification :start, start_notification(5)
+          expect(output.string).to include "Started 5 examples"
+        end
+      end
+
+      describe "#example_group_started" do
+        it "notifies formatter of example_group_started" do
+          send_notification :example_group_started, group_notification
+          expect(output.string).to include "Started Group"
+        end
+      end
+
+      describe "#example_group_finished" do
+        it "notifies formatter of example_group_finished" do
+          send_notification :example_group_finished, group_notification
+          expect(output.string).to include "Finished Group"
+        end
+      end
+
+      describe "#example_started" do
+        it "notifies formatter of example_started" do
+          send_notification :example_started, example_notification
+          expect(output.string).to include "Started Example"
+        end
+      end
+
+      describe "#example_passed" do
+        it "notifies formatter of example_passed" do
+          send_notification :example_passed, example_notification
+          expect(output.string).to include "."
+        end
+      end
+
+      describe "#example_pending" do
+        it "notifies formatter of example_pending" do
+          send_notification :example_pending, example_notification
+          expect(output.string).to include "P"
+        end
+      end
+
+      describe "#example_failed" do
+        it "notifies formatter of example_failed" do
+          send_notification :example_failed, example_notification
+          expect(output.string).to include "F"
+        end
+      end
+
+      describe "#message" do
+        it "notifies formatter of message" do
+          send_notification :message, message_notification("A Message")
+          expect(output.string).to include "A Message"
+        end
+      end
+
+      describe "#stop" do
+        it "notifies formatter of stop" do
+          send_notification :stop, null_notification
+          expect(output.string).to include "Stopped"
+        end
+      end
+
+      describe "#start_dump" do
+        it "notifies formatter of start_dump" do
+          send_notification :start_dump, null_notification
+          expect(output.string).to include "Dumping!"
+        end
+      end
+
+      describe "#dump_failures" do
+        it "notifies formatter of dump_failures" do
+          send_notification :dump_failures, null_notification
+          expect(output.string).to include "Failures:"
+        end
+      end
+
+      describe "#dump_summary" do
+        it "notifies formatter of dump_summary" do
+          duration, count, failures, pending = 3.5, 10, 3, 2
+          send_notification :dump_summary, summary_notification(duration, count, failures, pending, 0)
+          expect(output.string).to(
+                match("Finished in 3.5").
+            and match("3/10 failed.").
+            and match("2 pending.")
+          )
+        end
+      end
+
+      describe "#dump_pending" do
+        it "notifies formatter of dump_pending" do
+          send_notification :dump_pending, null_notification
+          expect(output.string).to match "Pending:"
+        end
+      end
+
+      describe "#seed" do
+        it "notifies formatter of seed" do
+          send_notification :seed, seed_notification(17)
+          expect(output.string).to match "Randomized with seed 17"
+        end
+      end
+
+      describe "#close" do
+        it "notifies formatter of close" do
+          send_notification :close, null_notification
+        end
+      end
+    end
+  end
+
+  describe LegacyFormatterUsingSubClassing do
+    let(:legacy_formatter) { formatter.formatter }
+
+    it "will lookup colour codes" do
+      expect(legacy_formatter.color_code_for(:black)).to eq 30
+    end
+
+    it "will colorize text" do
+      allow(RSpec.configuration).to receive(:color_enabled?) { true }
+      expect(legacy_formatter.colorize("text", :black)).to eq "\e[30mtext\e[0m"
+    end
+
+    it "will colorize summary" do
+      allow(RSpec.configuration).to receive(:color_enabled?) { true }
+      expect(legacy_formatter.colorise_summary("text")).to include "\e[32mtext\e[0m"
+    end
+
+    it "allows access to the deprecated constants" do
+      pending "caller filter update"
+      legacy_formatter
+      expect_deprecation_with_call_site(__FILE__, __LINE__ + 1)
+      expect(described_class::VT100_COLORS).to eq ::RSpec::Core::Formatters::ConsoleCodes::VT100_CODES
+      expect_deprecation_with_call_site(__FILE__, __LINE__ + 1)
+      expect(described_class::VT100_COLOR_CODES).to eq ::RSpec::Core::Formatters::ConsoleCodes::VT100_CODE_VALUES
+    end
+
+    ::RSpec::Core::Formatters::ConsoleCodes::VT100_CODES.each do |name, number|
+      next if name == :black || name == :bold
+
+      describe "##{name}" do
+        before do
+          allow(RSpec.configuration).to receive(:color_enabled?) { true }
+          allow(RSpec).to receive(:deprecate)
+        end
+
+        it "prints the text using the color code for #{name}" do
+          expect(legacy_formatter.send(name, "text")).to eq("\e[#{number}mtext\e[0m")
+        end
+
+        it "prints a deprecation warning" do
+          expect(RSpec).to receive(:deprecate) {|*args|
+            expect(args.first).to match(/#{name}/)
+          }
+          legacy_formatter.send(name, "text")
+        end
+      end
+    end
+  end
+end