minitap 0.4.1 → 0.5.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8fd52937451ba7b8dd7e6aa13c046edd8f1e155d
+  data.tar.gz: a6ade0eef28c83ceed201e31bca1ce26a70f6f53
+SHA512:
+  metadata.gz: 6711b064107559933f4feed63a07a7502f3ccd7d25c6442d6de1a5d34b606b4f598cd74af0aed3da94446f607818d5d626a7153de5644d4e5f57719b0122d611
+  data.tar.gz: a14469a6138cc9c29454f64710f5172aebc32a9d6d8ab91ee670d5481d2c2fad1aa2854e19467271155c2c373bafe03ea8e58ece9b7c693624dd073503acb96d

data/.index

@@ -8,13 +8,10 @@ authors:
   email: transfire@gmail.com
 organizations: []
 requirements:
-- version: ! '>= 0.3.0'
+- version: 0.3.0+
   name: tapout
-- name: minitest
-- groups:
-  - build
-  development: true
-  name: ergo
+- version: 5.0~
+  name: minitest
 - groups:
   - test
   development: true
@@ -23,6 +20,10 @@ requirements:
   - test
   development: true
   name: ae
+- groups:
+  - build
+  development: true
+  name: ergo
 conflicts: []
 alternatives: []
 resources:
@@ -54,10 +55,10 @@ customs: []
 paths:
   lib:
   - lib
-summary: TAP-Y/J reporters for MiniTest
-title: MiniTap
-version: 0.4.1
 name: minitap
+title: MiniTap
+summary: TAP-Y/J reporters for MiniTest
 description: MiniTap provides a MiniTest TAP-Y/J report format suitable for use with
   TAPOUT.
-date: '2013-03-17'
+version: 0.5.0
+date: '2013-11-15'

data/HISTORY.md

@@ -1,5 +1,19 @@
 # RELEASE HISTORY
 
+## 0.5.0 | 2013-11-15
+
+The release adds support for MiniTest 5. Minitest completely 
+changes the way custom reporters are handled so this release
+includes extensive new code. Note that this version is also
+no longer intended for use with Minitest 4 or older. If you
+are using Minitest 4, please use Minitap 4.x as well.
+
+Changes:
+
+* Add support for Minitest 5.
+* Deprecate support for Minitest 4.
+
+
 ## 0.4.1 | 2013-03-18
 
 Minor release improves upon backtrace filtering and makes
@@ -9,7 +23,7 @@ are used even though minitap has been requried.
 Changes:
 
 * Use $RUBY_IGNORE_CALLERS for backtrace filtering.
-* Endure hook methods exist before using them.
+* Ensure hook methods exist before using them.
  
 
 ## 0.4.0 | 2013-03-17

data/README.md

