spring 4.0.0 → 4.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9f13e2a4d08faffc1b15c2f1dfe801a3b0b6a12b80d7a66a39601e74ccf3feff
-  data.tar.gz: 60c63476055ff6050668abfc79489f7c6fbbfc9a7b3a11ea998cb5b2ab86ef9a
+  metadata.gz: a37d78748e084596d151cde2918d30799c8dfe9e10e029920ece9e9eee8118ad
+  data.tar.gz: c47e0897d3938b7350245854672812436505379cc498638c3eca9e2d52537fe6
 SHA512:
-  metadata.gz: 9c467ea15cea498f05ec7e5211bb014163e37a75557d9694e03cc4d6d6e94d4b62c6edcede752e61c4ff51accf472939150c7fc01901aab94cd60d4d06c8a8b1
-  data.tar.gz: 6d363498591c949b3a49885c38d8694db924d9a2b24c2cc8499236d67739f4cb863eff5db114385bba8cb02bf996af48acd892cbf5e2edebe495bf3bdfffca93
+  metadata.gz: cda176e1dd4d22cabb680cb85c4fd562c256f8fb3dc04f9064fc61f910cfb384f044f63bee74a424501505b62f80e0746f6c05bddf327c6be0150f12cc678a3f
+  data.tar.gz: e8b1675241b3fc42c52eabb9e2f501d4abae16c35ae3e3d19080de332f3d28b258b7245c127264326871f09c35c333a3b71fcfb8fbbfecdc87648a72e1328c14

data/README.md

@@ -16,8 +16,9 @@ boot it every time you run a test, rake task or migration.
 
 ## Compatibility
 
-* Ruby versions: MRI 2.7, MRI 3.0, MRI 3.1
-* Rails versions: 6.0, 6.1, 7.0
+* Ruby versions: MRI 3.1+
+* Rails versions: 7.1+
+* Bundler v2.1+
 
 Spring makes extensive use of `Process.fork`, so won't be able to
 provide a speed up on platforms which don't support forking (Windows, JRuby).
@@ -70,11 +71,39 @@ Rails directory.
 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
+Ensure that `config.enable_reloading` is `true` in the environments that
 Spring manages. That setting is typically configured in
-`config/environments/*.rb`. In particular, make sure it is `false` for the
+`config/environments/*.rb`. In particular, make sure it is `true` for the
 `test` environment.
 
+Note: in versions of Rails before 7.1, the setting is called `cache_classes`,
+and it needs to be `false` for Spring to work.
+
+#### Running Spring with reloading disabled (advanced, risky)
+
+If you know what you are doing, and if every reloadable resource is configured
+to materialize *lazily in the forked child*, not in the Spring server process,
+then you can decide to run Spring without Rail's in-process reloaders.
+
+To opt into this, set in `config/spring.rb`:
+
+```ruby
+Spring.dangerously_allow_disabling_reloading = true
+```
+
+If you set this, you should make sure that you are NOT pre-loading reloadable
+resource in the Spring server. One approach is to add boot-time assertions at
+the end of `Spring.after_environment_load`, e.g.:
+
+```ruby
+Spring.after_environment_load do
+  raise "routes were drawn at boot" if Rails.application.routes_reloader.loaded
+  raise "i18n locales where loaded at boot" unless I18n.backend.instance_variable_get(:@translations).nil?
+end
+```
+
+When unsure, leave this disabled.
+
 ### Usage
 
 For this walkthrough I've generated a new Rails application, and run
@@ -330,7 +359,8 @@ server process is started, it can be used to add new top-level commands.
 Spring must know how to find your Rails application. If you have a
 normal app everything works out of the box. If you are working on a
 project with a special setup (an engine for example), you must tell
-Spring where your app is located:
+Spring where your app is located by specifying the below code in a
+`config/spring.rb` file relative to your engines root directory :
 
 ```ruby
 Spring.application_root = './test/dummy'
@@ -388,6 +418,12 @@ a command runs:
 Spring.quiet = true
 ```
 
