test-loop 4.0.1 → 5.0.0

data/README.md

@@ -5,8 +5,8 @@ test-loop is a fast continuous testing tool for Ruby that continuously detects
 and tests changes in your Ruby application in an efficient manner, whereby it:
 
 1. Absorbs the test execution overhead into the main Ruby process.
-2. Forks to evaluate your test files directly and without overhead.
-3. Tries to run only the test blocks that changed in your test files.
+2. Forks to run (eval) your test files directly, without overhead.
+3. Avoids running unchanged test blocks inside changed test files.
 
 It relies on file modification times to determine what parts of your Ruby
 application have changed, applies a lambda mapping function to determine which
@@ -17,8 +17,8 @@ find and run only those test blocks that have changed inside your test files.
 Features
 --------
 
-* Tests *changes* in your Ruby application: ignores unmodified test files
-  as well as unmodified test blocks inside modified test files.
+* Tests *changes* in your Ruby application: avoids running (1) unchanged
+  test files and (2) unchanged test blocks inside changed test files.
 
 * Reabsorbs test execution overhead if the test or spec helper file changes.
 
@@ -75,27 +75,27 @@ Configuration
 -------------
 
 test-loop looks for a configuration file named `.test-loop` in the current
-working directory.  This configuration file is a normal Ruby script which can
-define the following instance variables:
+working directory.  This configuration file is a normal Ruby file whose last
+statement yields a hash that may optionally contain the following entries:
 
-* `@overhead_file_globs` is an array of file globbing patterns that describe a
+* `: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.
 
-* `@reabsorb_file_globs` is an array of file globbing patterns that describe a
+* `: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.
 
-* `@source_file_to_test_file_mapping` 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
+* `: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.
 
   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 to your
-  `.test-loop` file:
+  letters were in reverse order, then you would add the following hash entry
+  to your `.test-loop` file:
 
-      @source_file_to_test_file_mapping = {
+      :test_file_matchers => {
         '{lib,app}/**/*.rb' => lambda do |path|
           extn = File.extname(path)
           name = File.basename(path, extn)
@@ -103,11 +103,11 @@ define the following instance variables:
         end
       }
 
-* `@test_name_parser` is a lambda function that is passed a line of source
+* `: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
+* `: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.
@@ -119,13 +119,13 @@ define the following instance variables:
 * `@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 evaluated
-  those test files.
+  test files, and the exit statuses of the worker processes that ran them.
 
   For example, to display a summary of the test execution results as an OSD
-  notification via libnotify, add the following to your `.test-loop` file:
+  notification via libnotify, add the following hash entry to your
+  `.test-loop` file:
 
-      @after_all_tests = lambda do |success, ran_at, files, statuses|
+      :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|
@@ -134,7 +134,7 @@ define the following instance variables:
         system 'notify-send', '-i', icon, title, details.join("\n")
       end
 
-  Also add the following at the very top if you use Ruby 1.9.x:
+  Also add the following at the top of the file if you use Ruby 1.9.x:
 
       # encoding: utf-8
 

data/bin/test-loop

@@ -32,15 +32,16 @@ begin
   # load user's configuration and supply default values
   notify.call 'Loading configuration...'
   config_file = File.join(Dir.pwd, '.test-loop')
-  load config_file if File.exist? config_file
+  config_data = File.read(config_file) if File.exist? config_file
+  config = eval(config_data.to_s, TOPLEVEL_BINDING, config_file) || {}
 
-  (@overhead_file_globs ||= []).
+  (config[:overhead_file_globs] ||= []).
     push('{test,spec}/*{test,spec}_helper.rb').uniq!
 
-  (@reabsorb_file_globs ||= []).concat(@overhead_file_globs).
+  (config[:reabsorb_file_globs] ||= []).concat(config[:overhead_file_globs]).
     push(config_file, 'config/*.{rb,yml}', 'Gemfile').uniq!
 
-  (@source_file_to_test_file_mapping ||= {}).merge!(
+  (config[:test_file_matchers] ||= {}).merge!(
     # source files that correspond to test files
     '{lib,app}/**/*.rb' => lambda do |path|
       extn = File.extname(path)
@@ -52,16 +53,14 @@ begin
     '{test,spec}/**/*_{test,spec}.rb' => lambda {|path| path }
   )
 
-  @test_file_cache = {} # path => readlines
-
-  @test_name_parser ||= lambda do |line|
+  config[:test_name_parser] ||= lambda do |line|
     case line
     when /^\s*def test_(\w+)/ then $1
     when /^\s*(test|context|should|describe|it)\b (['"])(.*?)\2/ then $3.strip
     end
   end
 
-  @before_each_test ||= lambda do |test_file, test_names|
+  config[:before_each_test] ||= lambda do |test_file, test_names|
     unless test_names.empty?
       case File.basename(test_file)
 
@@ -75,31 +74,29 @@ begin
     end
   end
 
-  @after_all_tests ||= lambda {|success, ran_at, files, statuses|}
+  config[:after_all_tests] ||= lambda {|success, ran_at, files, statuses|}
 
   # absorb test execution overhead into master process
   $LOAD_PATH.unshift 'lib', 'test', 'spec'
 
   notify.call 'Absorbing overhead...'
-  Dir[*@overhead_file_globs].each do |file|
+  Dir[*config[:overhead_file_globs]].each do |file|
     require File.basename(file, File.extname(file))
   end
 
   # continuously watch for and test changed code
-  epoch_time = Time.at(0)
+  test_file_cache = {} # path => readlines
   started_at = last_ran_at = Time.now
-  trap(:QUIT) { started_at = epoch_time }
-  trap(:TSTP) { last_ran_at = epoch_time; @test_file_cache.clear }
+  trap(:QUIT) { started_at = Time.at(0) }
+  trap(:TSTP) { last_ran_at = Time.at(0); test_file_cache.clear }
 
   notify.call 'Ready for testing!'
   loop do
     # figure out what test files need to be run
-    test_files = @source_file_to_test_file_mapping.
-      map do |source_file_glob, test_file_glob_mapper|
-        Dir[source_file_glob].
-        select {|file| File.mtime(file) > last_ran_at }.
-        map {|path| Dir[test_file_glob_mapper.call(path)] }
-      end.flatten.uniq
+    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
 
     # fork worker processes to run the test files in parallel
     unless test_files.empty?
@@ -109,8 +106,8 @@ begin
       test_files.each do |test_file|
         # cache the contents of the test file for diffing below
         new_lines = File.readlines(test_file)
-        old_lines = @test_file_cache[test_file] || new_lines
-        @test_file_cache[test_file] = new_lines
+        old_lines = test_file_cache[test_file] || new_lines
+        test_file_cache[test_file] = new_lines
 
         fork do
           # determine which test blocks have changed inside the test file
@@ -119,14 +116,14 @@ begin
               # search backwards from the line that changed up to
               # the first line in the file for test definitions
               diff[0][1].downto(0) do |i| # [[+/-, line number, line value]]
-                if test_name = @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
 
-          @before_each_test.call test_file, test_names
+          config[:before_each_test].call test_file, test_names
 
           load test_file
 
@@ -147,11 +144,11 @@ begin
       end
       notify.call "Ran in #{Time.now - last_ran_at} seconds"
 
-      @after_all_tests.call(success, last_ran_at, test_files, statuses)
+      config[:after_all_tests].call success, last_ran_at, test_files, statuses
     end
 
     # reabsorb test execution overhead as necessary
-    if Dir[*@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

metadata

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