spin 0.5.3 → 0.6.0

data/README.md

@@ -0,0 +1,136 @@
+Spin
+====
+
+Spin speeds up your Rails testing workflow.
+
+By preloading your Rails environment in one process and then using fork(2) for each test run you don't load the same code over and over and over...
+Spin works with an autotest(ish) workflow.
+
+Installation
+===========
+
+Spin is available as a rubygem.
+
+``` ruby
+gem i spin
+```
+
+Spin is a tool for Rails 3 apps. It is compatible with the following testing libraries:
+
+* any version of test/unit or MiniTest
+* RSpec 2.x
+
+Usage
+=====
+
+There are two components to Spin, a server and client. The server has to be running for anything interesting to happen. You can start the Spin server from your `Rails.root` with the following command:
+
+``` bash
+spin serve
+```
+
+As soon as the server is running it will be ready to accept from clients. You can use the following command to specify a file for the server to load:
+
+``` bash
+spin push test/unit/product_test.rb
+```
+
+Or push multiple files to be loaded at once:
+
+``` bash
+spin push test/unit/product_test.rb test/unit/shop_test.rb test/unit/cart_test.rb
+```
+
+Or, when using RSpec, run the whole suite:
+
+``` bash
+spin push spec
+```
+
+Running a single RSpec example by adding a line number is also possible, e.g:
+
+``` bash
+spin push spec/models/user_spec.rb:14
+```
+
+If you experience issues with `test_helper.rb` not being available you may need to add your test directory to the load path using the `-I` option:
+
+``` bash
+spin serve -Itest
+```
+
+Send a SIGQUIT to spin serve (`Ctrl+\`) if you want to re-run the last files that were ran via `spin push [files]`.
+
+### With Kicker
+
+As mentioned, this tool works best with an autotest(ish) workflow. I haven't actually used with with `autotest` itself, but it works great with [kicker](http://github.com/alloy/kicker). Here's the suggested workflow for a Rails app:
+
+1. Start up the spin server
+
+    ``` bash
+    spin serve
+    ```
+
+2. Start up `kicker` using the custom binary option (and any other options you want)
+
+    ``` bash
+    kicker -r rails -b 'spin push'
+    ```
+
+3. Faster testing workflow!
+
+Motivation
+==========
+
+A few months back I did an experiment. I opened up the source code to my local copy of the ActiveRecord gem. I added a line at the top of `active_record/base` that incremented a counter in Redis each time it was evaluated. After about a week that counter was well above 2000!
+
+How did I load the ActiveRecord gem over 2000 times in one week? Autotest. I was using it all day while developing. The Rails version that the app was tracking doesn't change very often, yet I had to load the same code over and over again.
+
+Given that there's no way to compile Ruby code into a faster representation I immediately thought of fork(2). I just need a process to load up Rails and wait around until I need it. When I want to run the tests I just fork(2) that idle process and run the test. Then I only have to load Rails once at the start of my workflow, fork(2) takes care of sharing the code with each child process.
+
+I threw together the first version of this project in about 20 minutes and noticed an immediate difference in the speed of my testing workflow. Did I mention that I work on a big app? It takes about 10 seconds(!) to load Rails and all of the gem dependencies. With a bit more hacking I was able to get the idle process to load both Rails and my application dependencies, so each test run just initializes the application and loads the files needed for the test run.
+
+(10 seconds saved per test run) x (2000 test runs per week) = (lots of time saved!)
+
+### How is it different from Spork?
+
+There's another project ([spork](https://github.com/sporkrb/spork)) that aims to solve the same problem, but takes a different approach.
+
+1. It's unobtrusive.
+
+    Your application needs to know about Spork, Spin works entirely outside of your application.
+
+    You'll need to add spork to your Gemfile and introduce your `test_helper.rb` to spork. Spork needs to know details about your app's loading process.
+
+    Spin is designed so that your app never has to know about it. You can use Spin to run your tests while the rest of your team doesn't even know that Spin exists.
+
+2. It's simple.
+
+    Spin should work out of the box with any Rails app. No custom configuration required.
+
+3. It doesn't do any [crazy monkey patching](https://github.com/sporkrb/spork-rails/blob/master/lib/spork/app_framework/rails.rb#L43-80).
+
+Docs
+============
+
+[Rocco](http://rtomayko.github.com/rocco/)-annotated source:
+
+* [spin](http://jstorimer.github.com/spin/)
+    * [spin serve](http://jstorimer.github.com/spin/#section-spin_serve)
+    * [spin push](http://jstorimer.github.com/spin/#section-spin_push)
+
+Hacking
+=======
+
+I take pull requests, and it's commit bit, and there are no tests.
+
+Related Projects
+===============
+
+If Spin isn't scratching your itch then one of these projects might:
+
+* [guard-spin](https://github.com/vizjerai/guard-spin)
+* [Spork](https://github.com/sporkrb/spork)
+* [TestR](https://github.com/sunaku/testr)
+* [Zeus](https://github.com/burke/zeus)
+

data/bin/spin

@@ -1,357 +1,3 @@
 #!/usr/bin/env ruby
-# 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'
-require 'pathname'
-
-SEPARATOR = '|'
-
-def usage
-  <<-USAGE
-Usage: spin serve
-       spin push <file> <file>...
-Spin preloads your Rails environment to speed up your autotest(ish) workflow.
-  USAGE
-end
-
-def socket_file
-  key = Digest::MD5.hexdigest [Dir.pwd, 'spin-gem'].join
-  [Dir.tmpdir, key].join('/')
-end
-
-def determine_test_framework(force_rspec, force_testunit)
-  if force_rspec
-    :rspec
-  elsif force_testunit
-    :testunit
-  elsif defined?(RSpec)
-    :rspec
-  else
-    :testunit
-  end
-end
-
-def disconnect(connection)
-  connection.print "\0"
-  connection.close
-end
-
-def rails_root(preload)
-  path = Pathname.pwd
-  until path.join(preload).file?
-    return if path.root?
-    path = path.parent
-  end
-  path
-end
-
-# ## spin serve
-def serve(force_rspec, force_testunit, time, push_results, preload)
-  root_path = rails_root(preload) and Dir.chdir(root_path)
-  file = socket_file
-  Spin.parse_hook_file(root_path) if root_path
-
-  # 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)
-
-  # Trap SIGINT (Ctrl-C) so that we exit cleanly.
-  trap('SIGINT') {
-    socket.close
-    exit
-  }
-
-  ENV['RAILS_ENV'] = 'test' unless ENV['RAILS_ENV']
-
-  test_framework = nil
-
-  if root_path
-    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.
-      Spin.execute_hook(:before_preload)
-      require File.expand_path preload.sub('.rb','')
-      Spin.execute_hook(:after_preload)
-
-      # 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
-      begin
-        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=)
-          end
-        end
-      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..."
-  else
-    warn "Could not find #{preload}. Are you running this from the root of a Rails project?"
-  end
-
-  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
-        Process.wait
-      end
-    end
-
-    # 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.
-    Process.wait
-
-    # 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.
-    begin
-      disconnect(conn) if push_results
-    rescue Errno::EPIPE
-      # Don't abort if the client already disconnected
-    end
-  end
-ensure
-  File.delete(file) if file && File.exist?(file)
-end
-
-def fork_and_run(files, push_results, test_framework, conn)
-  Spin.execute_hook(:before_fork)
-  # 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.
-    tty = files.delete "tty?"
-    if push_results
-      $stdout.reopen(conn)
-      if tty
-        def $stdout.tty?
-          true
-        end
-      end
-      $stderr.reopen(conn)
-    end
-
-    Spin.execute_hook(:after_fork)
-
-    puts
-    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
-    else
-      # We require the full path of the file here in the child process.
-      files.each { |f| require File.expand_path f }
-    end
-
-  end
-  @last_files_ran = files
-end
-
-# ## spin push
-def push(preload)
-  # 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.
-  files_to_load = files_to_load.map do |file|
-    args = file.split(':')
-
-    file_name = args.first.to_s
-    line_number = args.last.to_i
-
-    # If the file exists then we can push it up just like it is
-    file_name = if File.exist?(file_name)
-                  file_name
-                # kicker-2.5.0 now gives us file names without extensions, so we have to try adding it
-                elsif File.extname(file_name).empty?
-                  full_file_name = [file_name, 'rb'].join('.')
-                  full_file_name if File.exist?(full_file_name)
-                end
-
-    if line_number > 0
-      abort "You specified a line number. Only one file can be pushed in this case." if files_to_load.length > 1
-
-      "#{file_name}:#{line_number}"
-    else
-      file_name
-    end
-  end.compact.uniq
-
-  if root_path = rails_root(preload)
-    files_to_load.map! do |file|
-      Pathname.new(file).expand_path.relative_path_from(root_path).to_s
-    end
-    Dir.chdir root_path
-  end
-
-  files_to_load << "tty?" if $stdout.tty?
-  f = files_to_load.join(SEPARATOR)
-
-  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
-  end
-rescue Errno::ECONNREFUSED, Errno::ENOENT
-  abort "Connection was refused. Have you started up `spin serve` yet?"
-end
-
-module Spin
-  HOOKS = [:before_fork, :after_fork, :before_preload, :after_preload]
-
-  def self.hook(name, &block)
-    raise unless HOOKS.include?(name)
-    _hooks(name) << block
-  end
-
-  def self.execute_hook(name)
-    raise unless HOOKS.include?(name)
-    _hooks(name).each(&:call)
-  end
-
-  def self.parse_hook_file(root)
-    file = root.join(".spin.rb")
-    load(file) if File.exist?(file)
-  end
-
-  private
-
-  def self._hooks(name)
-    @hooks ||= {}
-    @hooks[name] ||= []
-    @hooks[name]
-  end
-end
-
-force_rspec = false
-force_testunit = false
-time = false
-push_results = false
-preload = "config/application.rb"
-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|
-    $LOAD_PATH.concat(dirs.split(File::PATH_SEPARATOR))
-  end
-
-  opts.on('--rspec', 'Force the selected test framework to RSpec') do |v|
-    force_rspec = v
-  end
-
-  opts.on('--test-unit', 'Force the selected test framework to Test::Unit') do |v|
-    force_testunit = v
-  end
-
-  opts.on('-t', '--time', 'See total execution time for each test run') do |v|
-    time = true
-  end
-
-  opts.on('--push-results', 'Push test results to the push process') do |v|
-    push_results = v
-  end
-
-  opts.on('--preload FILE', "Preload this file instead of #{preload}") do |v|
-    preload = v
-  end
-
-  opts.separator "General Options:"
-  opts.on('-e', 'Stub to keep kicker happy')
-  opts.on('-h', '--help') do
-    $stderr.puts opts
-    exit 1
-  end
-end
-options.parse!
-
-subcommand = ARGV.shift
-case subcommand
-when 'serve' then serve(force_rspec, force_testunit, time, push_results, preload)
-when 'push' then push(preload)
-else
-  $stderr.puts options
-  exit 1
-end
-
+require 'spin/cli'
+Spin::CLI.run(ARGV)

data/lib/spin.rb

@@ -0,0 +1,289 @@
+require 'spin/version'
+require 'spin/hooks'
+require 'socket'
+require 'tempfile' # Dir.tmpdir
+# 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 'pathname'
+
+module Spin
+  extend Spin::Hooks
+
+  PUSH_FILE_SEPARATOR = '|'
+
+  class << self
+    def serve(options)
+      ENV['RAILS_ENV'] = 'test' unless ENV['RAILS_ENV']
+
+      if root_path = rails_root(options[:preload])
+        Dir.chdir(root_path)
+        Spin.parse_hook_file(root_path)
+      else
+        warn "Could not find #{options[:preload]}. Are you running this from the root of a Rails project?"
+      end
+
+      open_socket do |socket|
+        preload(options) if root_path
+
+        puts "Pushing test results back to push processes" if options[:push_results]
+
+        loop do
+          run_pushed_tests(socket, options)
+        end
+      end
+    end
+
+    def push(argv, options)
+      files_to_load = convert_push_arguments_to_files(argv)
+
+      if root_path = rails_root(options[:preload])
+        make_files_relative(files_to_load, root_path)
+        Dir.chdir root_path
+      end
+
+      files_to_load << "tty?" if $stdout.tty?
+
+      abort if files_to_load.empty?
+
+      puts "Spinning up #{files_to_load.join(" ")}"
+      send_files_to_serve(files_to_load)
+    end
+
+    private
+
+    def send_files_to_serve(files_to_load)
+      # 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 files_to_load.join(PUSH_FILE_SEPARATOR)
+
+      while line = socket.readpartial(100)
+        break if line[-1,1] == "\0"
+        print line
+      end
+    rescue Errno::ECONNREFUSED, Errno::ENOENT
+      abort "Connection was refused. Have you started up `spin serve` yet?"
+    end
+
+    # The filenames that we will spin up to `spin serve` are passed in as
+    # arguments.
+    def convert_push_arguments_to_files(argv)
+      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.
+      files_to_load = files_to_load.map do |file|
+        args = file.split(':')
+
+        file_name = args.first.to_s
+        line_number = args.last.to_i
+
+        # If the file exists then we can push it up just like it is
+        file_name = if File.exist?(file_name)
+          file_name
+          # kicker-2.5.0 now gives us file names without extensions, so we have to try adding it
+        elsif File.extname(file_name).empty?
+          full_file_name = [file_name, 'rb'].join('.')
+          full_file_name if File.exist?(full_file_name)
+        end
+
+        if line_number > 0
+          abort "You specified a line number. Only one file can be pushed in this case." if files_to_load.length > 1
+
+          "#{file_name}:#{line_number}"
+        else
+          file_name
+        end
+      end.reject(&:empty?).uniq
+    end
+
+    def make_files_relative(files_to_load, root_path)
+      files_to_load.map! do |file|
+        Pathname.new(file).expand_path.relative_path_from(root_path).to_s
+      end
+    end
+
+    def run_pushed_tests(socket, options)
+      rerun_last_tests_on_quit(options) unless options[:push_results]
+
+      # 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(PUSH_FILE_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 options[:time]
+
+      # If we're not sending results back to the push process, we can disconnect
+      # it immediately.
+      disconnect(conn) unless options[:push_results]
+
+      fork_and_run(files, conn, options)
+
+      # 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.
+      Process.wait
+
+      # 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.
+      begin
+        disconnect(conn) if options[:push_results]
+      rescue Errno::EPIPE
+        # Don't abort if the client already disconnected
+      end
+    end
+
+    # Trap SIGQUIT (Ctrl+\) and re-run the last files that were pushed
+    # TODO test this
+    def rerun_last_tests_on_quit(options)
+      trap('QUIT') do
+        fork_and_run(@last_files_ran, nil, options)
+        Process.wait
+      end
+    end
+
+    def preload(options)
+      duration = Benchmark.realtime do
+        # 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.
+        execute_hook(:before_preload)
+        require File.expand_path options[:preload].sub('.rb', '')
+        execute_hook(:after_preload)
+
+        # Determine the test framework to use using the passed-in 'force' options
+        # or else default to checking for defined constants.
+        options[:test_framework] ||= determine_test_framework
+
+        # Preload RSpec to save some time on each test run
+        if options[:test_framework]
+          begin
+            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=)
+              end
+            end
+          rescue LoadError
+          end
+        end
+      end
+      # This is the amount of time that you'll save on each subsequent test run.
+      puts "Preloaded Rails env in #{duration}s..."
+    end
+
+    # This socket is how we communicate with `spin push`.
+    # 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.
+    def open_socket
+      file = socket_file
+      File.delete(file) if File.exist?(file)
+      socket = UNIXServer.open(file)
+
+      # Trap SIGINT (Ctrl-C) so that we exit cleanly.
+      trap('SIGINT') do
+        socket.close
+        exit
+      end
+
+      yield socket
+    ensure
+      File.delete(file) if file && File.exist?(file)
+    end
+
+    def determine_test_framework
+      if defined?(RSpec)
+        :rspec
+      else
+        :testunit
+      end
+    end
+
+    def disconnect(connection)
+      connection.print "\0"
+      connection.close
+    end
+
+    def rails_root(preload)
+      path = Pathname.pwd
+      until path.join(preload).file?
+        return if path.root?
+        path = path.parent
+      end
+      path
+    end
+
+    def fork_and_run(files, conn, options)
+      execute_hook(:before_fork)
+      # 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.
+        tty = files.delete "tty?"
+        if options[:push_results]
+          $stdout.reopen(conn)
+          if tty
+            def $stdout.tty?
+              true
+            end
+          end
+          $stderr.reopen(conn)
+        end
+
+        execute_hook(:after_fork)
+
+        puts
+        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 options[:test_framework] == :rspec
+          # We pretend the filepath came in as an argument and duplicate the
+          # behaviour of the `rspec` binary.
+          ARGV.concat files
+        else
+          # We require the full path of the file here in the child process.
+          files.each { |f| require File.expand_path f }
+        end
+      end
+      @last_files_ran = files
+    end
+
+    def socket_file
+      key = Digest::MD5.hexdigest [Dir.pwd, 'spin-gem'].join
+      [Dir.tmpdir, key].join('/')
+    end
+  end
+end

data/lib/spin/cli.rb

@@ -0,0 +1,54 @@
+require 'spin'
+require 'optparse'
+
+module Spin
+  module CLI
+    class << self
+      def run(argv)
+        options = {
+          :preload => "config/application.rb"
+        }
+
+        parser = 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|
+            $LOAD_PATH.concat(dirs.split(File::PATH_SEPARATOR))
+          end
+
+          opts.on("--rspec", "Force the selected test framework to RSpec") { options[:test_framework] = :testunit }
+          opts.on("--test-unit", "Force the selected test framework to Test::Unit") { options[:test_framework] = :rspec }
+          opts.on("-t", "--time", "See total execution time for each test run") { options[:time] = true }
+          opts.on("--push-results", "Push test results to the push process") { options[:push_results] = true }
+          opts.on("--preload FILE", "Preload this file instead of #{options[:preload]}") { |v| options[:preload] = v }
+          opts.separator "General Options:"
+          opts.on("-e", "Stub to keep kicker happy")
+          opts.on("-v", "--version", "Show Version") { puts Spin::VERSION; exit }
+          opts.on("-h", "--help") { $stderr.puts opts; exit }
+        end
+        parser.parse!
+
+        subcommand = argv.shift
+        case subcommand
+        when "serve" then Spin.serve(options)
+        when "push" then Spin.push(argv, options)
+        else
+          $stderr.puts parser
+          exit 1
+        end
+      end
+
+      private
+
+      def usage
+        <<-USAGE.gsub(/^\s{8}/,"")
+          Usage: spin serve
+                 spin push <file> <file>...
+          Spin preloads your Rails environment to speed up your autotest(ish) workflow.
+        USAGE
+      end
+    end
+  end
+end

data/lib/spin/hooks.rb

@@ -0,0 +1,28 @@
+module Spin
+  module Hooks
+    HOOKS = [:before_fork, :after_fork, :before_preload, :after_preload]
+
+    def hook(name, &block)
+      raise unless HOOKS.include?(name)
+      _hooks(name) << block
+    end
+
+    def execute_hook(name)
+      raise unless HOOKS.include?(name)
+      _hooks(name).each(&:call)
+    end
+
+    def parse_hook_file(root)
+      file = root.join(".spin.rb")
+      load(file) if File.exist?(file)
+    end
+
+    private
+
+    def _hooks(name)
+      @hooks ||= {}
+      @hooks[name] ||= []
+      @hooks[name]
+    end
+  end
+end

data/lib/spin/version.rb

@@ -0,0 +1,3 @@
+module Spin
+  VERSION = "0.6.0"
+end

data/spec/integration_spec.rb

@@ -0,0 +1,234 @@
+
+describe "Spin" do
+  before do
+    # kill all Threads that might be hanging around
+    Thread.list.each { |thread| thread.exit unless thread == Thread.current }
+  end
+
+  around do |example|
+    folder = File.expand_path("../tmp", __FILE__)
+    `rm -rf #{folder}`
+    ensure_folder folder
+    Dir.chdir folder do
+      example.call
+    end
+    `rm -rf #{folder}`
+  end
+
+  def root
+    File.expand_path '../..', __FILE__
+  end
+
+  def spin(command, options={})
+    command = spin_command(command)
+    result = `#{command}`
+    raise "FAILED #{command}\n#{result}" if $?.success? == !!options[:fail]
+    result
+  end
+
+  def spin_command(command)
+    "ruby -I #{root}/lib #{root}/bin/spin #{command} 2>&1"
+  end
+
+  def record_serve(output, command)
+    IO.popen(spin_command("serve #{command}")) do |pipe|
+      while str = pipe.readpartial(100)
+        output << str
+      end rescue EOFError
+    end
+  end
+
+  def write(file, content)
+    ensure_folder File.dirname(file)
+    File.open(file, 'w'){|f| f.write content }
+  end
+
+  def read(file)
+    File.read file
+  end
+
+  def delete(file)
+    `rm #{file}`
+  end
+
+  def ensure_folder(folder)
+    `mkdir -p #{folder}` unless File.exist?(folder)
+  end
+
+  def serve_and_push(serve_command, push_commands)
+    serve_output = ""
+    t1 = Thread.new { record_serve(serve_output, serve_command) }
+    sleep 0.1
+    push_output = [*push_commands].map{ |cmd| spin("push #{cmd}") }
+    sleep 0.2
+    t1.kill
+    [serve_output, push_output]
+  end
+
+  context "with simple setup" do
+    before do
+      write "config/application.rb", "$xxx = 1234"
+      write "test/foo_test.rb", "puts $xxx * 2"
+      @default_pushed = "Spinning up test/foo_test.rb\n"
+    end
+
+    it "shows help when no arguments are given" do
+      spin("", :fail => true).should include("General Options:")
+    end
+
+    it "can serve and push" do
+      served, pushed = serve_and_push("", "test/foo_test.rb")
+      served.should include "Preloaded Rails env in "
+      served.should include "2468"
+      pushed.first.should == @default_pushed
+    end
+
+    it "can run files without .rb extension" do
+      served, pushed = serve_and_push("", "test/foo_test")
+      served.should include "Preloaded Rails env in "
+      served.should include "2468"
+      pushed.first.should == @default_pushed
+    end
+
+    it "can run multiple times" do
+      write "test/foo_test.rb", "puts $xxx *= 2"
+      served, pushed = serve_and_push("", ["test/foo_test.rb", "test/foo_test.rb", "test/foo_test.rb"])
+      served.should include "Preloaded Rails env in "
+      served.scan("2468").size.should == 3
+      pushed.size.should == 3
+      pushed.each{|x| x.should == @default_pushed }
+    end
+
+    it "can run multiple files at once" do
+      write "test/bar_test.rb", "puts $xxx / 2"
+      served, pushed = serve_and_push("", "test/foo_test.rb test/bar_test.rb")
+      served.should include "Preloaded Rails env in "
+      served.should include "2468"
+      served.should include "617"
+      pushed.first.should == "Spinning up test/foo_test.rb test/bar_test.rb\n"
+    end
+
+    it "complains when the preloaded file cannot be found" do
+      delete "config/application.rb"
+      write "test/foo_test.rb", "puts 2468"
+      served, pushed = serve_and_push("", "test/foo_test.rb")
+      served.should_not include "Preloaded Rails env in "
+      served.should include "Could not find config/application.rb. Are you running"
+      served.should include "2468"
+      pushed.first.should == @default_pushed
+    end
+
+    context "RSpec" do
+      before do
+        write "config/application.rb", "module RSpec;end"
+      end
+
+      it "can run files" do
+        write "spec/foo_spec.rb", "RSpec.configure{}; puts 'YES'"
+        served, pushed = serve_and_push("", "spec/foo_spec.rb")
+        served.should include "YES"
+      end
+
+      it "can run by line" do
+        write "spec/foo_spec.rb", <<-RUBY
+          describe "x" do
+            it("a"){ puts "AAA" }
+            it("b"){ puts "BBB" }
+            it("c"){ puts "CCC" }
+          end
+        RUBY
+        served, pushed = serve_and_push("", "spec/foo_spec.rb:3")
+        served.should_not include "AAA"
+        served.should include "BBB"
+        served.should_not include "CCC"
+      end
+    end
+
+    context "options" do
+      it "can show current version" do
+        spin("--version").should =~ /^\d+\.\d+\.\d+/
+      end
+
+      it "can show help" do
+        spin("--help").should include("General Options:")
+      end
+
+      it "can --push-results" do
+        served, pushed = serve_and_push("--push-results", "test/foo_test.rb")
+        served.should include "Preloaded Rails env in "
+        served.should_not include "2468"
+        pushed.first.should include "2468"
+      end
+
+      it "can --preload a different file" do
+        write "config/application.rb", "raise"
+        write "config/environment.rb", "$xxx = 1234"
+        served, pushed = serve_and_push("--preload config/environment.rb", "test/foo_test.rb")
+        served.should include "Preloaded Rails env in "
+        served.should include "2468"
+        pushed.first.should == @default_pushed
+      end
+
+      it "can add load paths via -I" do
+        write "lib/bar.rb", "puts 'bar'"
+        write "test/foo_test.rb", "require 'bar'"
+        served, pushed = serve_and_push("-Itest:lib", "test/foo_test.rb")
+        served.should include "bar"
+        pushed.first.should == @default_pushed
+      end
+
+      it "ignores -e" do
+        served, pushed = serve_and_push("-e", "test/foo_test.rb -e")
+        served.should include "Preloaded Rails env in "
+        served.should include "2468"
+        pushed.first.should == @default_pushed
+      end
+
+      # TODO process never reaches after the fork block with only 1 push command
+      it "can show total execution time" do
+        served, pushed = serve_and_push("--time", ["test/foo_test.rb", "test/foo_test.rb"])
+        served.should include "Total execution time was 0."
+        pushed.first.should == @default_pushed
+      end
+    end
+
+    context "hooks" do
+      before do
+        write "config/application.rb", "$calls << :real_preload"
+        write "test/calls_test.rb", "puts '>>' + $calls.inspect + '<<'"
+      end
+
+      it "calls preload hooks in correct order" do
+        write ".spin.rb", <<-RUBY
+          $calls = []
+          [:before_preload, :after_preload].each do |hook|
+            Spin.hook(hook) { $calls << hook }
+          end
+        RUBY
+        served, pushed = serve_and_push("--time", "test/calls_test.rb")
+        served[/>>.*<</].should == ">>[:before_preload, :real_preload, :after_preload]<<"
+      end
+
+      it "can have multiple hooks" do
+        write ".spin.rb", <<-RUBY
+          $calls = []
+          Spin.hook(:before_preload) { $calls << :before_preload_1 }
+          Spin.hook(:before_preload) { $calls << :before_preload_2 }
+        RUBY
+        served, pushed = serve_and_push("--time", "test/calls_test.rb")
+        served[/>>.*<</].should == ">>[:before_preload_1, :before_preload_2, :real_preload]<<"
+      end
+
+      it "can hook before/after fork" do
+        write ".spin.rb", <<-RUBY
+          $calls = []
+          [:before_fork, :after_fork].each do |hook|
+            Spin.hook(hook) { $calls << hook }
+          end
+        RUBY
+        served, pushed = serve_and_push("--time", "test/calls_test.rb")
+        served[/>>.*<</].should == ">>[:real_preload, :before_fork, :after_fork]<<"
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: spin
 version: !ruby/object:Gem::Version
-  version: 0.5.3
+  version: 0.6.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-07-27 00:00:00.000000000 Z
+date: 2013-02-13 00:00:00.000000000 Z
 dependencies: []
 description: ! 'Spin preloads your Rails environment to speed up your autotest(ish)
   workflow.
@@ -24,8 +24,13 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
-- !binary |-
-  YmluL3NwaW4=
+- README.md
+- lib/spin/cli.rb
+- lib/spin/hooks.rb
+- lib/spin/version.rb
+- lib/spin.rb
+- spec/integration_spec.rb
+- bin/spin
 homepage: http://jstorimer.github.com/spin
 licenses: []
 post_install_message: 
@@ -46,8 +51,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.11
+rubygems_version: 1.8.25
 signing_key: 
 specification_version: 3
 summary: Spin preloads your Rails environment to speed up your autotest(ish) workflow.
-test_files: []
+test_files:
+- spec/integration_spec.rb