spring 2.0.2 → 4.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 42ad763baaed56f6c7dd36b05566eec2e008481b
-  data.tar.gz: 6f228d8ea63046f99353e83e732a72ef1900b0fd
+SHA256:
+  metadata.gz: 557c3aebe1211983306061278ab800f1232e42d67a40bc4042c24560ff44409d
+  data.tar.gz: 6c1cdb2f00e1f7893d0fbf60b49d76d8841dd9c931dfa79c45387ddbec1bea5b
 SHA512:
-  metadata.gz: b049078c55028bbba601d2ca065fff5e3904cfd27b4ab6b719b7488e1bd044247cb88716126d46e5f26abb6296818d606b717ae4c0ad4c9c04726ff43e22c50e
-  data.tar.gz: 12560b678ff15621efb6b479a443048330088f40ad328b920525785d59aa64064895565f96db5bb14801ce6c516106f3296ec8966a83b55142e915fa0df7bf74
+  metadata.gz: 1da8511a30a3802f6b96ce29b342e70bf136de411278624758a55b73140130902ad7e1afa488df1f48a06685b1980b0f5dd9b9185f27e36ec3d3ba43b9c27841
+  data.tar.gz: c05785038b3a2a048c2b6e9f95f0979561c292714029ec58da934f1cd5e139b3e66b3da9d917082717e83891ac922292f636b53183de580672325b52c58665a9

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 1.9.3, MRI 2.0, MRI 2.1, MRI 2.2
-* Rails versions: 4.2, 5.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
+* 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).
@@ -27,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:
@@ -50,21 +50,35 @@ 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
+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, 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
@@ -90,7 +104,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:
 
 ```
@@ -167,8 +181,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:
 
 ```
@@ -176,9 +190,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
@@ -186,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
@@ -216,7 +233,7 @@ 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).
 
@@ -230,18 +247,22 @@ You can add these to your Gemfile for additional commands:
 * [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`.
 
@@ -252,12 +273,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:
@@ -357,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
@@ -373,38 +392,46 @@ 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_SERVER_COMMAND` - The command to run to start up the spring
+* `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
-run spring explicitly in a separate terminal:
+If you want to get more information about what Spring is doing, you can
+run Spring explicitly in a separate terminal:
 
 ```
 $ spring server

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,18 +91,20 @@ module Spring
 
       require Spring.application_root_path.join("config", "application")
 
-      # config/environments/test.rb will have config.cache_classes = true. However
-      # we want it to be false so that we can reload files. This is a hack to
-      # override the effect of config.cache_classes = true. We can then actually
-      # set config.cache_classes = false after loading the environment.
-      Rails::Application.initializer :initialize_dependency_mechanism, group: :all do
-        ActiveSupport::Dependencies.mechanism = :load
+      unless Rails.respond_to?(:gem_version) && Rails.gem_version >= Gem::Version.new('6.0.0')
+        raise "Spring only supports Rails >= 6.0.0"
       end
 
-      require Spring.application_root_path.join("config", "environment")
+      Rails::Application.initializer :ensure_reloading_is_enabled, group: :all do
+        if Rails.application.config.cache_classes
+          raise <<-MSG.strip_heredoc
+            Spring reloads, and therefore needs the application to have reloading enabled.
+            Please, set config.cache_classes to false in config/environments/#{Rails.env}.rb.
+          MSG
+        end
+      end
 
-      @original_cache_classes = Rails.application.config.cache_classes
-      Rails.application.config.cache_classes = false
+      require Spring.application_root_path.join("config", "environment")
 
       disconnect_database
 
@@ -113,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"]
@@ -125,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
@@ -147,10 +154,23 @@ module Spring
       log "got client"
       manager.puts
 
-      stdout, stderr, stdin = streams = 3.times.map { client.recv_io }
+      @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)
@@ -159,39 +179,39 @@ module Spring
       setup command
 
       if Rails.application.reloaders.any?(&:updated?)
-        # 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
+        Rails.application.reloader.reload!
       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")
 
-        STDERR.puts "Running via Spring preloader in process #{Process.pid}" unless Spring.quiet
+        unless Spring.quiet
+          STDERR.puts "Running via Spring preloader in process #{Process.pid}"
+
+          if Rails.env.production?
+            STDERR.puts "WARNING: Spring is running in production. To fix "         \
+                        "this make sure the spring gem is only present "            \
+                        "in `development` and `test` groups in your Gemfile "       \
+                        "and make sure you always use "                             \
+                        "`bundle install --without development test` in production"
+          end
+        end
 
         ARGV.replace(args)
         $0 = command.exec_name
 
-        # Delete all env vars which are unchanged from before spring started
+        # Delete all env vars which are unchanged from before Spring started
         original_env.each { |k, v| ENV.delete k if ENV[k] == v }
 
-        # Load in the current env vars, except those which *were* changed when spring started
+        # Load in the current env vars, except those which *were* changed when Spring started
         env.each { |k, v| ENV[k] ||= v }
 
-        # requiring is faster, so if config.cache_classes was true in
-        # the environment's config file, then we can respect that from
-        # here on as we no longer need constant reloading.
-        if @original_cache_classes
-          ActiveSupport::Dependencies.mechanism = :require
-          Rails.application.config.cache_classes = true
-        end
-
         connect_database
         srand
 
@@ -229,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
@@ -282,13 +302,13 @@ module Spring
       Kernel.module_eval do
         old_raise = Kernel.method(:raise)
         remove_method :raise
-        define_method :raise do |*args|
+        define_method :raise do |*args, **kwargs|
           begin
-            old_raise.call(*args)
+            old_raise.call(*args, **kwargs)
           ensure
             if $!
               lib = File.expand_path("..", __FILE__)
-              $!.backtrace.reject! { |line| line.start_with?(lib) }
+              $!.backtrace.reject! { |line| line.start_with?(lib) } unless $!.backtrace.frozen?
             end
           end
         end
@@ -321,7 +341,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/application_manager.rb

@@ -7,6 +7,7 @@ module Spring
       @spring_env = spring_env
       @mutex      = Mutex.new
       @state      = :running
+      @pid        = nil
     end
 
     def log(message)
@@ -92,7 +93,8 @@ module Spring
     def start_child(preload = false)
       @child, child_socket = UNIXSocket.pair
 
-      Bundler.with_clean_env do
+      Bundler.with_original_env do
+        bundler_dir = File.expand_path("../..", $LOADED_FEATURES.grep(/bundler\/setup\.rb$/).first)
         @pid = Process.spawn(
           {
             "RAILS_ENV"           => app_env,
@@ -101,7 +103,7 @@ module Spring
             "SPRING_PRELOAD"      => preload ? "1" : "0"
           },
           "ruby",
-          "-I", File.expand_path("../..", $LOADED_FEATURES.grep(/bundler\/setup\.rb$/).first),
+          *(bundler_dir != RbConfig::CONFIG["rubylibdir"] ? ["-I", bundler_dir] : []),
           "-I", File.expand_path("../..", __FILE__),
           "-e", "require 'spring/application/boot'",
           3 => child_socket,

data/lib/spring/binstub.rb

@@ -1,26 +1,6 @@
 command  = File.basename($0)
 bin_path = File.expand_path("../../../bin/spring", __FILE__)
 
-# When we run a command which does not go through Spring (e.g. DISABLE_SPRING
-# is used, or we just call 'rails' or something) then we get this warning from
-# Rubygems:
-#
-#   WARN: Unresolved specs during Gem::Specification.reset: activesupport (<= 5.1, >= 4.2)
-#   WARN: Clearing out unresolved specs.
-#   Please report a bug if this causes problems.
-#
-# This happens due to our dependency on activesupport, when Bundler.setup gets
-# called.  We don't actually *use* the dependency; it is purely there to
-# restrict the Rails version that we're compatible with.
-#
-# When the warning is shown, Rubygems just does the below.
-# Therefore, by doing it ourselves here, we can avoid the warning.
-if Gem::Specification.respond_to?(:unresolved_deps)
-  Gem::Specification.unresolved_deps.clear
-else
-  Gem.unresolved_deps.clear
-end
-
 if command == "spring"
   load bin_path
 else

data/lib/spring/client/binstub.rb

@@ -1,56 +1,48 @@
-require 'set'
-
 module Spring
   module Client
     class Binstub < Command
-      SHEBANG = /\#\!.*\n/
+      SHEBANG = /\#\!.*\n(\#.*\n)*/
 
-      # If loading the bin/spring file works, it'll run spring which will
+      # If loading the bin/spring file works, it'll run Spring which will
       # eventually call Kernel.exit. This means that in the client process
-      # we will never execute the lines after this block. But if the spring
+      # we will never execute the lines after this block. But if the 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 using 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 [
-        %{begin\n  load File.expand_path("../spring", __FILE__)\nrescue LoadError\nend\n},
+        %{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
-      ]
+      ].map { |binstub| /#{Regexp.escape(binstub).gsub("'", "['\"]")}/ }
 
       class Item
         attr_reader :command, :existing
@@ -79,7 +71,7 @@ CODE
               generate(fallback)
               status "upgraded"
             elsif existing.include?(LOADER)
-              status "spring already present"
+              status "Spring already present"
             elsif existing =~ BINSTUB_VARIATIONS
               upgraded = existing.sub(BINSTUB_VARIATIONS, LOADER)
               File.write(command.binstub, upgraded)
@@ -94,15 +86,15 @@ CODE
                 end
 
                 File.write(command.binstub, "#{head}#{shebang}#{LOADER}#{tail}")
-                status "spring inserted"
+                status "Spring inserted"
               else
-                status "doesn't appear to be ruby, so cannot use spring", $stderr
+                status "doesn't appear to be ruby, so cannot use Spring", $stderr
                 exit 1
               end
             end
           else
             generate
-            status "generated with spring"
+            status "generated with Spring"
           end
         end
 
@@ -119,7 +111,7 @@ CODE
         def remove
           if existing
             File.write(command.binstub, existing.sub(BINSTUB_VARIATIONS, ""))
-            status "spring removed"
+            status "Spring removed"
           end
         end
       end
@@ -127,7 +119,7 @@ CODE
       attr_reader :bindir, :items
 
       def self.description
-        "Generate spring based binstubs. Use --all to generate a binstub for all known commands. Use --remove to revert."
+        "Generate Spring based binstubs. Use --all to generate a binstub for all known commands. Use --remove to revert."
       end
 
       def self.rails_command
@@ -147,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/help.rb

@@ -32,7 +32,7 @@ module Spring
       def formatted_help
         ["Version: #{env.version}\n",
          "Usage: spring COMMAND [ARGS]\n",
-         *command_help("spring itself", spring_commands),
+         *command_help("Spring itself", spring_commands),
          '',
          *command_help("your application", application_commands)].join("\n")
       end