spring 2.0.1 → 3.0.0

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?
@@ -161,6 +161,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 +183,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

data/lib/spring/commands.rb

@@ -32,7 +32,7 @@ module Spring
   # then we need to be under bundler.
   require "bundler/setup"
 
-  # Auto-require any spring extensions which are in the Gemfile
+  # Auto-require any Spring extensions which are in the Gemfile
   Gem::Specification.map(&:name).grep(/^spring-/).each do |command|
     begin
       require command

data/lib/spring/configuration.rb

@@ -5,7 +5,11 @@ module Spring
     attr_accessor :application_root, :quiet
 
     def gemfile
-      ENV['BUNDLE_GEMFILE'] || "Gemfile"
+      if /\s1.9.[0-9]/ ===  Bundler.ruby_scope.gsub(/[\/\s]+/,'')
+        ENV["BUNDLE_GEMFILE"] || "Gemfile"
+      else
+        Bundler.default_gemfile
+      end
     end
 
     def after_fork_callbacks

data/lib/spring/env.rb

@@ -1,7 +1,5 @@
 require "pathname"
-require "fileutils"
 require "digest/md5"
-require "tmpdir"
 
 require "spring/version"
 require "spring/sid"
@@ -33,10 +31,12 @@ module Spring
     end
 
     def tmp_path
+      require "tmpdir"
       path = Pathname.new(
         ENV["SPRING_TMP_PATH"] ||
           File.join(ENV['XDG_RUNTIME_DIR'] || Dir.tmpdir, "spring-#{Process.uid}")
       )
+      require "fileutils"
       FileUtils.mkdir_p(path) unless path.exist?
       path
     end

data/lib/spring/errors.rb

@@ -24,7 +24,7 @@ module Spring
 
     def message
       "Spring was unable to find your config/application.rb file. " \
-        "Your project root was detected at #{project_root}, so spring " \
+        "Your project root was detected at #{project_root}, so Spring " \
         "looked for #{project_root}/config/application.rb but it doesn't exist. You can " \
         "configure the root of your application by setting Spring.application_root in " \
         "config/spring.rb."

data/lib/spring/process_title_updater.rb

@@ -1,6 +1,6 @@
 module Spring
   # Yes, I know this reimplements a bunch of stuff in Active Support, but
-  # I don't want the spring client to depend on AS, in order to keep its
+  # I don't want the Spring client to depend on AS, in order to keep its
   # load time down.
   class ProcessTitleUpdater
     SECOND = 1

data/lib/spring/version.rb

@@ -1,3 +1,3 @@
 module Spring
-  VERSION = "2.0.1"
+  VERSION = "3.0.0"
 end

data/lib/spring/watcher/abstract.rb

@@ -23,9 +23,21 @@ module Spring
         @directories = Set.new
         @stale       = false
         @listeners   = []
+
+        @on_debug    = nil
+      end
+
+      def on_debug(&block)
+        @on_debug = block
+      end
+
+      def debug
+        @on_debug.call(yield) if @on_debug
       end
 
       def add(*items)
+        debug { "watcher: add: #{items.inspect}" }
+
         items = items.flatten.map do |item|
           item = Pathname.new(item)
 
@@ -36,14 +48,30 @@ module Spring
           end
         end
 
-        items = items.select(&:exist?)
+        items = items.select do |item|
+          if item.symlink?
+            item.readlink.exist?.tap do |exists|
+              if !exists
+                debug { "add: ignoring dangling symlink: #{item.inspect} -> #{item.readlink.inspect}" }
+              end
+            end
+          else
+            item.exist?
+          end
+        end
 
         synchronize {
           items.each do |item|
             if item.directory?
               directories << item.realpath.to_s
             else
-              files << item.realpath.to_s
+              begin
+                files << item.realpath.to_s
+              rescue Errno::ENOENT
+                # Race condition. Ignore symlinks whose target was removed
+                # since the check above, or are deeply chained.
+                debug { "add: ignoring now-dangling symlink: #{item.inspect} -> #{item.readlink.inspect}" }
+              end
             end
           end
 
@@ -56,16 +84,19 @@ module Spring
       end
 
       def on_stale(&block)
+        debug { "added listener: #{block.inspect}" }
         @listeners << block
       end
 
       def mark_stale
         return if stale?
         @stale = true
+        debug { "marked stale, calling listeners: listeners=#{@listeners.inspect}" }
         @listeners.each(&:call)
       end
 
       def restart
+        debug { "restarting" }
         stop
         start
       end

data/lib/spring/watcher/polling.rb

@@ -12,7 +12,13 @@ module Spring
       end
 
       def check_stale
-        synchronize { mark_stale if mtime < compute_mtime }
+        synchronize do
+          computed = compute_mtime
+          if mtime < computed
+            debug { "check_stale: mtime=#{mtime.inspect} < computed=#{computed.inspect}" }
+            mark_stale
+          end
+        end
       end
 
       def add(*)
@@ -21,36 +27,67 @@ module Spring
       end
 
       def start
+        debug { "start: poller=#{@poller.inspect}" }
         unless @poller
           @poller = Thread.new {
             Thread.current.abort_on_exception = true
 
-            loop do
-              Kernel.sleep latency
-              check_stale
+            begin
+              until stale?
+                Kernel.sleep latency
+                check_stale
+              end
+            rescue Exception => e
+              debug do
+                "poller: aborted: #{e.class}: #{e}\n  #{e.backtrace.join("\n  ")}"
+              end
+              raise
+            ensure
+              @poller = nil
             end
           }
         end
       end
 
       def stop
+        debug { "stopping poller: #{@poller.inspect}" }
         if @poller
           @poller.kill
           @poller = nil
         end
       end
 
+      def running?
+        @poller && @poller.alive?
+      end
+
       def subjects_changed
-        @mtime = compute_mtime
+        computed = compute_mtime
+        debug { "subjects_changed: mtime #{@mtime} -> #{computed}" }
+        @mtime = computed
       end
 
       private
 
       def compute_mtime
-        expanded_files.map { |f| File.mtime(f).to_f }.max || 0
-      rescue Errno::ENOENT
-        # if a file does no longer exist, the watcher is always stale.
-        Float::MAX
+        expanded_files.map do |f|
+          # Get the mtime of symlink targets. Ignore dangling symlinks.
+          if File.symlink?(f)
+            begin
+              File.mtime(f)
+            rescue Errno::ENOENT
+              0
+            end
+          # If a file no longer exists, treat it as changed.
+          else
+            begin
+              File.mtime(f)
+            rescue Errno::ENOENT
+              debug { "compute_mtime: no longer exists: #{f}" }
+              Float::MAX
+            end
+          end.to_f
+        end.max || 0
       end
 
       def expanded_files

metadata

@@ -1,31 +1,31 @@
 --- !ruby/object:Gem::Specification
 name: spring
 version: !ruby/object:Gem::Version
-  version: 2.0.1
+  version: 3.0.0
 platform: ruby
 authors:
 - Jon Leighton
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2017-01-21 00:00:00.000000000 Z
+date: 2021-09-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: activesupport
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.2'
-  type: :runtime
+        version: '0'
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.2'
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: bump
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -39,7 +39,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: bump
+  name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -91,12 +91,6 @@ files:
 - lib/spring/process_title_updater.rb
 - lib/spring/server.rb
 - lib/spring/sid.rb
-- lib/spring/test.rb
-- lib/spring/test/acceptance_test.rb
-- lib/spring/test/application.rb
-- lib/spring/test/application_generator.rb
-- lib/spring/test/rails_version.rb
-- lib/spring/test/watcher_test.rb
 - lib/spring/version.rb
 - lib/spring/watcher.rb
 - lib/spring/watcher/abstract.rb
@@ -105,7 +99,7 @@ homepage: https://github.com/rails/spring
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -113,16 +107,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.5.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.5.1
-signing_key: 
+rubygems_version: 3.2.22
+signing_key:
 specification_version: 4
 summary: Rails application preloader
 test_files: []

data/lib/spring/test/acceptance_test.rb

@@ -1,558 +0,0 @@
-require "io/wait"
-require "timeout"
-require "spring/sid"
-require "spring/client"
-require "active_support/core_ext/string/strip"
-
-module Spring
-  module Test
-    class AcceptanceTest < ActiveSupport::TestCase
-      runnables.delete self # prevent Minitest running this class
-
-      DEFAULT_SPEEDUP = 0.8
-
-      def rails_version
-        ENV['RAILS_VERSION'] || '~> 5.0.0'
-      end
-
-      # Extension point for spring-watchers-listen
-      def generator_klass
-        Spring::Test::ApplicationGenerator
-      end
-
-      def generator
-        @@generator ||= generator_klass.new(rails_version)
-      end
-
-      def app
-        @app ||= Spring::Test::Application.new("#{Spring::Test.root}/apps/tmp")
-      end
-
-      def spring_env
-        app.spring_env
-      end
-
-      def assert_output(artifacts, expected)
-        expected.each do |stream, output|
-          assert artifacts[stream].include?(output),
-                 "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#{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#{app.debug(artifacts)}"
-        assert_output artifacts, expected_output if expected_output
-      end
-
-      def refute_output_includes(command, not_expected)
-        artifacts = app.run(*Array(command))
-        not_expected.each do |stream, output|
-          assert !artifacts[stream].include?(output),
-                 "expected #{stream} to not include '#{output}'.\n\n#{app.debug(artifacts)}"
-        end
-      end
-
-      def assert_speedup(ratio = DEFAULT_SPEEDUP)
-        if ENV['CI']
-          yield
-        else
-          app.with_timing do
-            yield
-            assert app.timing_ratio < ratio, "#{app.last_time} was not less than #{ratio} of #{app.first_time}"
-          end
-        end
-      end
-
-      def without_gem(name)
-        gem_home = app.gem_home.join('gems')
-        FileUtils.mv(gem_home.join(name), app.root)
-        yield
-      ensure
-        FileUtils.mv(app.root.join(name), gem_home)
-      end
-
-      setup do
-        generator.generate_if_missing
-        generator.install_spring
-        generator.copy_to(app.root)
-      end
-
-      teardown do
-        app.stop_spring
-      end
-
-      test "basic" do
-        assert_speedup do
-          2.times { app.run app.spring_test_command }
-        end
-      end
-
-      test "help message when called without arguments" do
-        assert_success "bin/spring", stdout: 'Usage: spring COMMAND [ARGS]'
-        assert spring_env.server_running?
-      end
-
-      test "shows help" do
-        assert_success "bin/spring help", stdout: 'Usage: spring COMMAND [ARGS]'
-        assert_success "bin/spring -h", stdout: 'Usage: spring COMMAND [ARGS]'
-        assert_success "bin/spring --help", stdout: 'Usage: spring COMMAND [ARGS]'
-        refute spring_env.server_running?
-      end
-
-      test "tells the user that spring is being used when used automatically via binstubs" do
-        assert_success "bin/rails runner ''", stderr: "Running via Spring preloader in process"
-        assert_success app.spring_test_command, stderr: "Running via Spring preloader in process"
-      end
-
-      test "does not tell the user that spring is being used when used automatically via binstubs but quiet is enabled" do
-        File.write("#{app.user_home}/.spring.rb", "Spring.quiet = true")
-        assert_success "bin/rails runner ''"
-        refute_output_includes "bin/rails runner ''", stderr: 'Running via Spring preloader in process'
-      end
-
-      test "test changes are picked up" do
-        assert_speedup do
-          assert_success app.spring_test_command, stdout: "0 failures"
-
-          app.insert_into_test "raise 'omg'"
-          assert_failure app.spring_test_command, stdout: "RuntimeError: omg"
-        end
-      end
-
-      test "code changes are picked up" do
-        assert_speedup do
-          assert_success app.spring_test_command, stdout: "0 failures"
-
-          File.write(app.controller, app.controller.read.sub("@posts = Post.all", "raise 'omg'"))
-          assert_failure app.spring_test_command, stdout: "RuntimeError: omg"
-        end
-      end
-
-      test "code changes in pre-referenced app files are picked up" do
-        File.write(app.path("config/initializers/load_posts_controller.rb"), "PostsController\n")
-
-        assert_speedup do
-          assert_success app.spring_test_command, stdout: "0 failures"
-
-          File.write(app.controller, app.controller.read.sub("@posts = Post.all", "raise 'omg'"))
-          assert_failure app.spring_test_command, stdout: "RuntimeError: omg"
-        end
-      end
-
-      test "app gets reloaded when preloaded files change" do
-        assert_success app.spring_test_command
-
-        File.write(app.application_config, app.application_config.read + <<-RUBY.strip_heredoc)
-          class Foo
-            def self.omg
-              raise "omg"
-            end
-          end
-        RUBY
-        app.insert_into_test "Foo.omg"
-
-        app.await_reload
-        assert_failure app.spring_test_command, stdout: "RuntimeError: omg"
-      end
-
-      test "app gets reloaded even with a ton of boot output" do
-        limit = UNIXSocket.pair.first.getsockopt(:SOCKET, :SNDBUF).int
-
-        assert_success app.spring_test_command
-        File.write(app.path("config/initializers/verbose.rb"), "#{limit}.times { puts 'x' }")
-
-        app.await_reload
-        assert_success app.spring_test_command
-      end
-
-      test "app gets reloaded even with abort_on_exception=true" do
-        assert_success app.spring_test_command
-        File.write(app.path("config/initializers/thread_config.rb"), "Thread.abort_on_exception = true")
-
-        app.await_reload
-        assert_success app.spring_test_command
-      end
-
-      test "app recovers when a boot-level error is introduced" do
-        config = app.application_config.read
-
-        assert_success app.spring_test_command
-
-        File.write(app.application_config, "#{config}\nomg")
-        app.await_reload
-
-        assert_failure app.spring_test_command
-
-        File.write(app.application_config, config)
-        assert_success app.spring_test_command
-      end
-
-      test "stop command kills server" do
-        app.run app.spring_test_command
-        assert spring_env.server_running?, "The server should be running but it isn't"
-
-        assert_success "bin/spring stop"
-        assert !spring_env.server_running?, "The server should not be running but it is"
-      end
-
-      test "custom commands" do
-        # Start spring before setting up the command, to test that it gracefully upgrades itself
-        assert_success "bin/rails runner ''"
-
-        File.write(app.spring_config, <<-RUBY.strip_heredoc)
-          class CustomCommand
-            def call
-              puts "omg"
-            end
-
-            def exec_name
-              "rake"
-            end
-          end
-
-          Spring.register_command "custom", CustomCommand.new
-        RUBY
-
-        assert_success "bin/spring custom", stdout: "omg"
-
-        assert_success "bin/spring binstub custom"
-        assert_success "bin/custom", stdout: "omg"
-
-        app.env["DISABLE_SPRING"] = "1"
-        assert_success %{bin/custom -e 'puts "foo"'}, stdout: "foo"
-      end
-
-      test "binstub" do
-        assert_success "bin/rails server --help", stdout: "Usage: rails server" # rails command fallback
-
-        assert_success "#{app.spring} binstub rake", stdout: "bin/rake: spring already present"
-
-        assert_success "#{app.spring} binstub --remove rake", stdout: "bin/rake: spring removed"
-        assert !app.path("bin/rake").read.include?(Spring::Client::Binstub::LOADER)
-        assert_success "bin/rake -T", stdout: "rake db:migrate"
-      end
-
-      test "binstub remove all" do
-        assert_success "bin/spring binstub --remove --all"
-        refute File.exist?(app.path("bin/spring"))
-      end
-
-      test "binstub when spring gem is missing" do
-        without_gem "spring-#{Spring::VERSION}" do
-          File.write(app.gemfile, app.gemfile.read.gsub(/gem 'spring.*/, ""))
-          assert_success "bin/rake -T", stdout: "rake db:migrate"
-        end
-      end
-
-      test "binstub when spring binary is missing" do
-        begin
-          File.rename(app.path("bin/spring"), app.path("bin/spring.bak"))
-          assert_success "bin/rake -T", stdout: "rake db:migrate"
-        ensure
-          File.rename(app.path("bin/spring.bak"), app.path("bin/spring"))
-        end
-      end
-
-      test "binstub upgrade with old binstub" do
-        File.write(app.path("bin/rake"), <<-RUBY.strip_heredoc)
-          #!/usr/bin/env ruby
-
-          if !Process.respond_to?(:fork) || Gem::Specification.find_all_by_name("spring").empty?
-            exec "bundle", "exec", "rake", *ARGV
-          else
-            ARGV.unshift "rake"
-            load Gem.bin_path("spring", "spring")
-          end
-        RUBY
-
-        File.write(app.path("bin/rails"), <<-RUBY.strip_heredoc)
-          #!/usr/bin/env ruby
-
-          if !Process.respond_to?(:fork) || Gem::Specification.find_all_by_name("spring").empty?
-            APP_PATH = File.expand_path('../../config/application',  __FILE__)
-            require_relative '../config/boot'
-            require 'rails/commands'
-          else
-            ARGV.unshift "rails"
-            load Gem.bin_path("spring", "spring")
-          end
-        RUBY
-
-        assert_success "bin/spring binstub --all", stdout: "upgraded"
-
-        expected = <<-RUBY.gsub(/^          /, "")
-          #!/usr/bin/env ruby
-          #{Spring::Client::Binstub::LOADER.strip}
-          require 'bundler/setup'
-          load Gem.bin_path('rake', 'rake')
-        RUBY
-        assert_equal expected, app.path("bin/rake").read
-
-        expected = <<-RUBY.gsub(/^          /, "")
-          #!/usr/bin/env ruby
-          #{Spring::Client::Binstub::LOADER.strip}
-          APP_PATH = File.expand_path('../../config/application',  __FILE__)
-          require_relative '../config/boot'
-          require 'rails/commands'
-        RUBY
-        assert_equal expected, app.path("bin/rails").read
-      end
-
-      test "binstub upgrade with new binstub variations" do
-        expected = <<-RUBY.gsub(/^          /, "")
-          #!/usr/bin/env ruby
-          #{Spring::Client::Binstub::LOADER.strip}
-          require 'bundler/setup'
-          load Gem.bin_path('rake', 'rake')
-        RUBY
-
-        # older variation with double quotes
-        File.write(app.path("bin/rake"), <<-RUBY.strip_heredoc)
-          #!/usr/bin/env ruby
-          begin
-            load File.expand_path("../spring", __FILE__)
-          rescue LoadError
-          end
-          require 'bundler/setup'
-          load Gem.bin_path('rake', 'rake')
-        RUBY
-
-        assert_success "bin/spring binstub rake", stdout: "bin/rake: upgraded"
-        assert_equal expected, app.path("bin/rake").read
-
-        # newer variation with single quotes
-        File.write(app.path("bin/rake"), <<-RUBY.strip_heredoc)
-          #!/usr/bin/env ruby
-          begin
-            load File.expand_path('../spring', __FILE__)
-          rescue LoadError
-          end
-          require 'bundler/setup'
-          load Gem.bin_path('rake', 'rake')
-        RUBY
-
-        assert_success "bin/spring binstub rake", stdout: "bin/rake: upgraded"
-        assert_equal expected, app.path("bin/rake").read
-
-        # newer variation which checks end of exception message
-        File.write(app.path("bin/rake"), <<-RUBY.strip_heredoc)
-          #!/usr/bin/env ruby
-          begin
-            spring_bin_path = File.expand_path('../spring', __FILE__)
-            load spring_bin_path
-          rescue LoadError => e
-            raise unless e.message.end_with? spring_bin_path, 'spring/binstub'
-          end
-          require 'bundler/setup'
-          load Gem.bin_path('rake', 'rake')
-        RUBY
-
-        assert_success "bin/spring binstub rake", stdout: "bin/rake: upgraded"
-        assert_equal expected, app.path("bin/rake").read
-      end
-
-      test "binstub remove with new binstub variations" do
-        # older variation with double quotes
-        File.write(app.path("bin/rake"), <<-RUBY.strip_heredoc)
-          #!/usr/bin/env ruby
-          begin
-            load File.expand_path("../spring", __FILE__)
-          rescue LoadError
-          end
-          require 'bundler/setup'
-          load Gem.bin_path('rake', 'rake')
-        RUBY
-
-        # newer variation with single quotes
-        File.write(app.path("bin/rails"), <<-RUBY.strip_heredoc)
-          #!/usr/bin/env ruby
-          begin
-            load File.expand_path('../spring', __FILE__)
-          rescue LoadError
-          end
-          APP_PATH = File.expand_path('../../config/application',  __FILE__)
-          require_relative '../config/boot'
-          require 'rails/commands'
-        RUBY
-
-        assert_success "bin/spring binstub --remove rake", stdout: "bin/rake: spring removed"
-        assert_success "bin/spring binstub --remove rails", stdout: "bin/rails: spring removed"
-
-        expected = <<-RUBY.strip_heredoc
-          #!/usr/bin/env ruby
-          require 'bundler/setup'
-          load Gem.bin_path('rake', 'rake')
-        RUBY
-        assert_equal expected, app.path("bin/rake").read
-
-        expected = <<-RUBY.strip_heredoc
-          #!/usr/bin/env ruby
-          APP_PATH = File.expand_path('../../config/application',  __FILE__)
-          require_relative '../config/boot'
-          require 'rails/commands'
-        RUBY
-        assert_equal expected, app.path("bin/rails").read
-      end
-
-      test "after fork callback" do
-        File.write(app.spring_config, "Spring.after_fork { puts '!callback!' }")
-        assert_success "bin/rails runner 'puts 2'", stdout: "!callback!\n2"
-      end
-
-      test "global config file evaluated" do
-        File.write("#{app.user_home}/.spring.rb", "Spring.after_fork { puts '!callback!' }")
-        assert_success "bin/rails runner 'puts 2'", stdout: "!callback!\n2"
-      end
-
-      test "can define client tasks" do
-        File.write("#{app.spring_client_config}", <<-RUBY)
-          Spring::Client::COMMANDS["foo"] = lambda { |args| puts "bar -- \#{args.inspect}" }
-        RUBY
-        assert_success "bin/spring foo --baz", stdout: "bar -- [\"foo\", \"--baz\"]\n"
-      end
-
-      test "missing config/application.rb" do
-        app.application_config.delete
-        assert_failure "bin/rake -T", stderr: "unable to find your config/application.rb"
-      end
-
-      test "piping with boot-level error" do
-        config = app.application_config.read
-        File.write(app.application_config, "#{config}\nomg")
-        assert_success "bin/rake -T | cat"
-      end
-
-      test "piping" do
-        assert_success "bin/rake -T | grep db", stdout: "rake db:migrate"
-      end
-
-      test "status" do
-        assert_success "bin/spring status", stdout: "Spring is not running"
-        assert_success "bin/rails runner ''"
-        assert_success "bin/spring status", stdout: "Spring is running"
-      end
-
-      test "runner command sets Rails environment from command-line options" do
-        assert_success "bin/rails runner -e test 'puts Rails.env'", stdout: "test"
-        assert_success "bin/rails runner --environment=test 'puts Rails.env'", stdout: "test"
-      end
-
-      test "forcing rails env via environment variable" do
-        app.env['RAILS_ENV'] = 'test'
-        assert_success "bin/rake -p 'Rails.env'", stdout: "test"
-      end
-
-      test "setting env vars with rake" do
-        File.write(app.path("lib/tasks/env.rake"), <<-RUBY.strip_heredoc)
-          task :print_rails_env => :environment do
-            puts Rails.env
-          end
-
-          task :print_env do
-            ENV.each { |k, v| puts "\#{k}=\#{v}" }
-          end
-
-          task(:default).clear.enhance [:print_rails_env]
-        RUBY
-
-        assert_success "bin/rake RAILS_ENV=test print_rails_env", stdout: "test"
-        assert_success "bin/rake FOO=bar print_env", stdout: "FOO=bar"
-        assert_success "bin/rake", stdout: "test"
-      end
-
-      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.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"), <<-RUBY.strip_heredoc)
-          gemfile = Rails.root.join("Gemfile")
-          File.write(gemfile, "\#{gemfile.read}gem 'text'\\n")
-          Bundler.with_clean_env do
-            system(#{app.env.inspect}, "bundle install")
-          end
-          output = `\#{Rails.root.join('bin/rails')} runner 'require "text"; puts "done";'`
-          exit output.include? "done\n"
-        RUBY
-
-        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'")
-
-        app.env["OMG"] = "1"
-        app.env["FOO"] = "1"
-        app.env["RUBYOPT"] = "-rubygems"
-
-        assert_success %(bin/rails runner 'p ENV["OMG"]'), stdout: "1"
-        assert_success %(bin/rails runner 'p ENV["BAR"]'), stdout: "bar"
-        assert_success %(bin/rails runner 'p ENV.key?("BUNDLE_GEMFILE")'), stdout: "true"
-        assert_success %(bin/rails runner 'p ENV["RUBYOPT"]'), stdout: "bundler"
-
-        app.env["OMG"] = "2"
-        app.env.delete "FOO"
-
-        assert_success %(bin/rails runner 'p ENV["OMG"]'), stdout: "2"
-        assert_success %(bin/rails runner 'p ENV.key?("FOO")'), stdout: "false"
-      end
-
-      test "Kernel.raise remains private" do
-        expr = "p Kernel.private_instance_methods.include?(:raise)"
-        assert_success %(bin/rails runner '#{expr}'), stdout: "true"
-      end
-
-      test "custom bundle path" do
-        bundle_path = app.path(".bundle/#{Bundler.ruby_scope}")
-        bundle_path.dirname.mkpath
-
-        FileUtils.cp_r "#{app.gem_home}/", bundle_path.to_s
-
-        app.run! "bundle install --path .bundle --clean --local"
-
-        assert_speedup do
-          2.times { assert_success "bundle exec rails runner ''" }
-        end
-      end
-
-      test "booting a foreground server" do
-        FileUtils.cd(app.root) do
-          assert !spring_env.server_running?
-          assert_success "bin/spring server &"
-
-          Timeout.timeout(10) do
-            sleep 0.1 until spring_env.server_running? && spring_env.socket_path.exist?
-          end
-
-          assert_success app.spring_test_command
-        end
-      end
-
-      test "server boot timeout" do
-        app.env["SPRING_SERVER_COMMAND"] = "sleep 1"
-        File.write("#{app.spring_client_config}", %(
-          Spring::Client::Run.const_set(:BOOT_TIMEOUT, 0.1)
-        ))
-
-        assert_failure "bin/rails runner ''", stderr: "timed out"
-      end
-
-      test "no warnings are shown for unsprung commands" do
-        app.env["DISABLE_SPRING"] = "1"
-        refute_output_includes "bin/rails runner ''", stderr: "WARN"
-      end
-    end
-  end
-end