tapout 0.1.0

data/bin/tapout

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require 'tapout'
+TapOut.cli(*ARGV)

data/lib/tapout.rb

@@ -0,0 +1,88 @@
+require 'tapout/tapy_parser'
+require 'tapout/tap_legacy_parser'
+
+require 'optparse'
+
+module TapOut
+
+  #
+  PARSERS = %w{breakdown dotprogress progressbar tap verbose}
+
+  #
+  def self.cli(*argv)
+    options = {}
+    type    = :modern
+
+    parser = OptionParser.new do |opt|
+      opt.banner = "tapout [options] [format]"
+
+      opt.separator("\nOPTIONS:")
+
+      #opt.on('--format', '-f FORMAT', 'Report format') do |fmt|
+      #  options[:format] = fmt
+      #end
+
+      #opt.on('-t', '--tap', 'Consume legacy TAP input') do |fmt|
+      #  type = :legacy
+      #end
+
+      opt.on('--no-color', 'Supress ANSI color codes') do
+        # TODO
+      end
+
+      opt.on('--debug', 'Run with $DEBUG flag on') do |fmt|
+        $DEBUG = true
+      end
+
+      opt.separator("\nFORMATS:\n        " + PARSERS.join("\n        "))
+    end
+
+    parser.parse!(argv)
+
+    options[:format] = argv.first
+
+    # TODO: would be nice if it could automatically determine which
+    #c = $stdin.getc
+    #    $stdin.pos = 0
+    #type = :legacy if c =~ /\d/
+    #type = :modern if c == '-'
+
+    stdin = Curmudgeon.new($stdin)
+
+    case stdin.line1
+    when /^\d/
+      type = :legacy
+    when /^\-/
+      type = :modern
+    else
+      raise "Not a recognized TAP stream!"
+    end
+
+    case type
+    when :legacy
+      stream_parser = TAPLegacyParser.new(options)
+      stream_parser.consume(stdin)
+    else
+      stream_parser = TAPYParser.new(options)
+      stream_parser.consume(stdin)
+    end
+  end
+
+  #
+  class Curmudgeon #< IO
+    def initialize(input)
+      @input = input
+      @line1 = input.gets
+    end
+    def line1
+      @line1
+    end
+    def gets
+      (class << self; self; end).class_eval %{
+        def gets; @input.gets; end
+      }
+      return @line1
+    end
+  end
+
+end

data/lib/tapout/reporters.rb

@@ -0,0 +1,6 @@
+require 'tapout/reporters/abstract'
+require 'tapout/reporters/dotprogress'
+require 'tapout/reporters/verbose'
+require 'tapout/reporters/tap'
+require 'tapout/reporters/progressbar'
+require 'tapout/reporters/breakdown'

data/lib/tapout/reporters/abstract.rb

