minitap 0.1.0

data/.ruby

@@ -0,0 +1,39 @@
+---
+authors:
+- name: Thomas Sawyer
+  email: transfire@gmail.com
+copyrights:
+- holder: Thomas Sawyer
+  year: '2011'
+  license: BSD-2-Clause
+replacements: []
+conflicts: []
+requirements:
+- name: tapout
+- name: detroit
+  groups:
+  - build
+  development: true
+- name: reap
+  groups:
+  - build
+  development: true
+dependencies: []
+repositories: []
+resources:
+  home: http://rubyworks.github.com/minitap
+  code: http://github.com/rubyworks/minitap
+load_path:
+- lib
+extra: {}
+name: minitap
+title: TAP-Y/J for MiniTest
+date: '2011-10-06'
+alternatives: []
+version: 0.1.0
+revision: 0
+source:
+- ruby.yml
+summary: MiniTest TAP-Y/J reporter
+description: MiniTap provides a custom MiniTest reporter that outs TAP-Y or TAP-J
+  formatted output.

data/COPYING.rdoc

@@ -0,0 +1,59 @@
+= COPYRIGHT NOTICES
+
+== MiniTap
+
+Copyright:: (c) 2010 Thomas Sawyer, Rubyworks
+License:: BSD-2-Clause
+Website:: http://rubyworks.github.com/tapout
+
+    Copyright 2011 Thomas Sawyer. All rights reserved.
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions are met:
+
+       1. Redistributions of source code must retain the above copyright notice,
+          this list of conditions and the following disclaimer.
+
+       2. Redistributions in binary form must reproduce the above copyright
+          notice, this list of conditions and the following disclaimer in the
+          documentation and/or other materials provided with the distribution.
+
+    THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+    INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+    AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+    COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+    INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+    NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR  SERVICES; LOSS OF USE,
+    DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+    OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+    NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+    EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+== MiniTest Reporter
+
+Copyright:: (c) 2011 Alexander Kern
+License:: MIT
+Website:: https://github.com/CapnKernul/minitest-reporters
+
+    Copyright (c) 2011 Alexander Kern
+
+    Permission is hereby granted, free of charge, to any person obtaining
+    a copy of this software and associated documentation files (the
+    "Software"), to deal in the Software without restriction, including
+    without limitation the rights to use, copy, modify, merge, publish,
+    distribute, sublicense, and/or sell copies of the Software, and to
+    permit persons to whom the Software is furnished to do so, subject to
+    the following conditions:
+
+    The above copyright notice and this permission notice shall be
+    included in all copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+    NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+    LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+    OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+    WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

data/HISTORY.rdoc

@@ -0,0 +1,10 @@
+= RELEASE HISTORY
+
+== 0.1.0 / 2011-10-06
+
+This is the first release of MiniTap, a TAP-Y/J reporter
+for the MiniTest test framework.
+
+Changes:
+
+* First Release Day!

data/README.rdoc

@@ -0,0 +1,46 @@
+= MiniTap
+
+{Website}[http://rubyworks.github.com/minitap]
+{Development}[http://github.com/rubyworks/minitap]
+
+
+== Description
+
+The MiniTap project provides a TAP-Y and TAP-J output reporters for
+the MiniTest test framework --the test framework that comes standard
+with Ruby 1.9+.
+
+See {TAPOUT}[http://rubyworks.github.com/tapout] for more information about
+TAP-Y/J formats.
+
+
+== Usage
+
+Simply require `minitest/tapy` or `minitest/tapj' when running your tests.
+For  example if you use `ruby` on the command line:
+
+  ruby -r'minitest/tapy' test_some_test.rb
+
+Now to do something intersing with the outout. Make sure `tapout` is installed:
+
+  $ gem install tapout
+
+Then pipe the output to the `tapout` command.
+
+  $ ruby -r'minitest/tapy' test/some_test.rb | tapout progressbar
+
+Adjust your Rake task or other means of running tests to suite.
+
+
+== Copying
+
+Copyright (c) 2011 Thomas Sawyer
+
+Made available under the terms of the BSD-2-Clause license.
+
+Portions of this program were drawn from Alexander Kern's
+MiniTest Reporter (c) 2011 Alexander Kern. Thanks Alexander
+for making my endeavor a little bit easier.
+
+See COPYING.rdoc for copyright and licensing details.
+

data/lib/minitap.rb

@@ -0,0 +1,534 @@
+# MiniTest adaptor for tapout.
+
+require 'minitest/unit'
+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.
+  # 
+  # This is a heavily refactored version of the built-in MiniTest runner. It's
+  # about the same speed, from what I can tell, but is significantly easier to
+  # extend.
+  # 
+  # Based upon Ryan Davis of Seattle.rb's MiniTest (MIT License).
+  # 
+  # @see https://github.com/seattlerb/minitest MiniTest
+  #
+  class MiniTap < ::MiniTest::Unit
+
+    # TAP-Y/J Revision
+    REVISION = 2
+
+    attr_accessor :suite_start_time, :test_start_time, :reporters
+    
+    def initialize
+      self.report = {}
+      self.errors = 0
+      self.failures = 0
+      self.skips = 0
+      self.test_count = 0
+      self.assertion_count = 0
+      self.verbose = false
+      self.reporters = []
+
+      @_source_cache = {}
+    end
+
+    # Top level driver, controls all output and filtering.
+    def _run args = []
+      self.options = process_args(args)
+
+      self.class.plugins.each do |plugin|
+        send plugin
+        break unless report.empty?
+      end
+
+      return failures + errors if @test_count > 0 # or return nil...
+    rescue Interrupt
+      abort 'Interrupted'
+    end
+
+    #
+    def _run_anything(type)
+      self.start_time = Time.now
+      
+      suites = suites_of_type(type)
+      tests = suites.inject({}) do |acc, suite|
+        acc[suite] = filtered_tests(suite, type)
+        acc
+      end
+      
+      self.test_count = tests.inject(0) { |acc, suite| acc + suite[1].length }
+      
+      if test_count > 0
+        trigger(:before_suites, suites, type)
+        
+        fix_sync do
+          suites.each { |suite| _run_suite(suite, tests[suite]) }
+        end
+        
+        trigger(:after_suites, suites, type)
+      end
+    end
+    
+    def _run_suite(suite, tests)
+      unless tests.empty?
+        begin
+          self.suite_start_time = Time.now
+          
+          trigger(:before_suite, suite)
+          suite.startup if suite.respond_to?(:startup)
+          
+          tests.each { |test| _run_test(suite, test) }
+        ensure
+          suite.shutdown if suite.respond_to?(:shutdown)
+          trigger(:after_suite, suite)
+        end
+      end
+    end
+    
+    #
+    def _run_test(suite, test)
+      self.test_start_time = Time.now
+
+      trigger(:before_test, suite, test)
+      
+      test_runner = TestRunner.new(suite, test)
+      test_runner.run
+      add_test_result(suite, test, test_runner)
+      
+      trigger(test_runner.result, suite, test, test_runner)
+    end
+    
+    #
+    def trigger(callback, *args)
+      send("tapout_#{callback}", *args)
+    end
+
+    private
+
+    #    
+    def filtered_tests(suite, type)
+      filter = options[:filter] || '/./'
+      filter = Regexp.new($1) if filter =~ /\/(.*)\//
+      suite.send("#{type}_methods").grep(filter)
+    end
+    
+    #
+    def suites_of_type(type)
+      TestCase.send("#{type}_suites")
+    end
+    
+    #
+    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
+
+    #
+    def fix_sync
+      sync = output.respond_to?(:'sync=') # stupid emacs
+      old_sync, output.sync = output.sync, true if sync
+      yield
+      output.sync = old_sync if sync
+    end
+
+    #
+    def tapout_before_suites(suites, type)
+      doc = {
+        'type'  => 'suite',
+        'start' => self.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_suites(suites, type)
+      doc = {
+        'type' => 'tally',
+        'time' => Time.now - self.test_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_suite(suite)
+      doc = {
+        'type'    => 'case',
+        'subtype' => '',
+        'label'   => "#{suite}",
+        'level'   => 0
+      }
+      return doc
+    end
+
+    #
+    def tapout_after_suite(suite)
+    end
+
+    #
+    def tapout_before_test(suite, test)
+    end
+
+    #
+    def tapout_pass(suite, test, test_runner)
+      doc = {
+        'type'        => 'test',
+        'subtype'     => '',
+        'status'      => 'pass',
+        #'setup': foo instance
+        'label'       => "#{test}",
+        #'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
+      }
+      return doc
+    end
+
+    #
+    def tapout_skip(suite, test, test_runner)
+      e = test_runner.exeception
+      e_file, e_line = location(test_runner.exception)
+
+      doc = {
+        'type'        => 'test',
+        'subtype'     => '',
+        'status'      => 'skip',
+        'label'       => "#{test}",
+        #'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),
+          'file'      => e_file,
+          'line'      => e_line,
+          #'source'   => '',
+          'snippet'   => code_snippet(e_file, e_line),
+          'backtrace' => filter_backtrace(e.backtrace)
+        },
+        'time' => Time.now - self.suite_start_time
+      }
+      return doc
+    end
+
+    #
+    def tapout_failure(suite, test, test_runner)
+      e = test_runner.exception
+      e_file, e_line = location(test_runner.exception)
+
+      doc = {
+        'type'        => 'test',
+        'subtype'     => '',
+        'status'      => 'fail',
+        'label'       => "#{test}",
+        #'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),
+          'file'      => e_file,
+          'line'      => e_line,
+          #'source'    => '',
+          'snippet'   => code_snippet(e_file, e_line),
+          'backtrace' => filter_backtrace(e.backtrace)
+        },
+        'time' => Time.now - self.suite_start_time
+      }
+      return doc
+    end
+
+    #
+    def tapout_error(suite, test, test_runner)
+      e = test_runner.exception
+      e_file, e_line = location(test_runner.exception)
+
+      doc = {
+        'type'        => 'test',
+        'subtype'     => '',
+        'status'      => 'error',
+        'label'       => "#{test}",
+        #'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.class}: #{e.message}"),
+          'file'      => e_file,
+          'line'      => e_line,
+          #'source'    => '',
+          'snippet'   => code_snippet(e_file, e_line),
+          'backtrace' => filter_backtrace(e.backtrace)
+        },
+        'time' => Time.now - self.suite_start_time
+      }
+      return doc
+    end
+
+    #
+    INTERNALS = /(lib|bin)#{Regexp.escape(File::SEPARATOR)}tapout/
+
+    #
+    def filter_backtrace(bt)
+      bt = clean_backtrace(bt)
+      bt = MiniTest::filter_backtrace(bt)
+      bt
+    end
+
+    # Clean the backtrace of any reference to ko/ paths and code.
+    def clean_backtrace(backtrace)
+      trace = backtrace.reject{ |bt| bt =~ INTERNALS }
+      trace = trace.map do |bt| 
+        if i = bt.index(':in')
+          bt[0...i]
+        else
+          bt
+        end
+      end
+      trace = backtrace if trace.empty?
+      trace = trace.map{ |bt| bt.sub(Dir.pwd+File::SEPARATOR,'') }
+      trace
+    end
+
+    # Returns a String of source code.
+    def code_snippet(file, line)
+      s = []
+
+      #case snippet
+      #when String
+      #  lines = snippet.lines.to_a
+      #  index = line - ((lines.size - 1) / 2)
+      #  lines.each do |line|
+      #    s << [index, line]
+      #    index += 1
+      #  end
+      #when Array
+      #  snippet.each do |h|
+      #    s << [h.key, h.value]
+      #  end
+      #else
+        ##backtrace = exception.backtrace.reject{ |bt| bt =~ INTERNALS }
+        ##backtrace.first =~ /(.+?):(\d+(?=:|\z))/ or return ""
+        #caller =~ /(.+?):(\d+(?=:|\z))/ or return ""
+        #source_file, source_line = $1, $2.to_i
+
+        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
+      #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
+      returnf 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
+
+  end
+
+  # 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
+    
+    def initialize(suite, test)
+      @suite = suite
+      @test = test
+      @assertions = 0
+    end
+    
+    def run
+      suite_instance = suite.new(test)
+      @result, @exception = fix_result(suite_instance.run(self))
+      @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
+    
+    private
+    
+    def fix_result(result)
+      result == '.' ? [:pass, nil] : result
+    end
+  end
+
+  #
+  class TapY < MiniTap
+    def initialize
+      require 'yaml'
+      super
+    end
+    def tapout_before_suites(suites, type)
+      puts super(suites, type).to_yaml
+    end
+    def tapout_before_suite(suite)
+      puts super(suite).to_yaml
+    end
+    def tapout_pass(suite, test, test_runner)
+      puts super(suite, test, test_runner).to_yaml
+    end
+    def tapout_skip(suite, test, test_runner)
+      puts super(suite, test, test_runner).to_yaml
+    end
+    def tapout_failure(suite, test, test_runner)
+      puts super(suite, test, test_runner).to_yaml
+    end
+    def tapout_error(suite, test, test_runner)
+      puts super(suite, test, test_runner).to_yaml
+    end
+    def tapout_after_suites(suites, type)
+      puts super(suites, type).to_yaml
+      puts "..."
+    end
+  end
+
+  #
+  class TapJ < MiniTap
+    def initialize
+      require 'json'
+      super
+    end
+    def tapout_before_suites(suites, type)
+      puts super(suites, type).to_json
+    end
+    def tapout_before_suite(suite)
+      puts super(suite).to_json
+    end
+    def tapout_pass(suite, test, test_runner)
+      puts super(suite, test, test_runner).to_json
+    end
+    def tapout_skip(suite, test, test_runner)
+      puts super(suite, test, test_runner).to_json
+    end
+    def tapout_failure(suite, test, test_runner)
+      puts super(suite, test, test_runner).to_json
+    end
+    def tapout_error(suite, test, test_runner)
+      puts super(suite, test, test_runner).to_json
+    end
+    def tapout_after_suites(suites, type)
+      puts super(suites, type).to_json
+    end
+  end
+
+end

data/lib/minitest/tapj.rb

@@ -0,0 +1,4 @@
+require 'minitap'
+
+MiniTest::Unit.runner = MiniTest::TapJ.new
+

data/lib/minitest/tapy.rb

@@ -0,0 +1,3 @@
+require 'minitap'
+
+MiniTest::Unit.runner = MiniTest::TapY.new

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification
+name: minitap
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Thomas Sawyer
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-10-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: tapout
+  requirement: &12167740 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *12167740
+- !ruby/object:Gem::Dependency
+  name: detroit
+  requirement: &12167140 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *12167140
+- !ruby/object:Gem::Dependency
+  name: reap
+  requirement: &12166280 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *12166280
+description: MiniTap provides a custom MiniTest reporter that outs TAP-Y or TAP-J
+  formatted output.
+email:
+- transfire@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- HISTORY.rdoc
+- README.rdoc
+- COPYING.rdoc
+files:
+- .ruby
+- lib/minitap.rb
+- lib/minitest/tapj.rb
+- lib/minitest/tapy.rb
+- HISTORY.rdoc
+- README.rdoc
+- COPYING.rdoc
+homepage: http://rubyworks.github.com/minitap
+licenses: []
+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.5
+signing_key: 
+specification_version: 3
+summary: MiniTest TAP-Y/J reporter
+test_files: []