Spin will speed up your autotest(ish) workflow for Rails.

Spin preloads your Rails environment for testing, so you don't load the same code over and over and over... Spin works best with an autotest(ish) workflow.

require 'socket'

This brings in Dir.tmpdir

require 'tempfile'

This lets us hash the parameters we want to include in the filename without having to worry about subdirectories, special chars, etc.

require 'digest/md5'

So we can tell users how much time they're saving by preloading their environment.

require 'benchmark'
require 'optparse'


def usage
Usage: spin serve
       spin push <file> <file>...
Spin preloads your Rails environment to speed up your autotest(ish) workflow.

def socket_file
  key = Digest::MD5.hexdigest [Dir.pwd, 'spin-gem'].join
  [Dir.tmpdir, key].join('/')

def determine_test_framework(force_rspec, force_testunit)
  if force_rspec
  elsif force_testunit
  elsif defined?(RSpec)

def disconnect(connection)
  connection.print "\0"

spin serve

def serve(force_rspec, force_testunit, time, push_results)
  file = socket_file

We delete the tmp file for the Unix socket if it already exists. The file is scoped to the pwd, so if it already exists then it must be from an old run of spin serve and can be cleaned up.

  File.delete(file) if File.exist?(file)

This socket is how we communicate with spin push.

  socket = UNIXServer.open(file)

  ENV['RAILS_ENV'] = 'test' unless ENV['RAILS_ENV']

  test_framework = nil

  if File.exist? 'config/application.rb'
    sec = Benchmark.realtime {

We require config/application because that file (typically) loads Rails and any Bundler deps, as well as loading the initialization code for the app, but it doesn't actually perform the initialization. That happens in config/environment.

In my experience that's the best we can do in terms of preloading. Rails and the gem dependencies rarely change and so don't need to be reloaded. But you can't initialize the application because any non-trivial app will involve it's models/controllers, etc. in its initialization, which you definitely don't want to preload.

      require File.expand_path 'config/application'

Determine the test framework to use using the passed-in 'force' options or else default to checking for defined constants.

      test_framework = determine_test_framework(force_rspec, force_testunit)

Preload RSpec to save some time on each test run

        require 'rspec/rails'
        require 'rspec/autorun'

Tell RSpec it's running with a tty to allow colored output

        if RSpec.respond_to?(:configure)
          RSpec.configure do |c|
            c.tty = true if c.respond_to?(:tty=)
      rescue LoadError
      end if test_framework == :rspec

This is the amount of time that you'll save on each subsequent test run.

    puts "Preloaded Rails env in #{sec}s..."
    warn "Could not find config/application.rb. Are you running this from the root of a Rails project?"

  puts "Pushing test results back to push processes" if push_results

  loop do

If we're not going to push the results, Trap SIGQUIT (Ctrl+) and re-run the last files that were pushed.

    if !push_results
      trap('QUIT') do
        fork_and_run(@last_files_ran, push_results, test_framework, nil)

See WAIT below


Since spin push reconnects each time it has new files for us we just need to accept(2) connections from it.

    conn = socket.accept

This should be a list of relative paths to files.

    files = conn.gets.chomp
    files = files.split(SEPARATOR)

If spin is started with the time flag we will track total execution so you can easily compare it with time rspec spec for example

    start = Time.now if time

If we're not sending results back to the push process, we can disconnect it immediately.

    disconnect(conn) unless push_results

    fork_and_run(files, push_results, test_framework, conn)

WAIT: We don't want the parent process handling multiple test runs at the same time because then we'd need to deal with multiple test databases, and that destroys the idea of being simple to use. So we wait(2) until the child process has finished running the test.


If we are tracking time we will output it here after everything has finished running

    puts "Total execution time was #{Time.now - start} seconds" if start

Tests have now run. If we were pushing results to a push process, we can now disconnect it.

      disconnect(conn) if push_results
    rescue Errno::EPIPE

Don't abort if the client already disconnected


def fork_and_run(files, push_results, test_framework, conn)

We fork(2) before loading the file so that our pristine preloaded environment is untouched. The child process will load whatever code it needs to, then it exits and we're back to the baseline preloaded app.

  fork do

To push the test results to the push process instead of having them displayed by the server, we reopen $stdout/$stderr to the open connection.

    if push_results

    puts "Loading #{files.inspect}"

Unfortunately rspec's interface isn't as simple as just requiring the test file that you want to run (suddenly test/unit seems like the less crazy one!).

    if test_framework == :rspec

We pretend the filepath came in as an argument and duplicate the behaviour of the rspec binary.

      ARGV.push files

We require the full path of the file here in the child process.

      files.each { |f| require File.expand_path f }

  @last_files_ran = files

spin push

def push

The filenames that we will spin up to spin serve are passed in as arguments.

  files_to_load = ARGV

We reject anything in ARGV that isn't a file that exists. This takes care of scripts that specify files like spin push -r file.rb. The -r bit will just be ignored.

We build a string like file1.rb|file2.rb and pass it up to the server.

  f = files_to_load.map do |file|
    file = file.split(':').first.to_s

If the file exists then we can push it up just like it is

    if File.exist?(file)

kicker-2.5.0 now gives us file names without extensions, so we have to try adding it

    elsif File.extname(file).empty?
      file = [file, 'rb'].join('.')
      file if File.exist?(file)

  abort if f.empty?
  puts "Spinning up #{f}"

This is the other end of the socket that spin serve opens. At this point spin serve will accept(2) our connection.

  socket = UNIXSocket.open(socket_file)

We put the filenames on the socket for the server to read and then load.

  socket.puts f

  while line = socket.readpartial(100)
    break if line[-1,1] == "\0"
    print line
rescue Errno::ECONNREFUSED
  abort "Connection was refused. Have you started up `spin serve` yet?"

force_rspec = false
force_testunit = false
time = false
push_results = false
options = OptionParser.new do |opts|
  opts.banner = usage
  opts.separator ""
  opts.separator "Server Options:"

  opts.on("-I", "--load-path=DIR#{File::PATH_SEPARATOR}DIR", "Appends directory to $LOAD_PATH") do |dirs|

  opts.on('--rspec', 'Force the selected test framework to RSpec') do |v|
    force_rspec = v

  opts.on('--test-unit', 'Force the selected test framework to Test::Unit') do |v|
    force_testunit = v

  opts.on('-t', '--time', 'See total execution time for each test run') do |v|
    time = true

  opts.on('--push-results', 'Push test results to the push process') do |v|
    push_results = v

  opts.separator "General Options:"
  opts.on('-e', 'Stub to keep kicker happy')
  opts.on('-h', '--help') do
    $stderr.puts opts
    exit 1

subcommand = ARGV.shift
case subcommand
when 'serve' then serve(force_rspec, force_testunit, time, push_results)
when 'push' then push
  $stderr.puts options
  exit 1