autotest 4.1.4

data/lib/autotest/autoupdate.rb

@@ -0,0 +1,26 @@
+module Autotest::AutoUpdate
+  @@sleep_time, @@update_cmd, @@updater = 60, "svn up", nil
+
+  def self.sleep_time= o
+    @@sleep_time = o
+  end
+
+  def self.update_cmd= o
+    @@update_cmd = o
+  end
+
+  Autotest.add_hook :run_command do  |at|
+    @@updater.kill if @@updater
+  end
+
+  Autotest.add_hook :ran_command do  |at|
+    @@updater = Thread.start do
+      loop do
+        puts "# Waiting for #{@@sleep_time} seconds before updating"
+        sleep @@sleep_time
+        puts "# Running #{@@update_cmd}"
+        system @@update_cmd
+      end
+    end
+  end
+end

data/lib/autotest/once.rb

@@ -0,0 +1,9 @@
+##
+# this is for autotest plugin developers only...
+
+module Autotest::Once
+  Autotest.add_hook :ran_command do |at|
+    exit 0
+  end
+end
+

data/lib/autotest/rcov.rb

@@ -0,0 +1,22 @@
+module Autotest::RCov
+  @@command, @@pattern = "rcov", "test/*.rb"
+
+  def self.command= o
+    @@command = o
+  end
+
+  def self.pattern= o
+    @@pattern = o
+  end
+
+  Autotest.add_hook :all_good do |at|
+    system "rake #{@@command} PATTERN=#{@@pattern}"
+  end
+
+  Autotest.add_hook :initialize do |at|
+    at.add_exception 'coverage'
+    at.add_exception 'coverage.info'
+    false
+  end
+end
+

data/lib/autotest/restart.rb

@@ -0,0 +1,11 @@
+module Autotest::Restart
+  Autotest.add_hook :updated do |at, *args|
+    if args.flatten.include? ".autotest" then
+      warn "Detected change to .autotest, restarting"
+      cmd = "autotest"
+      cmd << " -v" if $v
+      
+      exec cmd
+    end
+  end
+end

data/lib/autotest/timestamp.rb

@@ -0,0 +1,9 @@
+# -*- ruby -*-
+
+module Autotest::Timestamp
+  Autotest.add_hook :waiting do
+    puts
+    puts "# Waiting since #{Time.now.strftime "%Y-%m-%d %H:%M:%S"}"
+    puts
+  end
+end

data/lib/unit_diff.rb

