test-loop 5.0.3 → 6.0.0

data/README.md

@@ -14,6 +14,17 @@ test files in your test suite correspond to those changes, and uses diffing to
 find and run only those test blocks that have changed inside your test files.
 
 
+> IMPORTANT note for Ruby on Rails users!
+> ---------------------------------------
+>
+> Ensure that your `config/environments/test.rb` file disables class caching:
+>
+>     config.cache_classes = false
+>
+> Otherwise, test-loop will appear to ignore class-level changes in your
+> models, controllers, etc. and will thereby cause you great frustration!
+
+
 Features
 --------
 
@@ -76,76 +87,79 @@ Configuration
 -------------
 
 test-loop looks for a configuration file named `.test-loop` in the current
-working directory.  This configuration file is a normal Ruby file whose last
-statement yields a hash that may optionally contain the following entries:
+working directory.  This configuration file is a normal Ruby script, in which
+you can query and modify the `$test_loop_config` OpenStruct object as follows:
+
+* `$test_loop_config.overhead_file_globs` is an array of file globbing
+  patterns that describe a set of Ruby scripts that are loaded into the main
+  Ruby process as overhead.
+
+* `$test_loop_config.reabsorb_file_globs` is an array of file globbing
+  patterns that describe a set of files which cause the overhead to be
+  reabsorbed whenever they change.
+
+* `$test_loop_config.test_file_matchers` is a hash that maps a file globbing
+  pattern describing a set of source files to a lambda function yielding a
+  file globbing pattern describing a set of test files that need to be run.
+  In other words, whenever the source files (the hash key; left-hand side of
+  the mapping) change, their associated test files (the hash value; right-hand
+  side of the mapping) are run.
 
-* `:overhead_file_globs` is an array of file globbing patterns that describe a
-  set of Ruby scripts that are loaded into the main Ruby process as overhead.
+  For example, if test files had the same names as their source files but the
+  letters were in reverse order like this:
 
-* `:reabsorb_file_globs` is an array of file globbing patterns that describe a
-  set of files which cause the overhead to be reabsorbed whenever they change.
+  * lib/hello.rb => test/olleh.rb
+  * app/world.rb => spec/ldrow.rb
 
-* `:test_file_matchers` is a hash that maps a file globbing pattern
-  describing a set of source files to a lambda function yielding a file
-  globbing pattern describing a set of test files that need to be run.  In
-  other words, whenever the source files (the hash key; left-hand side of the
-  mapping) change, their associated test files (the hash value; right-hand
-  side of the mapping) are run.
+  Then you would add the following to your configuration file:
 
-  For example, if test files had the same names as their source files but the
-  letters were in reverse order, then you would add the following hash entry
-  to your configuration file:
-
-      :test_file_matchers => {
-        '{lib,app}/**/*.rb' => lambda do |path|
-          extn = File.extname(path)
-          name = File.basename(path, extn)
-          "{test,spec}/**/#{name.reverse}#{extn}" # <== notice the reverse()
-        end
-      }
+      $test_loop_config.test_file_matchers['{lib,app}/**/*.rb'] = lambda do |path|
+        extn = File.extname(path)
+        name = File.basename(path, extn)
+        "{test,spec}/**/#{name.reverse}#{extn}" # <== notice the reverse()
+      end
 
-* `:test_name_parser` is a lambda function that is passed a line of source
-  code to determine whether that line can be considered as a test definition,
-  in which case it must return the name of the test being defined.
+* `$test_loop_config.test_name_parser` is a lambda function that is passed a
+  line of source code to determine whether that line can be considered as a
+  test definition, in which case it must return the name of the test being
+  defined.
 
-* `:before_each_test` is a lambda function that is executed inside the worker
-  process before loading the test file.  It is passed the path to the test
-  file and the names of tests (identified by `@test_name_parser`) inside the
-  test file that have changed since the last time the test file was run.
+* `$test_loop_config.before_each_test` is a lambda function that is executed
+  inside the worker process before loading the test file.  It is passed (1)
+  the path to the test file and (2) the names of tests (which were identified
+  by `$test_loop_config.test_name_parser`) inside the test file that have
+  changed since the last time the test file was run.
 
   These test names should be passed down to your chosen testing library,
   instructing it to skip all other tests except those passed down to it.  This
   accelerates your test-driven development cycle and improves productivity!
 
