grosser-autotest 4.0.3

data/lib/autotest/menu.rb

@@ -0,0 +1,51 @@
+#!/usr/local/bin/ruby -w
+
+module Autotest::Menu
+  WINDOZE = /win32/ =~ RUBY_PLATFORM unless defined? WINDOZE
+
+  if WINDOZE then
+    require "Win32API"
+    def self.getchar
+      Win32API.new("crtdll", "_getch", [], "L").Call
+    end
+  else
+    STTY_SAVE_STATE=`stty -g`
+    def self.getchar
+      system 'stty raw echo'
+      STDIN.getc
+    ensure
+      system "stty '#{STTY_SAVE_STATE}'"
+    end
+  end
+
+  def self.menu(choices)
+    result = nil
+    choices.sort.each do |c, desc|
+      puts "#{c.chr}: #{desc}"
+    end
+    until choices[result]
+      print "menu> "
+      result = getchar
+      print " invalid input" unless choices[result]
+      puts
+    end
+    result
+  end
+
+  Autotest.add_hook(:interrupt) do |at|
+    $stderr.puts "menu"
+    case menu ?q => "quit", ?c => "continue", ?r => "restart"
+    when ?c
+      true
+    when ?r
+      at.reset
+      true
+    when ?q
+      at.wants_to_quit = true
+      true
+    else
+      false
+    end
+    # puts "you chose #{c.chr}"
+  end
+end

data/lib/autotest/migrate.rb

@@ -0,0 +1,7 @@
+# -*- ruby -*-
+
+module Autotest::Migrate
+  Autotest.add_hook(:run) do |autotest|
+    system "rake db:migrate" if autotest.class.to_s == "RailsAutotest"
+  end
+end

data/lib/autotest/notify.rb

@@ -0,0 +1,34 @@
+module Autotest::Notify
+  def self.notify(title, message, priority='critical')
+    icon = if priority == 'critical'
+      'dialog-error'
+    else
+      'dialog-information'
+    end
+    system "notify-send -u #{priority} -t 10000 -i #{icon} '#{title}' '#{message.inspect}'"
+  end
+
+  Autotest.add_hook :red do |at|
+    tests = 0
+    assertions = 0
+    failures = 0
+    errors = 0
+    at.results.scan(/(\d+) tests, (\d+) assertions, (\d+) failures, (\d+) errors/) do |t, a, f, e|
+      tests += t.to_i
+      assertions += a.to_i
+      failures += f.to_i
+      errors += e.to_i
+    end
+    message = "%d tests, %d assertions, %d failures, %d errors" % 
+      [tests, assertions, failures, errors]
+    notify("Tests Failed", message)
+  end
+
+  Autotest.add_hook :green do |at|
+    notify("Tests Passed", "Outstanding tests passed", 'low') if at.tainted
+  end
+
+  Autotest.add_hook :all do |at|_hook
+    notify("autotest", "Tests have fully passed", 'low')
+  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/pretty.rb

@@ -0,0 +1,83 @@
+# -*- ruby -*-
+
+require 'osx/cocoa'
+include Math
+include OSX
+
+OSX::NSBundle.bundleWithPath(File.expand_path("~/Library/Frameworks/Aquaterm.framework")).load
+OSX.ns_import :AQTAdapter
+
+class Autotest::Pretty
+  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.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 = Autotest::Pretty.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/rails.rb

