tork 16.0.0 → 17.0.0

data/HISTORY.markdown

@@ -1,3 +1,49 @@
+------------------------------------------------------------------------------
+Version 17.0.0 (2012-01-27)
+------------------------------------------------------------------------------
+
+Breaking changes:
+
+  * tork-herald(1) now emits batches of single-line JSON arrays instead of
+    printing one (raw) path per line.  This makes IPC uniform across Tork.
+
+  * tork-master(1) now emits log_file and worker_number in status messages.
+
+  * The order of parameters for before/after fork hooks has been changed to
+    better reflect the order of items in tork-master(1)'s status messages.
+
+    * The old order was: worker_number, log_file, test_file, line_numbers.
+
+    * The new order is:  test_file, line_numbers, log_file, worker_number.
+
+New features:
+
+  * GH-24: add `tork/config/dotlog` configuration helper to "hide" log files.
+
+  * GH-25: add `tork/config/logdir` configuration helper to isolate log files.
+
+  * tork(1) now strips all whitespace from your input, in case you pressed
+    spacebar or tab a few times, by accident, before entering your command.
+
+Housekeeping:
+
+  * tork/client: Replace write lock with queue to support SIGCHLD handler.
+
+    The SIGCHLD handler in tork-master(1) can be triggered at any time, even
+    in the middle of writing to the standard output stream!  Locking access
+    to the output stream in normal code (outside the signal handler) would
+    freeze the program because the signal handler, waiting for the lock to
+    be released, would never return!
+
+    One solution is to maintain a thread-safe queue of outgoing items that
+    need to be written to the output stream.  Both normal code and the
+    signal handler can quickly push an outgoing item onto the queue and
+    proceed with their business.  A separate thread can then have the sole
+    responsibility of (and access to) continually writing those outgoing
+    items to the output stream.
+
+  * README: revise instructions, reorganize document, and other improvements.
+
 ------------------------------------------------------------------------------
 Version 16.0.0 (2012-01-25)
 ------------------------------------------------------------------------------

data/LICENSE

@@ -10,6 +10,7 @@ Thanks to 2012 Jose Pablo Barrantes <xjpablobrx@gmail.com>
 Thanks to 2012 Spencer Steffen <spencer@citrusme.com>
 Thanks to 2012 Jesse Cooke <jesse@jc00ke.com>
 Thanks to 2012 Benjamin Quorning <benjamin@quorning.net>
+Thanks to 2012 Nicolas Fouché <nicolas.fouche@gmail.com>
 
 Permission to use, copy, modify, and/or distribute this software for any
 purpose with or without fee is hereby granted, provided that the above

data/README.markdown

@@ -39,19 +39,17 @@ Features
 
   * You can override the modular `tork*` programs with your own in $PATH.
 
-  * Its core is written in less than 360 lines (SLOC) of pure Ruby code! :-)
+  * Its core is written in less than 370 lines (SLOC) of pure Ruby code! :-)
 
-------------------------------------------------------------------------------
-Architecture
-------------------------------------------------------------------------------
+### Architecture
 
 Following UNIX philosophy, Tork is composed of simple text-based programs: so
 you can build your own custom Tork user interface by wrapping `tork-driver`!
 
-* `tork` is an interactive command-line user interface (CLI) for driver
-* `tork-herald` monitors current directory tree and reports changed files
-* `tork-driver` tells master to run tests and keeps track of test results
-* `tork-master` absorbs test execution overhead and forks to run your tests
+  * `tork` is an interactive command-line user interface (CLI) for driver
+  * `tork-herald` monitors current directory tree and reports changed files
+  * `tork-driver` tells master to run tests and keeps track of test results
+  * `tork-master` absorbs test execution overhead and forks to run your tests
 
 When the herald observes that files in or beneath the current directory have
 been written to, it tells the driver, which then commands the master to fork a
@@ -64,9 +62,11 @@ diff and regexps) and then attempts to run just those.  To make it run *all*
 tests in your saved file, simply save the file *again* without changing it.
 
 ------------------------------------------------------------------------------
-Starting off
+Installation
 ------------------------------------------------------------------------------
 
+    gem install tork
+
 ### Prerequisites
 
   * Ruby 1.8.7 or 1.9.2 or newer.
@@ -83,34 +83,128 @@ Starting off
         gem install rb-inotify  # linux
         gem install rb-fsevent  # macosx
 
