spring 2.0.0 → 3.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 492a555d7260fc775b233acca0a3fddfb2d20c88
-  data.tar.gz: ccfc69cc32e5105e3de6cb75ae19538d3958b44e
+SHA256:
+  metadata.gz: 1f2e2dd87b67447e8ec1404be4f904fe1339e536dabddde397662313a7bb116d
+  data.tar.gz: 467c115d0fff87ded2aa4a7d761419f74ce9b45798f12568e21d97e1b261599f
 SHA512:
-  metadata.gz: 7bb6d3f377d2004b10b01dcba207c2b1ec285f5e04d1721edc4ad436d6e50d99337d8ba584f08d5a99daf60ef06af853435a760edf467360a5a93919ec1d35ec
-  data.tar.gz: dea0ae70aa4e56ef9aeb525faa1350b711c1f90d87171ce1d530380469da3773b478285a50ab94b628cf6afb81e05237a8cc269cc09a1a3408275af59ff6db7c
+  metadata.gz: 3cc3b61d71972b7150fdbf7331ce1e55d447fabecbc4ba55914ce2621a9221fbb913efa31b715f80f77ff807dba06b3f89e26454ef623d8d2bc26af6b6f442a3
+  data.tar.gz: b459527ad5f9301dd75b1e2f5c9d6e6418e7c019c3a0073a4c6e905b9118db5193bcad051bba88fd5f55cbf124037332ed6a940cd857e4c59d67127d02dbb951

data/LICENSE.txt

@@ -1,4 +1,5 @@
-Copyright (c) 2012-2016 Jon Leighton
+Copyright (c) 2017-2021 Rafael Mendonça França
+Copyright (c) 2012-2017 Jon Leighton
 
 MIT License
 

data/README.md

@@ -1,10 +1,10 @@
 # Spring
 
-[![Build Status](https://travis-ci.org/rails/spring.svg?branch=master)](https://travis-ci.org/rails/spring)
-[![Gem Version](https://badge.fury.io/rb/spring.svg)](http://badge.fury.io/rb/spring)
+[![Build Status](https://github.com/rails/spring/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/rails/spring/actions/workflows/ci.yml?branch=main)
+[![Gem Version](https://badge.fury.io/rb/spring.svg)](https://badge.fury.io/rb/spring)
 
 Spring is a Rails application preloader. It speeds up development by
-keeping your application running in the background so you don't need to
+keeping your application running in the background, so you don't need to
 boot it every time you run a test, rake task or migration.
 
 ## Features
@@ -16,8 +16,8 @@ boot it every time you run a test, rake task or migration.
 
 ## Compatibility
 
-* Ruby versions: MRI 1.9.3, MRI 2.0, MRI 2.1, MRI 2.2
-* Rails versions: 4.2, 5.0 (Spring is installed by default when you do
+* Ruby versions: MRI 2.5, MRI 2.6
+* Rails versions: 5.2, 6.0 (Spring is installed by default when you do
   `rails new` to generate your application)
 
 Spring makes extensive use of `Process.fork`, so won't be able to
@@ -27,14 +27,14 @@ provide a speed up on platforms which don't support forking (Windows, JRuby).
 
 ### Setup
 
-Add spring to your Gemfile:
+Add Spring to your Gemfile:
 
 ``` ruby
 gem "spring", group: :development
 ```
 
 (Note: using `gem "spring", git: "..."` *won't* work and is not a
-supported way of using spring.)
+supported way of using Spring.)
 
 It's recommended to 'springify' the executables in your `bin/`
 directory:
@@ -50,21 +50,32 @@ code into relevant existing executables. The snippet looks like this:
 ``` ruby
 begin
   load File.expand_path('../spring', __FILE__)
-rescue LoadError
+rescue LoadError => e
+  raise unless e.message.include?('spring')
 end
 ```
 
-On platforms where spring is installed and supported, this snippet
-hooks spring into the execution of commands. In other cases, the snippet
-will just be silently ignored and the lines after it will be executed as
+On platforms where Spring is installed and supported, this snippet
+hooks Spring into the execution of commands. In other cases, the snippet
+will just be silently ignored, and the lines after it will be executed as
 normal.
 
 If you don't want to prefix every command you type with `bin/`, you
-can [use direnv](https://github.com/zimbatm/direnv#the-stdlib) to
+can [use direnv](https://github.com/direnv/direnv#the-stdlib) to
 automatically add `./bin` to your `PATH` when you `cd` into your application.
 Simply create an `.envrc` file with the command `PATH_add bin` in your
 Rails directory.
 
+### Enable reloading
+
+Spring reloads application code, and therefore needs the application to have
+reloading enabled.
+
+Please, make sure `config.cache_classes` is `false` in the environments that
+Spring manages. That setting is typically configured in
+`config/environments/*.rb`. In particular, make sure it is `false` for the
+`test` environment.
+
 ### Usage
 
 For this walkthrough I've generated a new Rails application, and run
@@ -90,7 +101,7 @@ user    0m0.281s
 sys     0m0.066s
 ```
 
-That wasn't particularly fast because it was the first run, so spring
+That wasn't particularly fast because it was the first run, so Spring
 had to boot the application. It's now running:
 
 ```
@@ -167,8 +178,8 @@ Spring is running:
 26707 spring app    | spring-demo-app | started 2 secs ago | development mode
 ```
 
-There's no need to "shut down" spring. This will happen automatically
-when you close your terminal. However if you do want to do a manual shut
+There's no need to "shut down" Spring. This will happen automatically
+when you close your terminal. However, if you do want to do a manual shut
 down, use the `stop` command:
 
 ```
@@ -176,9 +187,11 @@ $ bin/spring stop
 Spring stopped.
 ```
 
+From within your code, you can check whether Spring is active with `if defined?(Spring)`.
+
 ### Removal
 
-To remove spring:
+To remove Spring:
 
 * 'Unspring' your bin/ executables: `bin/spring binstub --remove --all`
 * Remove spring from your Gemfile
@@ -186,12 +199,13 @@ To remove spring:
 ### Deployment
 
 You must not install Spring on your production environment. To prevent it from
-being installed, provide the `--without development test` argument to the
+being installed, run the `bundle config set without 'development test'` before
 `bundle install` command which is used to install gems on your production
 machines:
 
 ```
-$ bundle install --without development test
+$ bundle config set without 'development test'
+$ bundle install
 ```
 
 ## Commands
@@ -216,7 +230,7 @@ Spring::Commands::Rake.environment_matchers[:default] = "development"
 ### `rails console`, `rails generate`, `rails runner`
 
 These execute the rails command you already know and love. If you run
-a different sub command (e.g. `rails server`) then spring will automatically
+a different sub command (e.g. `rails server`) then Spring will automatically
 pass it through to the underlying `rails` executable (without the
 speed-up).
 
@@ -230,18 +244,22 @@ You can add these to your Gemfile for additional commands:
 * [spring-commands-testunit](https://github.com/jonleighton/spring-commands-testunit) - useful for
   running `Test::Unit` tests on Rails 3, since only Rails 4 allows you
   to use `rake test path/to/test` to run a particular test/directory.
+* [spring-commands-parallel-tests](https://github.com/DocSpring/spring-commands-parallel-tests) - Adds the `parallel_*` commands from [`parallel_tests`](https://github.com/grosser/parallel_tests).
 * [spring-commands-teaspoon](https://github.com/alejandrobabio/spring-commands-teaspoon.git)
 * [spring-commands-m](https://github.com/gabrieljoelc/spring-commands-m.git)
 * [spring-commands-rubocop](https://github.com/p0deje/spring-commands-rubocop)
+* [spring-commands-rackup](https://github.com/wintersolutions/spring-commands-rackup)
+* [spring-commands-rack-console](https://github.com/wintersolutions/spring-commands-rack-console)
+* [spring-commands-standard](https://github.com/lakim/spring-commands-standard)
 
 ## Use without adding to bundle
 
-If you don't want spring-related code checked into your source
-repository, it's possible to use spring without adding to your Gemfile.
-However, using spring binstubs without adding spring to the Gemfile is not
+If you don't want Spring-related code checked into your source
+repository, it's possible to use Spring without adding to your Gemfile.
+However, using Spring binstubs without adding Spring to the Gemfile is not
 supported.
 
-To use spring like this, do a `gem install spring` and then prefix
+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`.
 
@@ -252,12 +270,10 @@ 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.
+Spring uses Rails' class reloading mechanism 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:
@@ -357,7 +373,7 @@ application restart, you can specify them with `Spring.watch`:
 Spring.watch "config/some_config_file.yml"
 ```
 
-By default Spring polls the filesystem for changes once every 0.2 seconds. This
+By default, Spring polls the filesystem for changes once every 0.2 seconds. This
 method requires zero configuration, but if you find that it's using too
 much CPU, then you can use event-based file system listening by
 installing the
@@ -377,34 +393,34 @@ Spring.quiet = true
 
 The following environment variables are used by Spring:
 
-* `DISABLE_SPRING` - If set, Spring will be bypassed and your
+* `DISABLE_SPRING` - If set, Spring will be bypassed, and your
   application will boot in a foreground process
 * `SPRING_LOG` - The path to a file which Spring will write log messages
   to.
 * `SPRING_TMP_PATH` - The directory where Spring should write its temporary
-  files (a pidfile and a socket). By default we use the
+  files (a pidfile and a socket). By default, we use the
   `XDG_RUNTIME_DIR` environment variable, or else `Dir.tmpdir`, and then
   create a directory in that named `spring-$UID`. We don't use your
   Rails application's `tmp/` directory because that may be on a
   filesystem which doesn't support UNIX sockets.
 * `SPRING_APPLICATION_ID` - Used to identify distinct Rails
-  applications. By default it is an MD5 hash of the current
+  applications. By default, it is an MD5 hash of the current
   `RUBY_VERSION`, and the path to your Rails project root.
 * `SPRING_SOCKET` - The path which should be used for the UNIX socket
   which Spring uses to communicate with the long-running Spring server
-  process. By default this is `SPRING_TMP_PATH/SPRING_APPLICATION_ID`.
+  process. By default, this is `SPRING_TMP_PATH/SPRING_APPLICATION_ID`.
 * `SPRING_PIDFILE` - The path which should be used to store the pid of
-  the long-running Spring server process. By default this is related to
+  the long-running Spring server process. By default, this is related to
   the socket path; if the socket path is `/foo/bar/spring.sock` the
   pidfile will be `/foo/bar/spring.pid`.
-* `SPRING_SERVER_COMMAND` - The command to run to start up the spring
+* `SPRING_SERVER_COMMAND` - The command to run to start up the Spring
   server when it is not already running. Defaults to `spring _[version]_
   server --background`.
 
 ## Troubleshooting
 
-If you want to get more information about what spring is doing, you can
-run spring explicitly in a separate terminal:
+If you want to get more information about what Spring is doing, you can
+run Spring explicitly in a separate terminal:
 
 ```
 $ spring server

data/lib/spring/application.rb

@@ -12,6 +12,7 @@ module Spring
       @spring_env   = spring_env
       @mutex        = Mutex.new
       @waiting      = Set.new
+      @clients      = Set.new
       @preloaded    = false
       @state        = :initialized
       @interrupt    = IO.pipe
@@ -66,7 +67,17 @@ module Spring
 
     def start_watcher
       @watcher = Spring.watcher
-      @watcher.on_stale { state! :watcher_stale }
+
+      @watcher.on_stale do
+        state! :watcher_stale
+      end
+
+      if @watcher.respond_to? :on_debug
+        @watcher.on_debug do |message|
+          spring_env.log "[watcher:#{app_env}] #{message}"
+        end
+      end
+
       @watcher.start
     end
 
@@ -81,18 +92,20 @@ module Spring
 
       require Spring.application_root_path.join("config", "application")
 
-      # config/environments/test.rb will have config.cache_classes = true. However
-      # we want it to be false so that we can reload files. This is a hack to
-      # override the effect of config.cache_classes = true. We can then actually
-      # set config.cache_classes = false after loading the environment.
-      Rails::Application.initializer :initialize_dependency_mechanism, group: :all do
-        ActiveSupport::Dependencies.mechanism = :load
+      unless Rails.respond_to?(:gem_version) && Rails.gem_version >= Gem::Version.new('5.2.0')
+        raise "Spring only supports Rails >= 5.2.0"
       end
 
-      require Spring.application_root_path.join("config", "environment")
+      Rails::Application.initializer :ensure_reloading_is_enabled, group: :all do
+        if Rails.application.config.cache_classes
+          raise <<-MSG.strip_heredoc
+            Spring reloads, and therefore needs the application to have reloading enabled.
+            Please, set config.cache_classes to false in config/environments/#{Rails.env}.rb.
+          MSG
+        end
+      end
 
-      @original_cache_classes = Rails.application.config.cache_classes
-      Rails.application.config.cache_classes = false
+      require Spring.application_root_path.join("config", "environment")
 
       disconnect_database
 
@@ -103,7 +116,7 @@ module Spring
       raise e unless initialized?
     ensure
       watcher.add loaded_application_features
-      watcher.add Spring.gemfile, "#{Spring.gemfile}.lock"
+      watcher.add Spring.gemfile, Spring.gemfile_lock
 
       if defined?(Rails) && Rails.application
         watcher.add Rails.application.paths["config/initializers"]
@@ -137,10 +150,23 @@ module Spring
       log "got client"
       manager.puts
 
-      stdout, stderr, stdin = streams = 3.times.map { client.recv_io }
+      @clients << client
+
+      _stdout, stderr, _stdin = streams = 3.times.map { client.recv_io }
       [STDOUT, STDERR, STDIN].zip(streams).each { |a, b| a.reopen(b) }
 
-      preload unless preloaded?
+      if preloaded?
+        client.puts(0) # preload success
+      else
+        begin
+          preload
+          client.puts(0) # preload success
+        rescue Exception
+          log "preload failed"
+          client.puts(1) # preload failure
+          raise
+        end
+      end
 
       args, env = JSON.load(client.read(client.gets.to_i)).values_at("args", "env")
       command   = Spring.command(args.shift)
@@ -149,39 +175,39 @@ module Spring
       setup command
 
       if Rails.application.reloaders.any?(&:updated?)
-        # Rails 5.1 forward-compat. AD::R is deprecated to AS::R in Rails 5.
-        if defined? ActiveSupport::Reloader
-          Rails.application.reloader.reload!
-        else
-          ActionDispatch::Reloader.cleanup!
-          ActionDispatch::Reloader.prepare!
-        end
+        Rails.application.reloader.reload!
       end
 
       pid = fork {
+        # Make sure to close other clients otherwise their graceful termination
+        # will be impossible due to reference from this fork.
+        @clients.select { |c| c != client }.each(&:close)
+
         Process.setsid
         IGNORE_SIGNALS.each { |sig| trap(sig, "DEFAULT") }
         trap("TERM", "DEFAULT")
 
-        STDERR.puts "Running via Spring preloader in process #{Process.pid}" unless Spring.quiet
+        unless Spring.quiet
+          STDERR.puts "Running via Spring preloader in process #{Process.pid}"
+
+          if Rails.env.production?
+            STDERR.puts "WARNING: Spring is running in production. To fix "         \
+                        "this make sure the spring gem is only present "            \
+                        "in `development` and `test` groups in your Gemfile "       \
+                        "and make sure you always use "                             \
+                        "`bundle install --without development test` in production"
+          end
+        end
 
         ARGV.replace(args)
         $0 = command.exec_name
 
-        # Delete all env vars which are unchanged from before spring started
+        # Delete all env vars which are unchanged from before Spring started
         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
+        # Load in the current env vars, except those which *were* changed when Spring started
         env.each { |k, v| ENV[k] ||= v }
 
-        # requiring is faster, so if config.cache_classes was true in
-        # the environment's config file, then we can respect that from
-        # here on as we no longer need constant reloading.
-        if @original_cache_classes
-          ActiveSupport::Dependencies.mechanism = :require
-          Rails.application.config.cache_classes = true
-        end
-
         connect_database
         srand
 
@@ -278,7 +304,7 @@ module Spring
           ensure
             if $!
               lib = File.expand_path("..", __FILE__)
-              $!.backtrace.reject! { |line| line.start_with?(lib) }
+              $!.backtrace.reject! { |line| line.start_with?(lib) } unless $!.backtrace.frozen?
             end
           end
         end
@@ -295,10 +321,11 @@ module Spring
     def with_pty
       PTY.open do |master, slave|
         [STDOUT, STDERR, STDIN].each { |s| s.reopen slave }
-        Thread.new { master.read }
+        reader_thread = Spring.failsafe_thread { master.read }
         begin
           yield
         ensure
+          reader_thread.kill
           reset_streams
         end
       end

data/lib/spring/application_manager.rb

@@ -7,6 +7,7 @@ module Spring
       @spring_env = spring_env
       @mutex      = Mutex.new
       @state      = :running
+      @pid        = nil
     end
 
     def log(message)
@@ -92,7 +93,8 @@ module Spring
     def start_child(preload = false)
       @child, child_socket = UNIXSocket.pair
 
-      Bundler.with_clean_env do
+      Bundler.with_original_env do
+        bundler_dir = File.expand_path("../..", $LOADED_FEATURES.grep(/bundler\/setup\.rb$/).first)
         @pid = Process.spawn(
           {
             "RAILS_ENV"           => app_env,
@@ -101,7 +103,7 @@ module Spring
             "SPRING_PRELOAD"      => preload ? "1" : "0"
           },
           "ruby",
-          "-I", File.expand_path("../..", $LOADED_FEATURES.grep(/bundler\/setup\.rb$/).first),
+          *(bundler_dir != RbConfig::CONFIG["rubylibdir"] ? ["-I", bundler_dir] : []),
           "-I", File.expand_path("../..", __FILE__),
           "-e", "require 'spring/application/boot'",
           3 => child_socket,

data/lib/spring/binstub.rb

@@ -1,26 +1,6 @@
 command  = File.basename($0)
 bin_path = File.expand_path("../../../bin/spring", __FILE__)
 
-# When we run a command which does not go through Spring (e.g. DISABLE_SPRING
-# is used, or we just call 'rails' or something) then we get this warning from
-# Rubygems:
-#
-#   WARN: Unresolved specs during Gem::Specification.reset: activesupport (<= 5.1, >= 4.2)
-#   WARN: Clearing out unresolved specs.
-#   Please report a bug if this causes problems.
-#
-# This happens due to our dependency on activesupport, when Bundler.setup gets
-# called.  We don't actually *use* the dependency; it is purely there to
-# restrict the Rails version that we're compatible with.
-#
-# When the warning is shown, Rubygems just does the below.
-# Therefore, by doing it ourselves here, we can avoid the warning.
-if Gem::Specification.respond_to?(:unresolved_deps)
-  Gem::Specification.unresolved_deps.clear
-else
-  Gem.unresolved_deps.clear
-end
-
 if command == "spring"
   load bin_path
 else

data/lib/spring/client/binstub.rb

@@ -3,11 +3,11 @@ require 'set'
 module Spring
   module Client
     class Binstub < Command
-      SHEBANG = /\#\!.*\n/
+      SHEBANG = /\#\!.*\n(\#.*\n)*/
 
-      # If loading the bin/spring file works, it'll run spring which will
+      # If loading the bin/spring file works, it'll run Spring which will
       # eventually call Kernel.exit. This means that in the client process
-      # we will never execute the lines after this block. But if the spring
+      # we will never execute the lines after this block. But if the Spring
       # client is not invoked for whatever reason, then the Kernel.exit won't
       # happen, and so we'll fall back to the lines after this block, which
       # should cause the "unsprung" version of the command to run.
@@ -26,7 +26,7 @@ CODE
       SPRING = <<'CODE'
 #!/usr/bin/env ruby
 
-# This file loads spring without using Bundler, in order to be fast.
+# 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)
@@ -34,7 +34,8 @@ unless defined?(Spring)
   require 'bundler'
 
   lockfile = Bundler::LockfileParser.new(Bundler.default_lockfile.read)
-  if spring = lockfile.specs.detect { |spec| spec.name == "spring" }
+  spring = lockfile.specs.detect { |spec| spec.name == 'spring' }
+  if spring
     Gem.use_paths Gem.dir, Bundler.bundle_path.to_s, *Gem.path
     gem 'spring', spring.version
     require 'spring/binstub'
@@ -45,11 +46,10 @@ CODE
       OLD_BINSTUB = %{if !Process.respond_to?(:fork) || Gem::Specification.find_all_by_name("spring").empty?}
 
       BINSTUB_VARIATIONS = Regexp.union [
-        %{begin\n  load File.expand_path("../spring", __FILE__)\nrescue LoadError\nend\n},
         %{begin\n  load File.expand_path('../spring', __FILE__)\nrescue LoadError\nend\n},
         %{begin\n  spring_bin_path = File.expand_path('../spring', __FILE__)\n  load spring_bin_path\nrescue LoadError => e\n  raise unless e.message.end_with? spring_bin_path, 'spring/binstub'\nend\n},
         LOADER
-      ]
+      ].map { |binstub| /#{Regexp.escape(binstub).gsub("'", "['\"]")}/ }
 
       class Item
         attr_reader :command, :existing
@@ -78,7 +78,7 @@ CODE
               generate(fallback)
               status "upgraded"
             elsif existing.include?(LOADER)
-              status "spring already present"
+              status "Spring already present"
             elsif existing =~ BINSTUB_VARIATIONS
               upgraded = existing.sub(BINSTUB_VARIATIONS, LOADER)
               File.write(command.binstub, upgraded)
@@ -93,15 +93,15 @@ CODE
                 end
 
                 File.write(command.binstub, "#{head}#{shebang}#{LOADER}#{tail}")
-                status "spring inserted"
+                status "Spring inserted"
               else
-                status "doesn't appear to be ruby, so cannot use spring", $stderr
+                status "doesn't appear to be ruby, so cannot use Spring", $stderr
                 exit 1
               end
             end
           else
             generate
-            status "generated with spring"
+            status "generated with Spring"
           end
         end
 
@@ -118,7 +118,7 @@ CODE
         def remove
           if existing
             File.write(command.binstub, existing.sub(BINSTUB_VARIATIONS, ""))
-            status "spring removed"
+            status "Spring removed"
           end
         end
       end
@@ -126,7 +126,7 @@ CODE
       attr_reader :bindir, :items
 
       def self.description
-        "Generate spring based binstubs. Use --all to generate a binstub for all known commands. Use --remove to revert."
+        "Generate Spring based binstubs. Use --all to generate a binstub for all known commands. Use --remove to revert."
       end
 
       def self.rails_command

data/lib/spring/client/help.rb

@@ -32,7 +32,7 @@ module Spring
       def formatted_help
         ["Version: #{env.version}\n",
          "Usage: spring COMMAND [ARGS]\n",
-         *command_help("spring itself", spring_commands),
+         *command_help("Spring itself", spring_commands),
          '',
          *command_help("your application", application_commands)].join("\n")
       end

data/lib/spring/client/rails.rb

@@ -14,7 +14,7 @@ module Spring
       }
 
       def self.description
-        "Run a rails command. The following sub commands will use spring: #{COMMANDS.to_a.join ', '}."
+        "Run a rails command. The following sub commands will use Spring: #{COMMANDS.to_a.join ', '}."
       end
 
       def call
@@ -22,6 +22,8 @@ module Spring
 
         if COMMANDS.include?(command_name)
           Run.call(["rails_#{command_name}", *args.drop(2)])
+        elsif command_name.start_with?("db:")
+          Run.call(["rake", *args.drop(1)])
         else
           require "spring/configuration"
           ARGV.shift

data/lib/spring/client/run.rb

@@ -44,7 +44,7 @@ module Spring
         require "spring/commands"
 
         if Spring.command?(args.first)
-          # Command installed since spring started
+          # Command installed since Spring started
           stop_server
           cold_run
         else
@@ -116,7 +116,7 @@ module Spring
       def verify_server_version
         server_version = server.gets.chomp
         if server_version != env.version
-          $stderr.puts "There is a version mismatch between the spring client " \
+          $stderr.puts "There is a version mismatch between the Spring client " \
                          "(#{env.version}) and the server (#{server_version})."
 
           if server_booted?
@@ -142,12 +142,17 @@ module Spring
       end
 
       def run_command(client, application)
-        log "sending command"
-
         application.send_io STDOUT
         application.send_io STDERR
         application.send_io STDIN
 
+        log "waiting for the application to be preloaded"
+        preload_status = application.gets
+        preload_status = preload_status.chomp if preload_status
+        log "app preload status: #{preload_status}"
+        exit 1 if preload_status == "1"
+
+        log "sending command"
         send_json application, "args" => args, "env" => ENV.to_hash
 
         pid = server.gets
@@ -161,6 +166,8 @@ module Spring
         if pid && !pid.empty?
           log "got pid: #{pid}"
 
+          suspend_resume_on_tstp_cont(pid)
+
           forward_signals(application)
           status = application.read.to_i
 
@@ -181,6 +188,18 @@ module Spring
         end
       end
 
+      def suspend_resume_on_tstp_cont(pid)
+        trap("TSTP") {
+          log "suspended"
+          Process.kill("STOP", pid.to_i)
+          Process.kill("STOP", Process.pid)
+        }
+        trap("CONT") {
+          log "resumed"
+          Process.kill("CONT", pid.to_i)
+        }
+      end
+
       def forward_signals(application)
         @signal_queue.each { |sig| kill sig, application }
 

data/lib/spring/client/stop.rb

@@ -4,7 +4,7 @@ module Spring
   module Client
     class Stop < Command
       def self.description
-        "Stop all spring processes for this project."
+        "Stop all Spring processes for this project."
       end
 
       def call