qed 1.3 → 2.0.0

data/lib/qed/reporter/summary.rb

@@ -1,68 +0,0 @@
-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.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
-
-    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/runner.rb

@@ -1,198 +0,0 @@
-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::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
-
-    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_accessor :format
-
-    #
-    attr_accessor :trace
-
-    #attr :context
-    #attr :count
-
-    #attr_accessor :before
-    #attr_accessor :after
-
-    # New Specification
-    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
-      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)
-      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
-
-    def start
-    end
-
-    def finish
-    end
-
-  end#class Runner
-
-end#module QED
-

data/lib/qed/script1.rb

@@ -1,495 +0,0 @@
-module QED
-  require 'yaml'
-  require 'facets/dir/ascend'
-
-  require 'ae'
-
-  require 'qed/reporter/dotprogress'
-  require 'qed/reporter/summary'
-  require 'qed/reporter/verbatim'
-
-  #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
-  #end
-
-  # = Script
-  #
-  class Script
-
-    #def self.load(file, output=nil)
-    #  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)
-      parse #_document(file)
-    end
-
-    # File basename less extension.
-    def name
-      @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
-      @lineno = 0
-
-      $LOAD_PATH.unshift(directory)
-
-      import_helpers
-
-      steps.each do |step|
-        output.report_step(step)
-        case step
-        when /^[=#]/
-          output.report_header(step)
-        when /^\S/
-          output.report_comment(step)
-          context.When.each do |(regex, proc)|
-            if md = regex.match(step)
-              proc.call(*md[1..-1])
-            end
-          end
-        else
-          #if context.table
-          #  run_table(step)
-          #else
-            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  # TODO: Is this still used?
-          blk.call #eval(step, context._binding)
-        else
-          #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
-        output.report_fail(step, error)
-      rescue Exception => error
-        output.report_error(step, error)
-      ensure
-        context.After.call if context.After
-        QED.After.call if QED.After
-      end
-    end
-
-=begin
-    #
-    def run_table(step)
-      file = context.table
-      Dir.ascend(Dir.pwd) do |path|
-        f1 = File.join(path, file)
-        f2 = File.join(path, 'fixtures', file)
-        fr = File.file?(f1) ? f1 : File.exist?(f2) ? f2 : nil
-        (file = fr; break) if fr
-      end
-      output.report_pass(step) #step)
-
-      tbl = YAML.load(File.new(file))
-      key = tbl.shift
-      tbl.each do |set|
-        assign = key.zip(set).map{ |k, v| "#{k}=#{v.inspect};" }.join
-        run_table_step(assign + step, set)
-        #run_step(set.inspect.tabto(4)){ blk.call(set) }
-        #@_script.run_step(set.to_yaml.tabto(2)){ blk.call(set) }
-        #@_script.output.report_table(set)
-      end
-      #output.report_pass(step) #step)
-      context.table = nil
-    end
-
-    #
-    #def run_table_step(step, set)
-    def run_table_step(set, &blk)
-      context.before.call if context.before
-      begin
-        #eval(step, context._binding, @file) # TODO: would be nice to know file and lineno here
-        blk.call(*set)
-        output.report_pass('    ' + set.inspect) #step)
-      rescue Assertion => error
-        output.report_fail(set.inspect, error)
-      rescue Exception => error
-        output.report_error(set.inspect, error)
-      ensure
-        context.after.call if context.after
-      end
-    end
-=end
-
-    # Cut-up script into steps.
-    def steps
-      @steps ||= (
-        code  = false
-        str   = ''
-        steps = []
-        @source.each_line do |line|
-          if /^\s*$/.match line
-            str << line
-          elsif /^[=]/.match line
-            steps << str #.chomp("\n")
-            steps << line #.chomp("\n")
-            str = ''
-            #str << line
-            code = false
-          elsif /^\S/.match line
-            if code
-              steps << str #.chomp("\n")
-              str = ''
-              str << line
-              code = false
-            else
-              str << line
-            end
-          else
-            if code
-              str << line
-            else
-              steps << str
-              str = ''
-              str << line
-              code = true
-            end
-          end
-        end
-        steps << str
-        #steps.map{ |s| s.chomp("\n") }
-        steps
-      )
-    end
-
-    #
-    def to_html
-      require 'tilt'
-      Tilt.new(file).render
-    end
-
-    #
-    def parse
-      steps = []
-      require 'nokogiri'
-      doc = Nokogiri::HTML(to_html)
-      doc.root.traverse do |elem|
-        case elem.name
-        when /h*/
-          steps << Head.new(elem.text)
-        when "p"
-          steps << Text.new(elem.text)
-        when 'pre'
-          steps << Code.new(elem.text)
-        end
-      end
-      steps
-    end
-
-    class Head
-      attr :text
-      def initialize(text)
-        @text = text
-      end
-    end
-
-    class Code
-      attr :text
-      def initialize(text)
-        @text = text
-      end
-    end
-
-    class Text
-      attr :text
-      def initialize(text)
-        @text = text
-      end
-    end
-
-    # The run context.
-    def context
-      @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
-      @footer = footer
-    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
-
-  #
-  class Context < Module
-
-    TABLE = /^TABLE\[(.*?)\]/i
-
-    def initialize(script)
-      @_script = script
-      @_when   = []
-      @_tables = []
-    end
-
-    def _binding
-      @_binding ||= binding
-    end
-
-    # Before each step.
-    def Before(&procedure)
-      @_before = procedure if procedure
-      @_before
-    end
-
-    # After each step.
-    def After(&procedure)
-      @_after = procedure if procedure
-      @_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
-      raise ArgumentError unless pattern
-      unless Regexp === pattern
-        pattern = __when_string_to_regexp(pattern)
-      end
-      @_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
-      tbl = YAML.load(File.new(file))
-      tbl.each do |set|
-        blk.call(*set)
-      end
-      @_tables << file
-    end
-
-    # Read/Write a fixture.
-    def Data(file, &content)
-      raise if File.directory?(file)
-      if content
-        FileUtils.mkdir_p(File.dirname(fname))
-        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
-      else
-        #raise LoadError, "no such fixture file -- #{fname}" unless File.exist?(fname)
-        case File.extname(file)
-        when '.yml', '.yaml'
-          YAML.load(File.new(file))
-        else
-          File.read(file)
-        end
-      end
-    end
-
-  private
-
-    def __when_string_to_regexp(str)
-      str = str.split(/(\(\(.*?\)\))(?!\))/).map{ |x|
-        x =~ /\A\(\((.*)\)\)\z/ ? $1 : Regexp.escape(x)
-      }.join
-      str = str.gsub(/(\\\ )+/, '\s+')
-      Regexp.new(str, Regexp::IGNORECASE)
-
-      #rexps = []
-      #str = str.gsub(/\(\((.*?)\)\)/) do |m|
-      #  rexps << '(' + $1 + ')'
-      #  "\0"
-      #end
-      #str = Regexp.escape(str)
-      #rexps.each do |r|
-      #  str = str.sub("\0", r)
-      #end
-      #str = str.gsub(/(\\\ )+/, '\s+')
-      #Regexp.new(str, Regexp::IGNORECASE)
-    end
-
-    # 
-    # check only local and maybe start paths
-    #def __locate_file(file)
-    #  Dir.ascend(Dir.pwd) do |path|
-    #    f1 = File.join(path, file)
-    #    f2 = File.join(path, 'fixtures', file)
-    #    fr = File.file?(f1) ? f1 : File.exist?(f2) ? f2 : nil
-    #    (file = fr; break) if fr
-    #  end
-    #end
-
-  end
-
-end
-