-### Installation
+### Development
 
-    gem install tork
+    git clone git://github.com/sunaku/tork
+    cd tork
+    bundle install --binstubs=bundle_bin
+    bundle_bin/tork --help  # run it directly
+    bundle exec rake -T     # packaging tasks
 
-### Invocation
+------------------------------------------------------------------------------
+Usage
+------------------------------------------------------------------------------
+
+### At the command line
 
     tork --help
 
-### Monitoring
+You can monitor your test processes from another terminal:
 
     watch 'ps xuw | sed -n "1p; /tor[k]/p" | fgrep -v sed'
 
-### Development
+### With [Ruby on Rails]
 
-    git clone git://github.com/sunaku/tork
-    cd tork
-    bundle install --binstubs=bundle_bin
-    bundle_bin/tork --help  # run it directly
-    bundle exec rake -T     # packaging tasks
+For Rails 3 or newer, use the rails configuration helper (see below).
+Otherwise, ensure that your `config/environments/test.rb` file contains:
+
+    config.cache_classes = false
+
+To use SQLite3 as your test database, install its [in-memory database
+adapter][memory_test_fix].  Otherwise, you *might* face these errors:
+
+> SQLite3::BusyException: database is locked
+
+> cannot start a transaction within a transaction
+
+### With [factory_girl]
+
+Do not load your factories into the master process as part of your test
+execution overhead in your test/spec helper because that would necessitate
+overhead reabsorption whenever you change or create factory definitions.
+
+Instead, use `at_exit()` to wait until (1) after the master process has forked
+a worker process and (2) just before that worker process runs its test suite
+(whose execution is started by your test framework's own `at_exit()` handler):
+
+    # in your test/spec helper
+    require 'factory_girl'
+    at_exit { FactoryGirl.find_definitions unless $! }
+
+This way, worker processes will pick up changes in your factories "for free"
+whenever they (re)run your test files.  Skip if Ruby is exiting because of a
+raised exception (denoted by the `$!` global variable in the snippet above).
+
+As a bonus, this arrangement also works when tests are run outside of Tork!
 
 ------------------------------------------------------------------------------
 Configuration
 ------------------------------------------------------------------------------
 
 Tork looks for a configuration file named `.tork.rb` in its current working
-directory.  The configuration file is a normal Ruby script.  Inside it, you
-can query and modify the `Tork::Config` object (OpenStruct) according to the
-configuration options listed below.
+directory.  The configuration file is a normal Ruby script, inside which you
+can query and modify the `Tork::Config` object: an instance of OpenStruct.
+
+------------------------------------------------------------------------------
+Configuration helpers
+------------------------------------------------------------------------------
+
+In case you did not read the `tork --help` manual page, please note that you
+can pass *multiple* configuration helpers to tork(1) at the command line!
+
+### [Ruby on Rails]
+
+At the command line:
+
+    tork rails
+
+Or in your configuration file:
+
+    require 'tork/config/rails'
+
+### [Cucumber]
+
+At the command line:
+
+    tork cucumber
+
+Or in your configuration file:
+
+    require 'tork/config/cucumber'
+
+### [parallel_tests]
+
+At the command line:
+
+    tork parallel_tests
+
+Or in your configuration file:
+
+    require 'tork/config/parallel_tests'
+
+### Hide log files by prefixing their names with a dot
+
+At the command line:
+
+    tork dotlog
+
+Or in your configuration file:
+
+    require 'tork/config/dotlog'
+
+### Isolate log files into a separate `log/` directory
+
+At the command line:
+
+    tork logdir
+
+Or in your configuration file:
+
+    require 'tork/config/logdir'
+
+------------------------------------------------------------------------------
+Configuration options
+-----------------------------------------------------------------------------
 
 ### Tork::Config.max_forked_workers
 
@@ -181,19 +275,21 @@ worker process is forked to run a test file.  These functions are given:
 
 3. The path of the test file that will be run by the worker process.
 
-4. An array of names of tests inside the test file that will be run.  If this
-   array is empty, then all tests in the test file will be run.
+4. An array of line numbers in the test file to run.  If this array is empty,
+   then the entire test file will be run.
 
 For example, to see some real values:
 
-    Tork::Config.before_fork_hooks << lambda do |worker_number, log_file, test_file, line_numbers|
+    Tork::Config.before_fork_hooks.push lambda {
+      |test_file, line_numbers, log_file, worker_number|
+
       p :before_fork_hooks => {
-        :worker_number => worker_number,
-        :log_file      => log_file,
         :test_file     => test_file,
         :line_numbers  => line_numbers,
+        :log_file      => log_file,
+        :worker_number => worker_number,
       }
-    end
+    }
 
 ### Tork::Config.after_fork_hooks
 
@@ -206,90 +302,27 @@ by `tork-master`.  These functions are given:
 
 3. The path of the test file that will be run by the worker process.
 
-4. An array of names of tests inside the test file that will be run.  If this
-   array is empty, then all tests in the test file will be run.
+4. An array of line numbers in the test file to run.  If this array is empty,
+   then the entire test file will be run.
 
 For example, to see some real values, including the worker process' PID:
 
-    Tork::Config.after_fork_hooks << lambda do |worker_number, log_file, test_file, line_numbers|
+    Tork::Config.after_fork_hooks.push lambda {
+      |test_file, line_numbers, log_file, worker_number|
+
       p :after_fork_hooks => {
-        :worker_pid    => $$,
-        :worker_number => worker_number,
-        :log_file      => log_file,
         :test_file     => test_file,
         :line_numbers  => line_numbers,
+        :log_file      => log_file,
+        :worker_number => worker_number,
+        :worker_pid    => $$,
       }
-    end
+    }
 
 The first function in this array instructs Test::Unit and RSpec to only run
 those tests that are defined on the given line numbers.  This accelerates your
 test-driven development cycle by only running tests you are currently editing.
 
-------------------------------------------------------------------------------
-Configuration helpers
-------------------------------------------------------------------------------
-
-The following libraries assist you with configuring Tork. To use them,
-simply add the `require()` lines shown below to your configuration file
-*or* pass their basenames to the tork(1) command, also as shown below.
-
-### require 'tork/config/rails' # tork rails
-
-Support for the [Ruby on Rails] web framework.
-
-### require 'tork/config/cucumber' # tork cucumber
-
-Support for the [Cucumber] testing framework.
-
-### require 'tork/config/parallel_tests' # tork parallel_tests
-
-Support for the [parallel_tests] library.
-
-------------------------------------------------------------------------------
-Usage tips
-------------------------------------------------------------------------------
-
-### [factory_girl] factories
-
-Don't load your factories in master process (as part of your test execution
-overhead) because that would necessitate the reloading of said overhead
-whenever you change an existing factory definition or create a new one.
-
-Instead, use `at_exit()` to wait until (1) after the master process has forked
-a worker process and (2) just before that worker process runs its test suite
-(whose execution is started by your test framework's own `at_exit()` handler):
-
-    require 'factory_girl'
-    at_exit { FactoryGirl.find_definitions unless $! }
-
-This way, worker processes will pick up changes in your factories "for free"
-whenever they (re)run your test files.  Also, don't load your factories or do
-anything else in your `at_exit()` handler if Ruby is exiting because of a
-raised exception (denoted by the `$!` global variable in the snippet above).
-
-------------------------------------------------------------------------------
-Known issues
-------------------------------------------------------------------------------
-
-### Ruby on Rails
-
-  * Ensure that your `config/environments/test.rb` file disables class caching
-    as follows (**NOTE:** if you are using Rails 3, the `tork/config/rails`
-    configuration helper can do this for you automatically):
-
-        config.cache_classes = false
-
-    Otherwise, Tork will appear to ignore source-code changes in your
-    models, controllers, helpers, and other Ruby source files.
-
-  * If SQLite3 raises one of the following errors, try using an [in-memory
-    adapter for SQLite3][memory_test_fix] or use different database software
-    (such as MySQL) for your test environment.
-
-    * SQLite3::BusyException: database is locked
-
-    * cannot start a transaction within a transaction
-
 ------------------------------------------------------------------------------
 License
 ------------------------------------------------------------------------------

data/bin/tork

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
 =begin
 
-TORK 1 2012-01-25 16.0.0
+TORK 1 2012-01-27 17.0.0
 ==============================================================================
 
 NAME
@@ -51,23 +51,21 @@ ENV['TORK_CONFIGS'] = JSON.dump(ARGV)
 require 'tork/client'
 
 warn 'tork: Absorbing test execution overhead...'
-@driver = Tork::Client::Transceiver.new('tork-driver') do |line|
-  evstr, *details = JSON.load(line)
-  event = evstr.to_sym
-
-  case event
+@driver = Tork::Client::Transceiver.new('tork-driver') do |event, *details|
+  case event_sym = event.to_sym
   when :load then warn 'tork: Overhead absorbed. Ready for testing!'
   when :over then warn 'tork: Reabsorbing changed overhead files...'
   else
-    test_file, line_numbers, *details = details
-    message = [evstr.upcase, test_file, line_numbers.inspect, details].join(' ')
+    test_file, line_numbers, log_file, worker_number, exit_status = details
+    message = [event.upcase, [test_file, *line_numbers].join(':'),
+               exit_status].compact.join(' ')
 
-    color = case event
+    color = case event_sym
             when :pass then "\e[34m%s\e[0m" # blue
             when :fail then "\e[31m%s\e[0m" # red
             end
     message = color % message if color and STDOUT.tty?
-    message = [message, File.read(test_file + '.log'), message] if event == :fail
+    message = [message, File.read(log_file), message] if event_sym == :fail
 
     puts message
   end
@@ -87,7 +85,7 @@ COMMANDS = {
 }
 
 begin
-  while key = STDIN.gets.chomp
+  while key = STDIN.gets.strip
     if command = COMMANDS[key]
       warn "tork: Sending #{command.to_s.inspect} command..."
       @driver.send [command]

data/bin/tork-driver

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
 =begin
 
-TORK-DRIVER 1 2012-01-25 16.0.0
+TORK-DRIVER 1 2012-01-27 17.0.0
 ==============================================================================
 
 NAME

data/bin/tork-herald

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
 =begin
 
-TORK-HERALD 1 2012-01-25 16.0.0
+TORK-HERALD 1 2012-01-27 17.0.0
 ==============================================================================
 
 NAME
@@ -18,7 +18,8 @@ DESCRIPTION
 ------------------------------------------------------------------------------
 
 This program monitors the current working directory and prints relative paths
-of modified files, one per line, to the standard output stream.
+of modified files in batches of single-line JSON arrays to the standard output
+stream.
 
 OPTIONS
 ------------------------------------------------------------------------------
@@ -40,8 +41,9 @@ BinMan.help
 
 require 'guard'
 require 'guard/listener'
+require 'json'
 
 listener = Guard::Listener.select_and_init(:watch_all_modifications => true)
-listener.on_change {|files| puts files }
+listener.on_change {|files| puts JSON.dump(files) }
 STDOUT.sync = true # don't buffer puts()
 listener.start

data/bin/tork-master

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
 =begin
 
-TORK-MASTER 1 2012-01-25 16.0.0
+TORK-MASTER 1 2012-01-27 17.0.0
 ==============================================================================
 
 NAME
@@ -30,16 +30,18 @@ standard input stream and performs the respective actions as described below.
   chosen unit testing framework (loaded by your test execution overhead) to
   only run those tests that are defined on the given array of *line_numbers*.
 
-  Prints the given command line to the standard output stream immediately
-  after forking the child process.
+  Prints the following status messages to the standard output stream.  The
+  standard output and error streams of the forked child process are captured
+  in the *log_file* specified in these status messages.
 
-  Prints the given command line, modified with `"pass"` (if the test passed)
-  or `"fail"` (if the test failed) in place of `"test"`, to the standard
-  output stream after the forked child process finishes.
+  * Test is running:
+    `["test",` *test_file*`,` *line_numbers*`,` *log_file*`,` *worker_number*`]`
 
-  The standard output and error streams of the forked child process are
-  redirected to a file whose path and name are the same as that of the test
-  file being run by the forked child process but with ".log" appended.
+  * Test has passed:
+    `["pass",` *test_file*`,` *line_numbers*`,` *log_file*`,` *worker_number*`,` *exit_status*`]`
+
+  * Test has failed:
+    `["fail",` *test_file*`,` *line_numbers*`,` *log_file*`,` *worker_number*`,` *exit_status*`]`
 
 `["stop"]`
   Stops all tests that are currently running and prints the given command line

data/lib/tork/client.rb

@@ -1,34 +1,50 @@
 require 'thread'
+require 'json'
 
 module Tork
 module Client
 
-  class Receiver < Thread
-    def initialize *popen_args
-      (@io = IO.popen(*popen_args)).sync = true
-      super() { loop { yield @io.gets } }
+  class Transmitter < Thread
+    def initialize output_stream
+      output_stream.sync = true
+      @outbox = Queue.new
+      super() do
+        while command = @outbox.deq
+          warn "#{$0}(#{$$}): SEND #{command.inspect}" if $DEBUG
+          output_stream.puts JSON.dump(command)
+        end
+      end
     end
 
-    def quit
-      kill # stop receive loop
-      Process.kill :SIGTERM, @io.pid
-      Process.wait @io.pid # reap zombie
-      @io.close # prevent further I/O
+    def send command
+      @outbox.enq command
+    end
+  end
+
+  class Receiver < Thread
+    def initialize input_stream
+      super() do
+        while command = JSON.load(input_stream.gets)
+          warn "#{$0}(#{$$}): RECV #{command.inspect}" if $DEBUG
+          yield command
+        end
+      end
     end
   end
 
-  class Transceiver < Receiver
-    def initialize *popen_args
-      @io_write_lock = Mutex.new
+  class Transceiver < Transmitter
+    def initialize *popen_args, &receive_block
       popen_args[1] = 'w+'
-      super
+      @popen_io = IO.popen(*popen_args)
+      @receiver = Receiver.new(@popen_io, &receive_block)
+      super @popen_io
     end
 
-    def send command
-      @io_write_lock.synchronize do
-        warn "#{caller[2]} SEND #{command.inspect}" if $DEBUG
-        @io.puts JSON.dump(command)
-      end
+    def quit
+      kill # stop receive loop
+      Process.kill :SIGTERM, @popen_io.pid
+      Process.wait @popen_io.pid # reap zombie
+      @popen_io.close # prevent further I/O
     end
   end
 

data/lib/tork/config.rb

@@ -42,7 +42,7 @@ module Tork
   Config.after_fork_hooks = [
     # instruct the testing framework to only run those
     # tests that are defined on the given line numbers
-    lambda do |worker_number, log_file, test_file, line_numbers|
+    lambda do |test_file, line_numbers, log_file, worker_number|
       case File.basename(test_file)
       when /(\b|_)spec(\b|_).*\.rb$/ # RSpec
         line_numbers.each {|line| ARGV.push '--line_number', line.to_s }
@@ -81,6 +81,7 @@ module Tork
   load _user_config_file if File.exist? _user_config_file
 
   if ENV.key? 'TORK_CONFIGS'
+    require 'json'
     JSON.load(ENV['TORK_CONFIGS']).each do |config|
       if File.exist? config
         load File.expand_path(config)

data/lib/tork/config/cucumber.rb

@@ -12,7 +12,9 @@ Tork::Config.test_file_globbers.update(
   %r<^features/.+\.feature$> => lambda {|path, matches| path }
 )
 
-Tork::Config.after_fork_hooks << lambda do |worker_number, log_file, test_file, line_numbers|
+Tork::Config.after_fork_hooks.push lambda {
+  |test_file, line_numbers, log_file, worker_number|
+
   # pass test_file in ARGV to cucumber(1) for running
   ARGV << [test_file, *line_numbers].join(':')
   require 'cucumber'
@@ -24,4 +26,4 @@ Tork::Config.after_fork_hooks << lambda do |worker_number, log_file, test_file,
   # because cucumber feature files are not Ruby scripts
   require 'tempfile'
   test_file.replace Tempfile.new('tork-cucumber').path
-end
+}

data/lib/tork/config/dotlog.rb

@@ -0,0 +1,8 @@
+require 'tork/config'
+
+Tork::Config.before_fork_hooks.unshift lambda {
+  |test_file, line_numbers, log_file, worker_number|
+
+  dirname, basename = File.split(log_file)
+  log_file.replace File.join(dirname, '.' + basename)
+}

data/lib/tork/config/logdir.rb

@@ -0,0 +1,10 @@
+require 'tork/config'
+require 'fileutils'
+
+Tork::Config.before_fork_hooks.unshift lambda {
+  |test_file, line_numbers, log_file, worker_number|
+
+  dirname, basename = File.split(log_file)
+  FileUtils.mkdir_p log_dir = File.join('log', dirname)
+  log_file.replace File.join(log_dir, basename)
+}

data/lib/tork/config/parallel_tests.rb

@@ -1,7 +1,9 @@
 require 'tork/config'
 
-Tork::Config.after_fork_hooks << proc do |worker_number|
+Tork::Config.after_fork_hooks.push lambda {
+  |test_file, line_numbers, log_file, worker_number|
+
   # for compatitibilty with parallel_tests gem,
   # store numbers as strings: "", "2", "3", "4"
   ENV['TEST_ENV_NUMBER'] = (worker_number + 1).to_s if worker_number > 0
-end
+}

data/lib/tork/driver.rb

@@ -1,4 +1,3 @@
-require 'json'
 require 'diff/lcs'
 require 'tork/client'
 require 'tork/server'
@@ -30,8 +29,8 @@ module Driver
   def reabsorb_overhead_files
     @master.quit if defined? @master
 
-    @master = Client::Transceiver.new('tork-master') do |line|
-      event, file, tests = JSON.load(line)
+    @master = Client::Transceiver.new('tork-master') do |message|
+      event, file, tests = message
 
       case event.to_sym
       when :test
@@ -51,7 +50,7 @@ module Driver
         @failed_test_files.push file unless @failed_test_files.include? file
       end
 
-      @client.print line
+      @client.send message
     end
 
     @master.send [:load, Config.overhead_load_paths,
@@ -63,22 +62,24 @@ module Driver
   def loop
     reabsorb_overhead_files
 
-    @herald = Client::Receiver.new('tork-herald') do |line|
-      changed_file = line.chomp
-      warn "tork-driver: herald: #{changed_file}" if $DEBUG
+    @herald = Client::Transceiver.new('tork-herald') do |changed_files|
+      warn "#{$0}(#{$$}): FILE BATCH #{changed_files.size}" if $DEBUG
+      changed_files.each do |changed_file|
+        warn "#{$0}(#{$$}): FILE #{changed_file}" if $DEBUG
 
-      # find and run the tests that correspond to the changed file
-      Config.test_file_globbers.each do |regexp, globber|
-        if regexp =~ changed_file and glob = globber.call(changed_file, $~)
-          run_test_files Dir[glob]
+        # find and run the tests that correspond to the changed file
+        Config.test_file_globbers.each do |regexp, globber|
+          if regexp =~ changed_file and glob = globber.call(changed_file, $~)
+            run_test_files Dir[glob]
+          end
         end
-      end
 
-      # reabsorb text execution overhead if overhead files changed
-      if Config.reabsorb_file_greps.any? {|r| r =~ changed_file }
-        @client.puts JSON.dump([:over, changed_file])
-        # NOTE: new thread because reabsorb_overhead_files will kill this one
-        Thread.new { reabsorb_overhead_files }.join
+        # reabsorb text execution overhead if overhead files changed
+        if Config.reabsorb_file_greps.any? {|r| r =~ changed_file }
+          @client.send [:over, changed_file]
+          # NOTE: new thread because reabsorb_overhead_files will kill this one
+          Thread.new { reabsorb_overhead_files }.join
+        end
       end
     end
 

data/lib/tork/master.rb

@@ -1,4 +1,3 @@
-require 'json'
 require 'tork/server'
 require 'tork/config'
 
@@ -17,7 +16,7 @@ module Master
       require file.sub(/\.rb$/, '')
     end
 
-    @client.print @command_line
+    @client.send @command
   end
 
   def test test_file, line_numbers
@@ -28,7 +27,7 @@ module Master
     worker_number = @worker_number_pool.shift
 
     Config.before_fork_hooks.each do |hook|
-      hook.call worker_number, log_file, test_file, line_numbers
+      hook.call test_file, line_numbers, log_file, worker_number
     end
 
     worker_pid = fork do
@@ -46,7 +45,7 @@ module Master
       STDERR.reopen(STDOUT.reopen(log_file, 'w')).sync = true
 
       Config.after_fork_hooks.each do |hook|
-        hook.call worker_number, log_file, test_file, line_numbers
+        hook.call test_file, line_numbers, log_file, worker_number
       end
 
       # after loading the user's test file, the at_exit() hook of the user's
@@ -56,8 +55,8 @@ module Master
       Kernel.load test_file
     end
 
-    @command_by_worker_pid[worker_pid] = @command.push(worker_number)
-    @client.print @command_line
+    @command_by_worker_pid[worker_pid] = @command.push(log_file, worker_number)
+    @client.send @command
   end
 
   def stop
@@ -83,9 +82,9 @@ private
       while wait2_array = Process.wait2(-1, Process::WNOHANG)
         child_pid, child_status = wait2_array
         if command = @command_by_worker_pid.delete(child_pid)
-          @worker_number_pool.push command.pop
-          command[0] = child_status.success? ? 'pass' : 'fail'
-          @client.puts JSON.dump(command.push(child_status))
+          @worker_number_pool.push command.last
+          command[0] = if child_status.success? then :pass else :fail end
+          @client.send command.push(child_status)
         else
           warn "tork-master: unknown child exited: #{wait2_array.inspect}"
         end

data/lib/tork/server.rb

@@ -1,31 +1,25 @@
-require 'json'
+require 'tork/client'
 
 module Tork
 module Server
 
   def quit
-    throw :tork_server_quit
+    Thread.exit # kill Client::Receiver in loop()
   end
 
   def loop
-    (@client = STDOUT.dup).sync = true
+    @client = Client::Transmitter.new(STDOUT.dup)
     STDOUT.reopen(STDERR).sync = true
 
-    catch :tork_server_quit do
-      while line = STDIN.gets
-        warn "#{caller[2]} RECV #{line.chomp}" if $DEBUG
-
-        command = JSON.load(line)
-        method = command.first
-
-        if respond_to? method and method != __method__ # prevent loops
-          @command, @command_line = command, line
-          __send__(*command)
-        else
-          warn "#{self}: bad command: #{method}"
-        end
+    Client::Receiver.new(STDIN) do |command|
+      method = command.first
+      if respond_to? method and method != __method__ # prevent loops
+        @command = command
+        __send__(*command)
+      else
+        warn "#{self}: invalid command: #{method}"
       end
-    end
+    end.join
   rescue Interrupt
     # forced quit
   end

data/lib/tork/version.rb

@@ -1,3 +1,3 @@
 module Tork
-  VERSION = "16.0.0"
+  VERSION = "17.0.0"
 end

data/man/man1/tork-driver.1

@@ -1,4 +1,4 @@
-.TH TORK\-DRIVER 1 2012\-01\-25 16.0.0
+.TH TORK\-DRIVER 1 2012\-01\-27 17.0.0
 .SH NAME
 .PP
 tork\-driver \- drives 

data/man/man1/tork-herald.1

@@ -1,4 +1,4 @@
-.TH TORK\-HERALD 1 2012\-01\-25 16.0.0
+.TH TORK\-HERALD 1 2012\-01\-27 17.0.0
 .SH NAME
 .PP
 tork\-herald \- reports modified files
@@ -8,7 +8,8 @@ tork\-herald \- reports modified files
 .SH DESCRIPTION
 .PP
 This program monitors the current working directory and prints relative paths
-of modified files, one per line, to the standard output stream.
+of modified files in batches of single\-line JSON arrays to the standard output
+stream.
 .SH OPTIONS
 .TP
 \fB\fC-h\fR, \fB\fC--help\fR

data/man/man1/tork-master.1

@@ -1,4 +1,4 @@
-.TH TORK\-MASTER 1 2012\-01\-25 16.0.0
+.TH TORK\-MASTER 1 2012\-01\-27 17.0.0
 .SH NAME
 .PP
 tork\-master \- absorbs overhead and runs tests
@@ -20,16 +20,20 @@ Runs the given \fItest_file\fP in a forked child process while instructing your
 chosen unit testing framework (loaded by your test execution overhead) to
 only run those tests that are defined on the given array of \fIline_numbers\fP.
 .IP
-Prints the given command line to the standard output stream immediately
-after forking the child process.
-.IP
-Prints the given command line, modified with \fB\fC"pass"\fR (if the test passed)
-or \fB\fC"fail"\fR (if the test failed) in place of \fB\fC"test"\fR, to the standard
-output stream after the forked child process finishes.
-.IP
-The standard output and error streams of the forked child process are
-redirected to a file whose path and name are the same as that of the test
-file being run by the forked child process but with ".log" appended.
+Prints the following status messages to the standard output stream.  The
+standard output and error streams of the forked child process are captured
+in the \fIlog_file\fP specified in these status messages.
+.RS
+.IP \(bu 2
+Test is running:
+\fB\fC["test",\fR \fItest_file\fP\fB\fC,\fR \fIline_numbers\fP\fB\fC,\fR \fIlog_file\fP\fB\fC,\fR \fIworker_number\fP\fB\fC]\fR
+.IP \(bu 2
+Test has passed:
+\fB\fC["pass",\fR \fItest_file\fP\fB\fC,\fR \fIline_numbers\fP\fB\fC,\fR \fIlog_file\fP\fB\fC,\fR \fIworker_number\fP\fB\fC,\fR \fIexit_status\fP\fB\fC]\fR
+.IP \(bu 2
+Test has failed:
+\fB\fC["fail",\fR \fItest_file\fP\fB\fC,\fR \fIline_numbers\fP\fB\fC,\fR \fIlog_file\fP\fB\fC,\fR \fIworker_number\fP\fB\fC,\fR \fIexit_status\fP\fB\fC]\fR
+.RE
 .TP
 \fB\fC["stop"]\fR
 Stops all tests that are currently running and prints the given command line

data/man/man1/tork.1

@@ -1,4 +1,4 @@
-.TH TORK 1 2012\-01\-25 16.0.0
+.TH TORK 1 2012\-01\-27 17.0.0
 .SH NAME
 .PP
 tork \- Continuous testing tool for Ruby

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tork
 version: !ruby/object:Gem::Version
-  version: 16.0.0
+  version: 17.0.0
   prerelease: 
 platform: ruby
 authors:
@@ -10,11 +10,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-01-26 00:00:00.000000000 Z
+date: 2012-01-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: binman
-  requirement: &15804480 !ruby/object:Gem::Requirement
+  requirement: &17780080 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -22,10 +22,10 @@ dependencies:
         version: '3'
   type: :runtime
   prerelease: false
-  version_requirements: *15804480
+  version_requirements: *17780080
 - !ruby/object:Gem::Dependency
   name: json
-  requirement: &15803820 !ruby/object:Gem::Requirement
+  requirement: &17779540 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -36,10 +36,10 @@ dependencies:
         version: '2'
   type: :runtime
   prerelease: false
-  version_requirements: *15803820
+  version_requirements: *17779540
 - !ruby/object:Gem::Dependency
   name: guard
-  requirement: &15818660 !ruby/object:Gem::Requirement
+  requirement: &17778800 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -50,10 +50,10 @@ dependencies:
         version: '1'
   type: :runtime
   prerelease: false
-  version_requirements: *15818660
+  version_requirements: *17778800
 - !ruby/object:Gem::Dependency
   name: diff-lcs
-  requirement: &15816880 !ruby/object:Gem::Requirement
+  requirement: &17778060 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -64,10 +64,10 @@ dependencies:
         version: '2'
   type: :runtime
   prerelease: false
-  version_requirements: *15816880
+  version_requirements: *17778060
 - !ruby/object:Gem::Dependency
   name: md2man
-  requirement: &15815560 !ruby/object:Gem::Requirement
+  requirement: &17777300 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -75,10 +75,10 @@ dependencies:
         version: '1'
   type: :development
   prerelease: false
-  version_requirements: *15815560
+  version_requirements: *17777300
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &15814800 !ruby/object:Gem::Requirement
+  requirement: &17776800 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -89,7 +89,7 @@ dependencies:
         version: '1'
   type: :development
   prerelease: false
-  version_requirements: *15814800
+  version_requirements: *17776800
 description: Continuous testing tool for Ruby.
 email:
 - sunaku@gmail.com
@@ -115,6 +115,8 @@ files:
 - lib/tork/client.rb
 - lib/tork/config.rb
 - lib/tork/config/cucumber.rb
+- lib/tork/config/dotlog.rb
+- lib/tork/config/logdir.rb
 - lib/tork/config/parallel_tests.rb
 - lib/tork/config/rails.rb
 - lib/tork/driver.rb
@@ -138,18 +140,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: 1234155726209121791
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: 1234155726209121791
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.11
@@ -157,3 +153,4 @@ signing_key:
 specification_version: 3
 summary: Test with fork.
 test_files: []
+has_rdoc: