ZenTest 3.2.0 → 3.3.0

data/History.txt

@@ -1,3 +1,24 @@
+*** 3.3.0 / 2006-07-28
+
++ 1 major enhancement:
+	+ autotest has been rewritten to be much cleaner, now has a plugin system.
++ 5 minor enhancement:
+	+ test/rails adds helper tests, "stolen" from Geoff's work, (which was "stolen" from ryan's work. :P)
+	+ autotest turnaround is now faster.
+	+ Added more prune dirs to autotest.
+	+ test/rails rewinds IOs containing captured output. Added assert_empty.
+	+ Document that autotest doesn't run the db:test:prepare rake task when in Rails mode.
+	+ Added ruby_fork, but haven't fully plugged into autotest yet.
++ 7 bug fixes:
+	+ Add SIGINT handler to unit_diff to give a more graceful exit.
+	+ Don't strip <> from tempfiles, parse_diff does it for us.
+	+ Fixed autotest problems on windoze. Ugh.
+	+ Fixed broken pipe bug and newline bug in unit_diff.
+	+ Make request_method in ControllerTestCase a String.
+	+ multitest installs rubygems if tarball found in versions dir.
+	+ multitest only configures when makefile is missing. Rebuilds much faster now.
+	+ ruby_fork exits without backtrace and allows redirection of output.
+
 *** 3.2.0 / 2006-04-10
 
 + 1 major enhancement:

data/Manifest.txt

@@ -6,48 +6,32 @@ Rakefile
 bin/autotest
 bin/multiruby
 bin/rails_test_audit
+bin/ruby_fork
+bin/ruby_fork_client
 bin/unit_diff
 bin/zentest
 example.txt
 example1.rb
 example2.rb
+example_dot_autotest.rb
 lib/autotest.rb
 lib/rails_autotest.rb
+lib/ruby_fork.rb
 lib/test/rails.rb
 lib/test/rails/controller_test_case.rb
 lib/test/rails/functional_test_case.rb
+lib/test/rails/helper_test_case.rb
 lib/test/rails/ivar_proxy.rb
+lib/test/rails/pp_html_document.rb
 lib/test/rails/rake_tasks.rb
 lib/test/rails/test_case.rb
 lib/test/rails/view_test_case.rb
 lib/test/zentest_assertions.rb
 lib/unit_diff.rb
 lib/zentest.rb
-test/data/normal/lib/.#photo.rb
-test/data/normal/lib/blah.rb
-test/data/normal/lib/photo.rb
-test/data/normal/test/#test_photo.rb#
-test/data/normal/test/test_camelcase.rb
-test/data/normal/test/test_photo.rb
-test/data/normal/test/test_route.rb
-test/data/normal/test/test_user.rb
-test/data/rails/app/controllers/admin/theme_controller.rb
-test/data/rails/app/controllers/route_controller.rb
-test/data/rails/app/models/flickr_photo.rb
-test/data/rails/app/models/route.rb
-test/data/rails/app/views/route/index.rhtml
-test/data/rails/config/environment.rb
-test/data/rails/config/routes.rb
-test/data/rails/test/controllers/route_controller_test.rb
-test/data/rails/test/fixtures/routes.yml
-test/data/rails/test/functional/admin/themes_controller_test.rb
-test/data/rails/test/functional/dummy_controller_test.rb
-test/data/rails/test/functional/route_controller_test.rb
-test/data/rails/test/unit/flickr_photo_test.rb
-test/data/rails/test/unit/photo_test.rb
-test/data/rails/test/unit/route_test.rb
-test/data/rails/test/views/route_view_test.rb
 test/test_autotest.rb
 test/test_rails_autotest.rb
+test/test_ruby_fork.rb
 test/test_unit_diff.rb
 test/test_zentest.rb
+test/test_zentest_assertions.rb

data/Rakefile

@@ -4,6 +4,7 @@ require 'rake'
 require 'rake/testtask'
 require 'rake/rdoctask'
 require 'rake/gempackagetask'
+require 'rake/contrib/sshpublisher'
 require 'rbconfig'
 
 require './lib/zentest.rb'
@@ -25,8 +26,12 @@ spec = Gem::Specification.new do |s|
   s.instance_variable_set "@description", paragraphs[3..10].join("\n\n")
   s.instance_variable_set "@summary", paragraphs[12]
 