@@ -0,0 +1,258 @@
+require 'tempfile'
+
+##
+# 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
+
+  WINDOZE = /win32/ =~ RUBY_PLATFORM unless defined? WINDOZE
+  DIFF = if WINDOZE
+           'diff.exe'
+         else
+           if system("gdiff", __FILE__, __FILE__)
+             'gdiff' # solaris and kin suck
+           else
+             'diff'
+           end
+         end unless defined? DIFF
+
+  ##
+  # Handy wrapper for UnitDiff#unit_diff.
+
+  def self.unit_diff
+    trap 'INT' do exit 1 end
+    puts UnitDiff.new.unit_diff
+  end
+
+  def parse_input(input, output)
+    current = []
+    data = []
+    data << current
+    print_lines = true
+
+    term = "\nFinished".split(//).map { |c| c[0] }
+    term_length = term.size
+
+    old_sync = output.sync
+    output.sync = true
+    while line = input.gets
+      case line
+      when /^(Loaded suite|Started)/ then
+        print_lines = true
+        output.puts line
+        chars = []
+        while c = input.getc do
+          output.putc c
+          chars << c
+          tail = chars[-term_length..-1]
+          break if chars.size >= term_length and tail == term
+        end
+        output.puts input.gets # the rest of "Finished in..."
+        output.puts
+       next
+      when /^\s*$/, /^\(?\s*\d+\) (Failure|Error):/, /^\d+\)/ then
+        print_lines = false
+        current = []
+        data << current
+      when /^Finished in \d/ then
+        print_lines = false
+      end
+      output.puts line if print_lines
+      current << line
+    end
+    output.sync = old_sync
+    data = data.reject { |o| o == ["\n"] or o.empty? }
+    footer = data.pop
+
+    return data, footer
+  end
+
+  # Parses a single diff recording the header and what
+  # was expected, and what was actually obtained.
+  def parse_diff(result)
+    header = []
+    expect = []
+    butwas = []
+    footer = []
+    found = false
+    state = :header
+
+    until result.empty? do
+      case state
+      when :header then
+        header << result.shift
+        state = :expect if result.first =~ /^<|^Expected/
+      when :expect then
+        case result.first
+        when /^Expected (.*?) to equal (.*?):$/ then
+          expect << $1
+          butwas << $2
+          state = :footer
+          result.shift
+        when /^Expected (.*?), not (.*)$/m then
+          expect << $1
+          butwas << $2
+          state = :footer
+          result.shift
+        when /^Expected (.*?)$/ then
+          expect << "#{$1}\n"
+          result.shift
+        when /^to equal / then
+          state = :spec_butwas
+          bw = result.shift.sub(/^to equal (.*):?$/, '\1')
+          butwas << bw
+        else
+          state = :butwas if result.first.sub!(/ expected( but was|, not)/, '')
+          expect << result.shift
+        end
+      when :butwas then
+        butwas = result[0..-1]
+        result.clear
+      when :spec_butwas then
+        if result.first =~ /^\s+\S+ at |^:\s*$/
+          state = :footer
+        else
+          butwas << result.shift
+        end
+      when :footer then
+        butwas.last.sub!(/:$/, '')
+        footer = result.map {|l| l.chomp }
+        result.clear
+      else
+        raise "unknown state #{state}"
+      end
+    end
+
+    return header, expect, nil, footer 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, footer
+  end
+
+  ##
+  # Scans Test::Unit output +input+ looking for comparison failures and makes
+  # them easily readable by passing them through diff.
+
+  def unit_diff(input=ARGF, output=$stdout)
+    $b = false unless defined? $b
+    $c = false unless defined? $c
+    $k = false unless defined? $k
+    $u = false unless defined? $u
+
+    data, footer = self.parse_input(input, output)
+
+    output = []
+
+    # Output
+    data.each do |result|
+      first = []
+      second = []
+
+      if result.first =~ /Error/ then
+        output.push result.join('')
+        next
+      end
+
+      prefix, expect, butwas, result_footer = parse_diff(result)
+
+      output.push prefix.compact.map {|line| line.strip}.join("\n")
+
+      if butwas then
+        output.push self.diff(expect, butwas)
+
+        output.push result_footer
+        output.push ''
+      else
+        output.push expect.join('')
+      end
+    end
+
+    if footer then
+      footer.shift if footer.first.strip.empty?# unless footer.first.nil?
+      output.push footer.compact.map {|line| line.strip}.join("\n")
+    end
+
+    return output.flatten.join("\n")
+  end
+
+  def diff expect, butwas
+    output = nil
+
+    Tempfile.open("expect") do |a|
+      a.write(massage(expect))
+      a.rewind
+      Tempfile.open("butwas") do |b|
+        b.write(massage(butwas))
+        b.rewind
+
+        diff_flags = $u ? "-u" : $c ? "-c" : ""
+        diff_flags += " -b" if $b
+
+        result = `#{DIFF} #{diff_flags} #{a.path} #{b.path}`
+        output = if result.empty? then
+                   "[no difference--suspect ==]"
+                 else
+                   result.split(/\n/)
+                 end
+
+        if $k then
+          warn "moving #{a.path} to #{a.path}.keep"
+          File.rename a.path, a.path + ".keep"
+          warn "moving #{b.path} to #{b.path}.keep"
+          File.rename b.path, b.path + ".keep"
+        end
+      end
+    end
+
+    output
+  end
+
+  def massage(data)
+    count = 0
+    # unescape newlines, strip <> from entire string
+    data = data.join
+    data = data.gsub(/\\n/, "\n").gsub(/0x[a-f0-9]+/m, '0xXXXXXX') + "\n"
+    data += "\n" unless data[-1] == ?\n
+    data
+  end
+end

