spring 1.3.6 → 1.7.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 53e40e388796f0694f931b786ba678246e64bb51
-  data.tar.gz: fce7e7274cf3155517ca3f11411fb7f90d3ce1a6
+  metadata.gz: 85d4ab3b84aa6f12fb90e262bcd8adf394cb94ef
+  data.tar.gz: 69c83b9fe81004f4c25b9a429bd1222316e1d25e
 SHA512:
-  metadata.gz: ea9be374bc7b1dec0ada6cb6aec41990fb872e96272c0536562a1c884fdc93016bd3d3b2abed67d0bcd36af739419bd2332f2add3699d3944a5a8f6f2cb9e763
-  data.tar.gz: f9f8ca0814f602e7ce30f05ee39e8c6d7313e38e1302c55d28ce30c10269974da5ca214709d4ec5c61df67053117aba92c066956c8c79bc92720363b61f0c1f4
+  metadata.gz: 491bc17d5c922c974ebe995469c5ebaa099c95351067eab312dad022426feecc006e6dd2211955e390eabb2371392a99e8cdfa39f07dc5b6938f5de73a30d1a7
+  data.tar.gz: 61f6d055f6b22aa94858dbd82227c0c4edbbdd6631a933a8bd5b2ebb0499c3d9c8cff27f1d41c6dca115a084cb0ddbffedef133345385069c87df69673e44ed5

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2012 Jon Leighton
+Copyright (c) 2012-2016 Jon Leighton
 
 MIT License
 
@@ -19,4 +19,4 @@ MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
 LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -16,7 +16,7 @@ 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
+* Ruby versions: MRI 1.9.3, MRI 2.0, MRI 2.1, MRI 2.2
 * Rails versions: 4.0+ (in Rails 4.1 and up Spring is included by default)
 
 Spring makes extensive use of `Process.fork`, so won't be able to
@@ -48,7 +48,7 @@ code into relevant existing executables. The snippet looks like this:
 
 ``` ruby
 begin
-  load File.expand_path("../spring", __FILE__)
+  load File.expand_path('../spring', __FILE__)
 rescue LoadError
 end
 ```
@@ -73,6 +73,7 @@ Let's run a test:
 
 ```
 $ time bin/rake test test/controllers/posts_controller_test.rb
+Running via Spring preloader in process 2734
 Run options:
 
 # Running tests:
@@ -103,6 +104,7 @@ The next run is faster:
 
 ```
 $ time bin/rake test test/controllers/posts_controller_test.rb
+Running via Spring preloader in process 8352
 Run options:
 
 # Running tests:
@@ -147,6 +149,7 @@ environment gets booted up:
 
 ```
 $ bin/rake routes
+Running via Spring preloader in process 2363
     posts GET    /posts(.:format)          posts#index
           POST   /posts(.:format)          posts#create
  new_post GET    /posts/new(.:format)      posts#new
@@ -227,6 +230,8 @@ You can add these to your Gemfile for additional commands:
   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-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)
 
 ## Use without adding to bundle
 
@@ -285,6 +290,13 @@ false
 So to avoid this problem, don't save off references to application
 constants in your initialization code.
 
+## Using Spring with a containerized development environment
+
+As of Spring 1.7, there is some support for doing this. See [this
+example
+repository](https://github.com/jonleighton/spring-docker-example) for
+information about how to do it with [Docker](https://www.docker.com/).
+
 ## Configuration
 
 Spring will read `~/.spring.rb` and `config/spring.rb` for custom
@@ -294,6 +306,9 @@ settings. Note that `~/.spring.rb` is loaded *before* bundler, but
 projects without having to be added to the project's Gemfile, require
 them in your `~/.spring.rb`.
 
+`config/spring_client.rb` is also loaded before bundler and before a
+server process is started, it can be used to add new top-level commands.
+
 ### Application root
 
 Spring must know how to find your Rails application. If you have a
@@ -348,13 +363,51 @@ installing the
 [spring-watcher-listen](https://github.com/jonleighton/spring-watcher-listen)
 gem.
 
+### Quiet output
+
+To disable the "Running via Spring preloader" message which is shown each time
+a command runs:
+
+``` ruby
+Spring.quiet = true
+```
+
+### Environment variables
+
+The following environment variables are used by Spring:
+
+* `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
+  `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
+  `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`.
+* `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 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
+  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
-specify a log file with the `SPRING_LOG` environment variable:
+run spring explicitly in a separate terminal:
 
 ```
-spring stop # if spring is already running
-export SPRING_LOG=/tmp/spring.log
-spring rake -T
+$ spring server
 ```
+
+Logging output will be printed to stdout. You can also send log output
+to a file with the `SPRING_LOG` environment variable.

data/bin/spring

@@ -43,6 +43,7 @@ if defined?(Gem)
   end
 end
 
-$LOAD_PATH.unshift File.expand_path("../../lib", __FILE__)
+lib = File.expand_path("../../lib", __FILE__)
+$LOAD_PATH.unshift lib unless $LOAD_PATH.include?(lib) # enable local development
 require 'spring/client'
 Spring::Client.run(ARGV)

data/lib/spring/application/boot.rb

@@ -5,7 +5,8 @@ require "spring/application"
 
 app = Spring::Application.new(
   UNIXSocket.for_fd(3),
-  Spring::JSON.load(ENV.delete("SPRING_ORIGINAL_ENV").dup)
+  Spring::JSON.load(ENV.delete("SPRING_ORIGINAL_ENV").dup),
+  Spring::Env.new(log_file: IO.for_fd(4))
 )
 
 Signal.trap("TERM") { app.terminate }

data/lib/spring/application.rb

@@ -6,10 +6,10 @@ module Spring
   class Application
     attr_reader :manager, :watcher, :spring_env, :original_env
 
-    def initialize(manager, original_env)
+    def initialize(manager, original_env, spring_env = Env.new)
       @manager      = manager
       @original_env = original_env
-      @spring_env   = Env.new
+      @spring_env   = spring_env
       @mutex        = Mutex.new
       @waiting      = Set.new
       @preloaded    = false
@@ -99,7 +99,7 @@ module Spring
       @preloaded = :success
     rescue Exception => e
       @preloaded = :failure
-      watcher.add e.backtrace.map { |line| line.match(/^(.*)\:\d+\:in /)[1] }
+      watcher.add e.backtrace.map { |line| line[/^(.*)\:\d+/, 1] }
       raise e unless initialized?
     ensure
       watcher.add loaded_application_features
@@ -149,14 +149,22 @@ module Spring
       setup command
 
       if Rails.application.reloaders.any?(&:updated?)
-        ActionDispatch::Reloader.cleanup!
-        ActionDispatch::Reloader.prepare!
+        # 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
       end
 
       pid = fork {
+        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
+
         ARGV.replace(args)
         $0 = command.exec_name
 
@@ -298,7 +306,7 @@ module Spring
       @mutex.synchronize { @waiting << pid }
 
       # Wait in a separate thread so we can run multiple commands at once
-      Thread.new {
+      Spring.failsafe_thread {
         begin
           _, status = Process.wait2 pid
           log "#{pid} exited with #{status.exitstatus}"
@@ -311,6 +319,17 @@ module Spring
           exit_if_finished
         end
       }
+
+      Spring.failsafe_thread {
+        while signal = client.gets.chomp
+          begin
+            Process.kill(signal, -Process.getpgid(pid))
+            client.puts(0)
+          rescue Errno::ESRCH
+            client.puts(1)
+          end
+        end
+      }
     end
 
     private

data/lib/spring/application_manager.rb

@@ -2,9 +2,9 @@ module Spring
   class ApplicationManager
     attr_reader :pid, :child, :app_env, :spring_env, :status
 
-    def initialize(app_env)
+    def initialize(app_env, spring_env)
       @app_env    = app_env
-      @spring_env = Env.new
+      @spring_env = spring_env
       @mutex      = Mutex.new
       @state      = :running
     end
@@ -101,9 +101,11 @@ module Spring
             "SPRING_PRELOAD"      => preload ? "1" : "0"
           },
           "ruby",
+          "-I", File.expand_path("../..", $LOADED_FEATURES.grep(/bundler\/setup\.rb$/).first),
           "-I", File.expand_path("../..", __FILE__),
           "-e", "require 'spring/application/boot'",
-          3 => child_socket
+          3 => child_socket,
+          4 => spring_env.log_file,
         )
       end
 
@@ -114,7 +116,7 @@ module Spring
     def start_wait_thread(pid, child)
       Process.detach(pid)
 
-      Thread.new {
+      Spring.failsafe_thread {
         # The recv can raise an ECONNRESET, killing the thread, but that's ok
         # as if it does we're no longer interested in the child
         loop do

data/lib/spring/boot.rb

@@ -6,3 +6,5 @@ require "spring/env"
 require "spring/process_title_updater"
 require "spring/json"
 require "spring/watcher"
+require "spring/failsafe_thread"
+

data/lib/spring/client/binstub.rb

@@ -13,8 +13,9 @@ module Spring
       # should cause the "unsprung" version of the command to run.
       LOADER = <<CODE
 begin
-  load File.expand_path("../spring", __FILE__)
-rescue LoadError
+  load File.expand_path('../spring', __FILE__)
+rescue LoadError => e
+  raise unless e.message.include?('spring')
 end
 CODE
 
@@ -33,19 +34,26 @@ CODE
 # It gets overwritten when you run the `spring binstub` command.
 
 unless defined?(Spring)
-  require "rubygems"
-  require "bundler"
+  require 'rubygems'
+  require 'bundler'
 
-  if match = Bundler.default_lockfile.read.match(/^GEM$.*?^    (?:  )*spring \((.*?)\)$.*?^$/m)
-    Gem.paths = { "GEM_PATH" => [Bundler.bundle_path.to_s, *Gem.path].uniq }
-    gem "spring", match[1]
-    require "spring/binstub"
+  if (match = Bundler.default_lockfile.read.match(/^GEM$.*?^    (?:  )*spring \((.*?)\)$.*?^$/m))
+    Gem.paths = { 'GEM_PATH' => [Bundler.bundle_path.to_s, *Gem.path].uniq.join(Gem.path_separator) }
+    gem 'spring', match[1]
+    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 [
+        %{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
+      ]
+
       class Item
         attr_reader :command, :existing
 
@@ -72,8 +80,12 @@ CODE
               fallback = nil if fallback.include?("exec")
               generate(fallback)
               status "upgraded"
-            elsif existing =~ /load .*spring/
+            elsif existing.include?(LOADER)
               status "spring already present"
+            elsif existing =~ BINSTUB_VARIATIONS
+              upgraded = existing.sub(BINSTUB_VARIATIONS, LOADER)
+              File.write(command.binstub, upgraded)
+              status "upgraded"
             else
               head, shebang, tail = existing.partition(SHEBANG)
 
@@ -108,7 +120,7 @@ CODE
 
         def remove
           if existing
-            File.write(command.binstub, existing.sub(LOADER, ""))
+            File.write(command.binstub, existing.sub(BINSTUB_VARIATIONS, ""))
             status "spring removed"
           end
         end
@@ -117,7 +129,7 @@ CODE
       attr_reader :bindir, :items
 
       def self.description
-        "Generate spring based binstubs. Use --all to generate a binstub for all known commands."
+        "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/run.rb

@@ -5,32 +5,37 @@ require "bundler"
 module Spring
   module Client
     class Run < Command
-      FORWARDED_SIGNALS = %w(INT QUIT USR1 USR2 INFO) & Signal.list.keys
-      TIMEOUT = 1
+      FORWARDED_SIGNALS = %w(INT QUIT USR1 USR2 INFO WINCH) & Signal.list.keys
+      CONNECT_TIMEOUT   = 1
+      BOOT_TIMEOUT      = 20
+
+      attr_reader :server
 
       def initialize(args)
         super
-        @signal_queue = []
+
+        @signal_queue  = []
+        @server_booted = false
       end
 
       def log(message)
         env.log "[client] #{message}"
       end
 
-      def server
-        @server ||= UNIXSocket.open(env.socket_name)
+      def connect
+        @server = UNIXSocket.open(env.socket_name)
       end
 
       def call
-        if env.server_running?
-          warm_run
-        else
+        begin
+          connect
+        rescue Errno::ENOENT, Errno::ECONNRESET, Errno::ECONNREFUSED
           cold_run
+        else
+          warm_run
         end
-      rescue Errno::ECONNRESET
-        exit 1
       ensure
-        server.close if @server
+        server.close if server
       end
 
       def warm_run
@@ -49,6 +54,7 @@ module Spring
 
       def cold_run
         boot_server
+        connect
         run
       end
 
@@ -60,24 +66,37 @@ module Spring
         queue_signals
         connect_to_application(client)
         run_command(client, application)
+      rescue Errno::ECONNRESET
+        exit 1
       end
 
       def boot_server
         env.socket_path.unlink if env.socket_path.exist?
 
-        pid = Process.spawn(
-          gem_env,
-          "ruby",
-          "-e", "gem 'spring', '#{Spring::VERSION}'; require 'spring/server'; Spring::Server.boot"
-        )
+        pid     = Process.spawn(gem_env, env.server_command, out: File::NULL)
+        timeout = Time.now + BOOT_TIMEOUT
+
+        @server_booted = true
 
         until env.socket_path.exist?
           _, status = Process.waitpid2(pid, Process::WNOHANG)
-          exit status.exitstatus if status
+
+          if status
+            exit status.exitstatus
+          elsif Time.now > timeout
+            $stderr.puts "Starting Spring server with `#{env.server_command}` " \
+                         "timed out after #{BOOT_TIMEOUT} seconds"
+            exit 1
+          end
+
           sleep 0.1
         end
       end
 
+      def server_booted?
+        @server_booted
+      end
+
       def gem_env
         bundle = Bundler.bundle_path.to_s
         paths  = Gem.path + ENV["GEM_PATH"].to_s.split(File::PATH_SEPARATOR)
@@ -97,13 +116,17 @@ module Spring
       def verify_server_version
         server_version = server.gets.chomp
         if server_version != env.version
-          $stderr.puts <<-ERROR
-There is a version mismatch between the spring client and the server.
-You should restart the server and make sure to use the same version.
-
-CLIENT: #{env.version}, SERVER: #{server_version}
-ERROR
-          exit 1
+          $stderr.puts "There is a version mismatch between the spring client " \
+                         "(#{env.version}) and the server (#{server_version})."
+
+          if server_booted?
+            $stderr.puts "We already tried to reboot the server, but the mismatch is still present."
+            exit 1
+          else
+            $stderr.puts "Restarting to resolve."
+            stop_server
+            cold_run
+          end
         end
       end
 
@@ -111,7 +134,7 @@ ERROR
         server.send_io client
         send_json server, "args" => args, "default_rails_env" => default_rails_env
 
-        if IO.select([server], [], [], TIMEOUT)
+        if IO.select([server], [], [], CONNECT_TIMEOUT)
           server.gets or raise CommandNotFound
         else
           raise "Error connecting to Spring server"
@@ -138,7 +161,7 @@ ERROR
         if pid && !pid.empty?
           log "got pid: #{pid}"
 
-          forward_signals(pid.to_i)
+          forward_signals(application)
           status = application.read.to_i
 
           log "got exit status #{status}"
@@ -158,26 +181,26 @@ ERROR
         end
       end
 
-      def forward_signals(pid)
-        @signal_queue.each { |sig| kill sig, pid }
+      def forward_signals(application)
+        @signal_queue.each { |sig| kill sig, application }
 
         FORWARDED_SIGNALS.each do |sig|
-          trap(sig) { forward_signal sig, pid }
+          trap(sig) { forward_signal sig, application }
         end
-      rescue Errno::ESRCH
       end
 
-      def forward_signal(sig, pid)
-        kill(sig, pid)
-      rescue Errno::ESRCH
-        # If the application process is gone, then don't block the
-        # signal on this process.
-        trap(sig, 'DEFAULT')
-        Process.kill(sig, Process.pid)
+      def forward_signal(sig, application)
+        if kill(sig, application) != 0
+          # If the application process is gone, then don't block the
+          # signal on this process.
+          trap(sig, 'DEFAULT')
+          Process.kill(sig, Process.pid)
+        end
       end
 
-      def kill(sig, pid)
-        Process.kill(sig, -Process.getpgid(pid))
+      def kill(sig, application)
+        application.puts(sig)
+        application.gets.to_i
       end
 
       def send_json(socket, data)

data/lib/spring/client/server.rb

@@ -0,0 +1,18 @@
+module Spring
+  module Client
+    class Server < Command
+      def self.description
+        "Explicitly start a Spring server in the foreground"
+      end
+
+      def call
+        require "spring/server"
+        Spring::Server.boot(foreground: foreground?)
+      end
+
+      def foreground?
+        !args.include?("--background")
+      end
+    end
+  end
+end

data/lib/spring/client.rb

@@ -9,17 +9,21 @@ require "spring/client/stop"
 require "spring/client/status"
 require "spring/client/rails"
 require "spring/client/version"
+require "spring/client/server"
 
 module Spring
   module Client
     COMMANDS = {
       "help"      => Client::Help,
+      "-h"        => Client::Help,
+      "--help"    => Client::Help,
       "binstub"   => Client::Binstub,
       "stop"      => Client::Stop,
       "status"    => Client::Status,
       "rails"     => Client::Rails,
       "-v"        => Client::Version,
-      "--version" => Client::Version
+      "--version" => Client::Version,
+      "server"    => Client::Server,
     }
 
     def self.run(args)
@@ -36,3 +40,9 @@ module Spring
     end
   end
 end
+
+# allow users to add hooks that do not run in the server
+# or modify start/stop
+if File.exist?("config/spring_client.rb")
+  require "./config/spring_client.rb"
+end

data/lib/spring/configuration.rb

@@ -2,7 +2,7 @@ require "spring/errors"
 
 module Spring
   class << self
-    attr_accessor :application_root
+    attr_accessor :application_root, :quiet
 
     def gemfile
       ENV['BUNDLE_GEMFILE'] || "Gemfile"
@@ -49,4 +49,6 @@ module Spring
       end
     end
   end
+
+  self.quiet = false
 end

data/lib/spring/env.rb

@@ -14,10 +14,10 @@ module Spring
   class Env
     attr_reader :log_file
 
-    def initialize(root = nil)
-      @root         = root
-      @project_root = root
-      @log_file     = File.open(ENV["SPRING_LOG"] || File::NULL, "a")
+    def initialize(options = {})
+      @root         = options[:root]
+      @project_root = options[:root]
+      @log_file     = options[:log_file] || File.open(ENV["SPRING_LOG"] || File::NULL, "a")
     end
 
     def root
@@ -33,17 +33,20 @@ module Spring
     end
 
     def tmp_path
-      path = Pathname.new(File.join(ENV['XDG_RUNTIME_DIR'] || Dir.tmpdir, "spring"))
+      path = Pathname.new(
+        ENV["SPRING_TMP_PATH"] ||
+          File.join(ENV['XDG_RUNTIME_DIR'] || Dir.tmpdir, "spring-#{Process.uid}")
+      )
       FileUtils.mkdir_p(path) unless path.exist?
       path
     end
 
     def application_id
-      Digest::MD5.hexdigest(RUBY_VERSION + project_root.to_s)
+      ENV["SPRING_APPLICATION_ID"] || Digest::MD5.hexdigest(RUBY_VERSION + project_root.to_s)
     end
 
     def socket_path
-      tmp_path.join(application_id)
+      Pathname.new(ENV["SPRING_SOCKET"] || tmp_path.join(application_id))
     end
 
     def socket_name
@@ -51,7 +54,7 @@ module Spring
     end
 
     def pidfile_path
-      tmp_path.join("#{application_id}.pid")
+      Pathname.new(ENV["SPRING_PIDFILE"] || socket_path.dirname.join("#{socket_path.basename(".*")}.pid"))
     end
 
     def pid
@@ -105,5 +108,9 @@ module Spring
     rescue Errno::ESRCH
       # already dead
     end
+
+    def server_command
+      ENV["SPRING_SERVER_COMMAND"] || "#{File.expand_path("../../../bin/spring", __FILE__)} server --background"
+    end
   end
 end