qed 1.3 → 2.0.0

data/lib/qed/evaluator.rb

@@ -0,0 +1,124 @@
+module QED
+
+  require 'tilt'
+  require 'nokogiri'
+  require 'qed/scope'
+
+  # = Demo Script Evaluator
+  #
+  #--
+  # TODO: Currently the Evaluator class uses #travserse to work
+  # thru the HTML document and trigger events accordingly. This
+  # works well enough for simple HTML documents --the kind produced
+  # by typical wiki-markup formats. However, for complex HTML it
+  # it will not produce ideal output (although the code segements
+  # should still run just fine). To counter this weakness, we will
+  # have to swtich to a more complex SAX parser in the future.
+  #--
+  class Evaluator
+
+    #
+    def initialize(script, *observers)
+      @script = script
+      @file   = script.file
+      @scope  = script.scope
+      @root   = script.root
+
+      @observers = observers
+    end
+
+    #
+    def run
+      Dir.chdir(File.dirname(@file)) do
+        advise!(:before_document, @script)
+        @root.traverse do |element|
+          call_tag(element)
+        end
+        advise!(:after_document, @script)
+      end
+    end
+
+    #
+    def call_tag(element)
+      advise!(:tag, element)
+      __send__("tag_#{element.name}", element)
+    end
+
+    # T A G S
+
+    #
+    def tag_a(element)
+      case element['href']
+      when /qed:\/\/(.*?)$/
+        file = $1
+        case File.extname(file)
+        when '.rb'
+          import!(file)
+        else
+          Script.new(file, scope).run
+        end
+      end
+    end
+
+    #
+    def tag_pre(element)
+      advise!(:before_code, element, @file)
+      begin
+        eval(element.text, @scope.__binding__, @file, element.line)
+        pass!(element)
+      rescue Assertion => exception
+        fail!(element, exception)
+      rescue Exception => exception
+        error!(element, exception)
+      end
+      advise!(:after_code, element, @file)
+    end
+
+    #
+    def tag_p(element)
+      advise!(:when, element.text)
+    end
+
+    #
+    def method_missing(s, *a)
+      super(s, *a) unless /^tag/ =~ s.to_s
+    end
+
+    #
+    def pass!(element)
+      advise!(:pass, element)
+    end
+
+    #
+    def fail!(element, exception)
+      advise!(:fail, element, exception)
+      #raise exception
+    end
+
+    #
+    def error!(element, exception)
+      advise!(:error, element, exception)
+      #raise exception
+    end
+
+    #
+    def import!(file)
+      advise!(:unload)
+      eval(File.read(file), @scope.__binding__, file)
+      advise!(:load, file)
+    end
+
+    #
+    def advise!(signal, *args)
+      @observers.each{ |o| o.update(signal, *args) }
+      @scope.__advice__.call(signal, *args)
+    end
+
+    #
+    #def advise_when!(match)
+    #  @scope.__advice__.call_when(match)
+    #end
+
+  end
+
+end

data/lib/qed/reporter/base.rb

@@ -6,99 +6,153 @@ module Reporter
 
   # = Reporter BaseClass
   #
-  # Serves as the base class for all other specification
-  # output formats.
+  # Serves as the base class for all other output formats.
   #
   class BaseClass
 
-    ANSICode = ANSI::Code
-
     attr :io
     attr :steps
+    attr :omit
     attr :pass
     attr :fail
     attr :error
 
     def initialize(options={})
-      @io      = options[:io] || STDOUT
-      @verbose = options[:verbose]
+      @io    = options[:io] || STDOUT
+      @trace = options[:trace]
 
       @demos = 0
       @steps = 0
+      @omit  = []
       @pass  = []
       @fail  = []
       @error = []
     end
 
     #
-    def verbose?
-      @verbose
+    def trace?
+      @trace
     end
 
-    # Before running any specifications.
-    def report_intro
+    #
+    def update(type, *args)
+      __send__("#{type}", *args)
     end
 
-    # Beginning of a specification.
-    def report_start(spec)
-      @demos += 1
+
+    def self.When(type, &block)
+      #raise ArgumentError unless %w{session demo demonstration step}.include?(type.to_s)
+      #type = :demonstration if type.to_s == 'demo'
+      define_method(type, &block)
     end
 
-    # Report a header.
-    def report_header(step)
+    def self.Before(type, &block)
+    #  raise ArgumentError unless %w{session demo demonstration step}.include?(type.to_s)
+    #  type = :demonstration if type.to_s == 'demo'
+      define_method("before_#{type}", &block)
     end
 
-    # Report a comment.
-    def report_comment(step)
+    def self.After(type, &block)
+    #  raise ArgumentError unless %w{session demo demonstration step pass fail error}.include?(type.to_s)
+    #  type = :demonstration if type.to_s == 'demo'
+      define_method("after_#{type}", &block)
     end
 
-    # Er... what was this for?
-    #def report_mode(step)
-    #  report_literal(step)
+    #
+    #def Before(type, target, *args)
+    #  type = :demonstration if type.to_s == 'demo'
+    #  __send__("before_#{type}", target, *args)
+    #end
+
+    #
+    #def After(type, target, *args)
+    #  type = :demonstration if type.to_s == 'demo'
+    #  __send__("after_#{type}", target, *args)
     #end
 
+    # At the start of a session, before running any demonstrations.
+    def before_session(session)
+    end
+
+    # Beginning of a demonstration.
+    def before_document(demo) #demo(demo)
+      @demos += 1
+    end
+
+    #
+    def tag(element)
+    end
+
+    #
+    def load(demo)
+    end
+    #
+    def import(file)
+    end
+
     # Before running a step.
-    def report_step(step)
+    def element(step)
+    end
+
+    def comment(elem)
+    end
+
+    # Before running a step that is omitted.
+    #def omit_step(step)
+    #  @omit << step
+    #end
+
+    #
+    def before_code(step, file)
       @steps += 1
     end
 
-    # Report step passed.
-    def report_pass(step)
+    # After running a step that passed.
+    def pass(step)
       @pass << step
     end
 
-    # Report step failed.
-    def report_fail(step, assertion)
+    # After running a step that failed.
+    def fail(step, assertion)
       @fail << [step, assertion]
     end
 
-    # Report step raised an error.
-    def report_error(step, exception)
+    # After running a step that raised an error.
+    def error(step, exception)
       raise exception if $DEBUG
       @error << [step, exception]
     end
 
-    # Since regular macro step does not pass or fail,
-    # this method is used instead.
     #
-    # TODO: Rename to #report_nominal (?)
-    def report_macro(step)
+    def after_code(step, file)
     end
 
-    # Report on omitted step.
-    def report_omit(step)
+    #
+    def after_element(elem)
     end
 
-    # After running a step.
-    def report_step_end(step)
+    #
+    def unload
     end
 
-    # End of a specification.
-    def report_end(spec)
+    # End of a demonstration.
+    def after_document(demo)  #demo(demo)
     end
 
-    # After running all specifications.
-    def report_summary
+    # After running all demonstrations. This is the place
+    # to output a summary of the session, if applicable.
+    def after_session(session)
+    end
+
+    #
+    def when(*args)
+    end
+
+  private
+
+    #
+    def clean_backtrace(btrace)
+      btrace.chomp(":in \`__binding__'")
     end
 
   end

data/lib/qed/reporter/bullet.rb

@@ -0,0 +1,79 @@
+module QED
+module Reporter #:nodoc:
+
+  require 'qed/reporter/base'
+
+  # = Bullet Point Reporter
+  #
+  # Similar to the Verbatim reporter, but does
+  # not display test code for passing tests.
+  class BulletPoint < BaseClass
+
+    #
+    def tag(step)
+      case step.name
+      when 'pre'
+        # none
+      when /h\d/
+        io.puts ANSI::Code.bold("#{step.text}\n")
+      when 'p'
+        txt = step.text.to_s.strip.tabto(2)
+        txt[0,1] = "*"
+        io.puts txt
+        io.puts
+      end
+    end
+
+    def pass(step)
+      #io.puts ANSICode.green("#{step}")
+    end
+
+    def fail(step, assertion)
+      msg = ''
+      msg << "  ##### FAIL #####\n"
+      msg << "  # " + assertion.to_s
+      msg = ANSI::Code.magenta(msg)
+      io.puts msg
+      #io.puts
+      io.puts ANSI::Code.red("#{step.text}")
+    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 = ANSI::Code.magenta(msg)
+      io.puts msg
+      #io.puts
+      io.puts ANSI::Code.red("#{step.text}")
+    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 ANSICode.magenta("#{step}")
+    #end
+
+  end #class Summary
+
+end#module Reporter
+end#module QED
+

data/lib/qed/reporter/dotprogress.rb

@@ -8,37 +8,24 @@ module Reporter #:nodoc:
   class DotProgress < BaseClass
 
     #
-    def report_intro
+    def before_session(session)
       @start_time = Time.now
       io.puts "Started"
     end
 
     #
-    def report_step(step)
-      super
-      #if step.code
-        io.print "."
-        #str = "(%s) %s" % [count.join('.'), str.tab(6).strip]
-        #puts "* #{step.text.tab(2).strip}"
-        #puts "\n#{step.code}\n" if $VERBOSE
-      #else
-        #puts "\n#{step.text}"
-      #end
+    def before_code(step, file)
+      super(step, file)
+      io.print "." if step.name == 'pre'
     end
 
-    #def report(str)
-    #  count[-1] += 1 unless count.empty?
-    #  str = str.chomp('.') + '.'
-    #  str = count.join('.') + ' ' + str
-    #  puts str.strip
-    #end
-
-    def report_summary
+    #
+    def after_session(session)
       io.puts "\nFinished in #{Time.now - @start_time} seconds.\n\n"
 
       @error.each do |step, exception|
         backtrace = clean_backtrace(exception.backtrace[0])
-        io.puts ANSICode.red("***** ERROR *****")
+        io.puts ANSI::Code.red("***** ERROR *****")
         io.puts "#{exception}"
         io.puts ":#{backtrace}:"
         #io.puts ":#{exception.backtrace[1]}:"
@@ -48,8 +35,8 @@ module Reporter #:nodoc:
 
       @fail.each do |step, assertion|
         backtrace = clean_backtrace(assertion.backtrace[0])
-        io.puts ANSICode.red("***** FAIL *****")
-        io.puts ANSICode.bold("#{assertion}")
+        io.puts ANSI::Code.red("***** FAIL *****")
+        io.puts ANSI::Code.bold("#{assertion}")
         io.puts ":#{backtrace}:"
         #io.puts assertion if $VERBOSE
         io.puts
@@ -58,13 +45,6 @@ module Reporter #:nodoc:
       io.puts "%s demos, %s steps, %s failures, %s errors" % [@demos, @steps, @fail.size, @error.size] #, @pass.size ]
     end
 
-    private
-
-    #
-    def clean_backtrace(btrace)
-      btrace.chomp(":in `_binding'")
-    end
-
   end#class DotProgress
 
 end#module Reporter