qed 1.2 → 1.3

data/lib/qed/config.rb

@@ -0,0 +1,25 @@
+module QED
+
+  class Config
+
+    def initialize
+      @local = ['qed', 'demos', 'test/demos']
+
+      if file = File.glob('{.,}config/qed.{yml,yaml}')
+        YAML.load(File.new(file)).each do |k,v|
+          __send__("#{k}=", v)
+        end
+      end
+    end
+
+    attr_accessor :local
+
+    # How ot identify a header?
+    #attr_accessor :header
+
+    # How ot identify a footer?
+    #attr_accessor :footer
+
+  end
+
+end

data/lib/qed/document.rb

@@ -36,7 +36,7 @@ module QED
       @paths  ||= []
 
       if @paths.empty?
-        dir = Dir['{test/demos,demo,demos}'].first || DEFAULT_PATH
+        dir = Dir['{test/demos,demos,demo}'].first || DEFAULT_PATH
         @paths  = File.join(dir, '**', '*')
       end
     end

data/lib/qed/document/template.rhtml

@@ -19,7 +19,7 @@
     h1 { border-bottom: 2px solid silver; }
     h2 { border-bottom: 2px solid silver; padding-top: 0.5em; }
 
-    hr { border: 1px solid silver; }
+    hr { color: #ccc; margin-top: 1.6em; }
 
     p { color: #222; text-align: justify; margin-top: 0.5em; margin-bottom: 0.5em; line-height: 1.4em; }
 

data/lib/qed/reporter/ditto.rb

@@ -0,0 +1,72 @@
+module QED
+module Reporter #:nodoc:
+
+  require 'qed/reporter/base'
+
+  # = DotProgress Reporter
+  #
+  class Ditto < 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|
+        backtrace = clean_backtrace(exception.backtrace[0])
+        io.puts ANSICode.red("***** ERROR *****")
+        io.puts "#{exception}"
+        io.puts ":#{backtrace}:"
+        #io.puts ":#{exception.backtrace[1]}:"
+        #io.puts exception.backtrace[1..-1] if $VERBOSE
+        io.puts
+      end
+
+      @fail.each do |step, assertion|
+        backtrace = clean_backtrace(assertion.backtrace[0])
+        io.puts ANSICode.red("***** FAIL *****")
+        io.puts ANSICode.bold("#{assertion}")
+        io.puts ":#{backtrace}:"
+        #io.puts assertion if $VERBOSE
+        io.puts
+      end
+
+      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
+end#module QED
+

data/lib/qed/reporter/dotprogress.rb

@@ -37,18 +37,20 @@ module Reporter #:nodoc:
       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 "#{exception}"
-        io.puts ":#{exception.backtrace[0]}:"
+        io.puts ":#{backtrace}:"
         #io.puts ":#{exception.backtrace[1]}:"
         #io.puts exception.backtrace[1..-1] if $VERBOSE
         io.puts
       end
 
       @fail.each do |step, assertion|
+        backtrace = clean_backtrace(assertion.backtrace[0])
         io.puts ANSICode.red("***** FAIL *****")
         io.puts ANSICode.bold("#{assertion}")
-        io.puts ":#{assertion.backtrace[2]}:"
+        io.puts ":#{backtrace}:"
         #io.puts assertion if $VERBOSE
         io.puts
       end
@@ -56,6 +58,13 @@ 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

data/lib/qed/runner.rb

@@ -1,6 +1,3 @@
-#require 'quarry/behave'
-#require 'quarry/runner/context'
-
 module QED
 
   require 'qed/script'
@@ -16,7 +13,7 @@ module QED
   #
   class Runner
 
-    #  QED::Spec::Runner.configure do
+    #  QED::Runner.configure do
     #    def setup(spec)
     #      ...
     #    end
@@ -35,8 +32,26 @@ module QED
     #  end
     #end
 
+    def self.configure(&block)
+      class_eval(&block)
+    end
+
+    def self.start(&block)
+      define_method(:start, &block)
+    end
+
+    def self.finish(&block)
+      define_method(:finish, &block)
+    end
+
+    #
     attr :specs
-    attr :output
+
+    #
+    attr_accessor :format
+
+    #
+    attr_accessor :trace
 
     #attr :context
     #attr :count
@@ -45,30 +60,59 @@ module QED
     #attr_accessor :after
 
     # New Specification
-    def initialize(specs, output=nil)
-      @specs  = [specs].flatten
-      @output = output || Reporter::DotProgress.new #(self)
+    def initialize(specs, options={})
+      @specs       = [specs].flatten
+
+      @format      = :dotprogress
+      @trace       = false
+
+      options.each do |k,v|
+        __send__("#{k}=", v) if v
+      end
+    end
+
+    # Instance of selected Reporter subclass.
+    def reporter
+      case format
+      when :dotprogress
+        Reporter::DotProgress.new(reporter_options)
+      when :verbatim
+        Reporter::Verbatim.new(reporter_options)
+      when :summary
+        Reporter::Summary.new(reporter_options)
+      when :script #ditto ?
+        # TODO
+      else
+        Reporter::DotProgress.new(reporter_options)
+      end
+    end
+
+    # Report options.
+    #--
+    # TODO: rename :verbose to :trace
+    #++
+    def reporter_options
+      { :verbose => @trace }
+    end
+
+    #
+    def output
+      @output ||= reporter
     end
 
     #
     def check
+      start
       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)
+      specs.each do |spec|   # loop through each specification and run it
+        run_spec(spec)       # run the specification
       end
       output.report_summary
+      finish
     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
@@ -142,7 +186,13 @@ module QED
     end
 =end
 
+    def start
+    end
+
+    def finish
+    end
+
   end#class Runner
 
-end#module Quarry
+end#module QED
 

data/lib/qed/script.rb

@@ -11,6 +11,18 @@ module QED
   #Assertion   = AE::Assertion
   Expectation = Assertor
 
+  # Global Before
+  def self.Before(&procedure)
+    @_before = procedure if procedure
+    @_before
+  end
+
+  # Global After
+  def self.After(&procedure)
+    @_after = procedure if procedure
+    @_after
+  end
+
   # New Specification
   #def initialize(specs, output=nil)
   #  @specs  = [specs].flatten
@@ -24,19 +36,20 @@ module QED
     #  new(File.read(file), output)
     #end
 
+    # Path of demonstration script.
     attr :file
+
+    # Reporter object to issue output calls.
     attr :output
 
+    # List of helper scripts to require.
+    attr :helpers
+
     # New Script
     def initialize(file, output=nil)
-      @file   = file
-      @output = output || Reporter::Verbatim.new #(self)
-
-      source = File.read(file)
-      index  = source.rindex('---') || source.size
-
-      @source = source[0...index]
-      @helper = source[index+3...-1].to_s.strip
+      @file    = file
+      @output  = output || Reporter::Verbatim.new #(self)
+      parse_document(file)
     end
 
     # File basename less extension.
@@ -44,14 +57,23 @@ module QED
       @name ||= File.basename(file).chomp(File.extname(file))
     end
 
+    #
+    def directory
+      @directory ||= Dir.pwd #File.dirname(File.expand_path(file))
+    end
+
     #def convert
     #  @source.gsub(/^\w/, '# \1')
     #end
 
     # Run the script.
     def run
-      #steps = @source.split(/\n\s*$/)
-      eval(@helper, context._binding, @file) if @helper
+      @lineno = 0
+
+      $LOAD_PATH.unshift(directory)
+
+      import_helpers
+
       steps.each do |step|
         output.report_step(step)
         case step
@@ -71,17 +93,31 @@ module QED
             run_step(step)
           #end
         end
+        @lineno += step.count("\n")
       end
+
+      $LOAD_PATH.index(directory){ |i| $LOAD_PATH.delete_at(i) }
     end
 
-    #
+    #--
+    # NOTE: The Around code is in place should we decide
+    # to use it. I'm not sure yet if it's really neccessary,
+    # since we have Before and After.
+    #++
     def run_step(step=nil, &blk)
+      QED.Before.call if QED.Before
       context.Before.call if context.Before
       begin
-        if blk
+        if blk  # TODO: Is this still used?
           blk.call #eval(step, context._binding)
         else
-          eval(step, context._binding, @file) # TODO: would be nice to know file and lineno here
+          #if context.Around
+          #  context.Around.call do
+          #    eval(step, context._binding, @file, @lineno+1)
+          #  end
+          #else
+            eval(step, context._binding, @file, @lineno+1)
+          #end
         end
         output.report_pass(step) if step
       rescue Assertion => error
@@ -90,6 +126,7 @@ module QED
         output.report_error(step, error)
       ensure
         context.After.call if context.After
+        QED.After.call if QED.After
       end
     end
 
@@ -182,6 +219,88 @@ module QED
       @context ||= Context.new(self)
     end
 
+    #
+    def import(helper)
+      code = File.read(helper)
+      eval(code, context._binding)
+    end
+
+    private
+
+    # Splits the document into main source and footer
+    # and extract the helper document references from
+    # the footer.
+    #
+    def parse_document(file)
+      text  = File.read(file)
+      index = text.rindex('---') || text.size
+      source   = text[0...index]
+      footer   = text[index+3..-1].to_s.strip
+      helpers  = parse_helpers(footer)
+      @source  = source
+      @helpers = helpers
+    end
+
+    #
+    def parse_helpers(footer)
+      helpers = []
+      footer.split("\n").each do |line|
+        next if line.strip == ''
+        case line
+        when /\[(.*?)\]\((.*?)\)/
+          helpers << $2 
+        when /(.*?)\[(.*?)\]/
+          helpers << $2
+        end
+      end
+      helpers
+    end
+
+=begin
+    # Looks for a master +helper.rb+ file and a special
+    # helpers/<name>.rb file. Both of these, when found, will
+    # be imported when this script is run.
+
+    def collect_helpers
+      dir  = File.dirname(file)
+      list = []
+      list << "helper.rb" if File.exist?(File.join(dir, "helper.rb"))
+      list << "helpers/#{name}.rb" if File.exist?(File.join(dir, "helpers/#{name}.rb"))
+      list
+    end
+=end
+
+    # TODO: How to determine where to find the env.rb file?
+    #def require_environment
+    #  dir = File.dirname(file)
+    #  dir = File.expand_path(dir)
+    #  env = loop do
+    #    file = File.join(dir, 'env.rb')
+    #    break file if File.exist?(file)
+    #    break nil  if ['demo', 'demos', 'doc', 'docs', 'test', 'tests'].include? File.basename(dir)
+    #    break nil  if dir == Dir.pwd
+    #    dir = File.dirname(dir)
+    #  end
+    #  require(env) if env
+    #end
+
+    # FIXME: where to stop looking for helpers.
+    def import_helpers
+      hlp = []
+      dir = Dir.pwd #File.expand_path(dir)
+      env = loop do
+        helpers.each do |helper|
+          file = File.join(dir, 'helpers', helper)
+          if File.exist?(file)
+            hlp << file
+          end
+        end
+        break if ['qed', 'demo', 'demos', 'doc', 'docs', 'test', 'tests'].include? File.basename(dir)
+        dir = File.dirname(dir)
+      end
+      hlp.each{ |helper| import(helper) }
+    end
+
   end
 
   #
@@ -211,6 +330,27 @@ module QED
       @_after
     end
 
+    # Run code around each step.
+    #
+    # Around procedures must take a block, in which the step is run.
+    #
+    #   Around do |&step|
+    #     ... do something here ...
+    #     step.call
+    #     ... do stiff stuff ...
+    #   end
+    #
+    #def Around(&procedure)
+    #  @_around = procedure if procedure
+    #  @_around
+    #end
+
+    # Comment match procedure.
+    #
+    # This is useful for creating unobtrusive setup and (albeit more
+    # limited) teardown code. A pattern is matched against each comment
+    # as it is processed. If there is match, the code procedure is
+    # triggered, passing in any mathcing expression arguments.
     #
     def When(pattern=nil, &procedure)
       return @_when unless procedure
@@ -221,6 +361,24 @@ module QED
       @_when << [pattern, procedure]
     end
 
+    # Code match-and-transform procedure.
+    #
+    # This is useful to transform human readable code examples
+    # into proper exectuable code. For example, say you want to
+    # run shell code, but want to make if look like typical
+    # shelle examples:
+    #
+    #    $ cp fixture/a.rb fixture/b.rb
+    #
+    # You can use a transform to convert lines starting with '$'
+    # into executable Ruby using #system.
+    #
+    #    system('cp fixture/a.rb fixture/b.rb')
+    #
+    #def Transform(pattern=nil, &procedure)
+    #
+    #end
+
     # Table-based steps.
     def Table(file=nil, &blk)
       file = file || @_tables.last