test-loop 12.0.0 → 12.0.1

data/README.md

@@ -4,39 +4,49 @@ test-loop - Continuous testing for Ruby with fork/eval
 test-loop is a fast continuous testing tool for Ruby that automatically
 detects and tests changes in your application in an efficient manner:
 
-1. Absorbs the test execution overhead into the main Ruby process.
-2. Forks to run your test files without overhead and in parallel.
-3. Avoids running unchanged test blocks inside changed test files.
+  1. Absorbs the test execution overhead into the main Ruby process.
+
+  2. Forks to run your test files without overhead and in parallel.
+
+  3. Avoids running unchanged test blocks inside changed test files.
 
 ------------------------------------------------------------------------------
 Features
 ------------------------------------------------------------------------------
 
-* Tests *changes* in your Ruby application: avoids running (1) unchanged
-  test files and (2) unchanged test blocks inside changed test files.
+  * Tests *changes* in your Ruby application: avoids running (1) unchanged
+    test files and (2) unchanged test blocks inside changed test files.
 
-* Supports Test::Unit, RSpec, and any other testing framework that (1)
-  reflects failures in the process' exit status and (2) is loaded by your
-  application's `test/test_helper.rb` or `spec/spec_helper.rb` file.
+  * Supports Test::Unit, RSpec, and any other testing framework that (1)
+    reflects failures in the process' exit status and (2) is loaded by your
+    application's `test/test_helper.rb` or `spec/spec_helper.rb` file.
 
-* Reabsorbs test execution overhead if the test or spec helper file changes.
+  * Reabsorbs test execution overhead if the test or spec helper file changes.
 
-* Executes test files in parallel, making full use of multiple processors.
+  * Executes test files in parallel, making full use of multiple processors.
 
-* Logs the output from your tests into separate files: one log per test file.
-  The path to a log file is simply the path of its test file plus ".log".
+  * Logs the output from your tests into separate files: one log per test.
+    The path to a log file is simply the path of its test file plus ".log".
 
-* Generally I/O bound, so you can have it always running without CPU slowdown.
+  * Generally I/O bound, so you can keep it running without CPU slowdown.
 
-* Configurable through a `.test-loop` file in your current working directory.
+  * Configurable through a `.test-loop` file in your working directory.
 
-* Implemented in less than 250 lines (SLOC) of pure Ruby code! :-)
+  * Implemented in less than 220 lines (SLOC) of pure Ruby code! :-)
 
 ------------------------------------------------------------------------------
 Prerequisites
 ------------------------------------------------------------------------------
 
-* Operating system that supports POSIX signals and the `fork()` system call.
+  * Ruby 1.8.7 or 1.9.2 or newer.
+
+  * Operating system that supports POSIX signals and the `fork()` system call.
+
+    To check if your system qualifies, launch `irb` and enter the following:
+
+        Process.respond_to? :fork                       # must be true
+
+        Signal.list.keys & %w[INT TSTP QUIT TERM CHLD]  # must not be empty
 
 ------------------------------------------------------------------------------
 Installation
@@ -65,7 +75,7 @@ If installed as a Git clone:
 
 You can monitor your test processes in another terminal:
 
-    watch 'ps xf | grep test-loop | sed 1,3d'
+    watch 'ps xf | fgrep test-loop | fgrep -v fgrep'
 
 If it stops responding, you can annihilate test-loop from another terminal:
 
@@ -75,13 +85,13 @@ If it stops responding, you can annihilate test-loop from another terminal:
 Operation
 ------------------------------------------------------------------------------
 
-* Press Control-Z or send the SIGTSTP signal to forcibly run all
-  tests, even if there are no changes in your Ruby application.
+  * Press Control-Z or send the SIGTSTP signal to forcibly run all
+    tests, even if there are no changes in your Ruby application.
 
-* Press Control-\ or send the SIGQUIT signal to forcibly reabsorb
-  the test execution overhead, even if its sources have not changed.
+  * Press Control-\ or send the SIGQUIT signal to forcibly reabsorb
+    the test execution overhead, even if its sources have not changed.
 
-* Press Control-C or send the SIGINT signal to quit the test loop.
+  * Press Control-C or send the SIGINT signal to quit the test loop.
 
 ------------------------------------------------------------------------------
 Configuration
@@ -112,8 +122,8 @@ hash key; left-hand side of the mapping) change, their associated test files
 For example, if test files had the same names as their source files followed
 by an underscore and the file name in reverse like this:
 
