spring 1.0.0 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ab103d29ee132ac8637c7ddca8d5c41fc567c31e
-  data.tar.gz: 88e600c6e1d59b4150625769f20f6d543958087c
+  metadata.gz: cf0643d72425f9cc14e93423dd4f131aa42b143a
+  data.tar.gz: 224eb7729ea0b874659a2951fea96fbdc3bb4c8a
 SHA512:
-  metadata.gz: 7b4d762562b8d4c1832bcec43819b6bcc6d9168473095fac089a743c0c421d4450f77e7c0a3cf31902256ed42a3d0fa57e7767cd4a0cf9d0bd55dc24c758f460
-  data.tar.gz: 9c929b2636980dc30486f475caeacb1f3de296420c22e9f0a52c67ce732a8953e28f1b090258a18456d210ce217610e8e4df8ffeb7a1a8ebd0e2b546554235ec
+  metadata.gz: f31525f82a8f8daa814e08ab0fb0ca65047fe25652037421899e7e4da566f7bbefb8b95bd4920fe40827d275b000e5f9dce5f1ea031c64bd807ebbe1912503e8
+  data.tar.gz: 07594958b366487e7b5f88d96edb3efa1b5f1378de5b68b37ef711d149084116cfd421562061e985c7d12a90d22a72caa8f96480362ca95eba40ed6916a3fa42

data/.gitignore

@@ -16,3 +16,4 @@ spec/reports
 test/tmp
 test/version_tmp
 tmp
+.ruby-version

data/.travis.yml

@@ -2,6 +2,11 @@ language: ruby
 rvm:
   - 1.9.3
   - 2.0.0
+  - 2.1.5
+  - 2.2.0
 env:
-  - RAILS_VERSION="~> 3.2.0"
   - RAILS_VERSION="~> 4.0.0"
+  - RAILS_VERSION="~> 4.1.0"
+  - RAILS_VERSION="~> 4.2.0"
+before_script:
+  - travis_retry gem install rails --version "$RAILS_VERSION"

data/CHANGELOG.md

@@ -1,3 +1,84 @@
+## 1.3.0
+
+* Automatically restart spring after new commands are added. This means
+  that you can add spring-commands-rspec to your Gemfile and then
+  immediately start using it, without having to run `spring stop`.
+  (Spring will effectively run `spring stop` for you.)
+* Make app reloading work in apps which spew out lots of output on
+  startup (previously a buffer would fill up and cause the process to
+  hang). Issue #332.
+* Make sure running `bin/spring` does not add an empty string to `Gem.path`.
+  Issues #297, #310.
+* Fixed problem with `$0` including the command line args, which could
+  confuse commands which try to parse `$0`. This caused the
+  spring-commands-rspec to not work properly in some cases. Issue #369.
+* Add OpenBSD compatibility for `spring status`. Issue #299.
+* Rails 3.2 no longer officially supported (but it may continue to work)
+
+## 1.2.0
+
+* Accept -e and --environment options for `rails console`.
+* Watch `config/secrets.yml` by default. #289 - @morgoth
+* Change monkey-patched `Kernel.raise` from public to private (to match default Ruby behavior) #351 - @mattbrictson
+* Let application_id also respect RUBY_VERSION for the use case of switching between Ruby versions for a given Rails app - @methodmissing
+* Extract the 'listen' watcher to a separate `spring-watcher-listen`
+  gem. This allows it to be developed/maintained separately.
+
+## 1.1.3
+
+* The `rails runner` command no longer passes environment switches to
+  files which it runs. Issue #272.
+* Various issues solved to do with termination / processes hanging around
+  longer than they should. Issue #290.
+
+## 1.1.2
+
+* Detect old binstubs generated with Spring 1.0 and exit with an error.
+  This prevents a situation where you can get stuck in an infinite loop
+  of spring invocations.
+* Avoid `warning: already initialized constant APP_PATH` when running
+  rails commands that do not use spring (e.g. `bin/rails server` would
+  emit this when you ^C to exit)
+* Fix `reload!` in rails console
+* Don't connect/disconnect the database if there are no connections
+  configured. Issue #256.
+
+## 1.1.1
+
+* Fix `$0` so that it is no longer prefixed with "spring ", as doing
+  this cause issues with rspec when running just `rspec` with no
+  arguments.
+* Ensure we're always connected to a tty when preloading the
+  application in the background, in order to avoid loading issues
+  with readline + libedit which affected pry-rails.
+
+## 1.1.0
+
+* A `bin/spring` binstub is now generated. This allows us to load spring
+  correctly if you have it installed locally with a `BUNDLE_PATH`, so
+  it's no longer necessary to install spring system-wide. We also
+  activate the correct version from your Gemfile.lock. Note that you
+  still can't have spring in your Gemfile as a git repository or local
+  path; it must be a proper gem.
+* Various changes to how springified binstubs are implemented. Existing
+  binstubs will continue to work, but it's recommended to run `spring binstub`
+  again to upgrade them to the new format.
+* `spring binstub --remove` option added for removing spring from
+  binstubs. This won't work unless you have upgraded your binstubs to
+  the new format.
+* `config/database.yml` is watched
+* Better application restarts - if you introduce an error, for example
+  by editing `config/application.rb`, spring will now continue to watch
+  your files and will immediately try to restart the application when
+  you edit `config/application.rb` again (hopefully to correct the error).
+  This means that by the time you come to run a command the application
+  may well already be running.
+* Gemfile changes are now gracefully handled. Previously they would
+  cause spring to simply quit, meaning that you'd incur the full startup
+  penalty on the next run. Now spring doesn't quit, and will try to load
+  up your new bundle in the background.
+* Fix support for using spring with Rails engines/plugins
+
 ## 1.0.0
 
 * Enterprise ready secret sauce added

