spring 3.0.0 → 4.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b33b73bbbedd5ed08ff1c6de6d040faaf347cfae0b6cc41c5378a834f0cefc87
-  data.tar.gz: 6e9c1f79634653bbf9875e6786a5e5d1df38d13d2f0b47fff129ff7a804a663c
+  metadata.gz: 1aaab82742a464eba8cafc32761c1f8509c661d3eae8816c7ce37402b1e454ba
+  data.tar.gz: dca019edd6550c1ce7d514da586df59a3c3838d1f36d113e9870cdf44052a655
 SHA512:
-  metadata.gz: 1e7c861899e73bec7b1dd623d0c486b66efdb257bc388caf10034dd11095f2feffa2695e09008d1669931f4e1c8d805c70ca7e403ea76431315f583d43664e37
-  data.tar.gz: 49587a245923eee35343818174edf141d2b687fb4b09cd9eeefe31c867848b03400cee41e98f2d5b35130d1b313c3f9b3433a557bfb5c5a20fc6fe4ae0822f7a
+  metadata.gz: 52b2c4a44be6f82f5c4877af16c52aacf98cf28641210dde453439e7e2d9ded480bc7ceb1e58465d30e8992b1bd88a8b591246bcfc66708c722fd5692c7c98a6
+  data.tar.gz: abb5569bb5d37f570003ba7784f181afd0598249cddc3c1519e2df63368b8db3a540119c8fedccb599c095a2b3c07dee5df0e0a09c09c30f551ccdf7e7f45f7b

data/LICENSE.txt

@@ -1,3 +1,4 @@
+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,9 +16,9 @@ boot it every time you run a test, rake task or migration.
 
 ## Compatibility
 
-* 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)
+* Ruby versions: MRI 2.7, MRI 3.0, MRI 3.1, MRI 3.2
+* Rails versions: 6.0, 6.1, 7.0
+* 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).
@@ -50,13 +50,14 @@ 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
+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
@@ -70,11 +71,14 @@ 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.
+
 ### Usage
 
 For this walkthrough I've generated a new Rails application, and run
@@ -178,7 +182,7 @@ Spring is running:
 ```
 
 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
+when you close your terminal. However, if you do want to do a manual shut
 down, use the `stop` command:
 
 ```
@@ -198,12 +202,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
@@ -248,6 +253,7 @@ You can add these to your Gemfile for additional commands:
 * [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
 
@@ -370,7 +376,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
@@ -386,30 +392,38 @@ 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:
 
-* `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_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.rb

@@ -1,5 +1,4 @@
 require "spring/boot"
-require "set"
 require "pty"
 
 module Spring
@@ -11,7 +10,8 @@ module Spring
       @original_env = original_env
       @spring_env   = spring_env
       @mutex        = Mutex.new
-      @waiting      = Set.new
+      @waiting      = {}
+      @clients      = {}
       @preloaded    = false
       @state        = :initialized
       @interrupt    = IO.pipe
@@ -91,8 +91,8 @@ module Spring
 
       require Spring.application_root_path.join("config", "application")
 
-      unless Rails.respond_to?(:gem_version) && Rails.gem_version >= Gem::Version.new('5.2.0')
-        raise "Spring only supports Rails >= 5.2.0"
+      unless Rails.respond_to?(:gem_version) && Rails.gem_version >= Gem::Version.new('6.0.0')
+        raise "Spring only supports Rails >= 6.0.0"
       end
 
       Rails::Application.initializer :ensure_reloading_is_enabled, group: :all do
@@ -115,7 +115,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"]
@@ -127,7 +127,12 @@ module Spring
     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
@@ -149,10 +154,23 @@ module Spring
       log "got client"
       manager.puts
 
+      @clients[client] = true
+
       _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)
@@ -165,6 +183,10 @@ module Spring
       end
 
       pid = fork {
+        # Make sure to close other clients otherwise their graceful termination
+        # will be impossible due to reference from this fork.
+        @clients.each_key { |c| c.close if c != client }
+
         Process.setsid
         IGNORE_SIGNALS.each { |sig| trap(sig, "DEFAULT") }
         trap("TERM", "DEFAULT")
@@ -227,7 +249,7 @@ module Spring
       if exiting?
         # Ensure that we do not ignore subsequent termination attempts
         log "forced exit"
-        @waiting.each { |pid| Process.kill("TERM", pid) }
+        @waiting.each_key { |pid| Process.kill("TERM", pid) }
         Kernel.exit
       else
         state! :terminating
@@ -280,13 +302,26 @@ 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) }
+        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?
+              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?
+              end
             end
           end
         end
@@ -319,7 +354,7 @@ module Spring
     end
 
     def wait(pid, streams, client)
-      @mutex.synchronize { @waiting << pid }
+      @mutex.synchronize { @waiting[pid] = true }
 
       # Wait in a separate thread so we can run multiple commands at once
       Spring.failsafe_thread {

data/lib/spring/client/binstub.rb

@@ -1,5 +1,3 @@
-require 'set'
-
 module Spring
   module Client
     class Binstub < Command
@@ -11,41 +9,36 @@ module 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.
-      LOADER = <<CODE
-begin
-  load File.expand_path('../spring', __FILE__)
-rescue LoadError => e
-  raise unless e.message.include?('spring')
-end
-CODE
+      LOADER = <<~CODE
+        load File.expand_path("spring", __dir__)
+      CODE
 
       # The defined? check ensures these lines don't execute when we load the
       # binstub from the application process. Which means that in the application
       # process we'll execute the lines which come after the LOADER block, which
       # is what we want.
-      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'
-
-  lockfile = Bundler::LockfileParser.new(Bundler.default_lockfile.read)
-  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'
-  end
-end
-CODE
+      SPRING = <<~CODE
+        #!/usr/bin/env ruby
+
+        # 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|
+            Gem.use_paths Gem.dir, Bundler.bundle_path.to_s, *Gem.path
+            gem "spring", spring.version
+            require "spring/binstub"
+          end
+        end
+      CODE
 
       OLD_BINSTUB = %{if !Process.respond_to?(:fork) || Gem::Specification.find_all_by_name("spring").empty?}
 
       BINSTUB_VARIATIONS = Regexp.union [
+        %{load File.expand_path("spring", __dir__)\n},
+        %{begin\n  load File.expand_path('../spring', __FILE__)\nrescue LoadError => e\n  raise unless e.message.include?('spring')\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
@@ -146,7 +139,7 @@ CODE
         @mode   = :add
         @items  = args.drop(1)
                       .map { |name| find_commands name }
-                      .inject(Set.new, :|)
+                      .flatten.uniq
                       .map { |command| Item.new(command) }
       end
 

data/lib/spring/client/rails.rb

@@ -1,9 +1,7 @@
-require "set"
-
 module Spring
   module Client
     class Rails < Command
-      COMMANDS = Set.new %w(console runner generate destroy test)
+      COMMANDS = %w(console runner generate destroy test)
 
       ALIASES = {
         "c" => "console",
@@ -22,6 +20,8 @@ module Spring
 
         if COMMANDS.include?(command_name)
           Run.call(["rails_#{command_name}", *args.drop(2)])
+        elsif command_name&.start_with?("db:") && !command_name.start_with?("db:system")
+          Run.call(["rake", *args.drop(1)])
         else
           require "spring/configuration"
           ARGV.shift

data/lib/spring/client/run.rb

@@ -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

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

@@ -2,16 +2,28 @@ require "spring/errors"
 
 module Spring
   class << self
-    attr_accessor :application_root, :quiet
+    attr_accessor :application_root
+    attr_writer :quiet
 
     def gemfile
+      require "bundler"
+
       if /\s1.9.[0-9]/ ===  Bundler.ruby_scope.gsub(/[\/\s]+/,'')
-        ENV["BUNDLE_GEMFILE"] || "Gemfile"
+        Pathname.new(ENV["BUNDLE_GEMFILE"] || "Gemfile").expand_path
       else
         Bundler.default_gemfile
       end
     end
 
+    def gemfile_lock
+      case gemfile.to_s
+      when /\bgems\.rb\z/
+        gemfile.sub_ext('.locked')
+      else
+        gemfile.sub_ext('.lock')
+      end
+    end
+
     def after_fork_callbacks
       @after_fork_callbacks ||= []
     end
@@ -41,6 +53,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,8 +1,6 @@
 require "pathname"
-require "digest/md5"
 
 require "spring/version"
-require "spring/sid"
 require "spring/configuration"
 
 module Spring
@@ -42,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

@@ -46,11 +46,9 @@ end
 
 # See https://github.com/kr/okjson for updates.
 
-require 'stringio'
-
 # Some parts adapted from
-# http://golang.org/src/pkg/json/decode.go and
-# http://golang.org/src/pkg/utf8/utf8.go
+# https://golang.org/src/pkg/json/decode.go and
+# https://golang.org/src/pkg/utf8/utf8.go
 module Spring
 module OkJson
   Upstream = '43'
@@ -468,19 +466,18 @@ private
 
 
   def strenc(s)
-    t = StringIO.new
-    t.putc(?")
+    t = '"'.b
     r = 0
 
     while r < s.length
       case s[r]
-      when ?"  then t.print('\\"')
-      when ?\\ then t.print('\\\\')
-      when ?\b then t.print('\\b')
-      when ?\f then t.print('\\f')
-      when ?\n then t.print('\\n')
-      when ?\r then t.print('\\r')
-      when ?\t then t.print('\\t')
+      when ?"  then t << '\\"'
+      when ?\\ then t << '\\\\'
+      when ?\b then t << '\\b'
+      when ?\f then t << '\\f'
+      when ?\n then t << '\\n'
+      when ?\r then t << '\\r'
+      when ?\t then t << '\\t'
       else
         c = s[r]
         # In ruby >= 1.9, s[r] is a codepoint, not a byte.
@@ -490,14 +487,14 @@ private
             if c.ord < Spc.ord
               c = "\\u%04x" % [c.ord]
             end
-            t.write(c)
+            t << c
           rescue
-            t.write(Ustrerr)
+            t << Ustrerr
           end
         elsif c < Spc
-          t.write("\\u%04x" % c)
+          t << "\\u%04x" % c
         elsif Spc <= c && c <= ?~
-          t.putc(c)
+          t << c
         else
           n = ucharcopy(t, s, r) # ensure valid UTF-8 output
           r += n - 1 # r is incremented below
@@ -505,8 +502,8 @@ private
       end
       r += 1
     end
-    t.putc(?")
-    t.string
+    t << '"'
+    t
   end
 
 
@@ -531,7 +528,7 @@ private
 
     # 1-byte, 7-bit sequence?
     if c0 < Utagx
-      t.putc(c0)
+      t << c0
       return 1
     end
 
@@ -544,8 +541,8 @@ private
     # 2-byte, 11-bit sequence?
     if c0 < Utag3
       raise Utf8Error if ((c0&Umask2)<<6 | (c1&Umaskx)) <= Uchar1max
-      t.putc(c0)
-      t.putc(c1)
+      t << c0
+      t << c1
       return 2
     end
 
@@ -559,9 +556,9 @@ private
     if c0 < Utag4
       u = (c0&Umask3)<<12 | (c1&Umaskx)<<6 | (c2&Umaskx)
       raise Utf8Error if u <= Uchar2max
-      t.putc(c0)
-      t.putc(c1)
-      t.putc(c2)
+      t << c0
+      t << c1
+      t << c2
       return 3
     end
 
@@ -574,16 +571,16 @@ private
     if c0 < Utag5
       u = (c0&Umask4)<<18 | (c1&Umaskx)<<12 | (c2&Umaskx)<<6 | (c3&Umaskx)
       raise Utf8Error if u <= Uchar3max
-      t.putc(c0)
-      t.putc(c1)
-      t.putc(c2)
-      t.putc(c3)
+      t << c0
+      t << c1
+      t << c2
+      t << c3
       return 4
     end
 
     raise Utf8Error
   rescue Utf8Error
-    t.write(Ustrerr)
+    t << Ustrerr
     return 1
   end
 

data/lib/spring/server.rb

@@ -81,7 +81,8 @@ module Spring
     # This will cause it to be automatically killed once the session
     # ends (i.e. when the user closes their terminal).
     def set_pgid
-      Process.setpgid(0, SID.pgid)
+      pgid = Process.getpgid(Process.getsid)
+      Process.setpgid(0, pgid)
     end
 
     # Ignore SIGINT and SIGQUIT otherwise the user typing ^C or ^\ on the command line

data/lib/spring/version.rb

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

data/lib/spring/watcher/abstract.rb

@@ -1,6 +1,4 @@
-require "set"
 require "pathname"
-require "mutex_m"
 
 module Spring
   module Watcher
@@ -10,23 +8,25 @@ 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       = Set.new
-        @directories = Set.new
+        @files       = {}
+        @directories = {}
         @stale       = false
         @listeners   = []
 
         @on_debug    = nil
       end
 
+      def synchronize(&block)
+        # Used by some gems.
+        @mutex.synchronize(&block)
+      end
+
       def on_debug(&block)
         @on_debug = block
       end
@@ -60,13 +60,13 @@ module Spring
           end
         end
 
-        synchronize {
+        @mutex.synchronize do
           items.each do |item|
             if item.directory?
-              directories << item.realpath.to_s
+              directories[item.realpath.to_s] = true
             else
               begin
-                files << item.realpath.to_s
+                files[item.realpath.to_s] = true
               rescue Errno::ENOENT
                 # Race condition. Ignore symlinks whose target was removed
                 # since the check above, or are deeply chained.
@@ -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}" }
@@ -91,7 +91,7 @@ module Spring
       end
 
       def expanded_files
-        files + Dir["{#{directories.map { |d| "#{d}/**/*" }.join(",")}}"]
+        (files.keys + Dir["{#{directories.keys.map { |d| "#{d}/**/*" }.join(",")}}"]).uniq
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: spring
 version: !ruby/object:Gem::Version
-  version: 3.0.0
+  version: 4.1.3
 platform: ruby
 authors:
 - Jon Leighton
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-09-08 00:00:00.000000000 Z
+date: 2023-11-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -90,7 +90,6 @@ files:
 - lib/spring/json.rb
 - lib/spring/process_title_updater.rb
 - lib/spring/server.rb
-- lib/spring/sid.rb
 - lib/spring/version.rb
 - lib/spring/watcher.rb
 - lib/spring/watcher/abstract.rb
@@ -98,7 +97,8 @@ files:
 homepage: https://github.com/rails/spring
 licenses:
 - MIT
-metadata: {}
+metadata:
+  rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -107,14 +107,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.5.0
+      version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.22
+rubygems_version: 3.3.7
 signing_key:
 specification_version: 4
 summary: Rails application preloader

data/lib/spring/sid.rb

@@ -1,42 +0,0 @@
-begin
-  # If rubygems is present, keep it out of the way when loading fiddle,
-  # otherwise if fiddle is not installed then rubygems will load all
-  # gemspecs in its (futile) search for fiddle, which is slow.
-  if respond_to?(:gem_original_require, true)
-    gem_original_require 'fiddle'
-  else
-    require 'fiddle'
-  end
-rescue LoadError
-end
-
-module Spring
-  module SID
-    def self.fiddle_func
-      @fiddle_func ||= Fiddle::Function.new(
-        DL::Handle::DEFAULT['getsid'],
-        [Fiddle::TYPE_INT],
-        Fiddle::TYPE_INT
-      )
-    end
-
-    def self.sid
-      @sid ||= begin
-        if Process.respond_to?(:getsid)
-          # Ruby 2
-          Process.getsid
-        elsif defined?(Fiddle) and defined?(DL)
-          # Ruby 1.9.3 compiled with libffi support
-          fiddle_func.call(0)
-        else
-          # last resort: shell out
-          `ps -p #{Process.pid} -o sess=`.to_i
-        end
-      end
-    end
-
-    def self.pgid
-      Process.getpgid(sid)
-    end
-  end
-end