+You can also set the initial state of the `quiet` configuration option to true
+by setting the `SPRING_QUIET` environment variable before executing Spring.
+This is useful if you want to set quiet mode when invoking the Spring executable
+in a subprocess, and cannot or prefer not to set it programmatically
+via the `Spring.quiet` option in `~/.spring.rb` or the app's `config/spring.rb`.
+
 ### Environment variables
 
 The following environment variables are used by Spring:
@@ -412,6 +448,8 @@ The following environment variables are used by Spring:
   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_QUIET` - If set, the initial state of the `Spring.quiet`
+  configuration option will default to `true`.
 * `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`.

data/lib/spring/application/boot.rb

@@ -11,9 +11,15 @@ app = Spring::Application.new(
 
 Signal.trap("TERM") { app.terminate }
 
-Spring::ProcessTitleUpdater.run { |distance|
-  "spring app    | #{app.app_name} | started #{distance} ago | #{app.app_env} mode"
-}
+Spring::ProcessTitleUpdater.run do |distance|
+  attributes = [
+    app.app_name,
+    "started #{distance} ago",
+    "#{app.app_env} mode",
+    app.spawn_env,
+  ].compact
+  "spring app    | #{attributes.join(" | ")}"
+end
 
 app.eager_preload if ENV.delete("SPRING_PRELOAD") == "1"
 app.run

data/lib/spring/application.rb

@@ -1,5 +1,4 @@
 require "spring/boot"
-require "set"
 require "pty"
 
 module Spring
@@ -29,6 +28,11 @@ module Spring
       @interrupt.last.write "."
     end
 
+    def spawn_env
+      env = JSON.load(ENV["SPRING_SPAWN_ENV"].dup).map { |key, value| "#{key}=#{value}" }
+      env.join(", ") if env.any?
+    end
+
     def app_env
       ENV['RAILS_ENV']
     end
@@ -97,16 +101,28 @@ module Spring
       end
 
       Rails::Application.initializer :ensure_reloading_is_enabled, group: :all do
+        next if Spring.dangerously_allow_disabling_reloading
+
         if Rails.application.config.cache_classes
+          config_name, set_to = if Rails.application.config.respond_to?(:enable_reloading=)
+            ["enable_reloading", "true"]
+          else
+            ["cache_classes", "false"]
+          end
           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.
+            Please, set config.#{config_name} to #{set_to} in config/environments/#{Rails.env}.rb.
+            (If you understand the trade-offs and want to disable Rails' reloader anyway,
+            set `Spring.dangerously_allow_disabling_reloading = true` in config/spring.rb.)
           MSG
         end
       end
 
       require Spring.application_root_path.join("config", "environment")
 
+      invoke_after_environment_load_callbacks
+      preload_framework_base_classes
+
       disconnect_database
 
       @preloaded = :success
@@ -120,6 +136,12 @@ module Spring
 
       if defined?(Rails) && Rails.application
         watcher.add Rails.application.paths["config/initializers"]
+        rails_root = Rails.root.to_s
+        Rails::Engine.subclasses.each do |engine|
+          if engine.root.to_s.start_with?(rails_root)
+            watcher.add engine.paths["config/initializers"].expanded
+          end
+        end
         watcher.add Rails.application.paths["config/database"]
         if secrets_path = Rails.application.paths["config/secrets"]
           watcher.add secrets_path
@@ -127,8 +149,26 @@ module Spring
       end
     end
 
+    # Eagerly autoload framework base classes
+    FRAMEWORK_BASE_CLASSES = %w[
+      ActionMailer::Base
+      ActionController::Base
+      ActionController::API
+    ].freeze
+
+    def preload_framework_base_classes
+      FRAMEWORK_BASE_CLASSES.each do |const|
+        Object.const_get(const) if Object.const_defined?(const)
+      end
+    end
+
     def eager_preload
-      with_pty { preload }
+      with_pty do
+        # we can't see stderr and there could be issues when it's overflown
+        # see https://github.com/rails/spring/issues/396
+        STDERR.reopen("/dev/null")
+        preload
+      end
     end
 
     def run
@@ -163,7 +203,7 @@ module Spring
           client.puts(0) # preload success
         rescue Exception
           log "preload failed"
-          client.puts(1) # preload failure
+          ignore_client_disconnect { client.puts(1) } # preload failure
           raise
         end
       end
@@ -224,15 +264,19 @@ module Spring
 
       wait pid, streams, client
     rescue Exception => e
-      log "exception: #{e}"
+      if e.is_a?(Errno::EPIPE)
+        log "client disconnected (#{e.message}), ignoring command"
+      else
+        log "exception: #{e}"
+      end
       manager.puts unless pid
 
       if streams && !e.is_a?(SystemExit)
-        print_exception(stderr, e)
-        streams.each(&:close)
+        ignore_client_disconnect { print_exception(stderr, e) }
+        streams.each { |stream| ignore_client_disconnect { stream.close } }
       end
 
-      client.puts(1) if pid
+      ignore_client_disconnect { client.puts(1) if pid }
       client.close
     ensure
       # Redirect STDOUT and STDERR to prevent from keeping the original FDs
@@ -280,6 +324,12 @@ module Spring
       end
     end
 
+    def invoke_after_environment_load_callbacks
+      Spring.after_environment_load_callbacks.each do |callback|
+        callback.call
+      end
+    end
+
     def loaded_application_features
       root = Spring.application_root_path.to_s
       $LOADED_FEATURES.select { |f| f.start_with?(root) }
@@ -298,13 +348,28 @@ module Spring
       Kernel.module_eval do
         old_raise = Kernel.method(:raise)
         remove_method :raise
-        define_method :raise do |*args|
-          begin
-            old_raise.call(*args)
-          ensure
-            if $!
-              lib = File.expand_path("..", __FILE__)
-              $!.backtrace.reject! { |line| line.start_with?(lib) } unless $!.backtrace.frozen?
+        if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('3.2.0')
+          define_method :raise do |*args, **kwargs|
+            begin
+              old_raise.call(*args, **kwargs)
+            ensure
+              if $!
+                lib = File.expand_path("..", __FILE__)
+                $!.backtrace.reject! { |line| line.start_with?(lib) } unless $!.backtrace.frozen?
+                $!.backtrace_locations.reject! { |line| line.path&.start_with?(lib) } unless $!.backtrace_locations.frozen?
+              end
+            end
+          end
+        else
+          define_method :raise do |*args|
+            begin
+              old_raise.call(*args)
+            ensure
+              if $!
+                lib = File.expand_path("..", __FILE__)
+                $!.backtrace.reject! { |line| line.start_with?(lib) } unless $!.backtrace.frozen?
+                $!.backtrace_locations.reject! { |line| line.path&.start_with?(lib) } unless $!.backtrace_locations.frozen?
+              end
             end
           end
         end
@@ -343,10 +408,10 @@ module Spring
       Spring.failsafe_thread {
         begin
           _, status = Process.wait2 pid
-          log "#{pid} exited with #{status.exitstatus}"
+          log "#{pid} exited with #{status.exitstatus || status.inspect}"
 
           streams.each(&:close)
-          client.puts(status.exitstatus)
+          client.puts(status.exitstatus || status.to_i)
           client.close
         ensure
           @mutex.synchronize { @waiting.delete pid }
@@ -368,6 +433,15 @@ module Spring
 
     private
 
+    # Tolerate Errno::EPIPE on writes to the client socket. Once the client
+    # disconnects, every subsequent write to it raises — that's expected
+    # during `serve`'s status reporting; we'd be talking to a process
+    # that's gone.
+    def ignore_client_disconnect
+      yield
+    rescue Errno::EPIPE
+    end
+
     def active_record_configured?
       defined?(ActiveRecord::Base) && ActiveRecord::Base.configurations.any?
     end

data/lib/spring/application_manager.rb

@@ -1,9 +1,10 @@
 module Spring
   class ApplicationManager
-    attr_reader :pid, :child, :app_env, :spring_env, :status
+    attr_reader :pid, :child, :app_env, :spawn_env, :spring_env, :status
 
-    def initialize(app_env, spring_env)
+    def initialize(app_env, spawn_env, spring_env)
       @app_env    = app_env
+      @spawn_env  = spawn_env
       @spring_env = spring_env
       @mutex      = Mutex.new
       @state      = :running
@@ -41,7 +42,7 @@ module Spring
         if alive?
           begin
             yield
-          rescue Errno::ECONNRESET, Errno::EPIPE
+          rescue Errno::ECONNRESET, Errno::EPIPE, Errno::EINVAL
             # The child has died but has not been collected by the wait thread yet,
             # so start a new child and try again.
             log "child dead; starting"
@@ -93,14 +94,16 @@ module Spring
     def start_child(preload = false)
       @child, child_socket = UNIXSocket.pair
 
-      Bundler.with_unbundled_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,
             "RACK_ENV"            => app_env,
             "SPRING_ORIGINAL_ENV" => JSON.dump(Spring::ORIGINAL_ENV),
-            "SPRING_PRELOAD"      => preload ? "1" : "0"
+            "SPRING_PRELOAD"      => preload ? "1" : "0",
+            "SPRING_SPAWN_ENV"    => JSON.dump(spawn_env.compact),
+            **spawn_env,
           },
           "ruby",
           *(bundler_dir != RbConfig::CONFIG["rubylibdir"] ? ["-I", bundler_dir] : []),
@@ -123,7 +126,8 @@ module Spring
         # 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?
+          peek = child.recv(1, Socket::MSG_PEEK)
+          break if peek.nil? || peek.empty?
           sleep 0.01
         end
 

data/lib/spring/client/binstub.rb

@@ -1,5 +1,3 @@
-require 'set'
-
 module Spring
   module Client
     class Binstub < Command
@@ -22,13 +20,13 @@ module Spring
       SPRING = <<~CODE
         #!/usr/bin/env ruby
 
-        # This file loads Spring without using loading other gems in the Gemfile, in order to be fast.
+        # This file loads Spring without loading other gems in the Gemfile in order to be fast.
         # It gets overwritten when you run the `spring binstub` command.
 
         if !defined?(Spring) && [nil, "development", "test"].include?(ENV["RAILS_ENV"])
           require "bundler"
 
-          Bundler.locked_gems.specs.find { |spec| spec.name == "spring" }&.tap do |spring|
+          Bundler.definition.requested_specs.find { |spec| spec.name == "spring" }&.tap do |spring|
             Gem.use_paths Gem.dir, Bundler.bundle_path.to_s, *Gem.path
             gem "spring", spring.version
             require "spring/binstub"

data/lib/spring/client/rails.rb

@@ -1,5 +1,3 @@
-require "set"
-
 module Spring
   module Client
     class Rails < Command
@@ -22,7 +20,7 @@ module Spring
 
         if COMMANDS.include?(command_name)
           Run.call(["rails_#{command_name}", *args.drop(2)])
-        elsif command_name.start_with?("db:")
+        elsif command_name&.start_with?("db:") && !command_name.start_with?("db:system")
           Run.call(["rake", *args.drop(1)])
         else
           require "spring/configuration"

data/lib/spring/client/run.rb

@@ -6,8 +6,7 @@ module Spring
   module Client
     class Run < Command
       FORWARDED_SIGNALS = %w(INT QUIT USR1 USR2 INFO WINCH) & Signal.list.keys
-      CONNECT_TIMEOUT   = 1
-      BOOT_TIMEOUT      = 20
+      ServerReadTimeout = Class.new(StandardError)
 
       attr_reader :server
 
@@ -73,8 +72,8 @@ module Spring
       def boot_server
         env.socket_path.unlink if env.socket_path.exist?
 
-        pid     = Process.spawn(gem_env, env.server_command, out: File::NULL)
-        timeout = Time.now + BOOT_TIMEOUT
+        pid     = Process.spawn(server_process_env, env.server_command, out: File::NULL)
+        timeout = Time.now + Spring.boot_timeout
 
         @server_booted = true
 
@@ -85,7 +84,7 @@ module Spring
             exit status.exitstatus
           elsif Time.now > timeout
             $stderr.puts "Starting Spring server with `#{env.server_command}` " \
