qed 2.3.0 → 2.4.0

data/lib/qed/reporter/abstract.rb

@@ -7,28 +7,40 @@ module Reporter
   # = Reporter Absract Base Class
   #
   # Serves as the base class for all other output formats.
-  #
   class Abstract
 
     attr :io
-    attr :steps
-    attr :omit
+    attr :record
 
     def initialize(options={})
       @io    = options[:io] || STDOUT
       @trace = options[:trace]
 
-      @demos = 0
-      @steps = 0
-      @omit  = []
-      @pass  = []
-      @fail  = []
-      @error = []
+      @record = {
+        :demo  => [],
+        :step  => [],
+        :omit  => [],
+        :pass  => [],
+        :fail  => [],
+        :error => []
+      }
+
+      #@demos = 0
+      #@steps = 0
+      #@omit  = []
+      #@pass  = []
+      #@fail  = []
+      #@error = []
+
+      @source = {}
     end
 
-    def passes   ; @pass  ; end
-    def errors   ; @error ; end
-    def failures ; @fail  ; end
+    def demos  ; @record[:demo]  ; end
+    def steps  ; @record[:step]  ; end
+    def omits  ; @record[:omit]  ; end
+    def passes ; @record[:pass]  ; end
+    def errors ; @record[:error] ; end
+    def fails  ; @record[:fail]  ; end
 
     #
     def trace?
@@ -37,10 +49,10 @@ module Reporter
 
     #
     def update(type, *args)
+      __send__("count_#{type}", *args) if respond_to?("count_#{type}")
       __send__("#{type}", *args)
     end
 
-
     def self.When(type, &block)
       #raise ArgumentError unless %w{session demo demonstration step}.include?(type.to_s)
       #type = :demonstration if type.to_s == 'demo'
@@ -71,13 +83,39 @@ module Reporter
     #  __send__("after_#{type}", target, *args)
     #end
 
+    def count_demo(demo)
+      @record[:demo] << demo
+    end
+
+    def count_desc(step)
+      @record[:step] << step
+    end
+
+    def count_code(step)
+      @record[:step] << step
+    end
+
+    def count_pass(step)
+      @record[:pass] << step
+    end
+
+    def count_fail(step, exception)
+      @record[:fail] << [step, exception]
+    end
+
+    def count_error(step, exception)
+      @record[:error] << [step, exception]
+    end
+
+
     # At the start of a session, before running any demonstrations.
     def before_session(session)
+      @start_time = Time.now
     end
 
     # Beginning of a demonstration.
     def before_demo(demo) #demo(demo)
-      @demos += 1
+      #demos << demo
     end
 
     #
@@ -91,42 +129,88 @@ module Reporter
     #def comment(elem)
     #end
 
+    #
+    def before_step(step)
+      #@steps += 1
+    end
+
+    #
+    def before_head(step)
+    end
+
+    #
+    def before_desc(step)
+      #steps << step
+    end
+
+    #
+    def before_data(step)
+    end
+
     # Before running a step that is omitted.
-    #def omit_step(step)
+    #def before_omit(step)
     #  @omit << step
     #end
 
     #
-    def before_step(step, file)
-      @steps += 1
+    def before_code(step)
+      #steps << step
     end
 
-    # Right before running code.
-    def code(section)
+    # Reight before demo.
+    def demo(demo)
+    end
+
+    # Right before header.
+    def head(step)
     end
 
     # Right before text section.
-    def text(section)
+    def desc(step)  #text ?
+    end
+
+    # Right before date section.
+    def data(step)
+    end
+
+    # Right before running code.
+    def code(step)
     end
 
     # After running a step that passed.
     def pass(step)
-      @pass << step
+      #@pass << step
     end
 
     # After running a step that failed.
     def fail(step, assertion)
-      @fail << [step, assertion]
+      #@fail << [step, assertion]
     end
 
     # After running a step that raised an error.
     def error(step, exception)
       raise exception if $DEBUG
-      @error << [step, exception]
+      #@error << [step, exception]
     end
 
     #