@@ -0,0 +1,266 @@
+require 'ansi'
+require 'abbrev'
+
+module TapOut
+
+  # Namespace for Report Formats.
+  module Reporters
+
+    # Returns a Hash of name to reporter class.
+    def self.index
+      @index ||= {}
+    end
+
+    # Returns a reporter class given it's name or a unique abbreviation of it.
+    def self.factory(name)
+      list = index.keys.abbrev
+      index[list[name]]
+    end
+
+    # The Abstract class serves as a base class for all reporters. Reporters
+    # must sublcass Abstract in order to be added the the Reporters Index.
+    #
+    # TODO: Simplify this class and have the sublcasses handle more of the load.
+    class Abstract
+      # When Abstract is inherited it saves a reference to it in `Reporters.index`.
+      def self.inherited(subclass)
+        name = subclass.name.split('::').last.downcase
+        Reporters.index[name] = subclass
+      end
+
+      # New reporter.
+      def initialize
+        @passed  = []
+        @failed  = []
+        @raised  = []
+        @skipped = []
+        @omitted = []
+
+        @source  = {}
+        @previous_case = nil
+      end
+
+      #
+      def <<(entry)
+        handle(entry)
+      end
+
+      # Handler method. This dispatches a given entry to the appropriate
+      # report methods.
+      def handle(entry)
+        case entry['type']
+        when 'header'
+          start_suite(entry)
+        when 'case'
+          finish_case(@previous_case) if @previous_case
+          @previous_case = entry
+          start_case(entry)
+        when 'note'
+          note(entry)
+        when 'test'
+          test(entry)
+          case entry['status']
+          when 'pass'
+            pass(entry)
+          when 'fail'
+            fail(entry)
+          when 'error'
+            err(entry)
+          when 'omit'
+            omit(entry)
+          when 'pending', 'skip'
+            skip(entry)
+          end
+        when 'footer'
+          finish_case(@previous_case) if @previous_case
+          finish_suite(entry)
+        end
+      end
+
+      # Handle header.
+      def start_suite(entry)
+      end
+
+      # At the start of a new test case.
+      def start_case(entry)
+      end
+
+      # Handle an arbitray note.
+      def note(entry)
+      end
+
+      # Handle test. This is run before the status handlers.
+      def test(entry)
+      end
+
+      # Handle test with pass status.
+      def pass(entry)
+        @passed << entry
+      end
+
+      # Handle test with fail status.
+      def fail(entry)
+        @failed << entry
+      end
+
+      # Handle test with error status.
+      def err(entry)
+        @raised << entry
+      end
+
+      # Handle test with omit status.
+      def omit(entry)
+        @omitted << entry
+      end
+
+      # Handle test with skip or pending status.
+      def skip(entry)
+        @skipped << entry
+      end
+
+      # When a test case is complete.
+      def finish_case(entry)
+      end
+
+      # Handle footer.
+      def finish_suite(entry)
+      end
+
+      # TODO: get the tally's from the footer entry ?
+      def tally(entry)
+        total = entry['count'] || (@passed.size + @failed.size + @raised.size)
+
+        if entry['tally']
+          count_fail  = entry['tally']['fail']  || 0
+          count_error = entry['tally']['error'] || 0
+        else
+          count_fail  = @failed.size
+          count_error = @raised.size
+        end
+
+        if tally = entry['tally']
+          sums = %w{pass fail error skip}.map{ |e| tally[e] || 0 }
+        else
+          sums = [@passed, @failed, @raised, @skipped].map{ |e| e.size }
+        end
+
+        assertions = entry['assertions']
+        failures   = entry['failures']
+
+        if assertions
+          text = "%s tests: %s pass, %s fail, %s err, %s pending (%s/%s assertions)"
+          text = text % [total, *sums] + [assertions - failures, assertions]
+        else
+          text = "%s tests: %s pass, %s fail, %s err, %s pending"
+          text = text % [total, *sums]
+        end
+
+        if count_fail > 0
+          text.ansi(:red)
+        elsif count_error > 0
+          text.ansi(:yellow)
+        else
+          text.ansi(:green)
+        end
+      end
+
+      #
+      INTERNALS = /(lib|bin)#{Regexp.escape(File::SEPARATOR)}ko/
+
+      # 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(entry)
+        file    = entry['file']
+        line    = entry['line']
+        snippet = entry['snippet']
+
+        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 = 3 # number of surrounding lines to show
+            region = [source_line - radius, 1].max ..
+                     [source_line + radius, source.length].min
+
+            #len = region.last.to_s.length
+
+            s = region.map do |n|
+              format % [n, source[n-1].chomp]
+            end
+          end
+        end
+
+        len = s.map{ |(n,t)| n }.max.to_s.length
+
+        # ensure proper alignment by zero-padding line numbers
+        format = " %5s %0#{len}d %s"
+
+        #s = s.map{|n,t|[n,t]}.sort{|a,b|a[0]<=>b[0]}
+
+        pretty = s.map do |(n,t)|
+          format % [('=>' if n == line), n, t.rstrip]
+        end #.unshift "[#{region.inspect}] in #{source_file}"
+
+        return pretty
+      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[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
+
+    end#class Abstract
+
+  end#module Reporters
+
+end

data/lib/tapout/reporters/breakdown.rb

@@ -0,0 +1,120 @@
+require 'tapout/reporters/abstract'
+
+module TapOut
+
+  module Reporters
+
+    # The Breakdown report format give a tally for each test case.
+    class Breakdown < Abstract
+
+      def initialize
+        super
+        @case = {}
+        @case_entries = []
+      end
+
+      def start_suite(entry)
+        headers = [ 'TESTCASE', 'TESTS', 'PASS', 'FAIL', 'ERR', 'SKIP' ]
+        puts "\n%-20s       %8s %8s %8s %8s %8s\n" % headers
+      end
+
+      def start_case(entry)
+        @case = entry
+        @case_entries = []
+      end
+
+      def test(entry)
+        @case_entries << entry
+      end
+
+      #
+      def finish_case(entry)
+        label  = entry['label'][0,19]
+        groups = @case_entries.group_by{ |e| e['status'] }
+
+        total = @case_entries.size
+        sums  = %w{pass fail error pending}.map{ |n| groups[n] ? groups[n].size : 0 }
+
+        result = sums[1] + sums[2] > 0 ? "FAIL".ansi(:red) : "PASS".ansi(:green)
+
+        puts "%-20s      %8s %8s %8s %8s %8s    [%s]" % ([label, total] + sums + [result])
+      end
+
+      #
+      def finish_suite(entry)
+        #@pbar.finish
+        post_report(entry)
+      end
+
+      #
+      def post_report(entry)
+
+        sums = %w{pass fail error pending}.map{ |n| entry['tally'][n] || 0 }
+
+        puts ("-" * 80)
+
+        tally_line = "%-20s      " % "TOTAL"
+        tally_line << "%8s %8s %8s %8s %8s" % [entry['count'], *sums]
+
+        puts(tally_line + "\n")
+
+=begin
+        tally = test_tally(entry)
+
+        width = suite.collect{ |tr| tr.name.size }.max
+
+        headers = [ 'TESTCASE  ', '  TESTS   ', 'ASSERTIONS', ' FAILURES ', '  ERRORS   ' ]
+        io.puts "\n%-#{width}s       %10s %10s %10s %10s\n" % headers
+
+        files = nil
+
+        suite.each do |testrun|
+          if testrun.files != [testrun.name] && testrun.files != files
+            label = testrun.files.join(' ')
+            label = Colorize.magenta(label)
+            io.puts(label + "\n")
+            files = testrun.files
+          end
+          io.puts paint_line(testrun, width)
+        end
+
+        #puts("\n%i tests, %i assertions, %i failures, %i errors\n\n" % tally)
+
+        tally_line = "-----\n"
+        tally_line << "%-#{width}s  " % "TOTAL"
+        tally_line << "%10s %10s %10s %10s" % tally
+
+        io.puts(tally_line + "\n")
+=end
+
+        bad = @failed + @raised
+
+        #fails = suite.select do |testrun|
+        #  testrun.fail? || testrun.error?
+        #end
+
+        #if tally[2] != 0 or tally[3] != 0
+          unless bad.empty? # or verbose?
+            #puts "\n-- Failures and Errors --\n"
+            puts
+            bad.each do |e|
+              message = e['message'].strip
+              message = message.ansi(:red)
+              puts(message)
+              puts "#{e['file']}:#{e['line']}"
+              puts
+              puts code_snippet(e)
+            end
+            puts
+          end
+        #end
+
+        puts tally(entry)
+      end
+
+    end
+
+  end
+
+end
+