-                         "timed out after #{BOOT_TIMEOUT} seconds"
+                         "timed out after #{Spring.boot_timeout} seconds"
             exit 1
           end
 
@@ -107,6 +106,14 @@ module Spring
         }
       end
 
+      def reset_env
+        ENV.slice(*Spring.reset_on_env)
+      end
+
+      def server_process_env
+        reset_env.merge(gem_env)
+      end
+
       def stop_server
         server.close
         @server = nil
@@ -114,7 +121,30 @@ module Spring
       end
 
       def verify_server_version
-        server_version = server.gets.chomp
+        begin
+          line = read_server_line
+        rescue ServerReadTimeout
+          if waiting_for_server_boot?
+            begin
+              # Try again, but with same timeout as booting, as server might still be booting
+              #   from another client starting it.
+              line = read_server_line(Spring.boot_timeout)
+            rescue ServerReadTimeout
+              reboot_or_raise_connection_error
+              return
+            end
+          else
+            reboot_or_raise_connection_error
+            return
+          end
+        end
+
+        if line.nil?
+          reboot_or_raise_connection_error
+          return
+        end
+
+        server_version = line.chomp
         if server_version != env.version
           $stderr.puts "There is a version mismatch between the Spring client " \
                          "(#{env.version}) and the server (#{server_version})."
@@ -130,11 +160,30 @@ module Spring
         end
       end
 
+      def read_server_line(timeout = Spring.connect_timeout)
+        raise ServerReadTimeout if IO.select([server], [], [], timeout).nil?
+
+        server.gets
+      end
+
+      def waiting_for_server_boot?
+        !server_booted? && env.server_running?
+      end
+
+      def reboot_or_raise_connection_error
+        if server_booted?
+          raise "Error connecting to Spring server"
+        else
+          stop_server
+          cold_run
+        end
+      end
+
       def connect_to_application(client)
         server.send_io client
-        send_json server, "args" => args, "default_rails_env" => default_rails_env
+        send_json server, "args" => args, "default_rails_env" => default_rails_env, "spawn_env" => spawn_env, "reset_env" => reset_env
 
-        if IO.select([server], [], [], CONNECT_TIMEOUT)
+        if IO.select([server], [], [], Spring.connect_timeout)
           server.gets or raise CommandNotFound
         else
           raise "Error connecting to Spring server"
@@ -169,11 +218,16 @@ module Spring
           suspend_resume_on_tstp_cont(pid)
 
           forward_signals(application)
-          status = application.read.to_i
+          status = application.read
+          log "got exit status #{status.inspect}"
 
-          log "got exit status #{status}"
+          # Status should always be an integer. If it is empty, something unexpected must have happened to the server.
+          if status.to_s.strip.empty?
+            log "unexpected empty exit status, app crashed?"
+            exit 1
+          end
 