-    def after_step(step, file)
+    def after_data(step)
+    end
+
+    #
+    def after_code(step)
+    end
+
+    #
+    def after_desc(step)
+    end
+
+    #
+    def after_head(step)
+    end
+
+    #
+    def after_step(step)
     end
 
     #
@@ -142,17 +226,83 @@ module Reporter
     def after_session(session)
     end
 
-    #
+    # TODO: should we rename b/c of keyword?
     def when(*args)
     end
 
   private
 
+    def print_time
+      io.puts "\nFinished in %.5f seconds.\n\n" % [Time.now - @start_time]
+    end
+
+    def print_tally
+      mask = "%s demos, %s steps: %s failures, %s errors (%s/%s assertions)"
+      vars = [demos.size, steps.size, fails.size, errors.size, $assertions-$failures, $assertions] #, @pass.size ]
+
+      io.puts mask % vars 
+    end
+
     #
     def clean_backtrace(btrace)
       btrace.chomp(":in \`__binding__'")
     end
 
+    #
+    INTERNALS = /(lib|bin)[\\\/]qed/
+
+=begin
+    # Clean the backtrace of any reference to ko/ paths and code.
+    def clean_backtrace(backtrace)
+      trace = backtrace.reject{ |bt| bt =~ INTERNALS }
+      trace.map do |bt| 
+        if i = bt.index(':in')
+          bt[0...i]
+        else
+          bt
+        end
+      end
+    end
+=end
+
+    #
+    def code_snippet(exception, bredth=3)
+      backtrace = exception.backtrace.reject{ |bt| bt =~ INTERNALS }
+      backtrace.first =~ /(.+?):(\d+(?=:|\z))/ or return ""
+      source_file, source_line = $1, $2.to_i
+
+      source = source(source_file)
+      
+      radius = bredth # number of surrounding lines to show
+      region = [source_line - radius, 1].max ..
+               [source_line + radius, source.length].min
+
+      # ensure proper alignment by zero-padding line numbers
+      format = " %2s %0#{region.last.to_s.length}d %s"
+
+      pretty = region.map do |n|
+        format % [('=>' if n == source_line), n, source[n-1].chomp]
+      end #.unshift "[#{region.inspect}] in #{source_file}"
+
+      pretty
+    end
+
+    #
+    def source(file)
+      @source[file] ||= (
+        File.readlines(file)
+      )
+    end
+
+    # TODO: Show more of the file name than just the basename.
+    def file_and_line(exception)
+      line = exception.backtrace[0]
+      return "" unless line
+      i = line.rindex(':in')
+      line = i ? line[0...i] : line
+      File.basename(line)
+    end
+
   end
 
 end

data/lib/qed/reporter/bullet.rb

@@ -10,16 +10,15 @@ module Reporter #:nodoc:
   class BulletPoint < Abstract
 
     #
-    def text(step)
-      case step.commentary
-      when /^\=/
-        io.print "#{step.commentary}".ansi(:bold)
-      else
-        txt = step.commentary.to_s.strip.tabto(2)
-        txt[0,1] = "*"
-        io.puts txt
-        io.puts
-      end
+    def head(step)
+      io.print "#{step}".ansi(:bold)
+    end
+
+    def desc(step)
+      txt = step.to_s.strip.tabto(2)
+      txt[0,1] = "*"
+      io.puts txt
+      io.puts
     end
 
     def pass(step)
@@ -68,6 +67,11 @@ module Reporter #:nodoc:
     #  #io.puts "#{step}".ansi(:magenta)
     #end
 
+    def after_session(session)
+      print_time
+      print_tally
+    end
+
   end #class Summary
 
 end#module Reporter

data/lib/qed/reporter/dotprogress.rb

@@ -14,39 +14,56 @@ module Reporter #:nodoc:
     end
 
     #
-    def before_step(step, file)
-      super(step, file)
+    #def before_step(step)
+    #  super(step)
+    #  io.print "."
+    #  io.flush
+    #end
+
+    def pass(step)
       io.print "."
       io.flush
+      super(step)
+    end
+
+    def fail(step, assertion)
+      io.print "F"
+      io.flush
+      super(step, assertion)
+    end
+
+    def error(step, exception)
+      io.print "E"
+      io.flush
+      super(step, exception)
     end
 
     #
     def after_session(session)
-      io.puts "\nFinished in #{Time.now - @start_time} seconds.\n\n"
+      print_time
 
-      @error.each do |step, exception|
+      errors.each do |step, exception|
         backtrace = clean_backtrace(exception.backtrace[0])
         io.puts "***** ERROR *****".ansi(:red)
         io.puts "#{exception}"
         io.puts ":#{backtrace}:"
         #io.puts ":#{exception.backtrace[1]}:"
         #io.puts exception.backtrace[1..-1] if $VERBOSE
+        io.puts code_snippet(exception)
         io.puts
       end
 
-      @fail.each do |step, assertion|
+      fails.each do |step, assertion|
         backtrace = clean_backtrace(assertion.backtrace[0])
         io.puts "***** FAIL *****".ansi(:red)
         io.puts "#{assertion}".ansi(:bold)
         io.puts ":#{backtrace}:"
         # -- io.puts assertion if $VERBOSE
+        io.puts code_snippet(assertion)
         io.puts
       end
 
-      mask = "%s demos, %s steps: %s failures, %s errors (%s/%s assertions)"
-      vars = [@demos, @steps, @fail.size, @error.size, $assertions-$failures, $assertions] #, @pass.size ]
-
-      io.puts mask % vars 
+      print_tally
     end
 
   end#class DotProgress

data/lib/qed/reporter/verbatim.rb

@@ -8,28 +8,42 @@ module Reporter #:nodoc:
   class Verbatim < Abstract
 
     #
-    def text(section)
-      text = section.commentary
-      text = text.gsub(/^([=#].*?)$/, '\1'.ansi(:bold))
-      io.print text
-      if section.continuation?
-        io.puts(section.clean_example.ansi(:blue))
-        io.puts
-      end
+    def before_session(session)
+      @start_time = Time.now
+    end
+
+    #
+    def head(step)
+      io.print step.text.ansi(:bold)
+    end
+
+    #
+    def desc(step)
     end
 
-    # headers ?
+    #
+    def data(step)
+      io.puts step.clean_text.ansi(:blue)
+      io.puts
+    end
 
     #
     def pass(step)
-      txt = step.example #.rstrip.sub("\n",'')
-      io.print "#{txt}".ansi(:green)
+      super(step)
+      if step.code?
+        io.print "#{step.text}".ansi(:green)
+      elsif step.header?
+        io.print "#{step.text}".ansi(:bold)
+      else
+        io.print "#{step.text}"
+      end
     end
 
     #
     def fail(step, error)
-      txt = step.example.rstrip #.sub("\n",'')
-      tab = step.example.index(/\S/)
+      super(step, error)
+      txt = step.text.rstrip #.sub("\n",'')
+      tab = step.text.index(/\S/)
       io.print "#{txt}\n\n".ansi(:red)
       msg = []
       #msg << ANSI::Code.bold(ANSI::Code.red("FAIL: ")) + error.to_str
@@ -42,9 +56,10 @@ module Reporter #:nodoc:
 
     #
     def error(step, error)
+      super(step, error)
       raise error if $DEBUG
-      txt = step.example.rstrip #.sub("\n",'')
-      tab = step.example.index(/\S/)
+      txt = step.text.rstrip #.sub("\n",'')
+      tab = step.text.index(/\S/)
       io.print "#{txt}\n\n".ansi(:red)
       msg = []
       msg << "ERROR: #{error.class} ".ansi(:bold,:red) + error.to_str #.sub(/for QED::Context.*?$/,'')
@@ -73,6 +88,12 @@ module Reporter #:nodoc:
     #  #io.puts
     #end
 
+    #
+    def after_session(session)
+      print_time
+      print_tally
+    end
+
   end
 
 end #module Reporter