spring 1.2.0 → 4.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 0bae3c5f77134086e25e77df5d700895438e16ba
-  data.tar.gz: 882c5139fed3fe573bb75136e683ca8ee3744069
+SHA256:
+  metadata.gz: a37d78748e084596d151cde2918d30799c8dfe9e10e029920ece9e9eee8118ad
+  data.tar.gz: c47e0897d3938b7350245854672812436505379cc498638c3eca9e2d52537fe6
 SHA512:
-  metadata.gz: c5d7a1655a09f56c5663024af741c3c58fe9542418603a59dddb0c19ee24203a1527911a4626f6a5eedd5daf5b6e19b1107582fdc2c7528563af1878034cf1a7
-  data.tar.gz: d143cad1d9b6f15440d80aa300b566a4fa19c0c90deada7fa627e3b230f9199ed56eae911c0005fa2ff83814bf3e66190777a42e0bb4cf5ee6d997df9d06b297
+  metadata.gz: cda176e1dd4d22cabb680cb85c4fd562c256f8fb3dc04f9064fc61f910cfb384f044f63bee74a424501505b62f80e0746f6c05bddf327c6be0150f12cc678a3f
+  data.tar.gz: e8b1675241b3fc42c52eabb9e2f501d4abae16c35ae3e3d19080de332f3d28b258b7245c127264326871f09c35c333a3b71fcfb8fbbfecdc87648a72e1328c14

data/LICENSE.txt

@@ -1,4 +1,5 @@
-Copyright (c) 2012 Jon Leighton
+Copyright (c) 2017-2021 Rafael Mendonça França
+Copyright (c) 2012-2017 Jon Leighton
 
 MIT License
 
@@ -19,4 +20,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

@@ -1,10 +1,10 @@
 # Spring
 
-[![Build Status](https://travis-ci.org/rails/spring.png?branch=master)](https://travis-ci.org/rails/spring)
-[![Gem Version](https://badge.fury.io/rb/spring.png)](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,8 +16,9 @@ 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
-* Rails versions: 3.2, 4.0 (in Rails 4.1 and up Spring is included by default)
+* 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).
@@ -26,14 +27,14 @@ provide a speed up on platforms which don't support forking (Windows, JRuby).
 
 ### Setup
 
-Add spring to your Gemfile:
+Add Spring to your Gemfile:
 
 ``` ruby
 gem "spring", group: :development
 ```
 
 (Note: using `gem "spring", git: "..."` *won't* work and is not a
-supported way of using spring.)
+supported way of using Spring.)
 
 It's recommended to 'springify' the executables in your `bin/`
 directory:
@@ -48,31 +49,71 @@ code into relevant existing executables. The snippet looks like this:
 
 ``` ruby
 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
 ```
 
-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
+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
 normal.
 
 If you don't want to prefix every command you type with `bin/`, you
-can [use direnv](https://github.com/zimbatm/direnv#the-stdlib) to
+can [use direnv](https://github.com/direnv/direnv#the-stdlib) to
 automatically add `./bin` to your `PATH` when you `cd` into your application.
 Simply create an `.envrc` file with the command `PATH_add bin` in your
 Rails directory.
 
+### Enable reloading
+
+Spring reloads application code, and therefore needs the application to have
+reloading enabled.
+
+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 `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
-`rails generate scaffold posts name:string`.
+`rails generate scaffold post name:string`.
 
 Let's run a test:
 
 ```
-$ time bin/rake test test/functional/posts_controller_test.rb
+$ time bin/rake test test/controllers/posts_controller_test.rb
+Running via Spring preloader in process 2734
 Run options:
 
 # Running tests:
@@ -88,7 +129,7 @@ user    0m0.281s
 sys     0m0.066s
 ```
 
-That wasn't particularly fast because it was the first run, so spring
+That wasn't particularly fast because it was the first run, so Spring
 had to boot the application. It's now running:
 
 ```
@@ -102,7 +143,8 @@ Spring is running:
 The next run is faster:
 
 ```
-$ time bin/rake test test/functional/posts_controller_test.rb
+$ time bin/rake test test/controllers/posts_controller_test.rb
+Running via Spring preloader in process 8352
 Run options:
 
 # Running tests:
@@ -147,6 +189,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
@@ -163,8 +206,8 @@ Spring is running:
 26707 spring app    | spring-demo-app | started 2 secs ago | development mode
 ```
 
-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
+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
 down, use the `stop` command:
 
 ```
@@ -172,9 +215,11 @@ $ bin/spring stop
 Spring stopped.
 ```
 
+From within your code, you can check whether Spring is active with `if defined?(Spring)`.
+
 ### Removal
 
-To remove spring:
+To remove Spring:
 
 * 'Unspring' your bin/ executables: `bin/spring binstub --remove --all`
 * Remove spring from your Gemfile
@@ -182,12 +227,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
@@ -212,14 +258,13 @@ Spring::Commands::Rake.environment_matchers[:default] = "development"
 ### `rails console`, `rails generate`, `rails runner`
 
 These execute the rails command you already know and love. If you run
-a different sub command (e.g. `rails server`) then spring will automatically
+a different sub command (e.g. `rails server`) then Spring will automatically
 pass it through to the underlying `rails` executable (without the
 speed-up).
 
 ### Additional commands
 
-You can add these to your Gemfile for additional commands (run `spring stop` afterwards
-to pick up the changes):
+You can add these to your Gemfile for additional commands:
 
 * [spring-commands-rspec](https://github.com/jonleighton/spring-commands-rspec)
 * [spring-commands-cucumber](https://github.com/jonleighton/spring-commands-cucumber)
@@ -227,16 +272,22 @@ to pick up the changes):
 * [spring-commands-testunit](https://github.com/jonleighton/spring-commands-testunit) - useful for
   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-parallel-tests](https://github.com/DocSpring/spring-commands-parallel-tests) - Adds the `parallel_*` commands from [`parallel_tests`](https://github.com/grosser/parallel_tests).
 * [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)
+* [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
 
-If you don't want spring-related code checked into your source
-repository, it's possible to use spring without adding to your Gemfile.
-However, using spring binstubs without adding spring to the Gemfile is not
+If you don't want Spring-related code checked into your source
+repository, it's possible to use Spring without adding to your Gemfile.
+However, using Spring binstubs without adding Spring to the Gemfile is not
 supported.
 
-To use spring like this, do a `gem install spring` and then prefix
+To use Spring like this, do a `gem install spring` and then prefix
 commands with `spring`. For example, rather than running `bin/rake -T`,
 you'd run `spring rake -T`.
 
@@ -247,12 +298,10 @@ run through Spring, set the `DISABLE_SPRING` environment variable.
 
 ## Class reloading
 
-Spring uses Rails' class reloading mechanism
-(`ActiveSupport::Dependencies`) to keep your code up to date between
-test runs. This is the same mechanism which allows you to see changes
-during development when you refresh the page. However, you may never
-have used this mechanism with your `test` environment before, and this
-can cause problems.
+Spring uses Rails' class reloading mechanism to keep your code up to date
+between test runs. This is the same mechanism which allows you to see changes
+during development when you refresh the page. However, you may never have used
+this mechanism with your `test` environment before, and this can cause problems.
 
 It's important to realise that code reloading means that the constants
 in your application are *different objects* after files have changed:
@@ -286,6 +335,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
@@ -295,12 +351,16 @@ 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
 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'
@@ -342,20 +402,66 @@ 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
 [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
+```
+
+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
+  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_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`.
+
 ## 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:
+If you want to get more information about what Spring is doing, you can
+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,14 +5,21 @@ 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 }
 
-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