+  s.homepage = "http://www.zenspider.com/ZSS/Products/ZenTest/"
+  s.rubyforge_project = "zentest"
+  s.has_rdoc = true
+
   if $DEBUG then
-    puts "ZenTest #{s.version}"
+    puts "#{s.name} #{s.version}"
     puts
     puts s.executables.sort.inspect
     puts
@@ -36,10 +41,6 @@ spec = Gem::Specification.new do |s|
     puts "** description:"
     puts s.description
   end
-
-  s.homepage = "http://www.zenspider.com/ZSS/Products/ZenTest/"
-  s.rubyforge_project = "zentest"
-  s.has_rdoc = true
 end
 
 desc 'Build Gem'
@@ -69,6 +70,16 @@ Rake::RDocTask.new :rdoc do |rd|
   rd.options << '-d' if `which dot` =~ /\/dot/ unless RUBY_PLATFORM =~ /win32/
   rd.options << '-t ZenTest RDoc'
 end
+  
+desc 'Upload RDoc to RubyForge'
+task :upload => :rdoc do
+    
+  user = "#{ENV['USER']}@rubyforge.org"
+  project = '/var/www/gforge-projects/zentest'
+  local_dir = 'doc'
+  pub = Rake::SshDirPublisher.new user, project, local_dir
+  pub.upload
+end
 
 $prefix = ENV['PREFIX'] || Config::CONFIG['prefix']
 $bin  = File.join($prefix, 'bin')
@@ -76,9 +87,8 @@ $lib  = Config::CONFIG['sitelibdir']
 $bins = spec.executables
 $libs = spec.files.grep(/^lib\//).map { |f| f.sub(/^lib\//, '') }.sort
 
-task :blah do
-    p $bins
-    p $libs
+task :autotest do
+  ruby "-Ilib ./bin/autotest"
 end
 
 task :install do
@@ -114,5 +124,19 @@ task :clean => [ :clobber_rdoc, :clobber_package ] do
   rm_f Dir["**/*~"]
 end
 
+task :help do
+  Rake.application.options.show_task_pattern = //
+  Rake.application.display_tasks_and_comments
+end
+
+task :sort do
+  begin
+    sh 'for f in lib/*.rb; do echo $f; grep "^ *def " $f | grep -v sort=skip > x; sort x > y; echo $f; echo; diff x y; done'
+    sh 'for f in test/test_*.rb; do echo $f; grep "^ *def.test_" $f > x; sort x > y; echo $f; echo; diff x y; done'
+  ensure
+    sh 'rm x y'
+  end
+end
+
 # vim:syntax=ruby
 

data/bin/autotest

@@ -17,7 +17,10 @@ if $h or $help then
   help << nil
   help << "\t-rails\t\tForce rails mode."
   help << "\t\t\tRails will be automatically detected by the presence of"
-  help << "\t\t\tconfig/environment.rb"
+  help << "\t\t\tconfig/environment.rb. Use this if you don't have one."
+  help << nil
+  help << "\t\t\tYou may need to run 'rake db:test:prepare' before"
+  help << "\t\t\tstarting autotest on a rails project."
   help << nil
   help << "\t-vcs=NAME\tVersion control system to update."
   help << "\t\t\tAutotest will automatically update every vcstime"

data/bin/multiruby

@@ -36,8 +36,13 @@ Dir.chdir root_dir do
     end
   end
 
+  tarballs = Dir["versions/rubygems*.tgz"]
+  raise "You should delete all but one rubygem tarball" if tarballs.size > 1
+  rubygem_tarball = File.expand_path tarballs.last
+
   Dir.chdir "build" do
     Dir["../versions/ruby*.tar.gz"].each do |tarball|
+      next if tarball =~ /rubygems/
       build_dir = File.basename tarball, ".tar.gz"
       version = build_dir.sub(/^ruby-?/, '')
       versions << version
@@ -46,15 +51,26 @@ Dir.chdir root_dir do
         unless test ?d, build_dir then
           puts "creating #{inst_dir}"
           Dir.mkdir inst_dir
-          puts "unpacking #{tarball}"
-          system "tar zxf #{tarball}"
+          run "tar zxf #{tarball}"
         end
         Dir.chdir build_dir do
+          puts "building and installing #{version}"
           run "autoconf" unless test ?f, "configure"
           FileUtils.rm_r "ext/readline" if test ?d, "ext/readline"
-          run "./configure --prefix #{inst_dir} &> log.configure"
-          run "make -j4 &> log.build"
+          run "./configure --prefix #{inst_dir} &> log.configure" unless test ?f, "Makefile"
+          run "nice make -j4 &> log.build"
           run "make install &> log.install"
+          build_dir = Dir.pwd
+
+          if rubygem_tarball then
+            next if version.gsub(/\./, '') =~ /^19/ # doesn't seem to work w/ ruby 1.9, filed bug
+            rubygems = File.basename rubygem_tarball, ".tgz"
+            run "tar zxf #{rubygem_tarball}" unless test ?d, rubygems
+
+            Dir.chdir rubygems do
+              run "../ruby ./setup.rb &> ../log.rubygems"
+            end
+          end
         end
       end
     end
@@ -78,5 +94,3 @@ puts
 puts "TOTAL RESULT = #{result} failures"
 
 exit result
-
-

data/bin/ruby_fork

@@ -0,0 +1,6 @@
+#!/usr/local/bin/ruby
+
+require 'ruby_fork'
+
+RubyFork.start_server ARGV
+

data/bin/ruby_fork_client

@@ -0,0 +1,6 @@
+#!/usr/local/bin/ruby
+
+require 'ruby_fork'
+
+RubyFork.start_client ARGV
+

data/example_dot_autotest.rb

@@ -0,0 +1,148 @@
+# -*- ruby -*-
+
+module AutoGrowl
+  def self.growl title, msg, pri=0
+    system "growlnotify -n autotest --image /Applications/Mail.app/Contents/Resources/Caution.tiff -p #{pri} -m #{msg.inspect} #{title}"
+  end
+
+  Autotest.add_hook :run do  |at|
+    growl "Run", "Run" unless $TESTING
+  end
+
+  Autotest.add_hook :red do |at|
+    growl "Tests Failed", "#{at.files_to_test.size} tests failed", 2
+  end
+
+  Autotest.add_hook :green do |at|
+    growl "Tests Passed", "All tests passed", -2 if at.tainted 
+  end
+
+  Autotest.add_hook :init do |at|
+    growl "autotest", "autotest was started" unless $TESTING
+  end
+
+  Autotest.add_hook :interrupt do |at|
+    growl "autotest", "autotest was reset" unless $TESTING
+  end
+
+  Autotest.add_hook :quit do |at|
+    growl "autotest", "autotest is exiting" unless $TESTING
+  end
+
+  Autotest.add_hook :all do |at|_hook
+    growl "autotest", "Tests have fully passed", -2 unless $TESTING
+  end
+end
+
+module HtmlConsole
+  MAX = 30
+  STATUS = {}
+  PATH = File.expand_path("~/Sites/autotest.html")
+
+  def self.update
+    STATUS.delete STATUS.keys.sort.last if STATUS.size > MAX
+    File.open(PATH, "w") do |f|
+      f.puts "<title>Autotest Status</title>"
+      STATUS.sort.reverse.each do |t,s|
+        if s > 0 then
+          f.puts "<p style=\"color:red\">#{t}: #{s}"
+        else
+          f.puts "<p style=\"color:green\">#{t}: #{s}"
+        end
+      end
+    end
+  end
+
+  Autotest.add_hook :red do |at|
+    STATUS[Time.now] = at.files_to_test.size
+    update
+  end
+
+  Autotest.add_hook :green do |at|
+    STATUS[Time.now] = 0
+    update
+  end
+end
+
+require 'osx/cocoa'
+include Math
+include OSX
+
+OSX::NSBundle.bundleWithPath(File.expand_path("~/Library/Frameworks/Aquaterm.framework")).load
+OSX.ns_import :AQTAdapter
+
+class StatusBoard
+  BLACK = 0
+  WHITE = 1
+  RED = 2
+  GREEN = 3
+  GRAY = 4
+
+  def initialize
+    @past = []
+
+    @adapter = AQTAdapter.alloc.init
+    @adapter.openPlotWithIndex 1
+    @adapter.setPlotSize([122,122])
+    @adapter.setPlotTitle("Autotest Status")
+
+    @adapter.setColormapEntry_red_green_blue(0, 0.0, 0.0, 0.0) # black
+    @adapter.setColormapEntry_red_green_blue(1, 1.0, 1.0, 1.0) # white
+    @adapter.setColormapEntry_red_green_blue(2, 1.0, 0.0, 0.0) # red
+    @adapter.setColormapEntry_red_green_blue(3, 0.0, 1.0, 0.0) # green
+    @adapter.setColormapEntry_red_green_blue(4, 0.7, 0.7, 0.7) # gray
+
+    draw
+  end
+
+  def draw
+#    @past = @past[10..-1] if @past.size >= 100
+    @past.shift if @past.size > 100
+
+    @adapter.takeColorFromColormapEntry(@past.last ? GREEN : RED)
+    @adapter.addFilledRect([0, 0, 122, 122])
+
+    @adapter.takeColorFromColormapEntry(BLACK)
+    @adapter.addFilledRect([10, 10, 102, 102])
+
+    @adapter.takeColorFromColormapEntry(GRAY)
+    @adapter.addFilledRect([11, 11, 100, 100])
+
+    @adapter.takeColorFromColormapEntry(0)
+
+    @past.each_with_index do |passed,i|
+      x = i % 10
+      y = i / 10
+      
+      @adapter.takeColorFromColormapEntry(passed ? GREEN : RED)
+      @adapter.addFilledRect([x*10+11, y*10+11, 10, 10])
+    end
+    @adapter.renderPlot
+  end
+
+  def pass
+    @past.push true
+    draw
+  end
+
+  def fail
+    @past.push false
+    draw
+  end
+
+  def close
+    @adapter.closePlot
+  end
+end
+
+unless $TESTING then
+  board = StatusBoard.new
+
+  Autotest.add_hook :red do |at|
+    board.fail unless $TESTING
+  end
+
+  Autotest.add_hook :green do |at|
+    board.pass unless $TESTING
+  end
+end

data/lib/autotest.rb

@@ -1,342 +1,289 @@
-$TESTING = defined? $TESTING
-
 require 'find'
 require 'rbconfig'
 
+$TESTING = false unless defined? $TESTING
+
 ##
-# Autotest continuously runs your tests as you work on your project.
+# Autotest continuously scans the files in your project for changes
+# and runs the appropriate tests.  Test failures are run until they
+# have all passed. Then the full test suite is run to ensure that
+# nothing else was inadvertantly broken.
+#
+# If you want Autotest to start over from the top, hit ^C once.  If
+# you want Autotest to quit, hit ^C twice.
+#
+# Rails:
+#
+# The autotest command will automatically discover a Rails directory
+# by looking for config/environment.rb. When Rails is discovered,
+# autotest uses RailsAutotest to perform file mappings and other work.
+# See RailsAutotest for details.
 #
-# 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.
+# Plugins:
 #
-# If you want Autotest to start over from the top, hit ^C.  If you want
-# Autotest to quit, hit ^C twice.
+# Plugins are available by creating a .autotest file either in your
+# project root or in your home directory. You can then write event
+# handlers in the form of:
 #
-# Autotest uses a simple naming scheme to figure out how to map implementation
-# files to test files following the Test::Unit naming scheme.
+#   Autotest.add_hook hook_name { |autotest| ... }
+#
+# The available hooks are: run, interrupt, quit, ran_command, red,
+#   green, all_good, and reset.
+#
+# See example_dot_autotest.rb for more details.
+#
+# Naming:
+#
+# 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
+# * Test class names must start with Test
 # * Implementation files must be stored in lib/
 # * Implementation files must match up with a test file named
 #   test_.*implementation.rb
-#--
-# New (proposed) strategy:
+#
+# Strategy:
 #
 # 1) find all files and associate them from impl <-> test
 # 2) run all tests
 # 3) scan for failures
 # 4) detect changes in ANY (ruby?) file, rerun all failures + changed files
-#    NOTE: this runs in a loop, loop handling should be improved slightly to
-#          have less crap (ruby command, failure count).
 # 5) until 0 defects, goto 3
 # 6) when 0 defects, goto 2
 
 class Autotest
-  
+
+  HOOKS = Hash.new { |h,k| h[k] = [] }
+
   def self.run
     new.run
   end
 
-  ##
-  # Creates a new Autotest.  If @exceptions is set, updated_files will use it
-  # to reject filenames.
+  attr_accessor :exceptions, :files, :files_to_test, :interrupted, :last_mtime, :libs, :output, :tainted
 
   def initialize
-    @interrupt = false
     @files = Hash.new Time.at(0)
-    @exceptions = nil
+    @files_to_test = Hash.new { |h,k| h[k] = [] }
+    @exceptions = false
+    @libs = '.:lib:test'
+    @output = $stderr
+    @sleep = 2
   end
 
-  ##
-  # Consolidates failed tests +failed+ for the same test class into a single
-  # test runner filter.  Also maps failed class to its file regexp.
-
-  def consolidate_failures(failed)
-    filters = Hash.new { |h,k| h[k] = [] }
-
-    failed.each do |method, klass|
-      failed_file = klass.sub('Test', '').gsub(/(.)([A-Z])/, '\1_?\2')
-      filters[failed_file.downcase] << method
+  def run
+    hook :run
+    reset
+    add_sigint_handler
+
+    loop do # ^c handler
+      begin
+        get_to_green
+        rerun_all_tests if @tainted
+        wait_for_changes
+      rescue Interrupt
+        if @wants_to_quit then
+          break
+        else
+          reset
+          hook :interrupt
+        end
+      end
     end
+    hook :quit
+  end
 
-    return filters.map do |klass, methods|
-      ["'/^(#{methods.join('|')})$/'", /#{klass}/]
+  def get_to_green
+    until all_good do
+      run_tests
+      wait_for_changes unless all_good
     end
   end
 
+  def run_tests
+    find_files_to_test # failed + changed/affected
+    cmd = make_test_cmd @files_to_test
 
-  ##
-  # Selects test files to run that match failures in +failed_file+ based on
-  # +updated_files+ and +tests+.
-  #
-  # Only test files matching +failed_file+ will be returned so the test
-  # runner's -n flag will correctly match the failed tests.
-  #--
-  # failed_test_files must never check for updated files, retest_failed reuses
-  # +updated_files+.
-
-  def failed_test_files(failed_file, tests, updated_files)
-    return [] if updated_files.empty?
-
-    updated_tests = updated_files.select { |f| f =~ /^test/ }
+    puts cmd
 
-    tests_to_filter = if updated_files == updated_tests then
-                        updated_tests
-                      else
-                        files = (updated_files + tests).uniq
-                        tests_to_filter = map_file_names(files).flatten.uniq
-                      end
+    @results = `#{cmd}`
+    hook :ran_command
+    puts @results
 
-    return tests_to_filter.select { |test| test =~ failed_file }
+    handle_results(@results)
   end
 
-  ##
-  # Returns a report of remaining failures in +failures+.
+  ############################################################
+  # Utility Methods, not essential to reading of logic
 
-  def failure_report(failed)
-    out = []
-    out << "# failures remain in #{failed.length} files:"
-    failed.each do |filter, failed_test|
-      tests = @files.keys.select { |file| file =~ /^test.*#{failed_test}/ }
-      test = tests.sort_by { |f| f.length }.first
-
-      filter =~ /\((.*)\)/
-      filter = $1.split('|')
-
-      out << "#  #{test}:"
-      out << "#    #{filter.join "\n#    "}"
+  def add_sigint_handler
+    trap 'INT' do
+      if @interrupted then
+        @wants_to_quit = true
+      else
+        puts "Interrupt a second time to quit"
+        @interrupted = true
+        sleep 1.5
+        raise Interrupt                 # let the run loop catch it
+      end
     end
-
-    return out.join("\n")
   end
 
-  ##
-  # Maps implementation files to test files.  Returns an Array of one or more
-  # Arrays of test filenames.
+  def all_good
+    @files_to_test.empty?
+  end
 
-  def map_file_names(updated)
-    tests = []
+  def consolidate_failures(failed)
+    filters = Hash.new { |h,k| h[k] = [] }
 
-    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
+    failed.each do |method, klass|
+      failed_file_name = klass.gsub(/(.)([A-Z])/, '\1_?\2')
+      failed_files = @files.keys.grep(/#{failed_file_name}/i)
+      case failed_files.size
+      when 0 then
+        @output.puts "Unable to map class #{klass} to a file" # FIX for testing
+      when 1 then
+        filters[failed_files.last] << method
       else
-        STDERR.puts "Dunno! #{filename}" if $v or $TESTING
+        @output.puts "multiple files matched class #{klass} #{failed_files.inspect}."
+        # nothing yet
       end
     end
 
-    return [tests]
+    return filters
   end
 
-  ##
-  # Resets all file timestamps in the list
+  def find_files
+    result = {}
+    Find.find '.' do |f|
+      Find.prune if @exceptions and f =~ @exceptions and test ?d, f
+      Find.prune if f =~ /(\.(svn|hg)|CVS|tmp|public|doc|pkg)$/ # prune dirs
 
-  def reset_times
-    ago = Time.at 0
-    @files.each_key { |file| @files[file] = ago }
-  end
+      next if test ?d, f
+      next if f =~ /(swp|~|rej|orig)$/        # temporary/patch files
+      next if f =~ /\/\.?#/                     # Emacs autosave/cvs merge files
 
-  ##
-  # Retests failed tests.
-  #--
-  # Runs through each failure and runs tests matching the failure.  If an
-  # implementation file was updated all failed tests should be run.
-  #
-  # TODO collapse multiple failures in the same file (in test) and use | in
-  # the filter.
-
-  def retest_failed(failed, tests)
-    puts "# Waiting for changes"
-
-    # -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
-
-      updated = updated_files
-
-      # REFACTOR
-      failed.map! do |filter, failed_test|
-        failed_files = failed_test_files failed_test, tests, updated
-        break [filter, failed_test] if failed_files.empty?
-
-        puts "# Rerunning failures: #{failed_files.join ' '}"
-
-        test_filter = " -n #{filter}" unless filter == "'/^(default_test)/'"
-        cmd = "#{ruby} -Ilib:test #{failed_files.join ' '}#{test_filter} | unit_diff -u"
-
-        puts "+ #{cmd}"
-        result = `#{cmd}`
-        puts result
-        status = result.split($/).last
-        rerun = status =~ / 0 failures, 0 errors/ ? nil : [filter, failed_test]
-        puts "# Waiting for changes" if rerun
-        rerun # needed for map!
-      end
+      filename = f.sub(/^\.\//, '')
 
-      puts failure_report(failed) if failed.compact! and not failed.empty?
+      result[filename] = File.stat(filename).mtime
     end
+    return result
   end
 
-  ##
-  # The path to this ruby for running tests.
-
-  def ruby
-    return File.join(Config::CONFIG['bindir'],
-                     Config::CONFIG['ruby_install_name'])
-  end
+  def find_files_to_test(files=find_files)
+    updated = []
 
-  ##
-  # Repeatedly scans for updated files and runs their tests.
+    # TODO: keep an mtime at app level and drop the files hash
+    files.each do |filename, mtime|
+      next if @files[filename] >= mtime
 
-  def run
-    trap 'INT' do
-      if @interrupt then
-        puts "# Ok, you really want to quit, doing so"
-        exit
+      tests_for_file(filename).each do |f|
+        @files_to_test[f] # creates key with default value
       end
-      # STDERR.puts "\t#{caller.join "\n\t"}"
-      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
-      last_update = Time.at 0
-
-      loop do
-        if $vcs and Time.now > last_update + $vcstime then
-          last_update = Time.now
-          case $vcs
-          when 'cvs' then
-            system 'cvs up'
-          when 'p4' then
-            system 'p4 sync'
-          when 'svn' then
-            system 'svn up'
-          else
-            puts "# Sorry, I don't know what version control system \"#{$vcs}\" is"
-          end
-        end
 
-        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
+      @files[filename] = mtime
     end
-  end
-
-  ##
-  # Runs tests for files in +updated+.  Implementation files are looked up
-  # with map_file_names.
-  #
-  # Returns true if any of the tests ever failed.
-
-  def test(updated)
-    ever_failed = false
-
-    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 }' | unit_diff -u"
-      puts "+ #{cmd}"
-      results = `#{cmd}`
-      puts results
-
-      if results =~ / 0 failures, 0 errors\Z/ then
-        puts '# Passed'
-        next
-      end
 
-      ever_failed = true
-
-      failed = results.scan(/^\s+\d+\) (?:Failure|Error):\n(.*?)\((.*?)\)/)
-
-      if failed.empty? then
-        puts '# Test::Unit exited without a parseable failure or error message.'
-        puts '# You probably have a syntax error in your code.'
-        puts '# I\'ll retry in 10 seconds'
-        sleep 10
-        redo
-      end
+    previous = @last_mtime
+    @last_mtime = @files.values.sort.last
+    @last_mtime > previous
+  end
 
-      failed = consolidate_failures(failed)
+  def handle_results(results)
+    failed = results.scan(/^\s+\d+\) (?:Failure|Error):\n(.*?)\((.*?)\)/)
+    @files_to_test = consolidate_failures failed
+    unless @files_to_test.empty? then
+      hook :red
+    else
+      hook :green
+    end unless $TESTING
+    @tainted = true unless @files_to_test.empty?
+  end
 
-      # REFACTOR: I don't think the two routines merit real differences
-      retest_failed failed, tests
+  def make_test_cmd files_to_test
+    cmds = []
+    full, partial = files_to_test.partition { |k,v| v.empty? }
 
-      break
+    unless full.empty? then
+      classes = full.map {|k,v| k}.flatten.join(' ')
+      cmds << "#{ruby} -I#{@libs} -rtest/unit -e \"%w[#{classes}].each { |f| load f }\" | unit_diff -u"
     end
 
-    if ever_failed
-      reset_times
-    else # We'll immediately test everything, so don't print this out.
-      puts '# All passed'
-      puts "# Waiting for changes"
+    partial.each do |klass, methods|
+      cmds << "#{ruby} -I#{@libs} #{klass} -n \"/^(#{Regexp.union(*methods).source})$/\" | unit_diff -u" 
     end
 
-    return ever_failed
+    return cmds.join('; ')
   end
 
-  ##
-  # Returns true or false if the file has been modified or not.  New files are
-  # always modified.
+  def rerun_all_tests
+    reset
+    run_tests
+    hook :all_good if all_good
+  end
 
-  def updated?(file)
-    mtime = File.stat(file).mtime
-    updated = @files[file] < mtime
-    @files[file] = mtime
-    return updated
+  def reset
+    @interrupted = @wants_to_quit = false
+    @files.clear
+    @files_to_test.clear
+    @last_mtime = Time.at(0)
+    find_files_to_test # failed + changed/affected
+    @tainted = false
+    hook :reset
   end
+  
+  def ruby
+    ruby = File.join(Config::CONFIG['bindir'],
+                     Config::CONFIG['ruby_install_name'])
 
-  ##
-  # 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.
+    unless File::ALT_SEPARATOR.nil? then
+      ruby.gsub! File::SEPARATOR, File::ALT_SEPARATOR
+    end
 
-  def updated_files
-    updated = []
+    return ruby
+  end
 
-    Find.find '.' do |f|
-      if @exceptions then
-        if f =~ @exceptions then
-          Find.prune if Kernel.test ?d, f
-          next
-        end
+  def tests_for_file(filename)
+    case filename
+    when /^lib\/.*\.rb$/ then
+      impl = File.basename(filename).gsub '_', '_?'
+      @files.keys.select do |k|
+        k =~ %r%^test/.*#{impl}$%
       end
+    when /^test\/test_.*rb$/ then
+      [filename]
+    else
+      @output.puts "Dunno! #{filename}" if $TESTING
+      []
+    end
+  end
 
-      Find.prune if f =~ /(?:\.svn|CVS)$/       # version control files
-
-      next if File.directory? f
-      next if f =~ /(?:swp|~|rej|orig)$/        # temporary/patch files
-      next if f =~ /\/\.?#/                     # Emacs autosave/cvs merge files
+  def wait_for_changes
+    begin
+      sleep @sleep
+    end until find_files_to_test
+  end
 
-      f = f.sub(/^\.\//, '')
+  ############################################################
+  # Hooks:
 
-      updated << f if updated? f
+  def hook(name)
+    HOOKS[name].each do |plugin|
+      plugin[self]
     end
-
-    return updated
   end
 
+  def self.add_hook(name, &block)
+    HOOKS[name] << block
+  end
 end
 
+if test ?f, './.autotest' then
+  load './.autotest'
+elsif test ?f, File.expand_path('~/.autotest') then
+  load File.expand_path('~/.autotest')
+else
+  puts "couldn't find ./.autotest in #{Dir.pwd}"
+end