guard-spork 0.3.2 → 0.4.0

data/README.md

@@ -1,131 +1,133 @@
-# Guard::Spork [![Build Status](https://secure.travis-ci.org/guard/guard-spork.png)](http://travis-ci.org/guard/guard-spokr)
-
-Guard::Spork allows to automatically & intelligently start/reload your RSpec/Cucumber/Test::Unit [Spork](https://github.com/timcharper/spork) server(s).
-
-* Compatible with Spork 0.8.4 & 0.9.0.rcX.
-* Tested against Ruby 1.8.7, 1.9.2, REE and the latest versions of JRuby & Rubinius.
-
-## Install
-
-Please be sure to have [Guard](https://github.com/guard/guard) installed before continue.
-
-Install the gem:
-
-    $ gem install guard-spork
-
-Add it to your Gemfile (inside test group):
-
-    gem 'guard-spork'
-
-Add guard definition to your Guardfile with:
-
-    $ guard init spork
-
-## Usage
-
-Please read the [Guard usage documentation](https://github.com/guard/guard#readme).
-
-## Guardfile
-
-Please read [Guard doc](https://github.com/guard/guard#readme) for more info about the Guardfile DSL.
-
-**IMPORTANT: place Spork guard before RSpec/Cucumber/Test::Unit guards!**
-
-### Rails app
-
-``` ruby
-guard 'spork' do
-  watch('config/application.rb')
-  watch('config/environment.rb')
-  watch(%r{^config/environments/.*\.rb$})
-  watch(%r{^config/initializers/.*\.rb$})
-  watch('Gemfile')
-  watch('Gemfile.lock')
-  watch('spec/spec_helper.rb')
-  watch('test/test_helper.rb')
-end
-```
-
-### Running specs over Spork
-
-Pass the `:cli => "--drb"` option to [Guard::RSpec](https://github.com/guard/guard-rspec) and/or [Guard::Cucumber](https://github.com/guard/guard-cucumber) to run them over the Spork DRb server:
-
-``` ruby
-guard 'rspec', :cli => "--drb" do
-  # ...
-end
-
-guard 'cucumber', :cli => "--drb" do
-  # ...
-end
-```
-
-For MiniTest Guard you should pass the `:drb => true` option:
-
-``` ruby
-guard 'minitest', :drb => true do
-  # ...
-end
-```
-
-## Options
-
-Guard::Spork automatically detect RSpec/Cucumber/Test::Unit/Bundler presence but you can disable any of them with the corresponding options:
-
-``` ruby
-guard 'spork', :cucumber => false, :bundler => false do
-  # ...
-end
-```
-
-
-You can provide additional environment variables for RSpec, Cucumber, and Test::Unit with the <tt>:rspec_env</tt>, <tt>:cucumber_env</tt>, and <tt>:test_unit_env</tt> options:
-
-``` ruby
-guard 'spork', :cucumber_env => { 'RAILS_ENV' => 'cucumber' }, :rspec_env => { 'RAILS_ENV' => 'test' }, :test_unit_env => { 'RAILS_ENV' => 'test' } do
-  # ...
-end
-```
-
-Available options:
-
-``` ruby
-:wait => 60                                # Seconds to wait for the server to start, default: 30
-:cucumber => false
-:rspec => false
-:test_unit => false
-:bundler => false                          # Don't use "bundle exec"
-:test_unit_port => 1233                    # Default: 8988
-:rspec_port => 1234                        # Default: 8989
-:cucumber_port => 4321                     # Default: 8990
-:test_unit_env => { 'RAILS_ENV' => 'baz' } # Default: nil
-:rspec_env => { 'RAILS_ENV' => 'foo' }     # Default: nil
-:cucumber_env => { 'RAILS_ENV' => 'bar' }  # Default: nil
-:aggressive_kill => false                 # Default: true, will search Spork pids from `ps aux` and kill them all on start.
-```
-
-## Common troubleshooting
-
-If you can start Spork manually but get the following error message when using Guard::Spork:
-
-  Starting Spork for RSpec ERROR: Could not start Spork for RSpec/Cucumber. Make sure you can use it manually first.
-
-Try to increase the value of the `:wait => 60` option before any further investigation.
-
-## Development
-
-* Source hosted at [GitHub](https://github.com/guard/guard-spork).
-* Report issues and feature requests to [GitHub Issues](https://github.com/guard/guard-spork/issues).
-
-Pull requests are very welcome! Please try to follow these simple "rules", though:
-
-* Please create a topic branch for every separate change you make.
-* Make sure your patches are well tested.
-* Update the README (if applicable).
-* Please **do not change** the version number.
-
-For questions please join us on our [Google group](http://groups.google.com/group/guard-dev) or on `#guard` (irc.freenode.net).
-
-## Author
-
-[Thibaud Guillaume-Gentil](https://github.com/thibaudgg)
+# Guard::Spork [![Build Status](https://secure.travis-ci.org/guard/guard-spork.png)](http://travis-ci.org/guard/guard-spork)
+
+Guard::Spork allows to automatically & intelligently start/reload your RSpec/Cucumber/Test::Unit [Spork](https://github.com/timcharper/spork) server(s).
+
+* Compatible with Spork 0.8.4 & 0.9.0.rcX.
+* Tested against Ruby 1.8.7, 1.9.2, REE and the latest versions of JRuby & Rubinius.
+
+## Install
+
+Please be sure to have [Guard](https://github.com/guard/guard) installed before continue.
+
+Install the gem:
+
+    $ gem install guard-spork
+
+Add it to your Gemfile (inside test group):
+
+    gem 'guard-spork'
+
+Add guard definition to your Guardfile with:
+
+    $ guard init spork
+
+## Usage
+
+Please read the [Guard usage documentation](https://github.com/guard/guard#readme).
+
+## Guardfile
+
+Please read [Guard doc](https://github.com/guard/guard#readme) for more info about the Guardfile DSL.
+
+**IMPORTANT: place Spork guard before RSpec/Cucumber/Test::Unit guards!**
+
+### Rails app
+
+``` ruby
+guard 'spork' do
+  watch('config/application.rb')
+  watch('config/environment.rb')
+  watch(%r{^config/environments/.*\.rb$})
+  watch(%r{^config/initializers/.*\.rb$})
+  watch('Gemfile')
+  watch('Gemfile.lock')
+  watch('spec/spec_helper.rb') { :rspec }
+  watch('test/test_helper.rb') { :test_unit }
+  watch(%r{features/support/}) { :cucumber }
+end
+```
+
+### Running specs over Spork
+
+Pass the `:cli => "--drb"` option to [Guard::RSpec](https://github.com/guard/guard-rspec) and/or [Guard::Cucumber](https://github.com/guard/guard-cucumber) to run them over the Spork DRb server:
+
+``` ruby
+guard 'rspec', :cli => "--drb" do
+  # ...
+end
+
+guard 'cucumber', :cli => "--drb" do
+  # ...
+end
+```
+
+For MiniTest Guard you should pass the `:drb => true` option:
+
+``` ruby
+guard 'minitest', :drb => true do
+  # ...
+end
+```
+
+## Options
+
+Guard::Spork automatically detect RSpec/Cucumber/Test::Unit/Bundler presence but you can disable any of them with the corresponding options:
+
+``` ruby
+guard 'spork', :cucumber => false, :bundler => false do
+  # ...
+end
+```
+
+
+You can provide additional environment variables for RSpec, Cucumber, and Test::Unit with the <tt>:rspec_env</tt>, <tt>:cucumber_env</tt>, and <tt>:test_unit_env</tt> options:
+
+``` ruby
+guard 'spork', :cucumber_env => { 'RAILS_ENV' => 'cucumber' }, :rspec_env => { 'RAILS_ENV' => 'test' }, :test_unit_env => { 'RAILS_ENV' => 'test' } do
+  # ...
+end
+```
+
+Available options:
+
+``` ruby
+:wait => 60                                # Seconds to wait for the server to start, default: 30
+:cucumber => false
+:rspec => false
+:test_unit => false
+:bundler => false                          # Don't use "bundle exec"
+:test_unit_port => 1233                    # Default: 8988
+:rspec_port => 1234                        # Default: 8989
+:cucumber_port => 4321                     # Default: 8990
+:test_unit_env => { 'RAILS_ENV' => 'baz' } # Default: nil
+:rspec_env => { 'RAILS_ENV' => 'foo' }     # Default: nil
+:cucumber_env => { 'RAILS_ENV' => 'bar' }  # Default: nil
+:aggressive_kill => false                 # Default: true, will search Spork pids from `ps aux` and kill them all on start.
+```
+
+## Common troubleshooting
+
+If you can start Spork manually but get the following error message when using Guard::Spork:
+
+  Starting Spork for RSpec ERROR: Could not start Spork for RSpec/Cucumber. Make sure you can use it manually first.
+
+Try to increase the value of the `:wait => 60` option before any further investigation.
+It's possible that this error is the result of an unnecessary /test directory in the root of your application. Removing the /test directory entirely may resolve this error.
+
+## Development
+
+* Source hosted at [GitHub](https://github.com/guard/guard-spork).
+* Report issues and feature requests to [GitHub Issues](https://github.com/guard/guard-spork/issues).
+
+Pull requests are very welcome! Please try to follow these simple "rules", though:
+
+* Please create a topic branch for every separate change you make.
+* Make sure your patches are well tested.
+* Update the README (if applicable).
+* Please **do not change** the version number.
+
+For questions please join us on our [Google group](http://groups.google.com/group/guard-dev) or on `#guard` (irc.freenode.net).
+
+## Author
+
+[Thibaud Guillaume-Gentil](https://github.com/thibaudgg)

data/lib/guard/spork.rb

@@ -5,15 +5,21 @@ module Guard
   class Spork < Guard
 
     autoload :Runner, 'guard/spork/runner'
+    autoload :SporkInstance, 'guard/spork/spork_instance'
     attr_accessor :runner
 
     def initialize(watchers=[], options={})
       super
       @runner = Runner.new(options)
+
+      # This class will be reinitialized by Guard when the Guardfile
+      # is reevaluated, so we must always begin by trying to clean
+      # up after any hypothetical predecessor
+      runner.reevaluate
     end
 
     def start
-      runner.kill_sporks
+      runner.kill_global_sporks
       runner.launch_sporks("start")
     end
 
@@ -22,9 +28,14 @@ module Guard
       runner.launch_sporks("reload")
     end
 
-    def run_on_change(paths)
-      runner.kill_sporks
-      runner.launch_sporks("reload")
+    def run_on_change(paths_or_symbol)
+      if paths_or_symbol.is_a?(Symbol)
+        runner.kill_sporks(paths_or_symbol)
+        runner.launch_sporks("reload", paths_or_symbol)
+      else
+        runner.kill_sporks
+        runner.launch_sporks("reload")
+      end
     end
 
     def stop

data/lib/guard/spork/runner.rb

@@ -1,188 +1,138 @@
-require 'socket'
-
-module Guard
-  class Spork
-    class Runner
-      attr_accessor :options
-
-      def initialize(options={})
-        options[:wait]           ||= 30 # seconds
-        options[:test_unit_port] ||= 8988
-        options[:cucumber_port]  ||= 8990
-        options[:rspec_port]     ||= 8989
-        options[:rspec_env]      ||= {}
-        options[:test_unit_env]  ||= {}
-        options[:cucumber_env]   ||= {}
-        options[:aggressive_kill]  = true unless options[:aggressive_kill] == false
-        @options  = options
-        ENV['SPORK_PIDS'] ||= ''
-      end
-
-      def launch_sporks(action)
-        UI.info "#{action.capitalize}ing Spork for #{sporked_gems} ", :reset => true
-        spawn_child(options[:test_unit_env], spork_command("test_unit")) if test_unit?
-        spawn_child(options[:rspec_env], spork_command("rspec")) if rspec?
-        spawn_child(options[:cucumber_env], spork_command("cucumber")) if cucumber?
-        verify_launches(action)
-      end
-
-      def kill_sporks
-        UI.debug "Killing Spork servers with PID: #{spork_pids.join(', ')}"
-        spork_pids.each do |pid|
-          ::Process.kill("KILL", pid)
-          remove_children(pid)
-        end
-      end
-
-    private
-
-      def spawn_child(env, cmd)
-        pid = fork
-        raise "Fork failed." if pid == -1
-
-        unless pid
-          if RUBY_VERSION > "1.9"
-            exec(env, cmd)
-          else
-            swap_env(env) { exec(cmd) }
-          end
-        end
-
-        UI.debug "Spawned Spork server #{pid} ('#{cmd}')"
-        add_children(pid)
-        pid
-      end
-
-      def swap_env(env)
-        old_env = {}
-        env.each do |key, value|
-          old_env[key] = ENV[key]
-          ENV[key]     = value
-        end
-
-        yield
-
-        env.each do |key, value|
-          ENV[key] = old_env[key]
-        end
-      end
-
-      def terminated_children
-        stats = []
-        loop do
-          begin
-            pid, stat = ::Process.wait2(-1, ::Process::WNOHANG)
-            break if pid.nil?
-            stats << stat
-          rescue Errno::ECHILD
-            break
-          end
-        end
-        stats
-      end
-
-      def spork_command(type)
-        cmd_parts = []
-        cmd_parts << "bundle exec" if bundler?
-        cmd_parts << "spork"
-
-        case type
-        when "test_unit"
-          cmd_parts << "testunit -p #{options[:test_unit_port]}"
-        when "rspec"
-          cmd_parts << "-p #{options[:rspec_port]}"
-        when "cucumber"
-          cmd_parts << "cu -p #{options[:cucumber_port]}"
-        end
-
-        cmd_parts.join(" ")
-      end
-
-      def verify_launches(action)
-        start_time = Time.now
-        if wait_for_launch(options[:wait])
-          UI.info "Spork server for #{sporked_gems} successfully #{action}ed", :reset => true
-          Notifier.notify "#{sporked_gems} successfully #{action}ed", :title => "Spork", :image => :success          
-        else
-          UI.reset_line # workaround before Guard::UI update
-          UI.error "Could not #{action} Spork server for #{sporked_gems} after #{options[:wait]} seconds. I will continue waiting for a further 60 seconds."
-          Notifier.notify "#{sporked_gems} NOT #{action}ed. Continuing to wait for 60 seconds.", :title => "Spork", :image => :failed
-          if wait_for_launch(60)
-            total_time = Time.now - start_time
-            UI.info "Spork server for #{sporked_gems} eventually #{action}ed after #{total_time.to_i} seconds. Consider adjusting your :wait option beyond this time.", :reset => true
-            Notifier.notify "#{sporked_gems} eventually #{action}ed after #{total_time.to_i} seconds", :title => "Spork", :image => :success
-          else 
-            UI.reset_line # workaround before Guard::UI update
-            UI.error "Could not #{action} Spork server for #{sporked_gems}. Make sure you can use it manually first."
-            Notifier.notify "#{sporked_gems} NOT #{action}ed", :title => "Spork", :image => :failed
-            throw :task_has_failed
-          end
-        end
-      end
-      
-      def wait_for_launch(wait)
-        wait.times do
-          sleep 1
-          begin
-            TCPSocket.new('localhost', options[:test_unit_port]).close if test_unit?
-            TCPSocket.new('localhost', options[:rspec_port]).close if rspec?
-            TCPSocket.new('localhost', options[:cucumber_port]).close if cucumber?
-          rescue Errno::ECONNREFUSED
-            next
-          end
-          return true # Success
-        end
-        return false # Failure
-      end
-
-      def add_children(pid)
-        pids              = spork_pids << pid
-        ENV['SPORK_PIDS'] = pids.join(',')
-      end
-
-      def remove_children(pid)
-        pids              = spork_pids
-        deleted_pid       = pids.delete(pid)
-        ENV['SPORK_PIDS'] = pids.join(',')
-        deleted_pid
-      end
-
-      def spork_pids
-        if ENV['SPORK_PIDS'] == '' && options[:aggressive_kill]
-          ps_spork_pids
-        else
-          ENV['SPORK_PIDS'].split(',').map { |pid| pid.to_i }
-        end
-      end
-
-      def ps_spork_pids
-        `ps aux | awk '/spork/&&!/awk/{print $2;}'`.split("\n").map { |pid| pid.to_i }
-      end
-
-      def sporked_gems
-        gems = []
-        gems << "Test::Unit" if test_unit?
-        gems << "RSpec" if rspec?
-        gems << "Cucumber" if cucumber?
-        gems.join(' & ')
-      end
-
-      def bundler?
-        @bundler ||= File.exist?("#{Dir.pwd}/Gemfile") && options[:bundler] != false
-      end
-
-      def test_unit?
-        @test_unit ||= File.exist?("#{Dir.pwd}/test/test_helper.rb") && options[:test_unit] != false
-      end
-
-      def rspec?
-        @rspec ||= File.exist?("#{Dir.pwd}/spec") && options[:rspec] != false
-      end
-
-      def cucumber?
-        @cucumber ||= File.exist?("#{Dir.pwd}/features") && options[:cucumber] != false
-      end
-
-    end
-  end
-end
+require 'socket'
+
+module Guard
+  class Spork
+    class Runner
+      attr_accessor :options
+      attr_reader :spork_instances
+
+      def initialize(options={})
+        options[:wait]           ||= 30 # seconds
+        options[:test_unit_port] ||= 8988
+        options[:cucumber_port]  ||= 8990
+        options[:rspec_port]     ||= 8989
+        options[:rspec_env]      ||= {}
+        options[:test_unit_env]  ||= {}
+        options[:cucumber_env]   ||= {}
+        options[:aggressive_kill]  = true unless options[:aggressive_kill] == false
+        @options  = options
+        initialize_spork_instances
+      end
+
+      def launch_sporks(action, type = nil)
+        instances = find_instances(type)
+        UI.info "#{action.capitalize}ing Spork for #{instances.join(', ')}", :reset => true
+        instances.each(&:start)
+        verify_launches(action, instances)
+      end
+
+      def kill_sporks(type = nil)
+        alive = find_instances(type).select(&:alive?)
+        UI.debug "Killing Spork servers with PID: #{alive.map(&:pid).join(', ')}"
+        alive.each(&:stop)
+      end
+
+      def kill_global_sporks
+        if options[:aggressive_kill]
+          kill_global_sporks!
+        end
+      end
+
+      def kill_global_sporks!
+        kill_pids ps_spork_pids
+      end
+
+      def reevaluate
+        if ENV['SPORK_PIDS']
+          kill_pids(ENV['SPORK_PIDS'].split(',').map(&:to_i))
+          ENV.delete('SPORK_PIDS')
+          launch_sporks("reload")
+        end
+      end
+
+    private
+      def initialize_spork_instances
+        @spork_instances = []
+        [:rspec, :cucumber, :test_unit].each do |type|
+          port, env = options[:"#{type}_port"], options[:"#{type}_env"]
+          spork_instances << SporkInstance.new(type, port, env, :bundler => should_use?(:bundler)) if should_use?(type)
+        end
+      end
+
+      def kill_pids(pids)
+        UI.debug "Killing Spork servers with PID: #{pids.join(', ')}"
+        pids.each { |pid| Process.kill("KILL", pid) }
+      end
+
+      def find_instances(type = nil)
+        if type.nil?
+          spork_instances
+        else
+          spork_instances.select { |instance| instance.type == type }
+        end
+      end
+
+      def verify_launches(action, instances)
+        start_time = Time.now
+        names = instances.join(', ')
+
+        if wait_for_launch(instances, options[:wait])
+          UI.info "Spork server for #{names} successfully #{action}ed", :reset => true
+          Notifier.notify "#{names} successfully #{action}ed", :title => "Spork", :image => :success
+        else
+          UI.reset_line # workaround before Guard::UI update
+          UI.error "Could not #{action} Spork server for #{names} after #{options[:wait]} seconds. I will continue waiting for a further 60 seconds."
+          Notifier.notify "#{names} NOT #{action}ed. Continuing to wait for 60 seconds.", :title => "Spork", :image => :failed
+          if wait_for_launch(instances, 60)
+            total_time = Time.now - start_time
+            UI.info "Spork server for #{names} eventually #{action}ed after #{total_time.to_i} seconds. Consider adjusting your :wait option beyond this time.", :reset => true
+            Notifier.notify "#{names} eventually #{action}ed after #{total_time.to_i} seconds", :title => "Spork", :image => :success
+          else
+            UI.reset_line # workaround before Guard::UI update
+            UI.error "Could not #{action} Spork server for #{names}. Make sure you can use it manually first."
+            Notifier.notify "#{names} NOT #{action}ed", :title => "Spork", :image => :failed
+            throw :task_has_failed
+          end
+        end
+      end
+
+      def wait_for_launch(instances, wait)
+        not_running = instances.dup
+        wait.times do
+          sleep 1
+          not_running.delete_if { |instance| instance.running? }
+          return true if not_running.empty?
+        end
+        false
+      end
+
+      def ps_spork_pids
+        `ps aux | awk '/spork/&&!/awk/{print $2;}'`.split("\n").map { |pid| pid.to_i }
+      end
+
+      def should_use?(what)
+        if options[what].nil?
+          send("detect_#{what}")
+        else
+          options[what]
+        end
+      end
+
+      def detect_bundler
+        File.exist?("Gemfile")
+      end
+
+      def detect_test_unit
+        File.exist?("test/test_helper.rb")
+      end
+
+      def detect_rspec
+        File.exist?("spec")
+      end
+
+      def detect_cucumber
+        File.exist?("features")
+      end
+    end
+  end
+end

data/lib/guard/spork/spork_instance.rb

@@ -0,0 +1,87 @@
+module Guard
+  class Spork
+    class SporkInstance
+      attr_reader :type, :env, :port, :options, :pid
+
+      def initialize(type, port, env, options)
+        @type = type
+        @port = port
+        @env = env
+        @options = options
+      end
+
+      def to_s
+        case type
+        when :rspec
+          "RSpec"
+        when :cucumber
+          "Cucumber"
+        when :test_unit
+          "Test::Unit"
+        else
+          type.to_s
+        end
+      end
+
+      def start
+        @pid = fork do
+          exec env, command
+        end
+        store_pid
+      end
+
+      def stop
+        Process.kill('KILL', pid)
+      end
+
+      def alive?
+        return false unless pid
+        Process.waitpid(pid, Process::WNOHANG).nil?
+      end
+
+      def running?
+        return false unless pid
+        TCPSocket.new('localhost', port).close
+        true
+      rescue Errno::ECONNREFUSED
+        false
+      end
+
+      def command
+        parts = []
+        parts << "bundle exec" if use_bundler?
+        parts << "spork"
+
+        if type == :test_unit
+          parts << "testunit"
+        elsif type == :cucumber
+          parts << "cu"
+        end
+
+        parts << "-p #{port}"
+        parts.join(" ")
+      end
+
+      def env_exec(environment, command)
+        if RUBY_VERSION > "1.9"
+          exec environment, command
+        else
+          environment.each_pair { |key, value| ENV[key] = value }
+          exec command
+        end
+      end
+
+      private
+        def use_bundler?
+          options[:bundler]
+        end
+
+        def store_pid
+          # We need to store away the PIDs somewhere safe since
+          # Guard will destroy our class instances when Guardfile is
+          # reevaluated without telling us beforehand
+          ENV['SPORK_PIDS'] = [ENV['SPORK_PIDS'], pid.to_s].compact.join(",")
+        end
+    end
+  end
+end

data/lib/guard/spork/templates/Guardfile

@@ -1,10 +1,11 @@
-guard 'spork', :cucumber_env => { 'RAILS_ENV' => 'test' }, :rspec_env => { 'RAILS_ENV' => 'test' } do
-  watch('config/application.rb')
-  watch('config/environment.rb')
-  watch(%r{^config/environments/.+\.rb$})
-  watch(%r{^config/initializers/.+\.rb$})
-  watch('Gemfile')
-  watch('Gemfile.lock')
-  watch('spec/spec_helper.rb')
-  watch('test/test_helper.rb')
-end
+guard 'spork', :cucumber_env => { 'RAILS_ENV' => 'test' }, :rspec_env => { 'RAILS_ENV' => 'test' } do
+  watch('config/application.rb')
+  watch('config/environment.rb')
+  watch(%r{^config/environments/.+\.rb$})
+  watch(%r{^config/initializers/.+\.rb$})
+  watch('Gemfile')
+  watch('Gemfile.lock')
+  watch('spec/spec_helper.rb') { :rspec }
+  watch('test/test_helper.rb') { :test_unit }
+  watch(%r{features/support/}) { :cucumber }
+end

data/lib/guard/spork/version.rb

@@ -1,5 +1,5 @@
 module Guard
   module SporkVersion
-    VERSION = "0.3.2"
+    VERSION = "0.4.0"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: guard-spork
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 0.4.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-11-18 00:00:00.000000000Z
+date: 2011-12-07 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: guard
-  requirement: &70366766978340 !ruby/object:Gem::Requirement
+  requirement: &70258365044020 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: 0.8.4
   type: :runtime
   prerelease: false
-  version_requirements: *70366766978340
+  version_requirements: *70258365044020
 - !ruby/object:Gem::Dependency
   name: spork
-  requirement: &70366766977880 !ruby/object:Gem::Requirement
+  requirement: &70258365042320 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: 0.8.4
   type: :runtime
   prerelease: false
-  version_requirements: *70366766977880
+  version_requirements: *70258365042320
 - !ruby/object:Gem::Dependency
   name: bundler
-  requirement: &70366766977420 !ruby/object:Gem::Requirement
+  requirement: &70258365039420 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -43,10 +43,10 @@ dependencies:
         version: '1.0'
   type: :development
   prerelease: false
-  version_requirements: *70366766977420
+  version_requirements: *70258365039420
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70366766976960 !ruby/object:Gem::Requirement
+  requirement: &70258365037420 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -54,10 +54,10 @@ dependencies:
         version: '2.6'
   type: :development
   prerelease: false
-  version_requirements: *70366766976960
+  version_requirements: *70258365037420
 - !ruby/object:Gem::Dependency
   name: guard-rspec
-  requirement: &70366766976500 !ruby/object:Gem::Requirement
+  requirement: &70258365026640 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -65,7 +65,7 @@ dependencies:
         version: '0.4'
   type: :development
   prerelease: false
-  version_requirements: *70366766976500
+  version_requirements: *70258365026640
 description: Guard::Spork automatically manage Spork DRb servers.
 email:
 - thibaud@thibaud.me
@@ -74,6 +74,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/guard/spork/runner.rb
+- lib/guard/spork/spork_instance.rb
 - lib/guard/spork/templates/Guardfile
 - lib/guard/spork/version.rb
 - lib/guard/spork.rb
@@ -99,8 +100,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.6
 requirements: []
 rubyforge_project: guard-spork
-rubygems_version: 1.8.9
+rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
 summary: Guard gem for Spork
 test_files: []
+has_rdoc: