spring 1.0.0 → 1.1.0.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ab103d29ee132ac8637c7ddca8d5c41fc567c31e
-  data.tar.gz: 88e600c6e1d59b4150625769f20f6d543958087c
+  metadata.gz: fe796fa453e40306865cb1cf6e6541ca01571d5d
+  data.tar.gz: 7210043ae71cdb012a21734c86984922a8127afe
 SHA512:
-  metadata.gz: 7b4d762562b8d4c1832bcec43819b6bcc6d9168473095fac089a743c0c421d4450f77e7c0a3cf31902256ed42a3d0fa57e7767cd4a0cf9d0bd55dc24c758f460
-  data.tar.gz: 9c929b2636980dc30486f475caeacb1f3de296420c22e9f0a52c67ce732a8953e28f1b090258a18456d210ce217610e8e4df8ffeb7a1a8ebd0e2b546554235ec
+  metadata.gz: 3c1bcd8097999582b66b2507029e807be714455fe95f70a52e222a3221c5e3921e89ba1131e3b16bd0d775eaae7f65c660b87e65c22526d3e2e79544a226e532
+  data.tar.gz: a0c20068387c73fd9203e6fc408ab1789240e9b244e4e627dc233f04f9850e3c984aca138a81f59b7c553958859e02349c15659910aa789ee95b5595cf95db5c

data/.travis.yml

@@ -1,7 +1,10 @@
 language: ruby
+before_install: if [[ "$TRAVIS_RUBY_VERSION" = "1.9.3" ]]; then gem install bundler --version="1.3.5"; else gem install bundler; fi
 rvm:
   - 1.9.3
   - 2.0.0
+  - 2.1.0
 env:
   - RAILS_VERSION="~> 3.2.0"
   - RAILS_VERSION="~> 4.0.0"
+  - RAILS_VERSION="~> 4.1.0.beta1"

data/CHANGELOG.md