@@ -0,0 +1,81 @@
+require 'autotest'
+
+class Autotest::Rails < Autotest
+
+  def initialize # :nodoc:
+    super
+
+    add_exception %r%^\./(?:db|doc|log|public|script|tmp|vendor)%
+
+    clear_mappings
+
+    self.add_mapping(/^lib\/.*\.rb$/) do |filename, _|
+      impl = File.basename(filename, '.rb')
+      files_matching %r%^test/unit/#{impl}_test.rb$%
+      # TODO: (unit|functional|integration) maybe?
+    end
+
+    add_mapping %r%^test/fixtures/(.*)s.yml% do |_, m|
+      ["test/unit/#{m[1]}_test.rb",
+       "test/controllers/#{m[1]}_controller_test.rb",
+       "test/views/#{m[1]}_view_test.rb",
+       "test/functional/#{m[1]}_controller_test.rb"]
+    end
+
+    add_mapping %r%^test/(unit|integration|controllers|views|functional)/.*rb$% do |filename, _|
+      filename
+    end
+
+    add_mapping %r%^app/models/(.*)\.rb$% do |_, m|
+      "test/unit/#{m[1]}_test.rb"
+    end
+
+    add_mapping %r%^app/helpers/application_helper.rb% do
+      files_matching %r%^test/(views|functional)/.*_test\.rb$%
+    end
+
+    add_mapping %r%^app/helpers/(.*)_helper.rb% do |_, m|
+      if m[1] == "application" then
+        files_matching %r%^test/(views|functional)/.*_test\.rb$%
+      else
+        ["test/views/#{m[1]}_view_test.rb",
+         "test/functional/#{m[1]}_controller_test.rb"]
+      end
+    end
+
+    add_mapping %r%^app/views/(.*)/% do |_, m|
+      ["test/views/#{m[1]}_view_test.rb",
+       "test/functional/#{m[1]}_controller_test.rb"]
+    end
+
+    add_mapping %r%^app/controllers/(.*)\.rb$% do |_, m|
+      if m[1] == "application" then
+        files_matching %r%^test/(controllers|views|functional)/.*_test\.rb$%
+      else
+        ["test/controllers/#{m[1]}_test.rb",
+         "test/functional/#{m[1]}_test.rb"]
+      end
+    end
+
+    add_mapping %r%^app/views/layouts/% do
+      "test/views/layouts_view_test.rb"
+    end
+
+    add_mapping %r%^config/routes.rb$% do # FIX:
+      files_matching %r%^test/(controllers|views|functional)/.*_test\.rb$%
+    end
+
+    add_mapping %r%^test/test_helper.rb|config/((boot|environment(s/test)?).rb|database.yml)% do
+      files_matching %r%^test/(unit|controllers|views|functional)/.*_test\.rb$%
+    end
+  end
+
+  # Convert the pathname s to the name of class.
+  def path_to_classname(s)
+    sep = File::SEPARATOR
+    f = s.sub(/^test#{sep}((unit|functional|integration|views|controllers|helpers)#{sep})?/, '').sub(/\.rb$/, '').split(sep)
+    f = f.map { |path| path.split(/_/).map { |seg| seg.capitalize }.join }
+    f = f.map { |path| path =~ /Test$/ ? path : "#{path}Test"  }
+    f.join('::')
+  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/redgreen.rb

@@ -0,0 +1,21 @@
+# -*- ruby -*-
+
+# special thanks to Pat Eyler, Sean Carley, and Rob Sanheim
+# and to Peter Havens for rspec patches
+module Autotest::RedGreen
+  BAR       = "=" * 78
+  REDCODE   = 31
+  GREENCODE = 32
+
+  Autotest.add_hook :ran_command do |at|
+    green = case at.results.last
+            when /^.* (\d+) failures, (\d+) errors$/   # Test::Unit
+              ($1 == "0" and $2 == "0")
+            when /^\d+\s+examples?,\s+(\d+)\s+failure/ # RSpec
+              ($1 == "0")
+            end
+
+    code = green ? GREENCODE : REDCODE
+    puts "\e[#{ code }m#{ BAR }\e[0m\n\n" unless green.nil?
+  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/shame.rb

@@ -0,0 +1,45 @@
+require 'code_statistics'
+require 'rbosa'
+
+module Autotest::Shame
+  @@chat_app = :adium
+
+  def self.chat_app= o
+    @@chat_app = o
+  end
+
+  # Until the rails team learns how to write modular code... I must steal :/
+  STATS_DIRECTORIES = [
+                       %w(Controllers        app/controllers),
+                       %w(Helpers            app/helpers),
+                       %w(Models             app/models),
+                       %w(Libraries          lib/),
+                       %w(APIs               app/apis),
+                       %w(Components         components),
+                       %w(Integration\ tests test/integration),
+                       %w(Functional\ tests  test/functional),
+                       %w(Unit\ tests        test/unit),
+                      ].select { |name, dir| File.directory?(dir) }
+
+  def self.shame
+    stats = CodeStatistics.new(*STATS_DIRECTORIES)
+    code  = stats.send :calculate_code
+    tests = stats.send :calculate_tests
+    msg = "Code To Test Ratio: 1:#{sprintf("%.2f", tests.to_f/code)}"
+    $-w = ! $-w
+    case @@chat_app
+    when :adium then
+      OSA.app('Adium').adium_controller.my_status_message = msg
+    when :ichat then
+      OSA.app('ichat').status_message = msg
+    else
+      raise "huh?"
+    end
+    $-w = ! $-w
+    $stderr.puts "Status set to: #{msg.inspect}"
+  end
+
+  Autotest.add_hook(:all_good) do |autotest|
+    shame
+  end
+end

data/lib/autotest/snarl.rb

@@ -0,0 +1,51 @@
+# special thanks to: Patrick Hurley <phurley@gmail.com>
+# requires the ruby-snarl gem.
+
+begin require 'rubygems'; rescue LoadError; end
+require 'snarl'
+
+module Autotest::Snarl  
+  def self.icon
+    # icons from http://www.famfamfam.com/lab/icons/silk/
+    path = File.join(File.dirname(__FILE__), "/../icons")
+    {
+      :green => "#{path}/accept.png",
+      :red    => "#{path}/exclamation.png",
+      :info   => "#{path}/information.png"
+    }
+  end
+  
+  def self.snarl title, msg, ico = nil
+    Snarl.show_message(title, msg, icon[ico])
+  end
+
+  Autotest.add_hook :run do  |at|
+    snarl "Run", "Run" unless $TESTING
+  end
+
+  Autotest.add_hook :red do |at|
+    failed_tests = at.files_to_test.inject(0){ |s,a| k,v = a;  s + v.size}
+    snarl "Tests Failed", "#{failed_tests} tests failed", :red
+  end
+
+  Autotest.add_hook :green do |at|
+    snarl "Tests Passed", "All tests passed", :green #if at.tainted 
+  end
+
+  Autotest.add_hook :run do |at|
+    snarl "autotest", "autotest was started", :info unless $TESTING
+  end
+
+  Autotest.add_hook :interrupt do |at|
+    snarl "autotest", "autotest was reset", :info unless $TESTING
+  end
+
+  Autotest.add_hook :quit do |at|
+    snarl "autotest", "autotest is exiting", :info unless $TESTING
+  end
+
+  Autotest.add_hook :all do |at|_hook
+    snarl "autotest", "Tests have fully passed", :green unless $TESTING
+  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