qed 1.0.0

data/lib/qed/reporter/base.rb

@@ -0,0 +1,101 @@
+module QED
+module Reporter
+
+  require 'facets/string'
+  require 'ansi/code'
+
+  # = Reporter BaseClass
+  #
+  # Serves as the base class for all other specification
+  # output formats.
+  #
+  class BaseClass
+
+    ANSICode = ANSI::Code
+
+    attr :io
+    attr :steps
+    attr :pass
+    attr :fail
+    attr :error
+
+    def initialize(io=STDOUT)
+      @io    = io
+      @specs = 0
+      @steps = 0
+      @pass  = []
+      @fail  = []
+      @error = []
+    end
+
+    # Before running any specifications.
+    def report_intro
+    end
+
+    # Beginning of a specification.
+    def report_start(spec)
+      @specs += 1
+    end
+
+    # Report a header.
+    def report_header(step)
+    end
+
+    # Report a comment.
+    def report_comment(step)
+    end
+
+    # Er... what was this for?
+    #def report_mode(step)
+    #  report_literal(step)
+    #end
+
+    # Before running a step.
+    def report_step(step)
+      @steps += 1
+    end
+
+    # Report step passed.
+    def report_pass(step)
+      @pass << step
+    end
+
+    # Report step failed.
+    def report_fail(step, assertion)
+      @fail << [step, assertion]
+    end
+
+    # Report step raised an error.
+    def report_error(step, exception)
+      raise exception if $RESPECT_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)
+    end
+
+    # Report on omitted step.
+    def report_omit(step)
+    end
+
+    # After running a step.
+    def report_step_end(step)
+    end
+
+    # End of a specification.
+    def report_end(spec)
+    end
+
+    # After running all specifications.
+    def report_summary
+    end
+
+  end
+
+end
+end
+

data/lib/qed/reporter/dotprogress.rb

@@ -0,0 +1,63 @@
+module QED
+module Reporter #:nodoc:
+
+  require 'qed/reporter/base'
+
+  # = DotProgress Reporter
+  #
+  class DotProgress < BaseClass
+
+    #
+    def report_intro
+      @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
+    end
+
+    #def report(str)
+    #  count[-1] += 1 unless count.empty?
+    #  str = str.chomp('.') + '.'
+    #  str = count.join('.') + ' ' + str
+    #  puts str.strip
+    #end
+
+    def report_summary
+      io.puts "\nFinished in #{Time.now - @start_time} seconds.\n\n"
+
+      @error.each do |step, exception|
+        io.puts ANSICode.red("***** ERROR *****")
+        io.puts "#{exception}"
+        io.puts ":#{exception.backtrace[0]}:"
+        #io.puts ":#{exception.backtrace[1]}:"
+        #io.puts exception.backtrace[1..-1] if $VERBOSE
+        io.puts
+      end
+
+      @fail.each do |step, assertion|
+        io.puts ANSICode.red("***** FAIL *****")
+        io.puts ANSICode.bold("#{assertion}")
+        io.puts ":#{assertion.backtrace[2]}:"
+        #io.puts assertion if $VERBOSE
+        io.puts
+      end
+
+      io.puts "%s specs, %s steps, %s failures, %s errors" % [@specs, @steps, @fail.size, @error.size] #, @pass.size ]
+    end
+
+  end#class DotProgress
+
+end#module Reporter
+end#module QED
+

data/lib/qed/reporter/summary.rb

@@ -0,0 +1,67 @@
+module QED
+module Reporter #:nodoc:
+
+  require 'qed/reporter/base'
+
+  # = Summary Reporter
+  #
+  # Similar to the Verbatim reporter, but does
+  # not display test code for passing tests.
+  class Summary < BaseClass
+
+    def report_header(step)
+      io.puts ANSICode.bold("#{step}")
+    end
+
+    def report_comment(step)
+      txt = step.to_s.tabto(2)
+      txt[0,1] = "*"
+      io.puts txt
+    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
+
+    def report_pass(step)
+      #io.puts ANSICode.green("#{step}")
+    end
+
+    def report_fail(step, assertion)
+      msg = ''
+      msg << "  ##### FAIL #####\n"
+      msg << "  # " + assertion.to_s
+      msg = ANSICode.magenta(msg)
+      io.puts msg
+      #io.puts
+      io.puts ANSICode.red("#{step}")
+    end
+
+    def report_error(step, exception)
+      raise exception if $DEBUG
+      msg = ''
+      msg << "  ##### ERROR #####\n"
+      msg << "  # " + exception.to_s + "\n"
+      msg << "  # " + exception.backtrace[0]
+      msg = ANSICode.magenta(msg)
+      io.puts msg
+      #io.puts
+      io.puts ANSICode.red("#{step}")
+    end
+
+    #def report(str)
+    #  count[-1] += 1 unless count.empty?
+    #  str = str.chomp('.') + '.'
+    #  str = count.join('.') + ' ' + str
+    #  io.puts str.strip
+    #end
+
+  end #class Summary
+
+end#module Reporter
+end#module QED
+

data/lib/qed/reporter/verbatim.rb

@@ -0,0 +1,90 @@
+module QED
+module Reporter #:nodoc:
+
+  require 'qed/reporter/base'
+
+  # = Verbatim Reporter
+  #
+  class Verbatim < BaseClass
+
+    #def report_step(step)
+    #  super
+    #  if step.code
+    #    #str = "(%s) %s" % [count.join('.'), str.tab(6).strip]
+    #    #io.puts "* #{step.to_s.tab(2).strip}"
+    #    #io.puts
+    #    #io.puts step.to_s
+    #    #io.puts
+    #  else
+    #    #io.puts "#{step}\n"  # TODO: This never happens.
+    #  end
+    #end
+
+    def report_header(step)
+      io.puts ANSICode.bold("#{step}")
+      #io.puts
+    end
+
+    def report_comment(step)
+      io.puts step
+      #io.puts
+    end
+
+    #
+    def report_macro(step)
+      #io.puts
+      #io.puts step.text
+      io.puts ANSICode.magenta("#{step}")
+      #io.puts
+    end
+
+    #
+    def report_pass(step)
+      io.puts ANSICode.green("#{step}")
+      #io.puts
+    end
+
+    def report_fail(step, error)
+      tab = step.to_s.index(/\S/) #step.tab
+      io.puts ANSICode.red("#{step}")
+      #puts
+      msg = []
+      msg << ANSICode.bold(ANSICode.red("FAIL: ")) + error.to_str
+      msg << ANSICode.bold(error.backtrace[0].chomp(":in \`_binding'"))
+      io.puts msg.join("\n").tabto(tab||2)
+      io.puts
+    end
+
+    def report_error(step, error)
+      raise error if $DEBUG
+      tab = step.to_s.index(/\S/) #step.tab
+      io.puts ANSICode.red("#{step}")
+      #io.puts
+      msg = []
+      msg << ANSICode.bold(ANSICode.red("ERROR: ")) + error.to_str.sub(/for QED::Context.*?$/,'')
+      msg << ANSICode.bold(error.backtrace[0].chomp(":in \`_binding'"))
+      #msg = ANSICode.red(msg)
+      io.puts msg.join("\n").tabto(tab||2)
+      io.puts
+    end
+
+    def report_step_end(step)
+      io.puts
+    end
+
+    #def report(str)
+    #  count[-1] += 1 unless count.empty?
+    #  str = str.chomp('.') + '.'
+    #  str = count.join('.') + ' ' + str
+    #  puts str.strip
+    #end
+
+    #def report_table(set)
+    #  puts ANSICode.magenta(set.to_yaml.tabto(2))
+    #end
+
+  end
+
+end #module
+end #module QED
+

data/lib/qed/runner.rb

@@ -0,0 +1,148 @@
+#require 'quarry/behave'
+#require 'quarry/runner/context'
+
+module QED
+
+  require 'qed/script'
+
+  # = Specificaton Runner
+  #
+  # The Runner class loops through a set of specifications
+  # and executes each one in turn.
+  #
+  # The current working directory is changed to that of the
+  # specification script's. So any relative file references
+  # within a spec must take that into account.
+  #
+  class Runner
+
+    #  QED::Spec::Runner.configure do
+    #    def setup(spec)
+    #      ...
+    #    end
+    #    def teardown(spec)
+    #      ...
+    #    end
+    #  end
+    #def self.configure(plugin=nil, &block)
+    #  if block_given?
+    #    m = Module.new(&block)
+    #    m.extend m
+    #    @config << m
+    #  end
+    #  if plugin
+    #    @config << plugin
+    #  end
+    #end
+
+    attr :specs
+    attr :output
+
+    #attr :context
+    #attr :count
+
+    #attr_accessor :before
+    #attr_accessor :after
+
+    # New Specification
+    def initialize(specs, output=nil)
+      @specs  = [specs].flatten
+      @output = output || Reporter::DotProgress.new #(self)
+    end
+
+    #
+    def check
+      output.report_intro
+      # loop through each specification and run it
+      specs.each do |spec|
+        # create a run context for the spec
+        #@context = Context.new(spec)
+        # run the specification
+        run_spec(spec)
+      end
+      output.report_summary
+    end
+
+    # Run a specification.
+    #
+    def run_spec(spec)
+      #report(spec.description)
+
+      #script = Script.load(spec, output)
+      script = Script.new(spec, output)
+
+      # pretty sure this is the thing to do
+      Dir.chdir(File.dirname(spec)) do
+
+        output.report_start(spec)
+
+        # TODO <-- plugin in here start (how to set?)
+        #context.instance_eval(&spec.given) if spec.given
+
+        script.run
+
+        #spec.steps.each do |step|
+          #output.report_step(self)
+          #step.run(self, spec, context, output)
+          #output.report_step_end(self)
+        #end
+
+        # TODO <-- plugin in here end
+        #context.instance_eval(&spec.complete) if spec.complete
+
+        output.report_end(spec)
+      end
+    end
+
+=begin
+    # Run a specification step.
+    #
+    def run_step(spec, step)
+      output.report_step(step)
+      # TODO: Would spec.before + spec.code be better?
+      context.instance_eval(@before, spec.file) if @before
+      begin
+        context.instance_eval(step.code, spec.file, step.lineno)
+        output.report_pass(step)
+      rescue Assertion => error
+        output.report_fail(step, error)
+      rescue Exception => error
+        output.report_error(step, error)
+      ensure
+        context.instance_eval(@after, spec.file) if @after
+      end
+    end
+
+    # Run a specification tabular step.
+    #
+    # TODO: Table reporting needs to be improved. Big time!
+    def run_table(spec, step)
+      table = YAML.load(File.new(step.file))  # yaml or csv ?
+
+      vars = *table[0]
+      rows = table[1..-1]
+
+      output.report_step(step)
+      context.instance_eval(@before, spec.file) if @before
+      rows.each do |row|
+        set  = vars.zip(row).map{ |a| "#{a[0]}=#{a[1].inspect}" }.join(';')
+        code = set + "\n" + step.code
+        begin
+          context.instance_eval(code, spec.file, step.lineno)
+          #output.report_literal(set)
+          output.report_pass(step)
+        rescue Assertion => error
+          output.report_fail(step, error)
+        rescue Exception => error
+          output.report_error(step, error)
+        ensure
+          context.instance_eval(@after, spec.file) if @after
+        end
+      end
+    end
+=end
+
+  end#class Runner
+
+end#module Quarry
+