@@ -1,3 +1,18 @@
+## Next version
+
+* 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. 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
+
 ## 1.0.0
 
 * Enterprise ready secret sauce added

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)
+[![Gem Version](https://badge.fury.io/rb/spring.png)](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,50 @@ boot it every time you run a test, rake task or migration.
 
 ## Compatibility
 
-* Ruby versions: MRI 1.9.3, MRI 2.0.0
+* Ruby versions: MRI 1.9.3, MRI 2.0, MRI 2.1
 * Rails versions: 3.2, 4.0
 
-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
+```
+
+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) to automatically add
+`./bin` to your `PATH` when you `cd` into your application.
+
+### Usage
 
 For this walkthrough I've generated a new Rails application, and run
 `rails generate scaffold posts name:string`.
@@ -40,7 +67,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 +87,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 +97,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 +113,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 +127,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 +150,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 +163,18 @@ 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
-
-The following commands are shipped by default.
+### Removal
 
-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.
+To remove spring:
 
-You can add the following gems to your Gemfile for additional commands:
+* 'Unspring' your bin/ executables: `bin/spring binstub --remove --all`
+* Remove spring from your Gemfile
 
-* [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.
+## Commands
 
 ### `rake`
 
@@ -194,6 +200,28 @@ 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):
+
+* [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.
+
+## 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`.
+
 ## Configuration
 
 Spring will read `~/.spring.rb` and `config/spring.rb` for custom
@@ -223,9 +251,14 @@ which get run when your application initializers, such as
 `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`.
+preload it to speed up your test runs. To do this you could add the
+following to your `config/environments/test.rb`:
+
+``` ruby
+config.after_initialize do
+  require Rails.root.join("test/helper")
+end
+```
 
 ### Running code after forking
 

data/lib/spring/application.rb

@@ -9,7 +9,6 @@ module Spring
     def initialize(manager, watcher = Spring.watcher)
       @manager    = manager
       @watcher    = watcher
-      @setup      = Set.new
       @spring_env = Env.new
       @preloaded  = false
       @mutex      = Mutex.new
@@ -54,6 +53,7 @@ module Spring
       watcher.add loaded_application_features
       watcher.add Spring.gemfile, "#{Spring.gemfile}.lock"
       watcher.add Rails.application.paths["config/initializers"]
+      watcher.add Rails.application.paths["config/database"]
 
       @preloaded = true
     end
@@ -116,22 +116,17 @@ module Spring
         # Load in the current env vars, except those which *were* changed when spring started
         env.each { |k, v| ENV[k] ||= v }
 
+        # requiring is faster, and we don't need constant reloading in this process
+        ActiveSupport::Dependencies.mechanism = :require
+        Rails.application.config.cache_classes = true
+
         connect_database
         srand
 
         invoke_after_fork_callbacks
         shush_backtraces
 
-        if command.respond_to?(:call)
-          command.call
-        else
-          exec_name = command.exec_name
-          gem_name  = command.gem_name if command.respond_to?(:gem_name)
-
-          exec = Gem.bin_path(gem_name || exec_name, exec_name)
-          $0 = exec
-          load exec
-        end
+        command.call
       }
 
       disconnect_database
@@ -167,11 +162,7 @@ module Spring
     # main process so that they are cached. For example a test command wants to
     # load the helper file once and have it cached.
     def setup(command)
-      return if @setup.include?(command.class)
-      @setup << command.class
-
-      if command.respond_to?(:setup)
-        command.setup
+      if command.setup
         watcher.add loaded_application_features # loaded features may have changed
       end
     end

data/lib/spring/binstub.rb

@@ -0,0 +1,12 @@
+command = File.basename($0)
+
+if command == "spring"
+  load Gem.bin_path("spring", "spring")
+else
+  disable = ENV["DISABLE_SPRING"]
+
+  if Process.respond_to?(:fork) && (disable.nil? || disable.empty? || disable == "0")
+    ARGV.unshift(command)
+    load Gem.bin_path("spring", "spring")
+  end
+end

data/lib/spring/client.rb

@@ -8,15 +8,18 @@ require "spring/client/binstub"
 require "spring/client/stop"
 require "spring/client/status"
 require "spring/client/rails"
+require "spring/client/version"
 
 module Spring
   module Client
     COMMANDS = {
-      "help"    => Client::Help,
-      "binstub" => Client::Binstub,
-      "stop"    => Client::Stop,
-      "status"  => Client::Status,
-      "rails"   => Client::Rails
+      "help"      => Client::Help,
+      "binstub"   => Client::Binstub,
+      "stop"      => Client::Stop,
+      "status"    => Client::Status,
+      "rails"     => Client::Rails,
+      "-v"        => Client::Version,
+      "--version" => Client::Version
     }
 
     def self.run(args)

data/lib/spring/client/binstub.rb

@@ -1,46 +1,160 @@
+require 'set'
+
 module Spring
   module Client
     class Binstub < Command
-      attr_reader :bindir, :commands
+      SHEBANG = /\#\!.*\n/
+
+      # 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
+      # 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
+end
+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.
+      #
+      # Gem.try_activate would be called inside rubygems due to the #require.
+      # However, when that happens $! gets set and it appears that there is a
+      # LoadError, which can cause problems. So we activate the gem separately
+      # to requiring the file.
+      SPRING = <<CODE
+#!/usr/bin/env ruby
+
+unless defined?(Spring)
+  require "rubygems"
+  require "bundler"
+
+  ENV["GEM_HOME"] = ""
+  ENV["GEM_PATH"] = Bundler.bundle_path.to_s
+  Gem.paths = ENV
+
+  Gem.try_activate("spring/binstub")
+  require "spring/binstub"
+end
+CODE
+
+      OLD_BINSTUB = %{if !Process.respond_to?(:fork) || Gem::Specification.find_all_by_name("spring").empty?}
+
+      class Item
+        attr_reader :command, :existing
+
+        def initialize(command)
+          @command = command
+
+          if command.binstub.exist?
+            @existing = command.binstub.read
+          elsif command.name == "rails"
+            scriptfile = Spring.application_root_path.join("script/rails")
+            @existing = scriptfile.read if scriptfile.exist?
+          end
+        end
+
+        def status(text, stream = $stdout)
+          stream.puts "* #{command.binstub_name}: #{text}"
+        end
+
+        def add
+          if existing
+            if existing.include?(OLD_BINSTUB)
+              fallback = existing.match(/#{Regexp.escape OLD_BINSTUB}\n(.*)else/m)[1]
+              fallback.gsub!(/^  /, "")
+              fallback = nil if fallback.include?("exec")
+              generate(fallback)
+              status "upgraded"
+            elsif existing =~ /load .*spring/
+              status "spring already present"
+            else
+              head, shebang, tail = existing.partition(SHEBANG)
+
+              if shebang.include?("ruby")
+                unless command.binstub.exist?
+                  FileUtils.touch command.binstub
+                  command.binstub.chmod 0755
+                end
+
+                File.write(command.binstub, "#{head}#{shebang}#{LOADER}#{tail}")
+                status "spring inserted"
+              else
+                status "doesn't appear to be ruby, so cannot use spring", $stderr
+                exit 1
+              end
+            end
+          else
+            generate
+            status "generated with spring"
+          end
+        end
+
+        def generate(fallback = nil)
+          unless fallback
+            fallback = "require 'bundler/setup'\n" \
+                       "load Gem.bin_path('#{command.gem_name}', '#{command.exec_name}')\n"
+          end
+
+          File.write(command.binstub, "#!/usr/bin/env ruby\n#{LOADER}#{fallback}")
+          command.binstub.chmod 0755
+        end
+
+        def remove
+          if existing
+            File.write(command.binstub, existing.sub(LOADER, ""))
+            status "spring removed"
+          end
+        end
+      end
+
+      attr_reader :bindir, :items
 
       def self.description
         "Generate spring based binstubs. Use --all to generate a binstub for all known commands."
       end
 
+      def self.rails_command
+        @rails_command ||= CommandWrapper.new("rails")
+      end
+
       def self.call(args)
         require "spring/commands"
         super
       end
 
-      class RailsCommand
-        def fallback
-          <<CODE
-APP_PATH = File.expand_path('../../config/application',  __FILE__)
-require_relative '../config/boot'
-require 'rails/commands'
-CODE
-        end
-      end
-
       def initialize(args)
         super
 
-        @bindir   = env.root.join("bin")
-        @commands = args.drop(1).inject({}) { |mem, name| mem.merge(find_commands(name)) }
+        @bindir = env.root.join("bin")
+        @all    = false
+        @mode   = :add
+        @items  = args.drop(1)
+                      .map { |name| find_commands name }
+                      .inject(Set.new, :|)
+                      .map { |command| Item.new(command) }
       end
 
       def find_commands(name)
         case name
         when "--all"
-          commands = Spring.commands
+          @all = true
+          commands = Spring.commands.dup
           commands.delete_if { |name, _| name.start_with?("rails_") }
-          commands["rails"] = RailsCommand.new
-          commands
+          commands.values + [self.class.rails_command]
+        when "--remove"
+          @mode = :remove
+          []
         when "rails"
-          { name => RailsCommand.new }
+          [self.class.rails_command]
         else
           if command = Spring.commands[name]
-            { name => command }
+            [command]
           else
             $stderr.puts "The '#{name}' command is not known to spring."
             exit 1
@@ -49,32 +163,27 @@ CODE
       end
 
       def call
-        bindir.mkdir unless bindir.exist?
-        commands.each { |name, command| generate_binstub(name, command) }
-      end
-
-      def generate_binstub(name, command)
-        File.write(bindir.join(name), <<CODE)
-#!/usr/bin/env ruby
-
-if !Process.respond_to?(:fork) || Gem::Specification.find_all_by_name("spring").empty?
-#{fallback(name, command).strip.gsub(/^/, "  ")}
-else
-  ARGV.unshift "#{name}"
-  load Gem.bin_path("spring", "spring")
-end
-CODE
+        case @mode
+        when :add
+          bindir.mkdir unless bindir.exist?
 
-        bindir.join(name).chmod 0755
-      end
+          unless spring_binstub.exist?
+            File.write(spring_binstub, SPRING)
+            spring_binstub.chmod 0755
+          end
 
-      def fallback(name, command)
-        if command.respond_to?(:fallback)
-          command.fallback
+          items.each(&:add)
+        when :remove
+          spring_binstub.delete if @all
+          items.each(&:remove)
         else
-          %{exec "bundle", "exec", "#{name}", *ARGV}
+          raise ArgumentError
         end
       end
+
+      def spring_binstub
+        bindir.join("spring")
+      end
     end
   end
 end