-          exit status
+          exit status.to_i
         else
           log "got no pid"
           exit 1
@@ -232,6 +286,12 @@ module Spring
       def default_rails_env
         ENV['RAILS_ENV'] || ENV['RACK_ENV'] || 'development'
       end
+
+      def spawn_env
+        Spring.spawn_on_env.to_h do |key|
+          [key, ENV[key]]
+        end
+      end
     end
   end
 end

data/lib/spring/commands.rb

@@ -28,9 +28,16 @@ module Spring
   config = File.expand_path("~/.spring.rb")
   require config if File.exist?(config)
 
-  # If the config/spring.rb contains requires for commands from other gems,
-  # then we need to be under bundler.
-  require "bundler/setup"
+  # We force the TTY so bundler doesn't show a backtrace in case gems are missing.
+  old_env = ENV["BUNDLER_FORCE_TTY"]
+  ENV["BUNDLER_FORCE_TTY"] = "true"
+  begin
+    # If the config/spring.rb contains requires for commands from other gems,
+    # then we need to be under bundler.
+    require "bundler/setup"
+  ensure
+    ENV["BUNDLER_FORCE_TTY"] = old_env
+  end
 
   # Auto-require any Spring extensions which are in the Gemfile
   Gem::Specification.map(&:name).grep(/^spring-/).each do |command|

data/lib/spring/configuration.rb

@@ -1,8 +1,18 @@
 require "spring/errors"
 
 module Spring
+  @connect_timeout = 5
+  @boot_timeout = 20
+  @dangerously_allow_disabling_reloading = false
+
   class << self
-    attr_accessor :application_root, :quiet
+    attr_accessor :application_root, :connect_timeout, :boot_timeout
+    attr_writer :quiet
+
+    # Opt-in: skip the `:ensure_reloading_is_enabled` initializer so Spring
+    # boots with `config.enable_reloading = false`. Default `false`. See
+    # README "Running Spring with reloading disabled" for what this gives up.
+    attr_accessor :dangerously_allow_disabling_reloading
 
     def gemfile
       require "bundler"
@@ -31,6 +41,22 @@ module Spring
       after_fork_callbacks << block
     end
 
+    def after_environment_load_callbacks
+      @after_environment_load_callbacks ||= []
+    end
+
+    def after_environment_load(&block)
+      after_environment_load_callbacks << block
+    end
+
+    def spawn_on_env
+      @spawn_on_env ||= []
+    end
+
+    def reset_on_env
+      @reset_on_env ||= []
+    end
+
     def verify_environment
       application_root_path
     end
@@ -52,6 +78,10 @@ module Spring
       @project_root_path ||= find_project_root(Pathname.new(File.expand_path(Dir.pwd)))
     end
 
+    def quiet
+      @quiet || ENV.key?('SPRING_QUIET')
+    end
+
     private
 
     def find_project_root(current_dir)

data/lib/spring/env.rb

@@ -1,5 +1,4 @@
 require "pathname"
-require "digest/md5"
 
 require "spring/version"
 require "spring/configuration"
@@ -41,6 +40,7 @@ module Spring
     end
 
     def application_id
+      require "digest/md5"
       ENV["SPRING_APPLICATION_ID"] || Digest::MD5.hexdigest(RUBY_VERSION + project_root.to_s)
     end
 

data/lib/spring/json.rb

@@ -1,4 +1,4 @@
-# encoding: UTF-8
+# frozen_string_literal: true
 
 # ### WHY SPRING VENDORS A JSON LIBRARY ###
 #
@@ -13,7 +13,7 @@
 module Spring
   module JSON
     def self.load(string)
-      string.force_encoding("utf-8")
+      string = string.dup.force_encoding("utf-8") unless string.encoding == Encoding::UTF_8
       OkJson.decode(string)
     end
 
@@ -364,7 +364,7 @@ private
             end
           end
           if rubydoesenc?
-            a[w] = '' << uchar
+            a[w] = +'' << uchar
             w += 1
           else
             w += ucharenc(a, w, uchar)

data/lib/spring/server.rb

@@ -19,7 +19,9 @@ module Spring
     def initialize(options = {})
       @foreground   = options.fetch(:foreground, false)
       @env          = options[:env] || default_env
-      @applications = Hash.new { |h, k| h[k] = ApplicationManager.new(k, env) }
+      @applications = Hash.new do |hash, key|
+        hash[key] = ApplicationManager.new(*key, env)
+      end
       @pidfile      = env.pidfile_path.open('a')
       @mutex        = Mutex.new
     end
@@ -57,24 +59,29 @@ module Spring
       app_client = client.recv_io
       command    = JSON.load(client.read(client.gets.to_i))
 
-      args, default_rails_env = command.values_at('args', 'default_rails_env')
+      args, default_rails_env, spawn_env, reset_env = command.values_at('args', 'default_rails_env', 'spawn_env', 'reset_env')
 
       if Spring.command?(args.first)
+        application = @applications[rails_env_for(args, default_rails_env, spawn_env)]
+        reset_if_env_changed(application, reset_env)
+
         log "running command #{args.first}"
         client.puts
-        client.puts @applications[rails_env_for(args, default_rails_env)].run(app_client)
+        client.puts application.run(app_client)
       else
         log "command not found #{args.first}"
         client.close
       end
     rescue SocketError => e
       raise e unless client.eof?
+    rescue Errno::EPIPE => e
+      log "client disconnected with error #{e.message}, ignoring command"
     ensure
       redirect_output
     end
 
-    def rails_env_for(args, default_rails_env)
-      Spring.command(args.first).env(args.drop(1)) || default_rails_env
+    def rails_env_for(args, default_rails_env, spawn_env)
+      [Spring.command(args.first).env(args.drop(1)) || default_rails_env, spawn_env]
     end
 
     # Boot the server into the process group of the current session.
@@ -136,6 +143,10 @@ module Spring
 
     private
 
+    def reset_if_env_changed(application, reset_env)
+      application.stop if ENV.slice(*reset_env.keys) != reset_env
+    end
+
     def default_env
       Env.new(log_file: default_log_file)
     end

data/lib/spring/version.rb

@@ -1,3 +1,3 @@
 module Spring
-  VERSION = "4.0.0"
+  VERSION = "4.7.0"
 end

data/lib/spring/watcher/abstract.rb

@@ -1,6 +1,4 @@
-require "set"
 require "pathname"
-require "mutex_m"
 
 module Spring
   module Watcher
@@ -10,13 +8,10 @@ module Spring
     #   IO.select([watcher]) # watcher is running in background
     #   watcher.stale? # => true
     class Abstract
-      include Mutex_m
-
       attr_reader :files, :directories, :root, :latency
 
       def initialize(root, latency)
-        super()
-
+        @mutex       = Mutex.new
         @root        = File.realpath(root)
         @latency     = latency
         @files       = {}
@@ -27,6 +22,11 @@ module Spring
         @on_debug    = nil
       end
 
+      def synchronize(&block)
+        # Used by some gems.
+        @mutex.synchronize(&block)
+      end
+
       def on_debug(&block)
         @on_debug = block
       end
@@ -60,7 +60,7 @@ module Spring
           end
         end
 
-        synchronize {
+        @mutex.synchronize do
           items.each do |item|
             if item.directory?
               directories[item.realpath.to_s] = true
@@ -76,7 +76,7 @@ module Spring
           end
 
           subjects_changed
-        }
+        end
       end
 
       def stale?

data/lib/spring/watcher/polling.rb

@@ -12,7 +12,7 @@ module Spring
       end
 
       def check_stale
-        synchronize do
+        @mutex.synchronize do
           computed = compute_mtime
           if mtime < computed
             debug { "check_stale: mtime=#{mtime.inspect} < computed=#{computed.inspect}" }

metadata

@@ -1,57 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: spring
 version: !ruby/object:Gem::Version
-  version: 4.0.0
+  version: 4.7.0
 platform: ruby
 authors:
 - Jon Leighton
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-12-10 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: bump
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: activesupport
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
 description: Preloads your application so things like console, rake and tests run
   faster
 email:
@@ -99,7 +56,7 @@ licenses:
 - MIT
 metadata:
   rubygems_mfa_required: 'true'
-post_install_message: 
+  changelog_uri: https://github.com/rails/spring/blob/main/CHANGELOG.md
 rdoc_options: []
 require_paths:
 - lib
@@ -107,15 +64,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.7.0
+      version: 3.1.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.32
-signing_key: 
+rubygems_version: 3.6.7
 specification_version: 4
 summary: Rails application preloader
 test_files: []