@@ -1,4 +1,4 @@
-# MiniTap
+# Minitap
 
 [Website](http://rubyworks.github.com/minitap) |
 [Documentation](http://rubydoc.info/gems/minitap/frames) |
@@ -22,10 +22,48 @@ TAP-Y/J formats.
 
 ## Usage
 
-MiniTest supports custom report format by setting `MiniTest::Unit.runner` to
-an instance of a custom runner class. In this case we want to set it to an
-instance of `MiniTest::TapY` or `MiniTest::TapJ`. So in your project's test
-helper script add, e.g.
+### Minitest 5+
+
+Minitest 5 has a new report system and plug-in API. Minitap takes advantage
+of this new API to allow the TAP-Y or TAP-J formats to be selected via command-line
+options instead of requiring that the format be set in the test helper scripts.
+
+To use simply add `--tapy` or `--tapj` after an isolated `-` separator on the
+ruby test command invocation, e.g.
+
+    $ ruby -Ilib test/runner.rb - --tapy
+
+In your test helper scripts be sure you have the standard Minitest line:
+
+    require 'minitest/autorun'
+
+And remove any old `MiniTest::Unit.runner=` assignments if you are migrating 
+from v4.
+
+Now to do something interesting with the TAP-Y/J output, you will probably want
+to install `tapout`:
+
+    $ gem install tapout
+
+Then pipe the output to the `tapout` command, e.g.
+
+    $ ruby test/some_test.rb - --tapy | tapout progressbar
+
+And that's all there is too it.
+
+
+### MiniTest 4
+
+If you are still using MiniTest 4.x you will need to use Minitap version 4.x
+as well. In your dependencies be sure to specify this version. For example in 
+your Gemfile:
+
+    gem "minitap", "~> 4.0"
+
+For Minitest 4 and and older, custom report formats are set by assigning
+the `MiniTest::Unit.runner` to an instance of a custom runner class. 
+In our case we want to set it to an instance of `MiniTest::TapY` or `MiniTest::TapJ`.
+So in your project's test helper script add, e.g.
 
     require 'minitap'
     MiniTest::Unit.runner = MiniTest::TapY.new

data/lib/minitap/minitest5.rb

@@ -0,0 +1,881 @@
+# MiniTest adaptor for tapout.
+
+# Have to make sure the latest version of minitest is used.
+begin; gem 'minitest'; rescue; end
+
+#require 'minitest/unit'
+require 'minitap/ignore_callers'
+require 'stringio'
+
+# Becuase of some wierdness in MiniTest
+#debug, $DEBUG = $DEBUG, false
+#require 'minitest/unit'
+#$DEBUG = debug
+
+module Minitest
+
+  ##
+  # Base class for TapY and TapJ runners.
+  #
+  class Minitap < StatisticsReporter #Reporter
+
+    # TAP-Y/J Revision
+    REVISION = 4
+
+    # Backtrace patterns to be omitted.
+    IGNORE_CALLERS = $RUBY_IGNORE_CALLERS
+
+    # Test results.
+    #attr_reader :test_results
+
+    attr_reader :test_cases
+    attr_reader :test_count
+
+    attr_accessor :suite_start_time
+    attr_accessor :case_start_time
+    attr_accessor :test_start_time
+
+    # Initialize new Minitap Minitest reporter.
+    def initialize(io = $stdout, options = {})
+      super(io, options)
+
+      #@_stdout = StringIO.new
+      #@_stderr = StringIO.new
+
+      #@test_results = {}
+      #self.assertion_count = 0
+
+      @_source_cache = {}
+    end
+
+    #
+    # Minitest's initial hook ran just before testing begins.
+    #
+    def start
+      super
+
+      @test_cases = Runnable.runnables
+
+      capture_io
+
+      #@_stdout, @_stderr = capture_io do
+      #  super_result = super(suite, type)
+      #end
+
+      before_suite(@test_cases)
+    end
+
+    #
+    # Process a test result.
+    #
+    def record(minitest_result)
+      super(minitest_result)
+
+      result = TestResult.new(minitest_result)
+
+      #if exception #&& ENV['minitap_debug']
+      #  STDERR.puts exception
+      #  STDERR.puts exception.backtrace.join("\n")
+      #end
+
+      #@test_results[suite] ||= {}
+      #@test_results[suite][test.to_sym] = record
+
+      case_change = false
+
+      if @previous_case != result.test_case
+        case_change = true  
+        before_case(result.test_case)
+      end
+
+      #before_test(result)
+      case result.type
+      when :skip
+        test_skip(result)
+      when :pass
+        test_pass(result)
+      when :fail
+        test_fail(result)
+      when :err
+        test_err(result)
+      end
+      after_test(result)
+
+      if case_change
+        after_case(result.test_case)
+      end
+
+      @previous_case = result.test_case
+    end
+
+    #
+    # Minitest's finalization hook.
+    #
+    def report
+      super
+
+      uncapture_io
+
+      after_suite()
+    end
+
+    #
+    # Intermediary Callbacks
+    #
+
+    #
+    def before_suite(test_cases)
+      @suite_start_time = Time.now
+      count_tests!(test_cases)
+      tapout_before_suite()
+    end
+
+    def after_suite() #(test_cases)
+      tapout_after_suite()
+    end
+
+    def before_case(test_case)
+      @case_start_time = Time.now
+      tapout_before_case(test_case)
+    end
+
+    def after_case(test_case)
+      tapout_after_case(test_case)
+    end
+
+    def before_test(result)
+      @test_start_time = Time.now
+      tapout_before_test(result)
+    end
+
+    def after_test(result)
+      tapout_after_test(result)
+    end
+
+    def test_skip(result)
+      tapout_test_skip(result)
+    end
+
+    def test_pass(result)
+      tapout_test_pass(result)
+    end
+
+    def test_fail(result)
+      tapout_test_failure(result)
+    end
+
+    def test_err(result)
+      tapout_test_error(result)
+    end
+
+=begin
+    def _run_suites(suites, type)
+      #output.puts "# Run options: #{@help}"
+
+      @suites_start_time = Time.now
+      count_tests!(suites, type)
+      trigger_callback(:before_suites, suites, type)
+      super(suites, type)
+    ensure
+      trigger_callback(:after_suites, suites, type)
+    end
+
+    def _run_suite(suite, type)
+      # The only reason this is here is b/c MiniTest wil try to run
+      # base classes like `MiniTest::Spec`. So to prevent that,
+      # if there are no tests to run, we don't bother to process
+      # the "suite" at all.
+      @_suite_tests = suite.send("#{type}_methods")
+      return [0,0] if @_suite_tests.empty?
+
+      begin
+        @suite_start_time = Time.now
+        trigger_callback(:before_suite, suite)
+
+        super_result = nil
+        @_stdout, @_stderr = capture_io do
+          super_result = super(suite, type)
+        end
+        super_result
+      ensure
+        trigger_callback(:after_suite, suite)
+      end
+    end
+
+    def before_test(suite, test)
+      @test_start_time = Time.now
+      trigger_callback(:before_test, suite, test)
+    end
+
+    def after_test(suite, test)
+      #runners = @test_recorder[suite, test.to_sym]
+      #records = @test_results[suite][test.to_sym]
+      record = @test_results[suite][test.to_sym]
+
+      #records.each do |record|
+      #  trigger_callback(record.result, suite, test.to_sym, record)
+      #end
+
+      trigger_callback(record.result, suite, test.to_sym, record)
+
+      #trigger_callback(:after_test, suite, test.to_sym)
+    end
+=end
+
+    # Stub out the three IO methods used by the built-in reporter.
+    def p(*args)
+      args.each{ |a| io.print(a.inspect); puts }
+    end
+
+    def puts(*args)
+      io.puts(*args)
+    end
+
+    def print(*args)
+      io.print(*args)
+    end
+
+    #def status(io = output); end
+
+  private
+
+    #    
+    def filtered_tests(test_case) #suite, type
+      filter = options[:filter] || '/./'
+      filter = Regexp.new($1) if filter =~ /\/(.*)\//
+      test_case.runnable_methods.grep(filter)
+    end
+
+=begin
+    #
+    def add_test_result(suite, test, test_runner)
+      self.report[suite] ||= {}
+      self.report[suite][test.to_sym] = test_runner
+      
+      self.assertion_count += test_runner.assertions
+      
+      case test_runner.result
+      when :skip then self.skips += 1
+      when :failure then self.failures += 1
+      when :error then self.errors += 1
+      end
+    end
+=end
+
+    def count_tests!(test_cases)
+      filter = options[:filter] || '/./'
+      filter = Regexp.new $1 if filter =~ /\/(.*)\//
+
+      @test_count = test_cases.inject(0) do |acc, test_case|
+        acc + test_case.runnable_methods.grep(filter).length
+      end
+    end
+
+    #
+    # Tapout Records
+    #
+
+    #
+    def tapout_before_suite()
+      doc = {
+        'type'  => 'suite',
+        'start' => self.suite_start_time.strftime('%Y-%m-%d %H:%M:%S'),
+        'count' => self.test_count,
+        'seed'  => self.options[:seed],
+        'rev'   => REVISION
+      }
+      return doc
+    end
+
+    #
+    def tapout_after_suite()
+      doc = {
+        'type' => 'final',
+        'time' => Time.now - self.suite_start_time,
+        'counts' => {
+          'total' => self.test_count,
+          'pass'  => self.test_count - self.failures - self.errors - self.skips,
+          'fail'  => self.failures,
+          'error' => self.errors,
+          'omit'  => self.skips,
+          'todo'  => 0  # TODO: does minitest support pending tests?
+        }
+      }
+      return doc
+    end
+
+    #
+    def tapout_before_case(test_case)
+      doc = {
+        'type'    => 'case',
+        'subtype' => '',
+        'label'   => "#{test_case}",
+        'level'   => 0
+      }
+
+      record_stdcom(doc)
+
+      return doc
+    end
+
+    #
+    def tapout_after_case(test_case)
+    end
+
+    #
+    def tapout_before_test(result)
+    end
+
+    #
+    def tapout_after_test(result)
+    end
+
+    # TAP record for pass.
+    #
+    # Returns [Hash].
+    def tapout_test_pass(result) #suite, test, test_runner
+      doc = {
+        'type'        => 'test',
+        'subtype'     => '',
+        'status'      => 'pass',
+        #'setup': foo instance
+        'label'       => "#{result.label}",
+        #'expected' => 2
+        #'returned' => 2
+        #'file' => 'test/test_foo.rb'
+        #'line': 45
+        #'source': ok 1, 2
+        #'snippet':
+        #  - 44: ok 0,0
+        #  - 45: ok 1,2
+        #  - 46: ok 2,4
+        #'coverage':
+        #  file: lib/foo.rb
+        #  line: 11..13
+        #  code: Foo#*
+        'time' => Time.now - self.suite_start_time
+      }
+
+      record_stdcom(doc)
+
+      #stdout, stderr = @_stdout, @_stderr
+      #doc['stdout'] = stdout unless stdout.empty?
+      #doc['stderr'] = stderr unless stderr.empty?
+
+      return doc
+    end
+
+    # TAP record for skip.
+    #
+    # Returns [Hash].
+    def tapout_test_skip(result) #suite, test, test_runner
+      e = result.exception
+      e_file, e_line = location(result.exception)
+      r_file = e_file.sub(Dir.pwd+'/', '')
+
+      doc = {
+        'type'        => 'test',
+        'subtype'     => '',
+        'status'      => 'skip',
+        'label'       => "#{result.label}",
+        #'setup' => "foo instance",
+        #'expected' => 2,
+        #'returned' => 1,
+        #'file' => test/test_foo.rb
+        #'line' => 45
+        #'source' => ok 1, 2
+        #'snippet' =>
+        #  - 44: ok 0,0
+        #  - 45: ok 1,2
+        #  - 46: ok 2,4
+        #'coverage' =>
+        #  'file' => lib/foo.rb
+        #  'line' => 11..13
+        #  'code' => Foo#*
+        'exception' => {
+          'message'   => clean_message(e.message),
+          'class'     => e.class.name,
+          'file'      => r_file,
+          'line'      => e_line,
+          'source'    => source(e_file)[e_line-1].strip,
+          'snippet'   => code_snippet(e_file, e_line),
+          'backtrace' => filter_backtrace(e.backtrace)
+        },
+        'time' => Time.now - self.suite_start_time
+      }
+      return doc
+    end
+
+    # TAP record for failure.
+    #
+    # Returns [Hash].
+    def tapout_test_failure(result)
+      e = result.exception
+      e_file, e_line = location(result.exception)
+      r_file = e_file.sub(Dir.pwd+'/', '')
+
+      doc = {
+        'type'        => 'test',
+        'subtype'     => '',
+        'status'      => 'fail',
+        'label'       => "#{result.label}",
+        #'setup' => "foo instance",
+        #'expected' => 2,
+        #'returned' => 1,
+        #'file' => test/test_foo.rb
+        #'line' => 45
+        #'source' => ok 1, 2
+        #'snippet' =>
+        #  - 44: ok 0,0
+        #  - 45: ok 1,2
+        #  - 46: ok 2,4
+        #'coverage' =>
+        #  'file' => lib/foo.rb
+        #  'line' => 11..13
+        #  'code' => Foo#*
+        'exception' => {
+          'message'   => clean_message(e.message),  
+          'class'     => e.class.name,
+          'file'      => r_file,
+          'line'      => e_line,
+          'source'    => source(e_file)[e_line-1].strip,
+          'snippet'   => code_snippet(e_file, e_line),
+          'backtrace' => filter_backtrace(e.backtrace)
+        },
+        'time' => Time.now - self.suite_start_time   # result.time
+      }
+
+      record_stdcom(doc)
+
+      #stdout, stderr = @_stdout, @_stderr
+      #doc['stdout'] = stdout unless stdout.empty?
+      #doc['stderr'] = stderr unless stderr.empty?
+
+      return doc
+    end
+
+    # TAP record for error.
+    #
+    # Returns [Hash].
+    def tapout_test_error(result)
+      e = result.exception
+      e_file, e_line = location(e)
+      r_file = e_file.sub(Dir.pwd+'/', '')
+
+      doc = {
+        'type'        => 'test',
+        'subtype'     => '',
+        'status'      => 'error',
+        'label'       => "#{result.label}",
+        #'setup' => "foo instance",
+        #'expected' => 2,
+        #'returned' => 1,
+        #'file' => test/test_foo.rb
+        #'line' => 45
+        #'source' => ok 1, 2
+        #'snippet' =>
+        #  - 44: ok 0,0
+        #  - 45: ok 1,2
+        #  - 46: ok 2,4
+        #'coverage' =>
+        #  'file' => lib/foo.rb
+        #  'line' => 11..13
+        #  'code' => Foo#*
+        'exception' => {
+          'message'   => clean_message(e.error.message),
+          'class'     => e.error.class.name,
+          'file'      => r_file,
+          'line'      => e_line,
+          'source'    => source(e_file)[e_line-1].strip,
+          'snippet'   => code_snippet(e_file, e_line),
+          'backtrace' => filter_backtrace(e.backtrace)
+        },
+        'time' => Time.now - self.suite_start_time  # result.time
+      }
+
+      record_stdcom(doc)
+
+      #stdout, stderr = @_stdout, @_stderr
+      #doc['stdout'] = stdout unless stdout.empty?
+      #doc['stderr'] = stderr unless stderr.empty?
+
+      return doc
+    end
+
+    # ---------------------------------------------------------------------
+
+    #
+    #
+    #
+    def record_stdcom(doc)
+      begin
+        doc['stdout'] = $stdout.string unless $stdout.length == 0 #empty?
+        doc['stderr'] = $stderr.string unless $stderr.length == 0 #empty?
+        $stdout.close; $stderr.close
+        $stdout, $stderr = StringIO.new, StringIO.new
+      #end
+      rescue => err
+        uncapture_io
+        raise err
+      end
+    end
+
+    #
+    #def filter_backtrace(backtrace)
+    #  trace = backtrace
+    #  trace = clean_backtrace(trace)
+    #  trace = MiniTest::filter_backtrace(trace)
+    #  trace
+    #end
+
+    # Clean the backtrace of any reference to test framework itself.
+    def filter_backtrace(backtrace)
+      ## remove backtraces that match any pattern in IGNORE_CALLERS
+      trace = backtrace.reject{|b| IGNORE_CALLERS.any?{|i| i=~b}}
+      ## remove `:in ...` portion of backtraces
+      trace = trace.map do |bt| 
+        i = bt.index(':in')
+        i ? bt[0...i] :  bt
+      end
+      ## now apply MiniTest's own filter (note: doesn't work if done first, why?)
+      trace = Minitest::filter_backtrace(trace)
+      ## if the backtrace is empty now then revert to the original
+      trace = backtrace if trace.empty?
+      ## simplify paths to be relative to current workding diectory
+      trace = trace.map{ |bt| bt.sub(Dir.pwd+File::SEPARATOR,'') }
+      return trace
+    end
+
+    # Returns a String of source code.
+    def code_snippet(file, line)
+      s = []
+      if File.file?(file)
+        source = source(file)
+        radius = 2 # TODO: make customizable (number of surrounding lines to show)
+        region = [line - radius, 1].max ..
+                 [line + radius, source.length].min
+
+        s = region.map do |n|
+          {n => source[n-1].chomp}
+        end
+      end
+      return s
+    end
+
+    # Cache source file text. This is only used if the TAP-Y stream
+    # doesn not provide a snippet and the test file is locatable.
+    def source(file)
+      @_source_cache[file] ||= (
+        File.readlines(file)
+      )
+    end
+
+    # Parse source location from caller, caller[0] or an Exception object.
+    def parse_source_location(caller)
+      case caller
+      when Exception
+        trace  = caller.backtrace.reject{ |bt| bt =~ INTERNALS }
+        caller = trace.first
+      when Array
+        caller = caller.first
+      end
+      caller =~ /(.+?):(\d+(?=:|\z))/ or return ""
+      source_file, source_line = $1, $2.to_i
+      return source_file, source_line
+    end
+
+    # Get location of exception.
+    def location e # :nodoc:
+      last_before_assertion = ""
+      e.backtrace.reverse_each do |s|
+        break if s =~ /in .(assert|refute|flunk|pass|fail|raise|must|wont)/
+        last_before_assertion = s
+      end
+      file, line = last_before_assertion.sub(/:in .*$/, '').split(':')
+      line = line.to_i if line
+      return file, line
+    end
+
+    #
+    def clean_message(message)
+      message.strip #.gsub(/\s*\n\s*/, "\n")
+    end
+
+    #
+    #def capture_io
+    #  ostdout, ostderr = $stdout, $stderr
+    #  cstdout, cstderr = StringIO.new, StringIO.new
+    #  $stdout, $stderr = cstdout, cstderr
+    #
+    #  yield
+    #
+    #  return cstdout.string.chomp("\n"), cstderr.string.chomp("\n")
+    #ensure
+    #  $stdout = ostdout
+    #  $stderr = ostderr
+    #end
+
+    #
+    def capture_io
+      @_stdout, @_stderr = $stdout, $stderr
+      $stdout, $stderr = StringIO.new, StringIO.new
+    end
+
+    #
+    def uncapture_io
+      $stdout, $stderr = @_stdout, @_stderr
+    end
+
+  end
+
+  #
+  # TestResult delegtes to Minitest's own test result object.
+  #
+  class TestResult
+    # Create new TestResult instance.
+    #
+    # result - MiniTest's test result object.
+    #
+    def initialize(result)
+      @result = result
+    end
+
+    def test_case
+      @result.class
+    end
+    alias :testcase :test_case
+
+    # Name of the test.
+    def name
+      @result.name
+    end
+    alias :test :name
+
+    #
+    def label
+      if spec?
+        name.sub(/^test_\d+_/, '').gsub('_', ' ')
+      else
+        name
+      end
+    end
+
+    # Is this a Minitest::Spec?
+    #
+    # Returns [Boolean].
+    def spec?
+      @is_spec ||= (
+        Minitest.const_defined?(:Spec) && @result.class < Minitest::Spec
+        #@result.class.methods.include?(:it) || @result.class.methods.include?('it')
+      )
+    end
+
+    # Number of assertions made by test.
+    #
+    # Returns [Integer].
+    def assertions
+      @result.assertions
+    end
+
+    #
+    def time
+      @result.time
+    end
+
+    #
+    def exception
+      @result.failure
+    end
+
+    # Result type.
+    def type
+      case exception
+      when UnexpectedError
+        :err
+      when Skip
+        :skip
+      when Assertion
+        :fail
+      when nil 
+        :pass
+      else 
+        :err
+      end
+    end
+  end
+
+=begin
+  # Runner for individual MiniTest tests.
+  # 
+  # You *should not* create instances of this class directly. Instances of
+  # {SuiteRunner} will create these and send them to the reporters.
+  # 
+  # Based upon Ryan Davis of Seattle.rb's MiniTest (MIT License).
+  # 
+  # @see https://github.com/seattlerb/minitest MiniTest
+  class TestRunner
+    attr_reader :suite, :test, :assertions, :result, :exception
+    attr_reader :stdout, :stderr
+
+    def initialize(suite, test)
+      @suite = suite
+      @test = test
+      @assertions = 0
+    end
+    
+    def run
+      suite_instance = suite.new(test)
+      test_result = nil
+      @stdout, @stderr = capture_io do
+        test_result = suite_instance.run(self)
+      end
+      @result, @exception = fix_result(test_result)
+      @assertions = suite_instance._assertions
+    end
+
+    def puke(suite, test, exception)
+      case exception
+      when MiniTest::Skip then [:skip, exception]
+      when MiniTest::Assertion then [:failure, exception]
+      else [:error, exception]
+      end
+    end
+
+    def record(suite, method, assertions, time, error)
+    end
+
+  private
+    
+    #
+    def fix_result(result)
+      result == '.' ? [:pass, nil] : result
+    end
+
+    #
+    def capture_io
+      ostdout, ostderr = $stdout, $stderr
+      cstdout, cstderr = StringIO.new, StringIO.new
+      $stdout, $stderr = cstdout, cstderr
+
+      yield
+
+      return cstdout.string.chomp("\n"), cstderr.string.chomp("\n")
+    ensure
+      $stdout = ostdout
+      $stderr = ostderr
+    end
+  end
+=end
+
+=begin
+  ##
+  # Around advice.
+  #
+  module AroundTestHooks
+    def self.before_test(instance)
+      if before_test = (MiniTest::Unit.runner.method(:before_test) rescue nil)
+        before_test.call(instance.class, instance.__name__)
+      end
+    end
+
+    def self.after_test(instance)
+      # MiniTest < 4.1.0 sends #record after all teardown hooks, so don't call
+      # #after_test here.
+      if MiniTest::Unit::VERSION > "4.1.0"
+        if after_test = (MiniTest::Unit.runner.method(:after_test) rescue nil)
+          after_test.call(instance.class, instance.__name__)
+        end
+      end
+    end
+
+    def before_setup
+      AroundTestHooks.before_test(self)
+      super
+    end
+
+    def after_teardown
+      super
+      AroundTestHooks.after_test(self)
+    end
+  end
+
+  class Unit::TestCase
+    include AroundTestHooks
+  end
+=end
+
+  ##
+  # TAP-Y adapater.
+  #
+  class TapY < Minitap
+    def initialize(io=$stdout, options={})
+      require 'yaml' unless respond_to?(:to_yaml)
+      super(io, options)
+    end
+
+    def tapout_before_suite()
+      wp super().to_yaml
+    end
+    def tapout_before_case(test_case)
+      wp super(test_case).to_yaml
+    end
+    def tapout_test_pass(result)
+      wp super(result).to_yaml
+    end
+    def tapout_test_skip(result)
+      wp super(result).to_yaml
+    end
+    def tapout_test_failure(result)
+      wp super(result).to_yaml
+    end
+    def tapout_test_error(result)
+      wp super(result).to_yaml
+    end
+    def tapout_after_suite()
+      wp super().to_yaml
+      wp "..."
+    end
+
+    def wp(str)
+      io.puts(str)
+    end
+  end
+
+  ##
+  # TAP-J adapater.
+  #
+  class TapJ < Minitap
+    def initialize(io=$stdout, options={})
+      require 'json' unless respond_to?(:to_json)
+      super(io, options)
+    end
+
+    def tapout_before_suite()
+      wp super().to_json
+    end
+    def tapout_before_case(test_case)
+      wp super(test_case).to_json
+    end
+    def tapout_test_pass(result)
+      wp super(result).to_json
+    end
+    def tapout_test_skip(result)
+      wp super(result).to_json
+    end
+    def tapout_test_failure(result)
+      wp super(result).to_json
+    end
+    def tapout_test_error(result)
+      wp super(result).to_json
+    end
+    def tapout_after_suite()
+      wp super().to_json
+    end
+
+    def wp(str)
+      io.puts(str)
+      #STDOUT.puts(str)
+    end
+  end
+
+end

data/lib/minitest/minitap_plugin.rb

@@ -0,0 +1,28 @@
+module Minitest
+
+  def self.plugin_minitap_options(opts, options)
+    opts.on "--tapy", "Use TapY reporter." do
+      options[:minitap] = 'tapy'
+    end
+    opts.on "--tapj", "Use TapJ reporter." do
+      options[:minitap] = 'tapj'
+    end
+  end
+
+  def self.plugin_minitap_init(options)
+    if options[:minitap]
+      require 'minitap/minitest5'
+
+      self.reporter.reporters.clear
+
+      case options[:minitap] || ENV['rpt']
+      when 'tapj'
+        self.reporter << TapJ.new(options[:io], options)
+      when 'tapy'
+        self.reporter << TapY.new(options[:io], options)
+      end
+    end
+  end
+
+end
+

metadata

@@ -1,94 +1,83 @@
 --- !ruby/object:Gem::Specification
 name: minitap
 version: !ruby/object:Gem::Version
-  version: 0.4.1
-  prerelease: 
+  version: 0.5.0
 platform: ruby
 authors:
 - trans
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-18 00:00:00.000000000 Z
+date: 2013-11-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: tapout
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: 0.3.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: 0.3.0
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '5.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '5.0'
 - !ruby/object:Gem::Dependency
-  name: ergo
+  name: qed
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: qed
+  name: ae
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: ae
+  name: ergo
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 description: MiniTap provides a MiniTest TAP-Y/J report format suitable for use with
@@ -99,46 +88,46 @@ executables: []
 extensions: []
 extra_rdoc_files:
 - LICENSE.txt
-- HISTORY.md
-- README.md
-- QED.md
 - NOTICE.md
+- README.md
+- HISTORY.md
+- DEMO.md
 files:
 - .index
 - .yardopts
 - lib/minitap/ignore_callers.rb
+- lib/minitap/minitest5.rb
 - lib/minitap/tapj.rb
 - lib/minitap/tapy.rb
 - lib/minitap.rb
-- HISTORY.md
-- README.md
-- QED.md
+- lib/minitest/minitap_plugin.rb
 - NOTICE.md
+- README.md
+- HISTORY.md
+- DEMO.md
 - LICENSE.txt
 homepage: http://rubyworks.github.com/minitap
 licenses:
 - BSD-2-Clause
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 2.0.3
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: TAP-Y/J reporters for MiniTest
 test_files: []
-has_rdoc: