ZenTest 3.0.0

data/lib/autotest.rb

@@ -0,0 +1,202 @@
+$TESTING = defined? $TESTING
+
+require 'find'
+
+##
+# Autotest continuously runs your tests as you work on your project.
+#
+# Autotest periodically scans the files in your project for updates then
+# figures out the appropriate tests to run and runs them.  If a test fails
+# Autotest will run just that test until you get it to pass.
+#
+# If you want Autotest to start over from the top, hit ^C.  If you want
+# Autotest to quit, hit ^C twice.
+#
+# Autotest uses a simple naming scheme to figure out how to map implementation
+# files to test files following the Test::Unit naming scheme.
+#
+# * Test files must be stored in test/
+# * Test files names must start with test_
+# * Test classes must start with Test
+# * Implementation files must be stored in lib/
+# * Implementation files must match up with a test file named
+#   test_.*implementation.rb
+
+class Autotest
+  
+  def self.run
+    new.run
+  end
+
+  ##
+  # Creates a new Autotest.  If @exceptions is set, updated_files will use it
+  # to reject filenames.
+
+  def initialize
+    @interrupt = false
+    @files = Hash.new Time.at(0)
+    @exceptions = nil
+  end
+
+  ##
+  # Maps failed class +klass+ to test files in +tests+ that have been updated.
+
+  def failed_test_files(klass, tests)
+    failed_klass = klass.sub('Test', '').gsub(/(.)([A-Z])/, '\1_?\2').downcase
+    # tests that match this failure
+    failed_files = tests.select { |test| test =~ /#{failed_klass}/ }
+    # updated implementations that match this failure
+    changed_impls = @files.keys.select do |file|
+      file =~ %r%^lib.*#{failed_klass}.rb$% and updated? file
+    end
+    tests_to_run = map_file_names(changed_impls).flatten
+    # add updated tests
+    failed_files.each { |f| tests_to_run << f if updated? f }
+    return tests_to_run.uniq
+  end
+
+  ##
+  # Maps implementation files to test files.  Returns an Array of one or more
+  # Arrays of test filenames.
+
+  def map_file_names(updated)
+    tests = []
+
+    updated.each do |filename|
+      case filename
+      when %r%^lib/(?:.*/)?(.*\.rb)$% then
+        impl = $1.gsub '_', '_?'
+        found = @files.keys.select do |k|
+          k =~ %r%^test/.*#{impl}$%
+        end
+        tests.push(*found)
+      when %r%^test/test_% then
+        tests << filename # always run tests
+      when %r%^(doc|pkg)/% then
+        # ignore
+      else
+        STDERR.puts "Dunno! #{filename}" # What are you trying to pull?
+      end
+    end
+
+    return [tests]
+  end
+
+  ##
+  # Retests failed tests.
+
+  def retest_failed(failed, tests)
+    # -t and -n includes all tests that match either filter, not tests that
+    # match both filters, so figure out which TestCase to run from the filename,
+    # and use -n on that.
+    until failed.empty? do
+      sleep 5 unless $TESTING
+
+      failed.map! do |method, klass|
+        failed_files = failed_test_files klass, tests
+        break [method, klass] if failed_files.empty?
+        puts "# Rerunning failures: #{failed_files.join ' '}"
+        filter = "-n #{method} " unless method == 'default_test'
+        cmd = "ruby -Ilib:test -S testrb #{filter}#{failed_files.join ' '}"
+        puts "+ #{cmd}"
+        system(cmd) ? nil : [method, klass] # clever
+      end
+
+      failed.compact!
+    end
+  end
+
+  ##
+  # Repeatedly scans for updated files and runs their tests.
+
+  def run
+    trap 'INT' do
+      if @interrupt then
+        puts "# Ok, you really want to quit, doing so"
+        exit
+      end
+      puts "# hit ^C again to quit"
+      sleep 1.5 # give them enough time to hit ^C again
+      @interrupt = true # if they hit ^C again, 
+      raise Interrupt # let the run loop catch it
+    end
+      
+    begin
+      loop do
+        files = updated_files
+        test files unless files.empty?
+        sleep 5
+      end
+    rescue Interrupt
+      @interrupt = false # they didn't hit ^C in time
+      puts "# ok, restarting from the top"
+      @files.clear
+      retry
+    end
+  end
+
+  ##
+  # Runs tests for files in +updated+.  Implementation files are looked up
+  # with map_file_names.
+
+  def test(updated)
+    map_file_names(updated).each do |tests|
+      next if tests.empty?
+      puts '# Testing updated files'
+      cmd = "ruby -Ilib:test -e '#{tests.inspect}.each { |f| load f }'"
+      puts "+ #{cmd}"
+      results = `#{cmd}`
+      puts results
+
+      if results =~ / 0 failures, 0 errors\Z/ then
+        puts '# Passed'
+        next
+      end
+
+      failed = results.scan(/^\s+\d+\) (?:Failure|Error):\n(.*?)\((.*?)\)/)
+
+      if failed.empty? then
+        puts '# Test::Unit died, you did a really bad thing, retrying in 10'
+        sleep 10
+        redo
+      end
+
+      retest_failed failed, tests
+    end
+
+    puts '# All passed'
+  end
+
+  ##
+  # Returns true or false if the file has been modified or not.  New files are
+  # always modified.
+
+  def updated?(file)
+    mtime = File.stat(file).mtime
+    updated = @files[file] < mtime
+    @files[file] = mtime
+    return updated
+  end
+
+  ##
+  # Returns names of files that have been modified since updated_files was
+  # last run.  Files and paths can be ignored by setting @exceptions in
+  # initialize.
+
+  def updated_files
+    updated = []
+
+    Find.find '.' do |f|
+      next if File.directory? f
+      next if f =~ /(?:swp|~|rej|orig)$/ # temporary/patch files
+      next if f =~ %r%/(?:.svn|CVS)/% # version control files
+      next if f =~ @exceptions unless @exceptions.nil? # custom exceptions
+      f = f.sub(/^\.\//, '') # trim the ./ that Find gives us
+      updated << f if updated? f
+    end
+
+    return updated
+  end
+
+end
+

data/lib/rails_autotest.rb

@@ -0,0 +1,57 @@
+require 'autotest'
+
+##
+# RailsAutotest is an Autotest subclass designed for use with Rails projects.
+#
+# To use RailsAutotest pass the -rails flag to autotest.
+
+class RailsAutotest < Autotest
+
+  def initialize # :nodoc:
+    super
+    @exceptions = %r%(?:^\./(?:db|doc|log|public|script))|(?:.rhtml$)%
+  end
+
+  def map_file_names(updated) # :nodoc:
+    model_tests = []
+    functional_tests = []
+
+    updated.each do |filename|
+      filename.sub!(/^\.\//, '') # trim the ./ that Find gives us
+
+      case filename
+      when %r%^test/fixtures/(.*)s.yml% then
+        model_test = "test/unit/#{$1}_test.rb"
+        functional_test = "test/functional/#{$1}_controller_test.rb"
+        model_tests << model_test if File.exists? model_test
+        functional_tests << functional_test if File.exists? functional_test
+      when %r%^test/unit/.*rb$% then
+        model_tests << filename
+      when %r%^app/models/(.*)\.rb$% then
+        model_tests << "test/unit/#{$1}_test.rb"
+      when %r%^test/functional/.*\.rb$% then
+        functional_tests << filename
+      when %r%^app/helpers/application_helper.rb% then
+        functional_tests.push(*Dir['test/functional/*_test.rb'])
+      when %r%^app/helpers/(.*)_helper.rb% then
+        functional_tests << "test/functional/#{$1}_controller_test.rb"
+      when %r%^app/controllers/application.rb$% then
+        functional_tests << "test/functional/dummy_controller_test.rb"
+      when %r%^app/controllers/(.*)\.rb$% then
+        functional_tests << "test/functional/#{$1}_test.rb"
+      when %r%^app/views/layouts/% then
+      when %r%^app/views/(.*)/% then
+        functional_tests << "test/functional/#{$1}_controller_test.rb"
+      else
+        puts "dunno! #{filename}"
+      end
+    end
+
+    model_tests.uniq!
+    functional_tests.uniq!
+
+    return model_tests, functional_tests
+  end
+
+end
+

data/lib/unit_diff.rb

@@ -0,0 +1,200 @@
+require 'tempfile'
+
+class Tempfile
+  # blatently stolen. Design was poor in Tempfile.
+  def self.make_tempname(basename, n=10)
+    sprintf('%s%d.%d', basename, $$, n)
+  end
+
+  def self.make_temppath(basename)
+    tempname = ""
+    n = 1
+    begin
+      tmpname = File.join('/tmp', make_tempname(basename, n))
+      n += 1
+    end while File.exist?(tmpname) and n < 100
+    tmpname
+  end
+end
+
+def temp_file(data)
+  temp = 
+    if $k then
+      File.new(Tempfile.make_temppath("diff"), "w")
+    else
+      Tempfile.new("diff")
+    end
+  count = 0
+  data = data.map { |l| '%3d) %s' % [count+=1, l] } if $l
+  data = data.join('')
+  # unescape newlines, strip <> from entire string
+  data = data.gsub(/\\n/, "\n").gsub(/\A</m, '').gsub(/>\Z/m, '').gsub(/0x[a-f0-9]+/m, '0xXXXXXX')
+  temp.print data
+  temp.puts unless data =~ /\n\Z/m
+  temp.flush
+  temp.rewind
+  temp
+end
+
+##
+# UnitDiff makes reading Test::Unit output easy and fun.  Instead of a
+# confusing jumble of text with nearly unnoticable changes like this:
+#
+#   1) Failure:
+#   test_to_gpoints(RouteTest) [test/unit/route_test.rb:29]:
+#   <"new GPolyline([\n  new GPoint(  47.00000, -122.00000),\n  new GPoint(  46.5000
+#   0, -122.50000),\n  new GPoint(  46.75000, -122.75000),\n  new GPoint(  46.00000,
+#    -123.00000)])"> expected but was
+#   <"new Gpolyline([\n  new GPoint(  47.00000, -122.00000),\n  new GPoint(  46.5000
+#   0, -122.50000),\n  new GPoint(  46.75000, -122.75000),\n  new GPoint(  46.00000,
+#    -123.00000)])">.
+#
+#
+# You get an easy-to-read diff output like this:
+#
+#   1) Failure:
+#   test_to_gpoints(RouteTest) [test/unit/route_test.rb:29]:
+#   1c1
+#   < new GPolyline([
+#   ---
+#   > new Gpolyline([
+#
+# == Usage
+#
+#   test.rb | unit_diff [options]
+#     options:
+#     -b ignore whitespace differences
+#     -c contextual diff
+#     -h show usage
+#     -k keep temp diff files around
+#     -l prefix line numbers on the diffs
+#     -u unified diff
+#     -v display version
+
+class UnitDiff
+
+  ##
+  # Handy wrapper for UnitDiff#unit_diff.
+
+  def self.unit_diff(input)
+    ud = UnitDiff.new
+    ud.unit_diff(input)
+  end
+
+  def input(input)
+    current = []
+    data = []
+    data << current
+
+    # Collect
+    input.each_line do |line|
+      if line =~ /^\s*$/ or line =~ /^\(?\s*\d+\) (Failure|Error):/ then
+        type = $1
+        current = []
+        data << current
+      end
+      current << line
+    end
+    data = data.reject { |o| o == ["\n"] }
+    header = data.shift
+    footer = data.pop
+    return header, data, footer
+  end
+
+  def parse_diff(result)
+    header = []
+    expect = []
+    butwas = []
+    found = false
+    state = :header
+
+    until result.empty? do
+      case state
+      when :header then
+        header << result.shift 
+        state = :expect if result.first =~ /^</
+      when :expect then
+        state = :butwas if result.first.sub!(/ expected but was/, '')
+        expect << result.shift
+      when :butwas then
+        butwas = result[0..-1]
+        result.clear
+      else
+        raise "unknown state #{state}"
+      end
+    end
+
+    return header, expect, nil if butwas.empty?
+
+    expect.last.chomp!
+    expect.first.sub!(/^<\"/, '')
+    expect.last.sub!(/\">$/, '')
+
+    butwas.last.chomp!
+    butwas.last.chop! if butwas.last =~ /\.$/
+    butwas.first.sub!( /^<\"/, '')
+    butwas.last.sub!(/\">$/, '')
+
+    return header, expect, butwas
+  end
+
+  ##
+  # Scans Test::Unit output +input+ looking for comparison failures and makes
+  # them easily readable by passing them through diff.
+
+  def unit_diff(input)
+    $b = false unless defined? $b
+    $c = false unless defined? $c
+    $k = false unless defined? $k
+    $l = false unless defined? $l
+    $u = false unless defined? $u
+
+    header, data, footer = self.input(input)
+
+    header = header.map { |l| l.chomp }
+    header << nil unless header.empty?
+
+    output = [header]
+
+    # Output
+    data.each do |result|
+      first = []
+      second = []
+
+      if result.first !~ /Failure/ then
+        output.push result.join('')
+        next
+      end
+
+      prefix, expect, butwas = parse_diff(result)
+
+      output.push prefix.compact.map {|line| line.strip}.join("\n")
+
+      if butwas then
+        a = temp_file(expect)
+        b = temp_file(butwas)
+
+        diff_flags = $u ? "-u" : $c ? "-c" : ""
+        diff_flags += " -b" if $b
+
+        result = `diff #{diff_flags} #{a.path} #{b.path}`
+        if result.empty? then
+          output.push "[no difference--suspect ==]"
+        else
+          output.push result.map {|line| line.strip}
+        end
+
+        output.push ''
+      else
+        output.push expect.join('')
+      end
+    end
+
+    footer.shift if footer.first.strip.empty?
+    output.push footer.compact.map {|line| line.strip}.join("\n")
+
+    return output.flatten.join("\n")
+  end
+
+end
+