data/CONTRIBUTING.md

@@ -0,0 +1,52 @@
+# Don't use the issue tracker to ask questions
+
+Please use Stack Overflow or similar. If you subsequently feel that the
+documentation is inadequate then plase submit a pull request to fix it.
+
+# Contributing guide
+
+## Getting set up
+
+Check out the code and run `bundle install` as usual.
+
+## Running tests
+
+Running `rake` will run all tests. There are both unit tests and
+acceptance tests. You can run them individually with `rake test:unit` or
+`rake test:acceptance`.
+
+If one doesn't already exist, the acceptance tests will generate a dummy
+Rails app in `test/apps/`. On each test run, the dummy app is copied to
+`test/apps/tmp/` so that any changes won't affect the pre-generated app
+(this saves us having to regenerate the app on each run).
+
+If tests are failing and you don't know why, it might be that the
+pre-generated app has become inconsistent in some way. In that case the
+best solution is to purge it with `rm -rf test/apps/*` and then run the
+acceptance tests again, which will generate a new app.
+
+## Testing different Rails versions
+
+You can set the `RAILS_VERSION` environment variable:
+
+```
+$ RAILS_VERSION="~> 3.2.0" rake test:acceptance
+```
+
+The apps in `test/apps` will be named based on the rails version and the
+spring version.
+
+## Testing with your app
+
+You cannot link to a git repo from your Gemfile. Spring doesn't support
+this due to the way that it gets loaded (bypassing bundler for
+performance reasons).
+
+Therefore, to test changes with your app, run `rake install` to properly
+install the gem on your system.
+
+## Submitting a pull request
+
+If your change is a bugfix or feature, please make sure you add to
+`CHANGELOG.md` under the "Next Release" heading (add the heading if
+needed).

data/Gemfile

@@ -2,5 +2,3 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in spring.gemspec
 gemspec
-
-gem 'listen', "~> 1.0", :require => false

data/README.md

@@ -1,6 +1,7 @@
 # Spring
 
-[![Build Status](https://travis-ci.org/jonleighton/spring.png?branch=master)](https://travis-ci.org/jonleighton/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)
 
 Spring is a Rails application preloader. It speeds up development by
 keeping your application running in the background so you don't need to
@@ -15,24 +16,55 @@ boot it every time you run a test, rake task or migration.
 
 ## Compatibility
 
-* Ruby versions: MRI 1.9.3, MRI 2.0.0
-* Rails versions: 3.2, 4.0
+* 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)
 
-Spring makes extensive use of `Process#fork`, so won't be able to
+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).
 
 ## Walkthrough
 
-Either `gem install spring` or add it to your Gemfile:
+### Setup
+
+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.)
+
+It's recommended to 'springify' the executables in your `bin/`
+directory:
+
+```
+$ bundle install
+$ bundle exec spring binstub --all
+```
+
+This generates a `bin/spring` executable, and inserts a small snippet of
+code into relevant existing executables. The snippet looks like this:
 
 ``` ruby
-group :development do
-  gem "spring"
+begin
+  load File.expand_path("../spring", __FILE__)
+rescue LoadError
 end
 ```
 
-Spring is designed to be used *without* bundle exec, so use `spring
-[command]` rather than `bundle exec spring [command]`.
+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
+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.
+
+### Usage
 
 For this walkthrough I've generated a new Rails application, and run
 `rails generate scaffold posts name:string`.
@@ -40,7 +72,7 @@ For this walkthrough I've generated a new Rails application, and run
 Let's run a test:
 
 ```
-$ time spring rake test test/functional/posts_controller_test.rb
+$ time bin/rake test test/functional/posts_controller_test.rb
 Run options:
 
 # Running tests:
@@ -60,7 +92,7 @@ That wasn't particularly fast because it was the first run, so spring
 had to boot the application. It's now running:
 
 ```
-$ spring status
+$ bin/spring status
 Spring is running:
 
 26150 spring server | spring-demo-app | started 3 secs ago
@@ -70,7 +102,7 @@ Spring is running:
 The next run is faster:
 
 ```
-$ time spring rake test test/functional/posts_controller_test.rb
+$ time bin/rake test test/functional/posts_controller_test.rb
 Run options:
 
 # Running tests:
@@ -86,20 +118,6 @@ user    0m0.276s
 sys     0m0.059s
 ```
 
-Writing `spring` before every command gets a bit tedious. Spring binstubs solve this:
-
-```
-$ spring binstub rake rails
-```
-
-This will generate `bin/rake` and `bin/rails`. They
-replace any binstubs that you might already have in your `bin/`
-directory. Check them in to source control.
-
-If you don't want to prefix every command you type with `bin/`, you
-can [use direnv](https://github.com/zimbatm/direnv) to automatically add
-`./bin` to your `PATH` when you `cd` into your application.
-
 If we edit any of the application files, or test files, the changes will
 be picked up on the next run without the background process having to
 restart. This works in exactly the same way as the code reloading
@@ -114,7 +132,7 @@ Let's "edit" `config/application.rb`:
 
 ```
 $ touch config/application.rb
-$ spring status
+$ bin/spring status
 Spring is running:
 
 26150 spring server | spring-demo-app | started 36 secs ago
@@ -137,7 +155,7 @@ edit_post GET    /posts/:id/edit(.:format) posts#edit
           PUT    /posts/:id(.:format)      posts#update
           DELETE /posts/:id(.:format)      posts#destroy
 
-$ spring status
+$ bin/spring status
 Spring is running:
 
 26150 spring server | spring-demo-app | started 1 min ago
@@ -150,25 +168,29 @@ when you close your terminal. However if you do want to do a manual shut
 down, use the `stop` command:
 
 ```
-$ spring stop
+$ bin/spring stop
 Spring stopped.
 ```
 
-## Commands
+### Removal
 
-The following commands are shipped by default.
+To remove spring:
 
-Custom commands can be specified in the Spring config file. See
-[`lib/spring/commands/`](https://github.com/jonleighton/spring/blob/master/lib/spring/commands/)
-for examples.
+* 'Unspring' your bin/ executables: `bin/spring binstub --remove --all`
+* Remove spring from your Gemfile
 
-You can add the following gems to your Gemfile for additional commands:
+### Deployment
 
-* [spring-commands-rspec](https://github.com/jonleighton/spring-commands-rspec)
-* [spring-commands-cucumber](https://github.com/jonleighton/spring-commands-cucumber)
-* [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.
+You must not install Spring on your production environment. To prevent it from
+being installed, provide the `--without development test` argument to the
+`bundle install` command which is used to install gems on your production
+machines:
+
+```
+$ bundle install --without development test
+```
+
+## Commands
 
 ### `rake`
 
@@ -194,6 +216,75 @@ 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:
+
+* [spring-commands-rspec](https://github.com/jonleighton/spring-commands-rspec)
+* [spring-commands-cucumber](https://github.com/jonleighton/spring-commands-cucumber)
+* [spring-commands-spinach](https://github.com/jvanbaarsen/spring-commands-spinach)
+* [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-teaspoon](https://github.com/alejandrobabio/spring-commands-teaspoon.git)
+
+## 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
+supported.
+
+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`.
+
+## Temporarily disabling Spring
+
+If you're using Spring binstubs, but temporarily don't want commands to
+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.
+
+It's important to realise that code reloading means that the constants
+in your application are *different objects* after files have changed:
+
+```
+$ bin/rails runner 'puts User.object_id'
+70127987886040
+$ touch app/models/user.rb
+$ bin/rails runner 'puts User.object_id'
+70127976764620
+```
+
+Suppose you have an initializer `config/initializers/save_user_class.rb`
+like so:
+
+``` ruby
+USER_CLASS = User
+```
+
+This saves off the *first* version of the `User` class, which will not
+be the same object as `User` after the code has been reloaded:
+
+```
+$ bin/rails runner 'puts User == USER_CLASS'
+true
+$ touch app/models/user.rb
+$ bin/rails runner 'puts User == USER_CLASS'
+false
+```
+
+So to avoid this problem, don't save off references to application
+constants in your initialization code.
+
 ## Configuration
 
 Spring will read `~/.spring.rb` and `config/spring.rb` for custom
@@ -218,15 +309,10 @@ Spring.application_root = './test/dummy'
 
 There is no `Spring.before_fork` callback. To run something before the
 fork, you can place it in `~/.spring.rb` or `config/spring.rb` or in any of the files
-which get run when your application initializers, such as
+which get run when your application initializes, such as
 `config/application.rb`, `config/environments/*.rb` or
 `config/initializers/*.rb`.
 
-For example, if loading your test helper is slow, you might like to
-preload it to speed up your test runs. To do this you could put a
-`require Rails.root.join("test/helper")` in
-`config/environments/test.rb`.
-
 ### Running code after forking
 
 You might want to run code after Spring forked off the process but
@@ -252,18 +338,15 @@ If there are additional files or directories which should trigger an
 application restart, you can specify them with `Spring.watch`:
 
 ```ruby
-Spring.watch "spec/factories"
+Spring.watch "config/some_config_file.yml"
 ```
 
 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 turn on event-based file system listening:
-
-```ruby
-Spring.watch_method = :listen
-```
-
-You may need to add the [`listen` gem](https://github.com/guard/listen) to your `Gemfile`.
+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.
 
 ## Troubleshooting
 

data/Rakefile

@@ -10,7 +10,7 @@ namespace :test do
 
   Rake::TestTask.new(:acceptance) do |t|
     t.libs << "test"
-    t.test_files = FileList["test/acceptance/*_test.rb"]
+    t.test_files = FileList["test/acceptance_test.rb"]
     t.verbose = true
   end
 

data/bin/spring

@@ -1,5 +1,21 @@
 #!/usr/bin/env ruby
 
+if defined?(Spring)
+  $stderr.puts "You've tried to invoke Spring when it's already loaded (i.e. the Spring " \
+               "constant is defined)."
+  $stderr.puts
+  $stderr.puts "This is probably because you generated binstubs with " \
+               "Spring 1.0, and you now have a Spring version > 1.0 on your system. To solve " \
+               "this, upgrade your bundle to the latest Spring version and then run " \
+               "`bundle exec spring binstub --all` to regenerate your binstubs. This is a one-time " \
+               "step necessary to upgrade from 1.0 to 1.1."
+  $stderr.puts
+  $stderr.puts "Here's the backtrace:"
+  $stderr.puts
+  $stderr.puts caller
+  exit 1
+end
+
 if defined?(Gem)
   if Gem::Version.new(Gem::VERSION) < Gem::Version.new("2.1.0")
     warn "Warning: You're using Rubygems #{Gem::VERSION} with Spring. " \
@@ -21,6 +37,7 @@ if defined?(Gem)
 
     if unstubbed.any?
       warn "Warning: Running `gem pristine --all` to regenerate your installed gemspecs " \
+           "(and deleting then reinstalling your bundle if you use bundle --path) " \
            "will improve the startup performance of Spring."
     end
   end

data/lib/spring/application/boot.rb

@@ -0,0 +1,18 @@
+# This is necessary for the terminal to work correctly when we reopen stdin.
+Process.setsid
+
+require "spring/application"
+
+app = Spring::Application.new(
+  UNIXSocket.for_fd(3),
+  Spring::JSON.load(ENV.delete("SPRING_ORIGINAL_ENV").dup)
+)
+
+Signal.trap("TERM") { app.terminate }
+
+Spring::ProcessTitleUpdater.run { |distance|
+  "spring app    | #{app.app_name} | started #{distance} ago | #{app.app_env} mode"
+}
+
+app.eager_preload if ENV.delete("SPRING_PRELOAD") == "1"
+app.run