-* `@after_all_tests` is a lambda function that is executed inside the master
-  process after all tests have finished running.  It is passed four things:
-  whether all tests had passed, the time when test execution began, a list of
-  test files, and the exit statuses of the worker processes that ran them.
+* `$test_loop_config.after_all_tests` is a lambda function that is executed
+  inside the master process after all tests have finished running.  It is
+  passed (1) a list of passing test files along with the exit statuses of the
+  worker processes that ran them, (2) a list of failing test files along with
+  the exit statuses of the worker processes that ran them, (3) the time when
+  test execution began, and (4) how many seconds it took for the overall test
+  execution to complete.
 
   For example, to display a summary of the test execution results as an OSD
-  notification via libnotify, add the following hash entry to your
-  configuration file:
-
-      :after_all_tests => lambda do |success, ran_at, files, statuses|
-        icon = success ? 'apple-green' : 'apple-red'
-        title = "#{success ? 'PASS' : 'FAIL'} at #{ran_at}"
-        details = files.zip(statuses).map do |file, status|
-          "#{status.success? ? '✔' : '✘'} #{file}"
-        end
-        system 'notify-send', '-i', icon, title, details.join("\n")
-      end
+  notification, add the following to your configuration file:
 
-  Also add the following at the top of the file if you use Ruby 1.9.x:
+      $test_loop_config.after_all_tests = lambda do |passes, fails, started_at, elapsed_time|
+        success = fails.empty?
 
-      # encoding: utf-8
+        title = started_at.strftime("#{success ? 'PASS' : 'FAIL'} at %X on %x")
 
-  That will prevent the following errors from occurring:
+        message = '%d ran, %d passed, %d failed in %0.1f seconds' %
+          [passes.length + fails.length, passes.length, fails.length, elapsed_time]
 
-      invalid multibyte char (US-ASCII)
-
-      syntax error, unexpected $end, expecting ':'
-      "#{status.success? ? '✔' : '✘'} #{file}"
-                            ^
+        Thread.new do # launch in background
+          system 'notify-send', '-i', "dialog-#{success ? 'information' : 'error'}", title, message or
+          system 'growlnotify', '-a', 'Xcode', '-m', message, title or
+          system 'xmessage', '-timeout', '5', '-title', title, message or
+          puts title, message
+        end
+      end
 
 
 License

data/bin/test-loop

@@ -24,24 +24,21 @@
 
 process_invocation_vector = [$0, *ARGV].map! {|s| s.dup }
 
+require 'ostruct'
 require 'diff/lcs'
 
 begin
   notify = lambda {|message| puts "test-loop: #{message}" }
 
-  # load user's configuration and supply default values
-  notify.call 'Loading configuration...'
-  config_file = File.join(Dir.pwd, '.test-loop')
-  config_data = File.read(config_file) if File.exist? config_file
-  config = eval(config_data.to_s, TOPLEVEL_BINDING, config_file) || {}
+  # supply default configuration
+  config = $test_loop_config = OpenStruct.new
 
-  (config[:overhead_file_globs] ||= []).
-    push('{test,spec}/*{test,spec}_helper.rb').uniq!
+  config.overhead_file_globs = ['{test,spec}/{test,spec}_helper.rb']
 
-  (config[:reabsorb_file_globs] ||= []).concat(config[:overhead_file_globs]).
-    push(config_file, 'config/*.{rb,yml}', 'Gemfile.lock').uniq!
+  config.reabsorb_file_globs = config.overhead_file_globs +
+    ['config/*.{rb,yml}', 'Gemfile.lock', '.test-loop']
 
-  (config[:test_file_matchers] ||= {}).merge!(
+  config.test_file_matchers = {
     # source files that correspond to test files
     '{lib,app}/**/*.rb' => lambda do |path|
       extn = File.extname(path)
@@ -51,16 +48,16 @@ begin
 
     # the actual test files themselves
     '{test,spec}/**/*_{test,spec}.rb' => lambda {|path| path }
-  )
+  }
 
