spring 1.6.2 → 1.7.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bde56190c414de761d3907f24e40ba5d8db5357d
-  data.tar.gz: ecf9a9762eda7467df6c49a93904576e451583ef
+  metadata.gz: 85d4ab3b84aa6f12fb90e262bcd8adf394cb94ef
+  data.tar.gz: 69c83b9fe81004f4c25b9a429bd1222316e1d25e
 SHA512:
-  metadata.gz: e55818211b5e112aaf57d29dc8b63e20d92a30ca0b9464641065ba047c69345d35ed17e498b9e12d344a3293f5d4442cbe268821995668a99cbd076e60e3fb45
-  data.tar.gz: 65c0b87b5e5cfe75cb6a1abb1edf6b05424bedd48d4ffeb3c452943184b329cdd38ea5e29230b0a552c4927daa8366ef4f2a9be563812051abe71421411c40a6
+  metadata.gz: 491bc17d5c922c974ebe995469c5ebaa099c95351067eab312dad022426feecc006e6dd2211955e390eabb2371392a99e8cdfa39f07dc5b6938f5de73a30d1a7
+  data.tar.gz: 61f6d055f6b22aa94858dbd82227c0c4edbbdd6631a933a8bd5b2ebb0499c3d9c8cff27f1d41c6dca115a084cb0ddbffedef133345385069c87df69673e44ed5

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
@@ -290,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
@@ -365,13 +372,42 @@ a command runs:
 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/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
@@ -149,11 +149,17 @@ 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")
 
@@ -300,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}"
@@ -313,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

@@ -38,7 +38,7 @@ unless defined?(Spring)
   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.paths = { 'GEM_PATH' => [Bundler.bundle_path.to_s, *Gem.path].uniq.join(Gem.path_separator) }
     gem 'spring', match[1]
     require 'spring/binstub'
   end

data/lib/spring/client/run.rb

@@ -6,31 +6,36 @@ module Spring
   module Client
     class Run < Command
       FORWARDED_SIGNALS = %w(INT QUIT USR1 USR2 INFO WINCH) & Signal.list.keys
-      TIMEOUT = 1
+      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,6 +9,7 @@ require "spring/client/stop"
 require "spring/client/status"
 require "spring/client/rails"
 require "spring/client/version"
+require "spring/client/server"
 
 module Spring
   module Client
@@ -22,6 +23,7 @@ module Spring
       "rails"     => Client::Rails,
       "-v"        => Client::Version,
       "--version" => Client::Version,
+      "server"    => Client::Server,
     }
 
     def self.run(args)

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-#{Process.uid}"))
+      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

data/lib/spring/failsafe_thread.rb

@@ -0,0 +1,14 @@
+require 'thread'
+
+module Spring
+  class << self
+    def failsafe_thread
+      Thread.new {
+        begin
+          yield
+        rescue
+        end
+      }
+    end
+  end
+end

data/lib/spring/process_title_updater.rb

@@ -10,7 +10,7 @@ module Spring
     def self.run(&block)
       updater = new(&block)
 
-      Thread.new {
+      Spring.failsafe_thread {
         $0 = updater.value
         loop { $0 = updater.next }
       }

data/lib/spring/server.rb

@@ -10,19 +10,24 @@ require "spring/commands"
 
 module Spring
   class Server
-    def self.boot
-      new.boot
+    def self.boot(options = {})
+      new(options).boot
     end
 
     attr_reader :env
 
-    def initialize(env = Env.new)
-      @env          = env
-      @applications = Hash.new { |h, k| h[k] = ApplicationManager.new(k) }
+    def initialize(options = {})
+      @foreground   = options.fetch(:foreground, false)
+      @env          = options[:env] || default_env
+      @applications = Hash.new { |h, k| h[k] = ApplicationManager.new(k, env) }
       @pidfile      = env.pidfile_path.open('a')
       @mutex        = Mutex.new
     end
 
+    def foreground?
+      @foreground
+    end
+
     def log(message)
       env.log "[server] #{message}"
     end
@@ -31,8 +36,8 @@ module Spring
       Spring.verify_environment
 
       write_pidfile
-      set_pgid
-      ignore_signals
+      set_pgid unless foreground?
+      ignore_signals unless foreground?
       set_exit_hook
       set_process_title
       start_server
@@ -42,6 +47,7 @@ module Spring
       server = UNIXServer.open(env.socket_name)
       log "started on #{env.socket_name}"
       loop { serve server.accept }
+    rescue Interrupt
     end
 
     def serve(client)
@@ -100,7 +106,7 @@ module Spring
         end
       end
 
-      @applications.values.map { |a| Thread.new { a.stop } }.map(&:join)
+      @applications.values.map { |a| Spring.failsafe_thread { a.stop } }.map(&:join)
     end
 
     def write_pidfile
@@ -126,5 +132,19 @@ module Spring
         "spring server | #{env.app_name} | started #{distance} ago"
       }
     end
+
+    private
+
+    def default_env
+      Env.new(log_file: default_log_file)
+    end
+
+    def default_log_file
+      if foreground? && !ENV["SPRING_LOG"]
+        $stdout
+      else
+        nil
+      end
+    end
   end
 end

data/lib/spring/test/acceptance_test.rb

@@ -28,6 +28,10 @@ module Spring
         @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),
@@ -92,14 +96,14 @@ module Spring
 
       test "help message when called without arguments" do
         assert_success "bin/spring", stdout: 'Usage: spring COMMAND [ARGS]'
-        assert app.spring_env.server_running?
+        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 app.spring_env.server_running?
+        refute spring_env.server_running?
       end
 
       test "tells the user that spring is being used when used automatically via binstubs" do
@@ -184,10 +188,10 @@ module Spring
 
       test "stop command kills server" do
         app.run app.spring_test_command
-        assert app.spring_env.server_running?, "The server should be running but it isn't"
+        assert spring_env.server_running?, "The server should be running but it isn't"
 
         assert_success "bin/spring stop"
-        assert !app.spring_env.server_running?, "The server should not be running but it is"
+        assert !spring_env.server_running?, "The server should not be running but it is"
       end
 
       test "custom commands" do
@@ -400,7 +404,7 @@ module Spring
       end
 
       test "can define client tasks" do
-        File.write("#{app.spring_config.sub('.rb', '_client.rb')}", <<-RUBY)
+        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"
@@ -461,11 +465,11 @@ module Spring
       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 'devise'\\n")
+          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 "devise"; puts "done";'`
+          output = `\#{Rails.root.join('bin/rails')} runner 'require "text"; puts "done";'`
           exit output.include? "done\n"
         RUBY
 
@@ -495,6 +499,41 @@ module Spring
         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
     end
   end
 end

data/lib/spring/test/application.rb

@@ -9,7 +9,8 @@ module Spring
 
       def initialize(root)
         @root       = Pathname.new(root)
-        @spring_env = Spring::Env.new(root)
+        @spring_env = Spring::Env.new(root: root)
+        @times      = nil
       end
 
       def exists?
@@ -88,6 +89,10 @@ module Spring
         path "config/spring.rb"
       end
 
+      def spring_client_config
+        path "config/spring_client.rb"
+      end
+
       def run(command, opts = {})
         start_time = Time.now
 
@@ -116,8 +121,8 @@ module Spring
         @times << (Time.now - start_time) if @times
 
         output.merge(status: status, command: command)
-      rescue Timeout::Error => e
-        raise e, "Output:\n\n#{dump_streams(command, read_streams)}"
+      rescue Timeout::Error
+        raise Timeout::Error, "While running command:\n\n#{dump_streams(command, read_streams)}"
       end
 
       def with_timing

data/lib/spring/test/application_generator.rb

@@ -8,6 +8,7 @@ module Spring
         @version            = RailsVersion.new(version_constraint.split(' ').last)
         @application        = Application.new(root)
         @bundled            = false
+        @installed          = false
       end
 
       def test_root
@@ -58,6 +59,10 @@ module Spring
           append_to_file(application.gemfile, "gem 'spring-commands-testunit'")
         end
 
+        if RUBY_VERSION == "1.9.3"
+          append_to_file(application.gemfile, "gem 'mime-types', '~> 2'")
+        end
+
         rewrite_file(application.gemfile) do |c|
           c.sub!("https://rubygems.org", "http://rubygems.org")
           c.gsub!(/(gem '(byebug|web-console|sdoc|jbuilder)')/, "# \\1")

data/lib/spring/version.rb

@@ -1,3 +1,3 @@
 module Spring
-  VERSION = "1.6.2"
+  VERSION = "1.7.2"
 end

data/lib/spring/watcher/polling.rb

@@ -1,5 +1,3 @@
-require "spring/watcher"
-
 module Spring
   module Watcher
     class Polling < Abstract

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: spring
 version: !ruby/object:Gem::Version
-  version: 1.6.2
+  version: 1.7.2
 platform: ruby
 authors:
 - Jon Leighton
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-08 00:00:00.000000000 Z
+date: 2016-07-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -75,6 +75,7 @@ files:
 - lib/spring/client/help.rb
 - lib/spring/client/rails.rb
 - lib/spring/client/run.rb
+- lib/spring/client/server.rb
 - lib/spring/client/status.rb
 - lib/spring/client/stop.rb
 - lib/spring/client/version.rb
@@ -85,6 +86,7 @@ files:
 - lib/spring/configuration.rb
 - lib/spring/env.rb
 - lib/spring/errors.rb
+- lib/spring/failsafe_thread.rb
 - lib/spring/json.rb
 - lib/spring/process_title_updater.rb
 - lib/spring/server.rb
@@ -119,7 +121,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.8
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Rails application preloader