data/test/helper.rb

@@ -0,0 +1,6 @@
+$LOAD_PATH << File.join(File.dirname('..'),'lib')
+$TESTING = true
+
+require 'stringio'
+require 'rubygems'
+require 'test/unit'

data/test/test_autotest.rb

@@ -0,0 +1,464 @@
+require 'test/helper'
+require 'autotest'
+
+
+# NOT TESTED:
+#   class_run
+#   add_sigint_handler
+#   all_good
+#   get_to_green
+#   reset
+#   ruby
+#   run
+#   run_tests
+
+class Autotest
+  attr_reader :test_mappings, :exception_list
+
+  def self.clear_hooks
+    HOOKS.clear
+  end
+end
+
+class TestAutotest < Test::Unit::TestCase
+
+  def deny test, msg=nil
+    if msg then
+      assert ! test, msg
+    else
+      assert ! test
+    end
+  end unless respond_to? :deny
+
+  RUBY = File.join(Config::CONFIG['bindir'], Config::CONFIG['ruby_install_name']) unless defined? RUBY
+
+  def setup
+    @test_class = 'TestBlah'
+    @test = 'test/test_blah.rb'
+    @other_test = 'test/test_blah_other.rb'
+    @impl = 'lib/blah.rb'
+    @inner_test = 'test/outer/test_inner.rb'
+    @outer_test = 'test/test_outer.rb'
+    @inner_test_class = "TestOuter::TestInner"
+
+    klassname = self.class.name.sub(/^Test/, '')
+    klassname.sub!(/^(\w+)(Autotest)$/, '\2::\1') unless klassname == "Autotest"
+    @a = klassname.split(/::/).inject(Object) { |k,n| k.const_get(n) }.new
+    @a.output = StringIO.new
+    @a.last_mtime = Time.at(2)
+
+    @files = {}
+    @files[@impl] = Time.at(1)
+    @files[@test] = Time.at(2)
+
+    @a.find_order = @files.keys.sort
+  end
+
+  def test_add_exception
+    current = util_exceptions
+    @a.add_exception 'blah'
+
+    actual = util_exceptions
+    expect = current + ["blah"]
+
+    assert_equal expect, actual
+  end
+
+  def test_add_mapping
+    current = util_mappings
+    @a.add_mapping(/blah/) do 42 end
+
+    actual = util_mappings
+    expect = current + [/blah/]
+
+    assert_equal expect, actual
+  end
+
+  def test_add_mapping_front
+    current = util_mappings
+    @a.add_mapping(/blah/, :front) do 42 end
+
+    actual = util_mappings
+    expect = [/blah/] + current
+
+    assert_equal expect, actual
+  end
+
+  def test_clear_exceptions
+    test_add_exception
+    @a.clear_exceptions
+
+    actual = util_exceptions
+    expect = []
+
+    assert_equal expect, actual
+  end
+
+  def test_clear_mapping
+    @a.clear_mappings
+
+    actual = util_mappings
+    expect = []
+
+    assert_equal expect, actual
+  end
+
+  def test_consolidate_failures_experiment
+    @files.clear
+    @files[@impl] = Time.at(1)
+    @files[@test] = Time.at(2)
+
+    @a.find_order = @files.keys.sort
+
+    input = [['test_fail1', @test_class], ['test_fail2', @test_class], ['test_error1', @test_class], ['test_error2', @test_class]]
+    result = @a.consolidate_failures input
+    expected = { @test => %w( test_fail1 test_fail2 test_error1 test_error2 ) }
+    assert_equal expected, result
+  end
+
+  def test_consolidate_failures_green
+    result = @a.consolidate_failures([])
+    expected = {}
+    assert_equal expected, result
+  end
+
+  def test_consolidate_failures_multiple_possibilities
+   @files[@other_test] = Time.at(42)
+    result = @a.consolidate_failures([['test_unmatched', @test_class]])
+    expected = { @test => ['test_unmatched']}
+    assert_equal expected, result
+    expected = ""
+    assert_equal expected, @a.output.string
+  end
+
+  def test_consolidate_failures_nested_classes
+    @files.clear
+    @files['lib/outer.rb'] = Time.at(5)
+    @files['lib/outer/inner.rb'] = Time.at(5)
+    @files[@inner_test] = Time.at(5)
+    @files[@outer_test] = Time.at(5)
+
+    @a.find_order = @files.keys.sort
+
+    result = @a.consolidate_failures([['test_blah1', @inner_test_class]])
+    expected = { @inner_test => ['test_blah1'] }
+    assert_equal expected, result
+    expected = ""
+    assert_equal expected, @a.output.string
+  end
+
+  def test_consolidate_failures_no_match
+    result = @a.consolidate_failures([['test_blah1', @test_class], ['test_blah2', @test_class], ['test_blah1', 'TestUnknown']])
+    expected = {@test => ['test_blah1', 'test_blah2']}
+    assert_equal expected, result
+    expected = "Unable to map class TestUnknown to a file\n"
+    assert_equal expected, @a.output.string
+  end
+
+  def test_consolidate_failures_red
+    result = @a.consolidate_failures([['test_blah1', @test_class], ['test_blah2', @test_class]])
+    expected = {@test => ['test_blah1', 'test_blah2']}
+    assert_equal expected, result
+  end
+
+  def test_exceptions
+    @a.clear_exceptions
+    test_add_exception
+    assert_equal(/blah/, @a.exceptions)
+  end
+
+  def test_exceptions_nil
+    @a.clear_exceptions
+    assert_nil @a.exceptions
+  end
+
+  # TODO: lots of filename edgecases for find_files_to_test
+  def test_find_files_to_test
+    @a.last_mtime = Time.at(0)
+    assert @a.find_files_to_test(@files)
+
+    @a.last_mtime = @files.values.sort.last + 1
+    deny @a.find_files_to_test(@files)
+  end
+
+  def test_find_files_to_test_dunno
+    empty = {}
+
+    files = { "fooby.rb" => Time.at(42) }
+    assert @a.find_files_to_test(files)  # we find fooby,
+    assert_equal empty, @a.files_to_test # but it isn't something to test
+    assert_equal "No tests matched fooby.rb\n", @a.output.string
+  end
+
+  def test_find_files_to_test_lib
+    # ensure we add test_blah.rb when blah.rb updates
+    util_find_files_to_test(@impl, @test => [])
+  end
+
+  def test_find_files_to_test_no_change
+    empty = {}
+
+    # ensure world is virginal
+    assert_equal empty, @a.files_to_test
+
+    # ensure we do nothing when nothing changes...
+    files = { @impl => @files[@impl] } # same time
+    deny @a.find_files_to_test(files)
+    assert_equal empty, @a.files_to_test
+    assert_equal "", @a.output.string
+
+    files = { @impl => @files[@impl] } # same time
+    assert(! @a.find_files_to_test(files))
+    assert_equal empty, @a.files_to_test
+    assert_equal "", @a.output.string
+  end
+
+  def test_find_files_to_test_test
+    # ensure we add test_blah.rb when test_blah.rb itself updates
+    util_find_files_to_test(@test, @test => [])
+  end
+
+  def test_reorder_alpha
+    @a.order = :alpha
+    expected = @files.sort
+
+    assert_equal expected, @a.reorder(@files)
+  end
+
+  def test_reorder_reverse
+    @a.order = :reverse
+    expected = @files.sort.reverse
+
+    assert_equal expected, @a.reorder(@files)
+  end
+
+  def test_reorder_random
+    @a.order = :random
+
+    srand 42
+    expected, size = @files.dup, @files.size
+    expected = expected.sort_by { rand(size) }
+
+    srand 42
+    result = @a.reorder(@files.dup)
+
+    assert_equal expected, result
+  end
+
+  def test_reorder_natural
+    srand 42
+
+    @files['lib/untested_blah.rb'] = Time.at(2)
+    @a.find_order = @files.keys.sort_by { rand }
+
+    @a.order = :natural
+    expected = @a.find_order.map { |f| [f, @files[f]] }
+
+    assert_equal expected, @a.reorder(@files)
+  end
+
+  def test_handle_results
+    @a.files_to_test.clear
+    @files.clear
+    @files[@impl] = Time.at(1)
+    @files[@test] = Time.at(2)
+
+    @a.find_order = @files.keys.sort
+
+    empty = {}
+    assert_equal empty, @a.files_to_test, "must start empty"
+
+    s1 = "Loaded suite -e
+Started
+............
+Finished in 0.001655 seconds.
+
+12 tests, 18 assertions, 0 failures, 0 errors
+"
+
+    @a.handle_results(s1)
+    assert_equal empty, @a.files_to_test, "must stay empty"
+
+    s2 = "
+  1) Failure:
+test_fail1(#{@test_class}) [#{@test}:59]:
+  2) Failure:
+test_fail2(#{@test_class}) [#{@test}:60]:
+  3) Error:
+test_error1(#{@test_class}):
+  3) Error:
+test_error2(#{@test_class}):
+
+12 tests, 18 assertions, 2 failures, 2 errors
+"
+
+    @a.handle_results(s2)
+    expected = { @test => %w( test_fail1 test_fail2 test_error1 test_error2 ) }
+    assert_equal expected, @a.files_to_test
+    assert @a.tainted
+
+    @a.handle_results(s1)
+    assert_equal empty, @a.files_to_test
+
+    s3 = '
+/opt/bin/ruby -I.:lib:test -rubygems -e "%w[test/unit #{@test}].each { |f| require f }" | unit_diff -u
+-e:1:in `require\': ./#{@test}:23: parse error, unexpected tIDENTIFIER, expecting \'}\' (SyntaxError)
+    settings_fields.each {|e| assert_equal e, version.send e.intern}
+                                                            ^   from -e:1
+        from -e:1:in `each\'
+        from -e:1
+'
+    @a.files_to_test[@test] = Time.at(42)
+    @files[@test] = []
+    expected = { @test => Time.at(42) }
+    assert_equal expected, @a.files_to_test
+    @a.handle_results(s3)
+    assert_equal expected, @a.files_to_test
+    assert @a.tainted
+    @a.tainted = false
+
+    @a.handle_results(s1)
+    assert_equal empty, @a.files_to_test
+    deny @a.tainted
+  end
+
+  def test_hook_overlap_returning_false
+    util_reset_hooks_returning false
+
+    @a.hook :blah
+
+    assert @a.instance_variable_get(:@blah1), "Hook1 should work on blah"
+    assert @a.instance_variable_get(:@blah2), "Hook2 should work on blah"
+    assert @a.instance_variable_get(:@blah3), "Hook3 should work on blah"
+  end
+
+  def test_hook_overlap_returning_true
+    util_reset_hooks_returning true
+
+    @a.hook :blah
+
+    assert @a.instance_variable_get(:@blah1), "Hook1 should work on blah"
+    deny @a.instance_variable_get(:@blah2), "Hook2 should NOT work on blah"
+    deny @a.instance_variable_get(:@blah3), "Hook3 should NOT work on blah"
+  end
+
+  def test_hook_response
+    Autotest.clear_hooks
+    deny @a.hook(:blah)
+
+    Autotest.add_hook(:blah) { false }
+    deny @a.hook(:blah)
+
+    Autotest.add_hook(:blah) { false }
+    deny @a.hook(:blah)
+
+    Autotest.add_hook(:blah) { true  }
+    assert @a.hook(:blah)
+  end
+
+  def test_make_test_cmd
+    f = {
+      @test => [],
+      'test/test_fooby.rb' => [ 'test_something1', 'test_something2' ]
+    }
+
+    expected = [ "#{RUBY} -I.:lib:test -rubygems -e \"%w[test/unit #{@test}].each { |f| require f }\" | unit_diff -u",
+                 "#{RUBY} -I.:lib:test -rubygems test/test_fooby.rb -n \"/^(test_something1|test_something2)$/\" | unit_diff -u" ].join("; ")
+
+    result = @a.make_test_cmd f
+    assert_equal expected, result
+  end
+
+  def test_path_to_classname
+    # non-rails
+    util_path_to_classname 'TestBlah', 'test/test_blah.rb'
+    util_path_to_classname 'TestOuter::TestInner', 'test/outer/test_inner.rb'
+    util_path_to_classname 'TestRuby2Ruby', 'test/test_ruby2ruby.rb'
+  end
+
+  def test_remove_exception
+    test_add_exception
+    current = util_exceptions
+    @a.remove_exception 'blah'
+
+    actual = util_exceptions
+    expect = current - ["blah"]
+
+    assert_equal expect, actual
+  end
+
+  def test_remove_mapping
+    current = util_mappings
+    @a.remove_mapping(/^lib\/.*\.rb$/)
+
+    actual = util_mappings
+    expect = current - [/^lib\/.*\.rb$/]
+
+    assert_equal expect, actual
+  end
+
+  def test_test_files_for
+    assert_equal [@test], @a.test_files_for(@impl)
+    assert_equal [@test], @a.test_files_for(@test)
+
+    assert_equal [], @a.test_files_for('test/test_unknown.rb')
+    assert_equal [], @a.test_files_for('lib/unknown.rb')
+    assert_equal [], @a.test_files_for('unknown.rb')
+    assert_equal [], @a.test_files_for('test_unknown.rb')
+  end
+
+  def test_testlib
+    assert_equal "test/unit", @a.testlib
+
+    @a.testlib = "MONKEY"
+    assert_equal "MONKEY", @a.testlib
+
+    f = { @test => [], "test/test_fooby.rb" => %w(first second) }
+    assert_match @a.testlib, @a.make_test_cmd(f)
+  end
+
+  def util_exceptions
+    @a.exception_list.sort_by { |r| r.to_s }
+  end
+
+  def util_find_files_to_test(f, expected)
+    t = @a.last_mtime
+    files = { f => t + 1 }
+
+    assert @a.find_files_to_test(files)
+    assert_equal expected, @a.files_to_test
+    assert_equal t, @a.last_mtime
+    assert_equal "", @a.output.string
+  end
+
+  def util_mappings
+    @a.test_mappings.map { |k,v| k }
+  end
+
+  def util_path_to_classname(e,i)
+    assert_equal e, @a.path_to_classname(i)
+  end
+
+  def util_reset_hooks_returning val
+    Autotest.clear_hooks
+
+    @a.instance_variable_set :@blah1, false
+    @a.instance_variable_set :@blah2, false
+    @a.instance_variable_set :@blah3, false
+
+    Autotest.add_hook(:blah) do |at|
+      at.instance_variable_set :@blah1, true
+      val
+    end
+
+    Autotest.add_hook(:blah) do |at|
+      at.instance_variable_set :@blah2, true
+      val
+    end
+
+    Autotest.add_hook(:blah) do |at|
+      at.instance_variable_set :@blah3, true
+      val
+    end
+  end
+end