-  config[:test_name_parser] ||= lambda do |line|
+  config.test_name_parser = lambda do |line|
     case line
     when /^\s*def\s+test_(\w+)/ then $1
     when /^\s*(test|context|should|describe|it)\b.+?(['"])(.*?)\2/ then $3
     end
   end
 
-  config[:before_each_test] ||= lambda do |test_file, test_names|
+  config.before_each_test = lambda do |test_file, test_names|
     unless test_names.empty?
       test_name_pattern = test_names.map do |name|
         # sanitize string interpolation and non-method-name characters
@@ -68,23 +65,27 @@ begin
       end.join('|')
 
       case File.basename(test_file)
-
       when /(\b|_)test(\b|_)/ # Test::Unit
         ARGV.push '--name', "/#{test_name_pattern}/"
-
       when /(\b|_)spec(\b|_)/ # RSpec
         ARGV.push '--example', test_name_pattern
       end
     end
   end
 
-  config[:after_all_tests] ||= lambda {|success, ran_at, files, statuses|}
+  config.after_all_tests = lambda {|passes, fails, started_at, elapsed_time|}
+
+  # load user's configuration overrides
+  if File.exist? config_file = File.join(Dir.pwd, '.test-loop')
+    notify.call 'Loading configuration...'
+    load config_file
+  end
 
   # absorb test execution overhead into master process
   $LOAD_PATH.unshift 'lib', 'test', 'spec'
 
   notify.call 'Absorbing overhead...'
-  Dir[*config[:overhead_file_globs]].each do |file|
+  Dir[*config.overhead_file_globs].each do |file|
     require File.basename(file, File.extname(file))
   end
 
@@ -97,7 +98,7 @@ begin
   notify.call 'Ready for testing!'
   loop do
     # figure out what test files need to be run
-    test_files = config[:test_file_matchers].map do |source_glob, test_matcher|
+    test_files = config.test_file_matchers.map do |source_glob, test_matcher|
       Dir[source_glob].select {|file| File.mtime(file) > last_ran_at }.
       map {|path| Dir[test_matcher.call path] }
     end.flatten.uniq
@@ -120,14 +121,14 @@ begin
               # search backwards from the line that changed up to
               # the first line in the file for test definitions
               change.position.downto(0) do |i|
-                if test_name = config[:test_name_parser].call(new_lines[i])
+                if test_name = config.test_name_parser.call(new_lines[i])
                   throw :found, test_name
                 end
               end; nil # prevent unsuccessful search from returning an integer
             end
           end.compact.uniq
 
-          config[:before_each_test].call test_file, test_names
+          config.before_each_test.call test_file, test_names
 
           load test_file
 
@@ -139,20 +140,21 @@ begin
       end
 
       # wait for worker processes to finish and report results
-      statuses = Process.waitall.map {|pid, status| status }
+      test_runs = Process.waitall.map {|pid, status| status }
+      elapsed_time = Time.now - last_ran_at
 
-      success = true
-      test_files.zip(statuses).each do |file, status|
-        success &&= test_passed = status.success?
-        notify.call "#{test_passed ? 'PASS' : 'FAIL'} #{file}"
-      end
-      notify.call "Ran in #{Time.now - last_ran_at} seconds"
+      passes, fails = test_files.zip(test_runs).each do |file, run|
+        notify.call "#{run.success? ? 'PASS' : 'FAIL'} #{file}"
+      end.partition {|file, run| run.success? }
+
+      notify.call '%d ran, %d passed, %d failed in %0.1f seconds' %
+        [test_runs.length, passes.length, fails.length, elapsed_time]
 
-      config[:after_all_tests].call success, last_ran_at, test_files, statuses
+      config.after_all_tests.call passes, fails, last_ran_at, elapsed_time
     end
 
     # reabsorb test execution overhead as necessary
-    if Dir[*config[:reabsorb_file_globs]].any? {|file| File.mtime(file) > started_at }
+    if Dir[*config.reabsorb_file_globs].any? {|file| File.mtime(file) > started_at }
       notify.call 'Restarting loop...'
       exec(*process_invocation_vector)
     end
@@ -161,9 +163,8 @@ begin
   end
 
 rescue Interrupt
-  # user wants to quit the loop; terminate worker processes
-  # NOTE: negative PID causes signal to propagate to all child processes
-  Process.kill :SIGKILL, -$$
+  # user wants to quit the loop so terminate all worker processes
+  Process.kill :SIGKILL, -$$ # negative PID propagates signal to children
 
 rescue Exception => error
   STDERR.puts error.inspect, error.backtrace

metadata

@@ -3,10 +3,10 @@ name: test-loop
 version: !ruby/object:Gem::Version 
   prerelease: false
   segments: 
-  - 5
+  - 6
   - 0
-  - 3
-  version: 5.0.3
+  - 0
+  version: 6.0.0
 platform: ruby
 authors: 
 - Suraj N. Kurapati
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-01-25 00:00:00 -08:00
+date: 2011-02-09 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency