spin 0.6.0 → 0.7.0

data/README.md

@@ -1,6 +1,8 @@
 Spin
 ====
 
+[![Build Status](https://travis-ci.org/jstorimer/spin.png)](https://travis-ci.org/jstorimer/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...
@@ -133,4 +135,4 @@ If Spin isn't scratching your itch then one of these projects might:
 * [Spork](https://github.com/sporkrb/spork)
 * [TestR](https://github.com/sunaku/testr)
 * [Zeus](https://github.com/burke/zeus)
-
+* [Spring](https://github.com/jonleighton/spring)

data/lib/spin.rb

@@ -1,5 +1,7 @@
 require 'spin/version'
 require 'spin/hooks'
+require 'spin/test_process'
+require 'spin/logger'
 require 'socket'
 require 'tempfile' # Dir.tmpdir
 # This lets us hash the parameters we want to include in the filename
@@ -14,6 +16,9 @@ module Spin
   extend Spin::Hooks
 
   PUSH_FILE_SEPARATOR = '|'
+  ARGS_SEPARATOR = ' -- '
+  # The time window used to detect 2 successive SIGINT (Ctrl+C) signals.
+  SIGINT_TIME_WINDOW = 5
 
   class << self
     def serve(options)
@@ -23,13 +28,15 @@ module Spin
         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?"
+        logger.warn "Could not find #{options[:preload]}. Are you running this from the root of a Rails project?"
       end
 
+      set_server_process_pid
+
       open_socket do |socket|
         preload(options) if root_path
 
-        puts "Pushing test results back to push processes" if options[:push_results]
+        logger.info "Pushing test results back to push processes" if options[:push_results]
 
         loop do
           run_pushed_tests(socket, options)
@@ -37,6 +44,20 @@ module Spin
       end
     end
 
+    def logger
+      @logger ||= Spin::Logger.new
+    end
+
+    # Called by the Spin server process to store its process pid.
+    def set_server_process_pid
+      @server_process_pid = Process.pid
+    end
+
+    # Returns +true+ if the current process is the Spin server process.
+    def server_process?
+      @server_process_pid == Process.pid
+    end
+
     def push(argv, options)
       files_to_load = convert_push_arguments_to_files(argv)
 
@@ -49,19 +70,21 @@ module Spin
 
       abort if files_to_load.empty?
 
-      puts "Spinning up #{files_to_load.join(" ")}"
-      send_files_to_serve(files_to_load)
+      logger.info "Spinning up #{files_to_load.join(" ")}"
+      send_files_to_serve(files_to_load, options[:trailing_pushed_args] || [])
     end
 
     private
 
-    def send_files_to_serve(files_to_load)
+    def send_files_to_serve(files_to_load, trailing_args)
       # 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)
+      payload = files_to_load.join(PUSH_FILE_SEPARATOR)
+      payload += "#{ARGS_SEPARATOR}#{trailing_args.join(PUSH_FILE_SEPARATOR)}" unless trailing_args.empty?
+      socket.puts payload
 
       while line = socket.readpartial(100)
         break if line[-1,1] == "\0"
@@ -101,9 +124,9 @@ module Spin
 
           "#{file_name}:#{line_number}"
         else
-          file_name
+          file_name.to_s
         end
-      end.reject(&:empty?).uniq
+      end.compact.reject(&:empty?).uniq
     end
 
     def make_files_relative(files_to_load, root_path)
@@ -115,11 +138,15 @@ module Spin
     def run_pushed_tests(socket, options)
       rerun_last_tests_on_quit(options) unless options[:push_results]
 
+      notify_ready
+
       # 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, trailing_args = files.split(ARGS_SEPARATOR)
+      options[:trailing_args] = trailing_args.nil? ? [] : trailing_args.split(PUSH_FILE_SEPARATOR)
       files = files.split(PUSH_FILE_SEPARATOR)
 
       # If spin is started with the time flag we will track total execution so
@@ -132,15 +159,9 @@ module Spin
 
       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
+      logger.info "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.
@@ -154,10 +175,33 @@ module Spin
     # 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
+      trap('QUIT') { sigquit_handler(options) }
+    end
+
+    # This method is called when a SIGQUIT ought to be handled.
+    def sigquit_handler(options)
+      # If the current process is not the Spin server process, ignore the
+      # signal by doing nothing.
+      return unless server_process?
+
+      unless @last_files_ran
+        logger.fatal "Cannot rerun last tests, please push a file to Spin server first"
+        return
+      end
+
+      if test_process.alive?
+        logger.fatal "Cannot rerun last tests, test process #{test_process} still alive"
+        return
       end
+
+      fork_and_run(@last_files_ran, nil, options.merge(:trailing_args => @last_trailing_args_used))
+
+      notify_ready
+    end
+
+    # Notify the user that Spin server is ready for new tests.
+    def notify_ready
+      logger.info "Ready"
     end
 
     def preload(options)
@@ -181,7 +225,7 @@ module Spin
         options[:test_framework] ||= determine_test_framework
 
         # Preload RSpec to save some time on each test run
-        if options[:test_framework]
+        if options[:test_framework] == :rspec
           begin
             require 'rspec/autorun'
 
@@ -196,7 +240,7 @@ module Spin
         end
       end
       # This is the amount of time that you'll save on each subsequent test run.
-      puts "Preloaded Rails env in #{duration}s..."
+      logger.info "Preloaded Rails environment in #{duration.round(2)}s"
     end
 
     # This socket is how we communicate with `spin push`.
@@ -208,17 +252,40 @@ module Spin
       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
+      trap('SIGINT') { sigint_handler(socket) }
 
       yield socket
     ensure
       File.delete(file) if file && File.exist?(file)
     end
 
+    # This method is called when a SIGINT ought to be handled.
+    def sigint_handler(socket)
+      # If the current process is not the Spin server process, allow the signal
+      # to "bubble up" by exiting.
+      exit unless server_process?
+
+      if sigint_recently_sent?
+        socket.close
+        exit
+      else
+        set_last_sigint_sent
+        logger.info "Press Ctrl+C again (within #{SIGINT_TIME_WINDOW}s) to exit"
+      end
+    end
+
+    # Updates the timestamp when the last SIGINT was sent.
+    def set_last_sigint_sent
+      @last_sigint_sent = Time.now
+    end
+
+    # Returns +true+ if a SIGINT has been sent within the time window.
+    def sigint_recently_sent?
+      return if @last_sigint_sent.nil?
+
+      (Time.now - SIGINT_TIME_WINDOW) < @last_sigint_sent
+    end
+
     def determine_test_framework
       if defined?(RSpec)
         :rspec
@@ -241,12 +308,17 @@ module Spin
       path
     end
 
+    # Returns (and caches) a TestProcess instance.
+    def test_process
+      @test_process ||= Spin::TestProcess.new
+    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
+      test_process.pid = 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.
@@ -263,8 +335,11 @@ module Spin
 
         execute_hook(:after_fork)
 
-        puts
-        puts "Loading #{files.inspect}"
+        logger.info "Loading #{files.inspect}"
+
+        trailing_args = options[:trailing_args]
+        logger.info "Will run with: #{trailing_args.inspect}" unless trailing_args.empty?
+
 
         # 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
@@ -272,13 +347,21 @@ module Spin
         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
+          ARGV.concat(files + trailing_args)
         else
+          # Pass any additional push arguments to the test runner
+          ARGV.concat trailing_args
           # 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
+      @last_trailing_args_used = options[:trailing_args]
+
+      # 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.
+      test_process.wait
     end
 
     def socket_file

data/lib/spin/cli.rb

@@ -18,8 +18,8 @@ module Spin
             $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("--rspec", "Force the selected test framework to RSpec") { options[:test_framework] = :rspec }
+          opts.on("--test-unit", "Force the selected test framework to Test::Unit") { options[:test_framework] = :testunit }
           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 }
@@ -27,13 +27,22 @@ module Spin
           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 }
+          opts.on('--', 'Separates trailing arguments to be forwarded to  the test runner') do |v|
+            trailing_pushed_args = []
+            while opt = ARGV.shift
+              trailing_pushed_args << opt
+            end
+            options[:trailing_pushed_args] = trailing_pushed_args
+          end
         end
         parser.parse!
 
         subcommand = argv.shift
         case subcommand
-        when "serve" then Spin.serve(options)
-        when "push" then Spin.push(argv, options)
+        when "serve", "s"
+          then Spin.serve(options)
+        when "push", "p"
+          then Spin.push(argv, options)
         else
           $stderr.puts parser
           exit 1

data/lib/spin/logger.rb

@@ -0,0 +1,42 @@
+require 'logger'
+require 'forwardable'
+
+module Spin
+  class Logger
+    extend Forwardable
+
+    attr_reader :logger
+    def_delegators :logger, :fatal,
+                            :error,
+                            :warn,
+                            :info,
+                            :debug
+
+    def initialize
+      @logger = ::Logger.new($stdout)
+      @logger.level = level
+      @logger.formatter = formatter
+    end
+
+  private
+
+    def level
+      ::Logger::INFO
+    end
+
+    def formatter
+      proc { |_, _, _, message| "[#{caller}] #{message}\n" }
+    end
+
+    # Returns a "Spin" label for log entries, with color, if supported.
+    def caller
+      name = "Spin"
+      $stdout.isatty ? cyan(name) : name
+    end
+
+    # Uses ANSI escape codes to create cyan-colored output.
+    def cyan(string)
+      "\e[36m#{string}\e[0m"
+    end
+  end
+end

data/lib/spin/test_process.rb

@@ -0,0 +1,21 @@
+module Spin
+  class TestProcess
+    attr_accessor :pid
+
+    # Use wait(2) to block execution until the test process has finished. When
+    # finished, reset the assigned pid.
+    def wait
+      Process.wait
+      @pid = nil
+    end
+
+    # Returns +true+ if the test process is alive.
+    def alive?
+      !@pid.nil?
+    end
+
+    def to_s
+      @pid.to_s
+    end
+  end
+end

data/lib/spin/version.rb

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

data/spec/integration_spec.rb

@@ -1,10 +1,5 @@
 
 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}`
@@ -15,61 +10,18 @@ describe "Spin" do
     `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]
+  after do
+    kill_all_threads
+    kill_all_children
   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"
+      @log_label = "[Spin]"
+      @default_pushed = "#{@log_label} Spinning up test/foo_test.rb\n"
+      @preloaded_message = "Preloaded Rails environment in "
     end
 
     it "shows help when no arguments are given" do
@@ -78,14 +30,14 @@ describe "Spin" do
 
     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 @preloaded_message
       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 @preloaded_message
       served.should include "2468"
       pushed.first.should == @default_pushed
     end
@@ -93,7 +45,7 @@ describe "Spin" do
     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.should include @preloaded_message
       served.scan("2468").size.should == 3
       pushed.size.should == 3
       pushed.each{|x| x.should == @default_pushed }
@@ -102,17 +54,17 @@ describe "Spin" do
     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 @preloaded_message
       served.should include "2468"
       served.should include "617"
-      pushed.first.should == "Spinning up test/foo_test.rb test/bar_test.rb\n"
+      pushed.first.should == "#{@log_label} 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_not include @preloaded_message
       served.should include "Could not find config/application.rb. Are you running"
       served.should include "2468"
       pushed.first.should == @default_pushed
@@ -142,6 +94,19 @@ describe "Spin" do
         served.should include "BBB"
         served.should_not include "CCC"
       end
+
+      it "can pass trailing arguments to the spec runner" 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 -- --profile"])
+        served.should include 'Will run with: ["--profile"]'
+        served.should include 'Top 3 slowest examples'
+      end
     end
 
     context "options" do
@@ -155,7 +120,7 @@ describe "Spin" do
 
       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 include @preloaded_message
         served.should_not include "2468"
         pushed.first.should include "2468"
       end
@@ -164,7 +129,7 @@ describe "Spin" 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 @preloaded_message
         served.should include "2468"
         pushed.first.should == @default_pushed
       end
@@ -179,7 +144,7 @@ describe "Spin" do
 
       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 @preloaded_message
         served.should include "2468"
         pushed.first.should == @default_pushed
       end
@@ -190,6 +155,12 @@ describe "Spin" do
         served.should include "Total execution time was 0."
         pushed.first.should == @default_pushed
       end
+
+      it "can pass trailing arguments to the test runner" do
+        served, pushed = serve_and_push("", ["test/foo_test.rb -- -n /validates/"])
+        served.should include 'Will run with: ["-n", "/validates/"]'
+        pushed.first.should == @default_pushed
+      end
     end
 
     context "hooks" do
@@ -231,4 +202,74 @@ describe "Spin" do
       end
     end
   end
+
+  private
+
+  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
+
+  def kill_all_threads
+    Thread.list.each { |thread| thread.exit unless thread == Thread.current }
+  end
+
+  def kill_all_children
+    children = child_pids
+    `kill -9 #{children.join(" ")}` unless children.empty?
+  end
+
+  def child_pids
+    pid = Process.pid
+    pipe = IO.popen("ps -ef | grep #{pid}")
+    pipe.readlines.map do |line|
+      parts = line.split(/\s+/)
+      parts[2] if parts[3] == pid.to_s and parts[2] != pipe.pid.to_s
+    end.compact
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: spin
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,8 +9,40 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-02-13 00:00:00.000000000 Z
-dependencies: []
+date: 2013-07-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.13.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.13.0
 description: ! 'Spin preloads your Rails environment to speed up your autotest(ish)
   workflow.
 
@@ -27,6 +59,8 @@ files:
 - README.md
 - lib/spin/cli.rb
 - lib/spin/hooks.rb
+- lib/spin/logger.rb
+- lib/spin/test_process.rb
 - lib/spin/version.rb
 - lib/spin.rb
 - spec/integration_spec.rb
@@ -51,7 +85,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.25
+rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
 summary: Spin preloads your Rails environment to speed up your autotest(ish) workflow.