qed 2.5.1 → 2.6.0

data/lib/qed/reporter/bullet.rb

@@ -3,10 +3,9 @@ module Reporter #:nodoc:
 
   require 'qed/reporter/abstract'
 
-  # = Bullet Point Reporter
-  #
-  # Similar to the Verbose reporter, but does
+  # Bullet Point Reporter - similar to the Verbose reporter, but does
   # not display test code for passing tests.
+  #
   class BulletPoint < Abstract
 
     #
@@ -26,23 +25,37 @@ module Reporter #:nodoc:
     end
 
     def fail(step, assertion)
-      msg = ''
-      msg << "  ##### FAIL #####\n"
-      msg << "  # " + assertion.to_s
-      msg = msg.ansi(:magenta)
-      io.puts msg
-      io.print "#{step.example}".ansi(:red)
+      backtrace = sane_backtrace(assertion)
+
+      msg = []
+      msg << "  " + "FAIL".ansi(:red)
+      msg << ""
+      msg << assertion.to_s.gsub(/^/, '  ')
+      msg << ""
+      backtrace.each do |bt|
+        msg << "  " + relative_file(bt)
+      end
+      io.puts msg.join("\n")
+      io.puts
+      io.print step.text.tabto(4)
     end
 
     def error(step, exception)
       raise exception if $DEBUG
-      msg = ''
-      msg << "  ##### ERROR #####\n"
-      msg << "  # " + exception.to_s + "\n"
-      msg << "  # " + clean_backtrace(exception.backtrace[0])
-      msg = msg.ansi(:magenta)
-      io.puts msg
-      io.print "#{step.example}".ansi(:red)
+
+      backtrace = sane_backtrace(exception)
+
+      msg = []
+      msg << "  " + "ERROR".ansi(:red)
+      msg << ""
+      msg << "  " + exception.to_s
+      msg << ""
+      backtrace.each do |bt|
+        msg << "  " + relative_file(bt)
+      end
+      io.puts msg.join("\n")
+      io.puts
+      io.print step.text.tabto(4)
     end
 
     #def report(str)
@@ -76,4 +89,3 @@ module Reporter #:nodoc:
 
 end#module Reporter
 end#module QED
-

data/lib/qed/reporter/dotprogress.rb

@@ -43,23 +43,26 @@ module Reporter #:nodoc:
       print_time
 
       errors.each do |step, exception|
-        backtrace = clean_backtrace(exception.backtrace[0])
+        backtrace = sane_backtrace(exception)
+
         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)
+        backtrace.each do |bt|
+          io.puts bt
+          io.puts code_snippet(bt)
+        end
         io.puts
       end
 
       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)
+        backtrace = sane_backtrace(assertion)
+
+        io.puts "***** FAIL *****".ansi(:red, :bold)
+        io.puts "#{assertion}"
+        backtrace.each do |bt|
+          io.puts bt
+          io.puts code_snippet(bt)
+        end
         io.puts
       end
 

data/lib/qed/reporter/dtrace.rb

@@ -0,0 +1,67 @@
+module QED
+module Reporter #:nodoc:
+
+  require 'qed/reporter/abstract'
+
+  #  Deep trace reporter
+  #
+  class DTrace < Abstract
+
+    #
+    def before_session(session)
+      @start_time = Time.now
+      io.puts "Started"
+    end
+
+    #
+    #def before_step(step)
+    #  super(step)
+    #  io.print "."
+    #  io.flush
+    #end
+
+    def pass(step)
+      super(step)
+    end
+
+    #
+    def fail(step, assertion)
+      super(step, assertion)
+
+      io.puts "#{assertion}".ansi(:red)
+
+      backtrace = sane_backtrace(assertion)
+      backtrace.each do |bt|
+        io.puts bt
+        io.puts code_snippet(bt)
+      end
+
+      io.puts
+    end
+
+    #
+    def error(step, exception)
+      super(step, exception)
+
+      io.puts "#{exception}".ansi(:red)
+
+      backtrace = sane_backtrace(exception)
+      backtrace.each do |bt|
+        io.puts bt
+        io.puts code_snippet(bt)
+      end
+
+      io.puts
+    end
+
+
+    #
+    def after_session(session)
+      print_time
+      print_tally
+    end
+
+  end
+
+end#module Reporter
+end#module QED

data/lib/qed/reporter/tapy.rb