-* `lib/hello.rb` => `test/hello_olleh.rb`
-* `app/world.rb` => `spec/world_ldrow.rb`
+  * `lib/hello.rb` => `test/hello_olleh.rb`
+  * `app/world.rb` => `spec/world_ldrow.rb`
 
 Then you would add the following to your configuration file:
 

data/lib/test/loop.rb

@@ -70,9 +70,9 @@ module Test
 
     private
 
-    MASTER_ARGV = [$0, *ARGV].map {|s| s.dup.freeze }.freeze
+    MASTER_EXECV = [$0, *ARGV].map {|s| s.dup.freeze }.freeze
+    MASTER_ENV = Hash[ENV.map {|k,v| [k.freeze, v.freeze] }].freeze
     RESUME_ENV_KEY = 'TEST_LOOP_RESUME_FILES'.freeze
-    MASTER_ENV = ENV.to_hash.delete_if {|k,v| k == RESUME_ENV_KEY }.freeze
 
     ANSI_CLEAR_LINE = "\e[2K\e[0G".freeze
     ANSI_GREEN = "\e[32m%s\e[0m".freeze
@@ -97,7 +97,7 @@ module Test
     def register_signals
       # this signal is ignored in master and honored in workers, so all
       # workers can be killed by sending it to the entire process group
-      trap :TERM, :IGNORE
+      trap :TERM, 'IGNORE'
 
       trap :CHLD do
         finished_at = Time.now
@@ -106,24 +106,22 @@ module Test
           worker_pid = Process.wait
           run_status = $?
 
-          worker = @worker_by_pid.delete(worker_pid)
-          elapsed_time = finished_at - worker.started_at
-
-          # report test results along with any failure logs
-          if run_status.success?
-            notify ANSI_GREEN % "PASS #{worker.test_file}"
-          elsif run_status.exited?
-            notify ANSI_RED % "FAIL #{worker.test_file}"
-            STDERR.print File.read(worker.log_file)
-          end
-
-          after_each_test.each do |hook|
-            hook.call worker.test_file, worker.log_file, run_status,
-                      worker.started_at, elapsed_time
+          if worker = @worker_by_pid.delete(worker_pid)
+            @running_files.delete worker.test_file
+
+            # report test results along with any failure logs
+            if run_status.success?
+              notify ANSI_GREEN % "PASS #{worker.test_file}"
+            elsif run_status.exited?
+              notify ANSI_RED % "FAIL #{worker.test_file}"
+              STDERR.print File.read(worker.log_file)
+            end
+
+            after_each_test.each do |hook|
+              hook.call worker.test_file, worker.log_file, run_status,
+                        worker.started_at, finished_at - worker.started_at
+            end
           end
-
-          @running_files.delete worker.test_file
-
         rescue Errno::ECHILD
           # could not get the terminated child's PID.
           # Ruby's backtick operator can cause this:
@@ -132,8 +130,8 @@ module Test
       end
 
       trap(:INT)  { raise Interrupt }
-      trap(:QUIT) { reload_master_process }
       trap(:TSTP) { forcibly_run_all_tests }
+      trap(:QUIT) { reload_master_process }
     end
 
     def kill_workers
@@ -147,8 +145,8 @@ module Test
     def reload_master_process test_files = []
       test_files.concat @running_files
       kill_workers
-      exec MASTER_ENV.merge(RESUME_ENV_KEY => test_files.inspect),
-           *MASTER_ARGV, {:unsetenv_others => true}
+      ENV.replace MASTER_ENV.merge(RESUME_ENV_KEY => test_files.inspect)
+      exec(*MASTER_EXECV)
     end
 
     def load_user_config
@@ -226,10 +224,10 @@ module Test
       started_at = Time.now
       worker_pid = fork do
         # handle signals meant for worker process
-        [:TERM, :CHLD].each {|sig| trap sig, :DEFAULT }
+        [:TERM, :CHLD].each {|sig| trap sig, 'DEFAULT' }
 
         # ignore signals meant for master process
-        [:INT, :QUIT, :TSTP].each {|sig| trap sig, :IGNORE }
+        [:INT, :TSTP, :QUIT].each {|sig| trap sig, 'IGNORE' }
 
         # detach worker from master's terminal device so that
         # it does not receieve the user's control-key presses

metadata

@@ -2,7 +2,7 @@
 name: test-loop
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 12.0.0
+  version: 12.0.1
 platform: ruby
 authors: 
 - Suraj N. Kurapati
@@ -11,7 +11,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-04-19 00:00:00 -07:00
+date: 2011-04-20 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency