spring 1.1.0.beta1 → 1.1.0.beta2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fe796fa453e40306865cb1cf6e6541ca01571d5d
-  data.tar.gz: 7210043ae71cdb012a21734c86984922a8127afe
+  metadata.gz: 9be8bb694add40714afc5a6b350c2efc4a5348d0
+  data.tar.gz: 5af55d085e93f225c9d3ad9cdcbf89739a8dc6e4
 SHA512:
-  metadata.gz: 3c1bcd8097999582b66b2507029e807be714455fe95f70a52e222a3221c5e3921e89ba1131e3b16bd0d775eaae7f65c660b87e65c22526d3e2e79544a226e532
-  data.tar.gz: a0c20068387c73fd9203e6fc408ab1789240e9b244e4e627dc233f04f9850e3c984aca138a81f59b7c553958859e02349c15659910aa789ee95b5595cf95db5c
+  metadata.gz: 38c97ef6b3025ed82fca2d2784ead4c978deaab7226bf8504da55e4e8e7aa9d51ac49f5379ec1d27ab2fa9dd077623b99c8685e9f71c018dbfb74457b9f66958
+  data.tar.gz: d9501f771bdaf0f9b9da74bc4353b6b73baeb99671384034fd8307c90c91ba212aa31e45f868ee6d92bd418da02404570722be2fe2e6a2688acb4600cace8af5

data/.travis.yml

@@ -1,5 +1,4 @@
 language: ruby
-before_install: if [[ "$TRAVIS_RUBY_VERSION" = "1.9.3" ]]; then gem install bundler --version="1.3.5"; else gem install bundler; fi
 rvm:
   - 1.9.3
   - 2.0.0

data/CHANGELOG.md

@@ -2,7 +2,8 @@
 
 * A `bin/spring` binstub is now generated. This allows us to load spring
   correctly if you have it installed locally with a `BUNDLE_PATH`, so
-  it's no longer necessary to install spring system-wide. Note that you
+  it's no longer necessary to install spring system-wide. We also
+  activate the correct version from your Gemfile.lock. Note that you
   still can't have spring in your Gemfile as a git repository or local
   path; it must be a proper gem.
 * Various changes to how springified binstubs are implemented. Existing
@@ -12,6 +13,17 @@
   binstubs. This won't work unless you have upgraded your binstubs to
   the new format.
 * `config/database.yml` is watched
+* Better application restarts - if you introduce an error, for example
+  by editing `config/application.rb`, spring will now continue to watch
+  your files and will immediately try to restart the application when
+  you edit `config/application.rb` again (hopefully to correct the error).
+  This means that by the time you come to run a command the application
+  may well already be running.
+* Gemfile changes are now gracefully handled. Previously they would
+  cause spring to simply quit, meaning that you'd incur the full startup
+  penalty on the next run. Now spring doesn't quit, and will try to load
+  up your new bundle in the background.
+* Fix support for using spring with Rails engines/plugins
 
 ## 1.0.0
 

data/README.md

@@ -1,6 +1,6 @@
 # Spring
 
-[![Build Status](https://travis-ci.org/jonleighton/spring.png?branch=master)](https://travis-ci.org/jonleighton/spring)
+[![Build Status](https://travis-ci.org/rails/spring.png?branch=master)](https://travis-ci.org/rails/spring)
 [![Gem Version](https://badge.fury.io/rb/spring.png)](http://badge.fury.io/rb/spring)
 
 Spring is a Rails application preloader. It speeds up development by
@@ -222,6 +222,52 @@ To use spring like this, do a `gem install spring` and then prefix
 commands with `spring`. For example, rather than running `bin/rake -T`,
 you'd run `spring rake -T`.
 
+## Temporarily disabling Spring
+
+If you're using Spring binstubs, but temporarily don't want commands to
+run through Spring, set the `DISABLE_SPRING` environment variable.
+
+## Class reloading
+
+Spring uses Rails' class reloading mechanism
+(`ActiveSupport::Dependencies`) to keep your code up to date between
+test runs. This is the same mechanism which allows you to see changes
+during development when you refresh the page. However, you may never
+have used this mechanism with your `test` environment before, and this
+can cause problems.
+
+It's important to realise that code reloading means that the constants
+in your application are *different objects* after files have changed:
+
+```
+$ bin/rails runner 'puts User.object_id'
+70127987886040
+$ touch app/models/user.rb
+$ bin/rails runner 'puts User.object_id'
+70127976764620
+```
+
+Suppose you have an initializer `config/initializers/save_user_class.rb`
+like so:
+
+``` ruby
+USER_CLASS = User
+```
+
+This saves off the *first* version of the `User` class, which will not
+be the same object as `User` after the code has been reloaded:
+
+```
+$ bin/rails runner 'puts User == USER_CLASS'
+true
+$ touch app/models/user.rb
+$ bin/rails runner 'puts User == USER_CLASS'
+false
+```
+
+So to avoid this problem, don't save off references to application
+constants in your initialization code.
+
 ## Configuration
 
 Spring will read `~/.spring.rb` and `config/spring.rb` for custom
@@ -250,16 +296,6 @@ which get run when your application initializers, such as
 `config/application.rb`, `config/environments/*.rb` or
 `config/initializers/*.rb`.
 
-For example, if loading your test helper is slow, you might like to
-preload it to speed up your test runs. To do this you could add the
-following to your `config/environments/test.rb`:
-
-``` ruby
-config.after_initialize do
-  require Rails.root.join("test/helper")
-end
-```
-
 ### Running code after forking
 
 You might want to run code after Spring forked off the process but

data/lib/spring/application.rb

@@ -1,40 +1,79 @@
+require "spring/boot"
 require "set"
-require "spring/watcher"
-require "thread"
 
 module Spring
   class Application
-    attr_reader :manager, :watcher, :spring_env
+    attr_reader :manager, :watcher, :spring_env, :original_env
+
+    def initialize(manager, original_env)
+      @manager      = manager
+      @original_env = original_env
+      @spring_env   = Env.new
+      @mutex        = Mutex.new
+      @waiting      = 0
+      @preloaded    = false
+      @state        = :initialized
+      @interrupt    = IO.pipe
+    end
 
-    def initialize(manager, watcher = Spring.watcher)
-      @manager    = manager
-      @watcher    = watcher
-      @spring_env = Env.new
-      @preloaded  = false
-      @mutex      = Mutex.new
-      @waiting    = 0
-      @exiting    = false
+    def state(val)
+      return if exiting?
+      log "#{@state} -> #{val}"
+      @state = val
+    end
 
-      # Workaround for GC bug in Ruby 2 which causes segfaults if watcher.to_io
-      # instances get dereffed.
-      @fds = [manager, watcher.to_io]
+    def state!(val)
+      state val
+      @interrupt.last.write "."
+    end
+
+    def app_env
+      ENV['RAILS_ENV']
     end
 
     def log(message)
-      spring_env.log "[application:#{ENV['RAILS_ENV']}] #{message}"
+      spring_env.log "[application:#{app_env}] #{message}"
     end
 
     def preloaded?
       @preloaded
     end
 
+    def preload_failed?
+      @preloaded == :failure
+    end
+
     def exiting?
-      @exiting
+      @state == :exiting
+    end
+
+    def terminating?
+      @state == :terminating
+    end
+
+    def watcher_stale?
+      @state == :watcher_stale
+    end
+
+    def initialized?
+      @state == :initialized
+    end
+
+    def start_watcher
+      @watcher = Spring.watcher
+      @watcher.on_stale { state! :watcher_stale }
+      @watcher.start
     end
 
     def preload
       log "preloading app"
 
+      begin
+        require "spring/commands"
+      ensure
+        start_watcher
+      end
+
       require Spring.application_root_path.join("config", "application")
 
       # config/environments/test.rb will have config.cache_classes = true. However
@@ -50,45 +89,43 @@ module Spring
       Rails.application.config.cache_classes = false
       disconnect_database
 
+      @preloaded = :success
+    rescue Exception => e
+      @preloaded = :failure
+      watcher.add e.backtrace.map { |line| line.match(/^(.*)\:\d+\:in /)[1] }
+      raise e unless initialized?
+    ensure
       watcher.add loaded_application_features
       watcher.add Spring.gemfile, "#{Spring.gemfile}.lock"
-      watcher.add Rails.application.paths["config/initializers"]
-      watcher.add Rails.application.paths["config/database"]
 
-      @preloaded = true
+      if defined?(Rails)
+        watcher.add Rails.application.paths["config/initializers"]
+        watcher.add Rails.application.paths["config/database"]
+      end
     end
 
     def run
-      log "running"
-      watcher.start
+      state :running
+      manager.puts
+      update_process_title
 
       loop do
-        IO.select(@fds)
-
-        if watcher.stale?
-          log "watcher stale; exiting"
-          manager.close
-          @exiting = true
-          try_exit
-          sleep
+        IO.select [manager, @interrupt.first]
+
+        if terminating? || watcher_stale? || preload_failed?
+          exit
         else
           serve manager.recv_io(UNIXSocket)
         end
       end
     end
 
-    def try_exit
-      @mutex.synchronize {
-        exit if exiting? && @waiting == 0
-      }
-    end
-
     def serve(client)
       log "got client"
       manager.puts
 
-      streams = 3.times.map { client.recv_io }
-      [STDOUT, STDERR].zip(streams).each { |a, b| a.reopen(b) }
+      stdout, stderr, stdin = streams = 3.times.map { client.recv_io }
+      [STDOUT, STDERR].zip([stdout, stderr]).each { |a, b| a.reopen(b) }
 
       preload unless preloaded?
 
@@ -105,13 +142,14 @@ module Spring
 
       pid = fork {
         Process.setsid
-        STDIN.reopen(streams.last)
+        STDIN.reopen(stdin)
         IGNORE_SIGNALS.each { |sig| trap(sig, "DEFAULT") }
+        trap("TERM", "DEFAULT")
 
         ARGV.replace(args)
 
         # Delete all env vars which are unchanged from before spring started
-        Spring.original_env.each { |k, v| ENV.delete k if ENV[k] == v }
+        original_env.each { |k, v| ENV.delete k if ENV[k] == v }
 
         # Load in the current env vars, except those which *were* changed when spring started
         env.each { |k, v| ENV[k] ||= v }
@@ -147,15 +185,37 @@ module Spring
         client.close
 
         @mutex.synchronize { @waiting -= 1 }
-        try_exit
+        exit_if_finished
       }
 
-    rescue => e
+    rescue Exception => e
       log "exception: #{e}"
-      streams.each(&:close) if streams
-      client.puts(1)
+      manager.puts unless pid
+
+      if streams && !e.is_a?(SystemExit)
+        print_exception(stderr, e)
+        streams.each(&:close)
+      end
+
+      client.puts(1) if pid
       client.close
-      raise
+    end
+
+    def terminate
+      state! :terminating
+    end
+
+    def exit
+      state :exiting
+      manager.shutdown(:RDWR)
+      exit_if_finished
+      sleep
+    end
+
+    def exit_if_finished
+      @mutex.synchronize {
+        Kernel.exit if exiting? && @waiting == 0
+      }
     end
 
     # The command might need to require some files in the
@@ -174,7 +234,8 @@ module Spring
     end
 
     def loaded_application_features
-      $LOADED_FEATURES.select { |f| f.start_with?(File.realpath(Rails.root)) }
+      root = Spring.application_root_path.to_s
+      $LOADED_FEATURES.select { |f| f.start_with?(root) }
     end
 
     def disconnect_database
@@ -202,5 +263,17 @@ module Spring
         end
       end
     end
+
+    def print_exception(stream, error)
+      first, rest = error.backtrace.first, error.backtrace.drop(1)
+      stream.puts("#{first}: #{error} (#{error.class})")
+      rest.each { |line| stream.puts("\tfrom #{line}") }
+    end
+
+    def update_process_title
+      ProcessTitleUpdater.run { |distance|
+        "spring app    | #{spring_env.app_name} | started #{distance} ago | #{app_env} mode"
+      }
+    end
   end
 end

data/lib/spring/application/boot.rb

@@ -0,0 +1,10 @@
+require "spring/application"
+
+app = Spring::Application.new(
+  UNIXSocket.for_fd(3),
+  Spring::JSON.load(ENV.delete("SPRING_ORIGINAL_ENV").dup)
+)
+Signal.trap("TERM") { app.terminate }
+
+app.preload if ENV.delete("SPRING_PRELOAD") == "1"
+app.run

data/lib/spring/application_manager.rb

@@ -1,20 +1,15 @@
-require "socket"
-require "thread"
-require "spring/application"
-
 module Spring
   class ApplicationManager
-    attr_reader :pid, :child, :app_env, :spring_env, :server
+    attr_reader :pid, :child, :app_env, :spring_env, :status
 
-    def initialize(server, app_env)
-      @server     = server
+    def initialize(app_env)
       @app_env    = app_env
       @spring_env = Env.new
       @mutex      = Mutex.new
     end
 
     def log(message)
-      server.log(message)
+      spring_env.log "[application_manager:#{app_env}] #{message}"
     end
 
     # We're not using @mutex.synchronize to avoid the weird "<internal:prelude>:10"
@@ -28,7 +23,6 @@ module Spring
 
     def start
       start_child
-      start_wait_thread
     end
 
     def restart
@@ -63,13 +57,15 @@ module Spring
     def run(client)
       with_child do
         child.send_io client
-        child.gets
+        child.gets or raise Errno::EPIPE
       end
 
-      pid = child.gets
-      pid = pid.chomp.to_i if pid
-      log "got worker pid #{pid}"
-      pid
+      pid = child.gets.to_i
+
+      unless pid.zero?
+        log "got worker pid #{pid}"
+        pid
+      end
     rescue Errno::ECONNRESET, Errno::EPIPE => e
       log "#{e} while reading from child; returning no pid"
       nil
@@ -84,39 +80,47 @@ module Spring
     private
 
     def start_child(preload = false)
-      server.application_starting
-
       @child, child_socket = UNIXSocket.pair
-      @pid = fork {
-        (ObjectSpace.each_object(IO).to_a - [STDOUT, STDERR, STDIN, child_socket])
-          .reject(&:closed?)
-          .each(&:close)
 
-        ENV['RAILS_ENV'] = ENV['RACK_ENV'] = app_env
-
-        ProcessTitleUpdater.run { |distance|
-          "spring app    | #{spring_env.app_name} | started #{distance} ago | #{app_env} mode"
-        }
+      Bundler.with_clean_env do
+        @pid = Process.spawn(
+          {
+            "RAILS_ENV"           => app_env,
+            "RACK_ENV"            => app_env,
+            "SPRING_ORIGINAL_ENV" => JSON.dump(Spring::ORIGINAL_ENV),
+            "SPRING_PRELOAD"      => preload ? "1" : "0"
+          },
+          "ruby",
+          "-I", File.expand_path("../..", __FILE__),
+          "-e", "require 'spring/application/boot'",
+          3 => child_socket
+        )
+      end
 
-        app = Application.new(child_socket)
-        app.preload if preload
-        app.run
-      }
+      start_wait_thread(pid, child) if child.gets
       child_socket.close
     end
 
-    def start_wait_thread
-      @wait_thread = Thread.new {
-        Thread.current.abort_on_exception = true
-
-        while alive?
-          _, status = Process.wait2(pid)
-          @pid = nil
+    def start_wait_thread(pid, child)
+      Process.detach(pid)
 
-          # In the forked child, this will block forever, so we won't
-          # return to the next iteration of the loop.
-          synchronize { restart if !alive? && status.success? }
+      Thread.new {
+        # The recv can raise an ECONNRESET, killing the thread, but that's ok
+        # as if it does we're no longer interested in the child
+        loop do
+          IO.select([child])
+          break if child.recv(1, Socket::MSG_PEEK).empty?
+          sleep 0.01
         end
+
+        log "child #{pid} shutdown"
+
+        synchronize {
+          if @pid == pid
+            @pid = nil
+            restart
+          end
+        }
       }
     end
   end

data/lib/spring/boot.rb

@@ -0,0 +1,12 @@
+require "socket"
+require "thread"
+
+# readline must be required before we setpgid, otherwise the require may hang,
+# if readline has been built against libedit. See issue #70.
+require "readline"
+
+require "spring/configuration"
+require "spring/env"
+require "spring/process_title_updater"
+require "spring/json"
+require "spring/watcher"

data/lib/spring/client/binstub.rb

@@ -23,22 +23,27 @@ CODE
       # process we'll execute the lines which come after the LOADER block, which
       # is what we want.
       #
-      # Gem.try_activate would be called inside rubygems due to the #require.
-      # However, when that happens $! gets set and it appears that there is a
-      # LoadError, which can cause problems. So we activate the gem separately
-      # to requiring the file.
-      SPRING = <<CODE
+      # Parsing the lockfile in this way is pretty nasty but reliable enough
+      # The regex ensures that the match must be between a GEM line and an empty
+      # line, so it won't go on to the next section.
+      SPRING = <<'CODE'
 #!/usr/bin/env ruby
 
+# This file loads spring without using Bundler, in order to be fast
+# It gets overwritten when you run the `spring binstub` command
+
 unless defined?(Spring)
   require "rubygems"
   require "bundler"
 
+  match = Bundler.default_lockfile.read.match(/^GEM$.*?^    spring \((.*?)\)$.*?^$/m)
+  version = match && match[1]
+
+  ENV["GEM_PATH"] = ([Bundler.bundle_path.to_s] + Gem.path).join(File::PATH_SEPARATOR)
   ENV["GEM_HOME"] = ""
-  ENV["GEM_PATH"] = Bundler.bundle_path.to_s
   Gem.paths = ENV
 
-  Gem.try_activate("spring/binstub")
+  gem "spring", version
   require "spring/binstub"
 end
 CODE
@@ -167,10 +172,8 @@ CODE
         when :add
           bindir.mkdir unless bindir.exist?
 
-          unless spring_binstub.exist?
-            File.write(spring_binstub, SPRING)
-            spring_binstub.chmod 0755
-          end
+          File.write(spring_binstub, SPRING)
+          spring_binstub.chmod 0755
 
           items.each(&:add)
         when :remove

data/lib/spring/configuration.rb

@@ -22,15 +22,24 @@ module Spring
 
     def application_root_path
       @application_root_path ||= begin
-        path = Pathname.new(File.expand_path(application_root || find_project_root))
+        if application_root
+          path = Pathname.new(File.expand_path(application_root))
+        else
+          path = project_root_path
+        end
+
         raise MissingApplication.new(path) unless path.join("config/application.rb").exist?
         path
       end
     end
 
+    def project_root_path
+      @project_root_path ||= find_project_root(Pathname.new(File.expand_path(Dir.pwd)))
+    end
+
     private
 
-    def find_project_root(current_dir = Pathname.new(Dir.pwd))
+    def find_project_root(current_dir)
       if current_dir.join(gemfile).exist?
         current_dir
       elsif current_dir.root?

data/lib/spring/env.rb

@@ -14,14 +14,19 @@ module Spring
     attr_reader :log_file
 
     def initialize(root = nil)
-      @root     = root
-      @log_file = File.open(ENV["SPRING_LOG"] || "/dev/null", "a")
+      @root         = root
+      @project_root = root
+      @log_file     = File.open(ENV["SPRING_LOG"] || "/dev/null", "a")
     end
 
     def root
       @root ||= Spring.application_root_path
     end
 
+    def project_root
+      @project_root ||= Spring.project_root_path
+    end
+
     def version
       Spring::VERSION
     end
@@ -33,7 +38,7 @@ module Spring
     end
 
     def application_id
-      Digest::MD5.hexdigest(root.to_s)
+      Digest::MD5.hexdigest(project_root.to_s)
     end
 
     def socket_path
@@ -60,7 +65,7 @@ module Spring
     end
 
     def server_running?
-      pidfile = pidfile_path.open('r')
+      pidfile = pidfile_path.open('r+')
       !pidfile.flock(File::LOCK_EX | File::LOCK_NB)
     rescue Errno::ENOENT
       false
@@ -71,12 +76,8 @@ module Spring
       end
     end
 
-    def bundle_mtime
-      [Bundler.default_lockfile, Bundler.default_gemfile].select(&:exist?).map(&:mtime).max
-    end
-
     def log(message)
-      log_file.puts "[#{Time.now}] #{message}"
+      log_file.puts "[#{Time.now}] [#{Process.pid}] #{message}"
       log_file.flush
     end
   end

data/lib/spring/server.rb

@@ -1,26 +1,13 @@
 module Spring
-  class << self
-    attr_reader :original_env
-  end
-  @original_env = ENV.to_hash
+  ORIGINAL_ENV = ENV.to_hash
 end
 
-require "socket"
-require "thread"
-
-require "spring/configuration"
-require "spring/env"
+require "spring/boot"
 require "spring/application_manager"
-require "spring/process_title_updater"
-require "spring/json"
 
-# Must be last, as it requires bundler/setup
+# Must be last, as it requires bundler/setup, which alters the load path
 require "spring/commands"
 
-# readline must be required before we setpgid, otherwise the require may hang,
-# if readline has been built against libedit. See issue #70.
-require "readline"
-
 module Spring
   class Server
     def self.boot
@@ -31,7 +18,7 @@ module Spring
 
     def initialize(env = Env.new)
       @env          = env
-      @applications = Hash.new { |h, k| h[k] = ApplicationManager.new(self, k) }
+      @applications = Hash.new { |h, k| h[k] = ApplicationManager.new(k) }
       @pidfile      = env.pidfile_path.open('a')
       @mutex        = Mutex.new
     end
@@ -48,7 +35,6 @@ module Spring
       ignore_signals
       set_exit_hook
       set_process_title
-      watch_bundle
       start_server
     end
 
@@ -95,7 +81,7 @@ module Spring
     # Ignore SIGINT and SIGQUIT otherwise the user typing ^C or ^\ on the command line
     # will kill the server/application.
     def ignore_signals
-      IGNORE_SIGNALS.each { |sig| trap(sig,  "IGNORE") }
+      IGNORE_SIGNALS.each { |sig| trap(sig, "IGNORE") }
     end
 
     def set_exit_hook
@@ -138,13 +124,5 @@ module Spring
         "spring server | #{env.app_name} | started #{distance} ago"
       }
     end
-
-    def watch_bundle
-      @bundle_mtime = env.bundle_mtime
-    end
-
-    def application_starting
-      @mutex.synchronize { exit if env.bundle_mtime != @bundle_mtime }
-    end
   end
 end

data/lib/spring/version.rb

@@ -1,3 +1,3 @@
 module Spring
-  VERSION = "1.1.0.beta1"
+  VERSION = "1.1.0.beta2"
 end

data/lib/spring/watcher/abstract.rb

@@ -22,7 +22,7 @@ module Spring
         @files       = Set.new
         @directories = Set.new
         @stale       = false
-        @io_listener = nil
+        @listeners   = []
       end
 
       def add(*items)
@@ -55,15 +55,14 @@ module Spring
         @stale
       end
 
-      def mark_stale
-        @stale = true
-        @io_listener.write "." if @io_listener
+      def on_stale(&block)
+        @listeners << block
       end
 
-      def to_io
-        read, write = IO.pipe
-        @io_listener = write
-        read
+      def mark_stale
+        return if stale?
+        @stale = true
+        @listeners.each(&:call)
       end
 
       def restart

data/spring.gemspec

@@ -10,7 +10,7 @@ Gem::Specification.new do |gem|
   gem.email         = ["j@jonathanleighton.com"]
   gem.description   = %q{Rails application preloader}
   gem.summary       = %q{Rails application preloader}
-  gem.homepage      = "http://github.com/jonleighton/spring"
+  gem.homepage      = "http://github.com/rails/spring"
   gem.license       = "MIT"
 
   gem.files         = `git ls-files`.split($/)

data/test/acceptance/app_test.rb

@@ -21,28 +21,22 @@ class AppTest < ActiveSupport::TestCase
     @app ||= Spring::Test::Application.new("#{TEST_ROOT}/apps/tmp")
   end
 
-  def debug(artifacts)
-    artifacts = artifacts.dup
-    artifacts.delete :status
-    app.dump_streams(artifacts.delete(:command), artifacts)
-  end
-
   def assert_output(artifacts, expected)
     expected.each do |stream, output|
       assert artifacts[stream].include?(output),
-             "expected #{stream} to include '#{output}'.\n\n#{debug(artifacts)}"
+             "expected #{stream} to include '#{output}'.\n\n#{app.debug(artifacts)}"
     end
   end
 
   def assert_success(command, expected_output = nil)
     artifacts = app.run(*Array(command))
-    assert artifacts[:status].success?, "expected successful exit status\n\n#{debug(artifacts)}"
+    assert artifacts[:status].success?, "expected successful exit status\n\n#{app.debug(artifacts)}"
     assert_output artifacts, expected_output if expected_output
   end
 
   def assert_failure(command, expected_output = nil)
     artifacts = app.run(*Array(command))
-    assert !artifacts[:status].success?, "expected unsuccessful exit status\n\n#{debug(artifacts)}"
+    assert !artifacts[:status].success?, "expected unsuccessful exit status\n\n#{app.debug(artifacts)}"
     assert_output artifacts, expected_output if expected_output
   end
 
@@ -196,7 +190,7 @@ class AppTest < ActiveSupport::TestCase
 
   test "binstub when spring is uninstalled" do
     app.run! "gem uninstall --ignore-dependencies spring"
-    File.write(app.gemfile, app.gemfile.read.sub("gem 'spring-commands-testunit'\n", ""))
+    File.write(app.gemfile, app.gemfile.read.gsub(/gem 'spring.*/, ""))
     assert_success "bin/rake -T", stdout: "rake db:migrate"
   end
 
@@ -296,16 +290,29 @@ CODE
     assert_success "bin/rake", stdout: "test"
   end
 
-  test "changing the Gemfile restarts the server" do
+  test "changing the Gemfile works" do
     assert_success %(bin/rails runner 'require "sqlite3"')
 
     File.write(app.gemfile, app.gemfile.read.sub(%{gem 'sqlite3'}, %{# gem 'sqlite3'}))
-    app.bundle
-
     app.await_reload
+
     assert_failure %(bin/rails runner 'require "sqlite3"'), stderr: "sqlite3"
   end
 
+  test "changing the Gemfile works when spring calls into itself" do
+    File.write(app.path("script.rb"), <<-CODE)
+      gemfile = Rails.root.join("Gemfile")
+      File.write(gemfile, "\#{gemfile.read}gem 'devise'\\n")
+      Bundler.with_clean_env do
+        system(#{app.env.inspect}, "bundle install")
+      end
+      output = `\#{Rails.root.join('bin/rails')} runner 'require "devise"; puts "done";'`
+      exit output == "done\n"
+    CODE
+
+    assert_success [%(bin/rails runner 'load Rails.root.join("script.rb")'), timeout: 60]
+  end
+
   test "changing the environment between runs" do
     File.write(app.application_config, "#{app.application_config.read}\nENV['BAR'] = 'bar'")
 

data/test/acceptance/helper.rb

@@ -57,8 +57,12 @@ module Spring
         @stderr ||= IO.pipe
       end
 
+      def log_file_path
+        path("tmp/spring.log")
+      end
+
       def log_file
-        @log_file ||= path("tmp/spring.log").open("w+")
+        @log_file ||= log_file_path.open("w+")
       end
 
       def env
@@ -68,7 +72,7 @@ module Spring
           "HOME"       => user_home.to_s,
           "RAILS_ENV"  => nil,
           "RACK_ENV"   => nil,
-          "SPRING_LOG" => log_file.path
+          "SPRING_LOG" => log_file_path.to_s
         }
       end
 
@@ -202,6 +206,12 @@ module Spring
         output
       end
 
+      def debug(artifacts)
+        artifacts = artifacts.dup
+        artifacts.delete :status
+        dump_streams(artifacts.delete(:command), artifacts)
+      end
+
       def await_reload
         raise "no pid" if @application_pids.nil? || @application_pids.empty?
 
@@ -212,13 +222,15 @@ module Spring
 
       def run!(*args)
         artifacts = run(*args)
-        raise "command failed" unless artifacts[:status].success?
+        unless artifacts[:status].success?
+          raise "command failed\n\n#{debug(artifacts)}"
+        end
         artifacts
       end
 
       def bundle
         run! "(gem list bundler | grep bundler) || gem install bundler", timeout: nil
-        run! "bundle check || bundle update", timeout: nil
+        run! "bundle update", timeout: nil
       end
 
       private
@@ -238,16 +250,23 @@ module Spring
         @version_constraint = version_constraint
         @version            = RailsVersion.new(version_constraint.split(' ').last)
         @application        = Application.new(root)
+        @bundled            = false
       end
 
       def root
-        "#{TEST_ROOT}/apps/rails-#{version.major}-#{version.minor}"
+        "#{TEST_ROOT}/apps/rails-#{version.major}-#{version.minor}-spring-#{Spring::VERSION}"
       end
 
       def system(command)
         Kernel.system("#{command} > /dev/null") or raise "command failed: #{command}"
       end
 
+      def bundle
+        return if @bundled
+        application.bundle
+        @bundled = true
+      end
+
       # Sporadic SSL errors keep causing test failures so there are anti-SSL workarounds here
       def generate
         Bundler.with_clean_env do
@@ -263,6 +282,8 @@ module Spring
           FileUtils.mkdir_p(application.user_home)
           FileUtils.rm_rf(application.path("test/performance"))
 
+          File.write(application.gemfile, "#{application.gemfile.read}gem 'spring', '#{Spring::VERSION}'\n")
+
           if version.needs_testunit?
             File.write(application.gemfile, "#{application.gemfile.read}gem 'spring-commands-testunit'\n")
           end
@@ -274,7 +295,7 @@ module Spring
           end
         end
 
-        application.bundle
+        bundle
         application.run! "bundle exec rails g scaffold post title:string"
         application.run! "bundle exec rake db:migrate db:test:clone"
       end
@@ -287,7 +308,7 @@ module Spring
         unless @installed
           # Need to do this here too because the app may have been generated with
           # a different ruby
-          application.bundle
+          bundle
 
           system("gem build spring.gemspec 2>/dev/null")
           application.run! "gem install ../../../spring-#{Spring::VERSION}.gem", timeout: nil

data/test/unit/watcher_test.rb

@@ -1,6 +1,7 @@
 require "helper"
 require "tmpdir"
 require "fileutils"
+require "timeout"
 require "active_support/core_ext/numeric/time"
 require "spring/watcher"
 require "spring/watcher/polling"
@@ -120,22 +121,25 @@ module WatcherTests
     assert_stale
   end
 
-  def test_can_io_select
+  def test_on_stale
     file = "#{@dir}/omg"
     touch file, Time.now - 2.seconds
 
     watcher.add file
     watcher.start
 
-    io = watcher.to_io
+    stale = false
+    watcher.on_stale { stale = true }
 
-    Thread.new {
-      sleep LATENCY * 3
-      touch file, Time.now
-    }
+    touch file, Time.now
 
-    assert IO.select([io], [], [], 1), "IO.select timed out before watcher was readable"
-    assert watcher.stale?
+    Timeout.timeout(1) { sleep 0.01 until stale }
+    assert stale
+
+    # Check that we only get notified once
+    stale = false
+    sleep LATENCY * 3
+    assert !stale
   end
 
   def test_add_relative_path

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: spring
 version: !ruby/object:Gem::Version
-  version: 1.1.0.beta1
+  version: 1.1.0.beta2
 platform: ruby
 authors:
 - Jon Leighton
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-03 00:00:00.000000000 Z
+date: 2014-01-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -55,8 +55,10 @@ files:
 - Rakefile
 - bin/spring
 - lib/spring/application.rb
+- lib/spring/application/boot.rb
 - lib/spring/application_manager.rb
 - lib/spring/binstub.rb
+- lib/spring/boot.rb
 - lib/spring/client.rb
 - lib/spring/client/binstub.rb
 - lib/spring/client/command.rb
@@ -92,7 +94,7 @@ files:
 - test/unit/commands_test.rb
 - test/unit/process_title_updater_test.rb
 - test/unit/watcher_test.rb
-homepage: http://github.com/jonleighton/spring
+homepage: http://github.com/rails/spring
 licenses:
 - MIT
 metadata: {}