@@ -0,0 +1,224 @@
+module QED
+module Reporter #:nodoc:
+
+  require 'qed/reporter/abstract'
+
+  # TAP-Y Reporter 
+  #
+  # NOTE: I suppose techincally that each TAP-Y test should be an assertion,
+  # but that's a whole other ball of wax, and would require AE to remember
+  # every assertion made. It also would have no means of providing an upfront
+  # count.
+  #
+  class TapY < Abstract
+
+    #
+    def head(step)
+      data = {
+        'type'  => 'header',
+        'start' => Time.now.strftime('%Y-%m-%d %H:%M:%S'),
+        'count' => session.total_step_count
+      }
+      io.puts data.to_yaml
+    end
+
+    #
+    def desc(step)
+      #data = {
+      #  'type'        => 'note',
+      #  'description' => step.to_s.strip
+      #}
+      #io.puts data.to_yaml
+    end
+
+    #
+    # @todo How to get the line number so we can do proper snippets?
+    def pass(step)
+      super(step)
+
+      lines = step.text.split("\n")
+      #snip, l = [], step.line
+      #lines.map do |line|
+      #  snip << { (l += 1) => line }
+      #end
+
+      if step.header?
+        data = {
+          'type'        => 'note',
+          'description' => step.text, #.strip,
+        }
+      elsif step.code?
+        data = {
+          'type'        => 'test',
+          'status'      => 'pass',
+          'description' => step.text.strip,
+          #'file'        => step.file,
+          #'line'        => step.line,
+          #'returned'    => nil,
+          #'expected'    => nil,
+          'source'      => lines.first,
+          'snippet'     => step.text.strip,
+          'time'        => time_since_start
+        }
+      else
+        data = {
+          'type'        => 'test',
+          'status'      => 'pass',
+          'description' => step.text.strip,
+          #'file'        => step.file,
+          #'line'        => step.line,
+          #'returned'    => nil,
+          #'expected'    => nil,
+          'source'      => lines.first,
+          'snippet'     => step.text.strip,
+          'time'        => time_since_start
+        }
+      end
+      io.puts data.to_yaml
+    end
+
+    #
+    def fail(step, assertion)
+      super(step, assertion)
+
+      backtrace = sane_backtrace(assertion)
+
+      file, line = file_line(backtrace)
+
+      snippet = structured_code_snippet(assertion, bredth=3)
+      source  = snippet.map{ |h| h.values.first }[snippet.size / 2].strip
+
+      data = {
+        'type'        => 'test',
+        'status'      => 'fail',
+        'description' => step.text.strip,
+        'file'        => file,
+        'line'        => line,
+        'message'     => assertion.to_s.unansi,
+        #'returned'    => nil,
+        #'expected'    => nil,
+        'source'      => source,
+        'snippet'     => snippet,
+        'time'        => time_since_start
+      }
+
+      io.puts data.to_yaml
+    end
+
+    #
+    def error(step, exception)
+      super(step, exception)
+
+      backtrace = sane_backtrace(exception)
+
+      file, line = file_line(backtrace)
+
+      snippet = structured_code_snippet(exception, bredth=3)
+      source  = snippet.map{ |h| h.values.first }[snippet.size / 2].strip
+
+      data = {
+        'type'        => 'test',
+        'status'      => 'error',
+        'description' => step.text.strip,
+        'file'        => file,
+        'line'        => line,
+        'message'     => exception.to_s.unansi,
+        #'returned'    => nil,
+        #'expected'    => nil,
+        'backtrace'   => backtrace,
+        'source'      => source,
+        'snippet'     => snippet,
+        'time'        => time_since_start
+      }
+
+      io.puts data.to_yaml
+    end
+
+
+=begin
+    def fail(step, assertion)
+      backtrace = sane_backtrace(assertion)
+
+      msg = []
+      msg << "  " + "FAIL".ansi(:red)
+      msg << ""
+      msg << assertion.to_s.gsub(/^/, '  ')
+      msg << ""
+      backtrace.each do |bt|
+        msg << "  " + relative_file(bt)
+      end
+      io.puts msg.join("\n")
+      io.puts
+      io.print step.text.tabto(4)
+    end
+
+    def error(step, exception)
+      raise exception if $DEBUG
+
+      backtrace = sane_backtrace(exception)
+
+      msg = []
+      msg << "  " + "ERROR".ansi(:red)
+      msg << ""
+      msg << "  " + exception.to_s
+      msg << ""
+      backtrace.each do |bt|
+        msg << "  " + relative_file(bt)
+      end
+      io.puts msg.join("\n")
+      io.puts
+      io.print step.text.tabto(4)
+    end
+=end
+
+    #def report(str)
+    #  count[-1] += 1 unless count.empty?
+    #  str = str.chomp('.') + '.'
+    #  str = count.join('.') + ' ' + str
+    #  io.puts str.strip
+    #end
+
+    #def report_comment(step)
+    #  txt = step.to_s.strip.tabto(2)
+    #  txt[0,1] = "*"
+    #  io.puts txt
+    #  io.puts
+    #end
+
+    #def report_macro(step)
+    #  txt = step.to_s.tabto(2)
+    #  txt[0,1] = "*"
+    #  io.puts txt
+    #  #io.puts
+    #  #io.puts "#{step}".ansi(:magenta)
+    #end
+
+    def after_session(session)
+      pass_size = steps.size - (fails.size + errors.size + omits.size)
+
+      data = {
+        'type'  => 'footer',
+        'tally' => {
+           'pass'    => pass_size,
+           'fail'    => fails.size,
+           'error'   => errors.size,
+           'omit'    => omits.size,
+           'pending' => 0
+         },
+         'time' => time_since_start
+      }
+
+      io.puts data.to_yaml
+    end
+
+    private
+
+    #
+    def time_since_start
+      Time.now - @start_time
+    end
+
+  end
+
+end#module Reporter
+end#module QED

data/lib/qed/reporter/verbatim.rb

@@ -51,7 +51,7 @@ module Reporter #:nodoc:
       #msg << ANSI::Code.bold(ANSI::Code.red("FAIL: ")) + error.message
       #msg << ANSI::Code.bold(clean_backtrace(error.backtrace[0]))
       msg << "FAIL: ".ansi(:bold, :red) + error.message.to_s #to_str
-      msg << clean_backtrace(error.backtrace[0]).ansi(:bold)
+      msg << sane_backtrace(error).first.ansi(:bold)
       io.puts msg.join("\n").tabto(tab||2)
       io.puts
     end
@@ -65,7 +65,7 @@ module Reporter #:nodoc:
       io.print "#{txt}\n\n".ansi(:red)
       msg = []
       msg << "ERROR: #{error.class} ".ansi(:bold,:red) + error.message #.sub(/for QED::Context.*?$/,'')
-      msg << clean_backtrace(error.backtrace[0]).ansi(:bold)
+      msg << sane_backtrace(error).first.ansi(:bold)
       #msg = msg.ansi(:red)
       io.puts msg.join("\n").tabto(tab||2)
       io.puts

data/lib/qed/scope.rb

@@ -29,7 +29,7 @@ module QED
       #@loadlist = []
 
       include *applique
-      extend self
+      #extend self
       #extend applique # TODO: extend or include applique or none ?
       #extend DSLi
 
@@ -112,15 +112,23 @@ module QED
       @_applique.first.After(type, &procedure)
     end
 
+    # Directory of current document.
+    def __DIR__(file=nil)
+      if file
+        Dir.glob(File.join(File.dirname(@_file), file)).first || file
+      else
+        File.dirname(@_file)
+      end
+    end
 
     # TODO: Should Table and Data be extensions that can be loaded if desired?
 
-    # Use sample table to run steps. The table file will be
-    # looked for relative to the demo, failing that it will
-    # be looked for relative to the working directory.
+    # Use sample table to run steps. The table file is located relative to
+    # the demo, failing that it will be looked for relative to the working
+    # directory.
     #
     # TODO: Cache data for speed ?
-    def Table(file=nil) #:yield:
+    def Table(file=nil, options={}) #:yield:
       if file
         file = Dir.glob(File.join(File.dirname(@_file), file)).first || file
       else
@@ -128,40 +136,47 @@ module QED
       end
       @_last_table = file
 
-      tbl  = YAML.load(File.new(file))
-      tbl.each do |set|
-        yield(*set)
+      file_handle = File.new(file)
+
+      if options[:stream]
+        if block_given?
+          YAML.load_documents(file_handle) do |data|
+            yield data
+          end
+        else
+          YAML.load_stream(file_handle)
+        end
+      else
+        if block_given?
+          tbl = YAML.load(file_handle)
+          tbl.each do |data|
+            yield(*data)
+          end
+        else
+          YAML.load(file_handle)
+        end
       end
     end
 
-    # Read a static data sample.
+    # Read a static data file and yield contents to block if given.
     #
+    # This method no longer automatically uses YAML.load.
+    #--
     # TODO: Cache data for speed ?
+    #++
     def Data(file) #:yield:
-      #raise if File.directory?(file)
-      #if content
-      #  FileUtils.mkdir_p(File.dirname(file))
-      #  case File.extname(file)
-      #  when '.yml', '.yaml'
-      #    File.open(file, 'w'){ |f| f << content.call.to_yaml }
-      #  else
-      #    File.open(file, 'w'){ |f| f << content.call }
-      #  end
+      file = Dir.glob(File.join(File.dirname(@_file), file)).first || file
+      #case File.extname(file)
+      #when '.yml', '.yaml'
+      #  data = YAML.load(File.new(file))
       #else
-        #raise LoadError, "no such fixture file -- #{fname}" unless File.exist?(fname)
-        file = Dir.glob(File.join(File.dirname(@_file), file)).first || file
-        case File.extname(file)
-        when '.yml', '.yaml'
-          data = YAML.load(File.new(file))
-        else
-          data = File.read(file)
-        end
-        if block_given?
-          yield(data)
-        else
-          data
-        end
+        data = File.read(file)
       #end
+      if block_given?
+        yield(data)
+      else
+        data
+      end
     end
 
     # Clear temporary work directory.