spring 0.0.11 → 0.9.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0824c6fabd2c8830c1a610f25821f746367cee6f
+  data.tar.gz: 108cf6e1bd07af03dfbfe9078727315eab78b39e
+SHA512:
+  metadata.gz: c2ca57a02be596e85692d0b8e75f60bc28278f99d82bd5352e5f9ef283c49720b75cca34101061e897f692923d83e030d57da6796e90611c68c01dd3bf688813
+  data.tar.gz: ec4654a54e32ea00418c230ed1c159d6cc628309bb025292c109458140c5b6c41212106004c2b3c2546fc53b81027a3f70b3a58d8b1ad5d695afbad6c43c2f8b

data/CHANGELOG.md

@@ -1,3 +1,26 @@
+## 0.9.0
+
+* Display spring version in the help message
+* Remove workaround for Rubygems performance issue. This issue is solved
+  with Rubygems 2.1, so we no longer need to generate a "spring" binstub
+  file. We warn users if they are not taking advantage of the Rubygems
+  perf fix (e.g. if they are not on 2.1, or haven't run `gem pristine
+  --all`). To upgrade, delete your `bin/spring` and re-run `spring
+  binstub` for each of your binstubs.
+* Binstubs now fall back to non-spring execution of a command if the
+  spring gem is not present. This might be useful for production
+  environments.
+* The ENV will be replaced on each run to match the ENV which exists
+  when the spring command is actually run (rather than the ENV which
+  exists when spring first starts).
+* Specifying the rails env after the rake command (e.g. `rake
+  RAILS_ENV=test db:migrate`) now works as expected.
+* Provide an explicit way to set the environment to use when running
+  `rake` on its own.
+* The `rspec` and `cucumber` commands are no longer shipped by default.
+  They've been moved to the `spring-commands-rspec` and
+  `spring-commands-cucumber` gems.
+
 ## 0.0.11
 
 * Added the `rails destroy` command.

data/README.md

@@ -2,63 +2,42 @@
 
 [![Build Status](https://travis-ci.org/jonleighton/spring.png?branch=master)](https://travis-ci.org/jonleighton/spring)
 
-Spring is a Rails application preloader. It's trying to solve the same
-problem as [spork](https://github.com/sporkrb/spork),
-[zeus](https://github.com/burke/zeus) and
-[commands](https://github.com/rails/commands).
+Spring is a Rails application preloader. It speeds up development by
+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
 
-Spring is most similar to Zeus, but it's implemented in pure Ruby, and
-is more tightly integrated with Rails (it makes use of Rails' built-in
-code reloader).
-
-Spring tries to be totally automatic.
-It boots up in the background the first time you run a
-command. Then it speeds up subsequent commands. If it detects that your
-pre-loaded environment has changed (maybe `config/application.rb` has
-been edited) then it will reload your environment in the background,
-ready for the next command. When you close your terminal session, Spring
-will automatically shut down. There's no "server" to manually start and
-stop.
-
-Spring operates via a command line interface. Other solutions (e.g.
-commands) take the approach of using a special console to run commands
-from. This means we will have to re-implement shell features such as
-history, completion, etc. Whilst it's not impossible to re-implement
-those features, it's unnecessary work and our re-implementation
-won't be as feature complete as a real shell. Using a real shell also
-prevents the user having to constantly jump between a terminal with a
-real shell and a terminal running the rails "commands console".
+* Totally automatic; no need to explicitly start and stop the background process
+* Reloads your application code on each run
+* Restarts your application when configs / initializers / gem
+  dependencies are changed
 
 ## Compatibility
 
-Ruby versions supported:
+* Ruby versions: MRI 1.9.3, MRI 2.0.0
+* Rails versions: 3.2, 4.0
 
-* MRI 1.9.3
-* MRI 2.0.0
+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).
 
-Rails versions supported:
+## Walkthrough
 
-* 3.2
-* 4.0
+Either `gem install spring` or add it to your Gemfile:
 
-Spring makes extensive use of `Process#fork`, so won't be able to run on
-any platform which doesn't support that (Windows, JRuby).
+``` ruby
+group :development do
+  gem "spring"
+end
+```
 
-## Usage
+Spring is designed to be used *without* bundle exec, so use `spring
+[command]` rather than `bundle exec spring [command]`.
 
-Install the `spring` gem. You can add it to your Gemfile if you like but
-it's optional. You now have a `spring` command. Don't use it with
-`bundle exec` or it will be extremely slow.
+For this walkthrough I've generated a new Rails application, and run
+`rails generate scaffold posts name:string`.
 
-For this walkthrough, I'm using the test app in the Spring repository:
-
-```
-cd /path/to/spring/test/apps/rails-3-2
-```
-
-We can run a test:
+Let's run a test:
 
 ```
 $ time spring testunit test/functional/posts_controller_test.rb
@@ -77,21 +56,18 @@ user    0m0.281s
 sys     0m0.066s
 ```
 
-That booted our app in the background:
+That wasn't particularly fast because it was the first run, so spring
+had to boot the application. It's now running:
 
 ```
 $ spring status
 Spring is running:
 
-26150 spring server | rails-3-2 | started 3 secs ago
-26155 spring app    | rails-3-2 | started 3 secs ago | test mode
+26150 spring server | spring-demo-app | started 3 secs ago
+26155 spring app    | spring-demo-app | started 3 secs ago | test mode
 ```
 
-We can see two processes, one is the Spring server, the other is the
-application running in the test environment. When we close the terminal,
-the processes will be killed automatically.
-
-Running the test is faster next time:
+The next run is faster:
 
 ```
 $ time spring testunit test/functional/posts_controller_test.rb
@@ -110,79 +86,50 @@ user    0m0.276s
 sys     0m0.059s
 ```
 
-Running `spring testunit`, `spring rake`, `spring rails`, etc gets a bit
-tedious. It also suffers from a performance issue in Rubygems ([which I
-am actively working on](https://github.com/rubygems/rubygems/pull/435))
-which means the `spring` command takes a while to start up. The more
-gems you have, the longer it takes.
-
-Spring binstubs solve both of these problems. If you will be running the
-`testunit` command regularly, run:
+Writing `spring` before every command gets a bit tedious. Spring binstubs solve this:
 
 ```
 $ spring binstub testunit
+$ spring binstub rake
+$ spring binstub rails
 ```
 
-This generates a `bin/spring` and a `bin/testunit`, which allows you to run
-`spring` and `spring testunit` in a way that doesn't trigger the Rubygems
-performance bug:
-
-```
-$ time bin/testunit test/functional/posts_controller_test.rb
-Run options:
-
-# Running tests:
-
-.......
-
-Finished tests in 0.166585s, 42.0207 tests/s, 60.0296 assertions/s.
+This will generate `bin/testunit`, `bin/rake` and `bin/rails`. They
+replace any binstubs that you might already have in your `bin/`
+directory. Check them in to source control.
 
-7 tests, 10 assertions, 0 failures, 0 errors, 0 skips
-
-real    0m0.407s
-user    0m0.077s
-sys     0m0.059s
-```
-
-You can add "./bin" to your `PATH` when in your application's directory
-[with direnv](https://github.com/zimbatm/direnv), but you should
-recognise and understand the security implications of using that.
+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.
 
-Note: Don't use spring binstubs with `bundle install --binstubs`.  If
-you do this, spring and bundler will overwrite each other. If _you will_
-not be using a command with spring, use `bundle binstub [GEM]` to
-generate a bundler binstub for that specific gem.  If you _will_ be
-using a command with spring, generate a spring binstub _instead of_ a
-bundler binstub; spring will run your command inside the bundle anyway.
+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
+which allows you to refresh your browser and instantly see changes during
+development.
 
-If we edit any of the application files, or test files, the change will
-be picked up on the next run, without the background process
-having to be restarted.
+But if we edit any of the files which were used to start the application
+(configs, initializers, your gemfile), the application needs to be fully
+restarted. This happens automatically.
 
-If we edit any of the preloaded files, the application needs to restart
-automatically. Let's "edit" `config/application.rb`:
+Let's "edit" `config/application.rb`:
 
 ```
 $ touch config/application.rb
 $ spring status
 Spring is running:
 
-26150 spring server | rails-3-2 | started 36 secs ago
-26556 spring app    | rails-3-2 | started 1 sec ago | test mode
+26150 spring server | spring-demo-app | started 36 secs ago
+26556 spring app    | spring-demo-app | started 1 sec ago | test mode
 ```
 
-The application process detected the change and exited. The server process
-then detected that the application process exited, so it started a new application.
-All of this happened automatically. Next time we run a
-command we'll be running against a fresh application. We can see that
-the start time and PID of the app process has changed.
+The application detected that `config/application.rb` changed and
+automatically restarted itself.
 
-If we run a command that uses a different environment, then it gets
-booted up. For example, the `rake` command uses the `development`
-environment by default:
+If we run a command that uses a different environment, then that
+environment gets booted up:
 
 ```
-$ spring binstub rake
 $ bin/rake routes
     posts GET    /posts(.:format)          posts#index
           POST   /posts(.:format)          posts#create
@@ -191,24 +138,21 @@ edit_post GET    /posts/:id/edit(.:format) posts#edit
      post GET    /posts/:id(.:format)      posts#show
           PUT    /posts/:id(.:format)      posts#update
           DELETE /posts/:id(.:format)      posts#destroy
-```
 
-We now have 3 processes: the server, and application in test mode and
-the application in development mode.
-
-```
-$ bin/spring status
+$ spring status
 Spring is running:
 
-26150 spring server | rails-3-2 | started 1 min ago
-26556 spring app    | rails-3-2 | started 42 secs ago | test mode
-26707 spring app    | rails-3-2 | started 2 secs ago | development mode
+26150 spring server | spring-demo-app | started 1 min ago
+26556 spring app    | spring-demo-app | started 42 secs ago | test mode
+26707 spring app    | spring-demo-app | started 2 secs ago | development mode
 ```
 
-To stop the background processes:
+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:
 
 ```
-$ bin/spring stop
+$ spring stop
 Spring stopped.
 ```
 
@@ -217,13 +161,13 @@ Spring stopped.
 The following commands are shipped by default.
 
 Custom commands can be specified in the Spring config file. See
-[`lib/spring/commands.rb`](https://github.com/jonleighton/spring/blob/master/lib/spring/commands.rb)
+[`lib/spring/commands/`](https://github.com/jonleighton/spring/blob/master/lib/spring/commands/)
 for examples.
 
-A bunch of different test frameworks are supported at the moment in
-order to make it easy for people to try spring. However in the future
-the code to use a specific test framework should not be contained in the
-spring repository.
+You can also install the following gems for additional commands:
+
+* [spring-commands-rspec](https://github.com/jonleighton/spring-commands-rspec)
+* [spring-commands-cucumber](https://github.com/jonleighton/spring-commands-cucumber)
 
 ### `testunit`
 
@@ -235,17 +179,6 @@ This command can also recursively run a directory of tests. For example,
 If your test helper file takes a while to load, consider preloading it
 (see "Running code before forking" below).
 
-### `rspec`
-
-Runs an rspec spec, exactly the same as the `rspec` executable.
-
-If your spec helper file takes a while to load, consider preloading it
-(see "Running code before forking" below).
-
-### `cucumber`
-
-Runs a cucumber feature.
-
 ### `rake`
 
 Runs a rake task. Rake tasks run in the `development` environment by
@@ -258,6 +191,9 @@ environment, you'd do it like this:
 ``` ruby
 Spring::Commands::Rake.environment_matchers["perf_test"] = "test"
 Spring::Commands::Rake.environment_matchers[/^perf/]     = "test"
+
+# To change the environment when you run `rake` with no arguments
+Spring::Commands::Rake.environment_matchers[:default] = "development"
 ```
 
 ### `rails console`, `rails generate`, `rails runner`

data/bin/spring

@@ -1,9 +1,31 @@
 #!/usr/bin/env ruby
 
-if Process.respond_to?(:fork)
-  $LOAD_PATH.unshift File.expand_path("../../lib", __FILE__)
-  require 'spring/client'
-  Spring::Client.run(ARGV)
-else
-  exec "bundle", "exec", *ARGV
+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. " \
+         "Upgrade to at least Rubygems 2.1.0 and run `gem pristine --all` for better " \
+         "startup performance."
+  else
+    stubs = Gem::Specification.stubs.grep(Gem::StubSpecification)
+
+    # stubbed? method added in https://github.com/rubygems/rubygems/pull/694
+    if Gem::Specification.stubs.first.respond_to?(:stubbed?)
+      unstubbed = stubs.reject(&:stubbed?)
+    else
+      unstubbed = stubs.reject { |s| s.send(:data).is_a?(Gem::StubSpecification::StubLine) }
+    end
+
+    # `gem pristine --all` ignores default gems. it doesn't really matter,
+    # as there are probably not many of them on the system.
+    unstubbed.reject!(&:default_gem?)
+
+    if unstubbed.any?
+      warn "Warning: Running `gem pristine --all` to regenerate your installed gemspecs " \
+           "will improve the startup performance of Spring."
+    end
+  end
 end
+
+$LOAD_PATH.unshift File.expand_path("../../lib", __FILE__)
+require 'spring/client'
+Spring::Client.run(ARGV)

data/lib/spring/application.rb

@@ -98,8 +98,8 @@ module Spring
 
       preload unless preloaded?
 
-      args    = JSON.load(client.read(client.gets.to_i))
-      command = Spring.command(args.shift)
+      args, env = JSON.load(client.read(client.gets.to_i)).values_at("args", "env")
+      command   = Spring.command(args.shift)
 
       connect_database
       setup command
@@ -112,8 +112,10 @@ module Spring
         STDIN.reopen(streams.last)
         IGNORE_SIGNALS.each { |sig| trap(sig, "DEFAULT") }
 
-        connect_database
         ARGV.replace(args)
+        ENV.replace(env)
+
+        connect_database
         srand
 
         invoke_after_fork_callbacks

data/lib/spring/client/binstub.rb

@@ -1,7 +1,7 @@
 module Spring
   module Client
     class Binstub < Command
-      attr_reader :bindir, :name
+      attr_reader :bindir, :name, :command
 
       def self.description
         "Generate spring based binstubs."
@@ -15,61 +15,52 @@ module Spring
       def initialize(args)
         super
 
-        @bindir = env.root.join("bin")
-        @name   = args[1]
+        @bindir  = env.root.join("bin")
+        @name    = args[1]
+        @command = Spring.commands[name]
       end
 
       def call
-        if Spring.command?(name) || name == "rails"
+        if command || name == "rails"
           bindir.mkdir unless bindir.exist?
-          generate_spring_binstub
-          generate_command_binstub
+          generate_binstub
         else
           $stderr.puts "The '#{name}' command is not known to spring."
           exit 1
         end
       end
 
-      def spring_binstub
-        bindir.join("spring")
-      end
-
-      def command_binstub
+      def binstub
         bindir.join(name)
       end
 
-      def generate_spring_binstub
-        File.write(spring_binstub, <<'CODE')
+      def generate_binstub
+        File.write(binstub, <<CODE)
 #!/usr/bin/env ruby
 
-# This is a special way of invoking the spring gem in order to
-# work around the performance issue discussed in
-# https://github.com/rubygems/rubygems/pull/435
-
-glob       = "{#{Gem::Specification.dirs.join(",")}}/spring-*.gemspec"
-candidates = Dir[glob].to_a.sort_by { |c| Gem::Version.new(File.basename(c).split(/[-\.]/)[1...-1].join(".")) }
-
-spec = Gem::Specification.load(candidates.last)
-
-if spec
-  spec.activate
-  load spec.bin_file("spring")
+if !Process.respond_to?(:fork) || Gem::Specification.find_all_by_name("spring").empty?
+#{fallback.strip.gsub(/^/, "  ")}
 else
-  $stderr.puts "Could not find spring gem in #{Gem::Specification.dirs.join(", ")}."
-  exit 1
+  ARGV.unshift "#{name}"
+  load Gem.bin_path("spring", "spring")
 end
 CODE
 
-        spring_binstub.chmod 0755
+        binstub.chmod 0755
       end
 
-      def generate_command_binstub
-        File.write(command_binstub, <<CODE)
-#!/usr/bin/env bash
-exec $(dirname $0)/spring #{name} "$@"
+      def fallback
+        if command.respond_to?(:fallback)
+          command.fallback
+        elsif name == "rails"
+          <<CODE
+APP_PATH = File.expand_path('../../config/application',  __FILE__)
+require_relative '../config/boot'
+require 'rails/commands'
 CODE
-
-        command_binstub.chmod 0755
+        else
+          %{exec "bundle", "exec", "#{name}", *ARGV}
+        end
       end
     end
   end

data/lib/spring/client/help.rb

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

data/lib/spring/client/run.rb

@@ -69,7 +69,7 @@ ERROR
         application.send_io STDERR
         application.send_io STDIN
 
-        send_json application, args
+        send_json application, "args" => args, "env" => ENV.to_hash
 
         pid = server.gets
         pid = pid.chomp if pid

data/lib/spring/commands.rb

@@ -22,8 +22,6 @@ module Spring
   require "spring/commands/rails"
   require "spring/commands/rake"
   require "spring/commands/testunit"
-  require "spring/commands/rspec"
-  require "spring/commands/cucumber"
 
   # If the config/spring.rb contains requires for commands from other gems,
   # then we need to be under bundler.

data/lib/spring/commands/rake.rb

@@ -6,13 +6,21 @@ module Spring
       end
 
       self.environment_matchers = {
+        :default                     => "test",
         /^(test|spec|cucumber)($|:)/ => "test"
       }
 
       def env(args)
+        # This is an adaption of the matching that Rake itself does.
+        # See: https://github.com/jimweirich/rake/blob/3754a7639b3f42c2347857a0878beb3523542aee/lib/rake/application.rb#L691-L692
+        if env = args.grep(/^(RAILS|RACK)_ENV=(.*)$/m).last
+          return env.split("=").last
+        end
+
         self.class.environment_matchers.each do |matcher, environment|
-          return environment if matcher === args.first
+          return environment if matcher === (args.first || :default)
         end
+
         nil
       end
 

data/lib/spring/commands/testunit.rb

@@ -25,6 +25,10 @@ module Spring
       def description
         "Execute a Test::Unit test."
       end
+
+      def fallback
+        %{exec "bundle", "exec", "ruby", "-Itest", *ARGV}
+      end
     end
 
     Spring.register_command "testunit", TestUnit.new

data/lib/spring/json.rb

@@ -53,7 +53,7 @@ require 'stringio'
 # http://golang.org/src/pkg/utf8/utf8.go
 module Spring
 module OkJson
-  Upstream = '42'
+  Upstream = '43'
   extend self
 
 
@@ -486,11 +486,16 @@ private
         # In ruby >= 1.9, s[r] is a codepoint, not a byte.
         if rubydoesenc?
           begin
-            c.ord # will raise an error if c is invalid UTF-8
+            # c.ord will raise an error if c is invalid UTF-8
+            if c.ord < Spc.ord
+              c = "\\u%04x" % [c.ord]
+            end
             t.write(c)
           rescue
             t.write(Ustrerr)
           end
+        elsif c < Spc
+          t.write("\\u%04x" % c)
         elsif Spc <= c && c <= ?~
           t.putc(c)
         else

data/lib/spring/version.rb

@@ -1,3 +1,3 @@
 module Spring
-  VERSION = "0.0.11"
+  VERSION = "0.9.0"
 end

data/test/acceptance/app_test.rb

@@ -179,8 +179,10 @@ class AppTest < ActiveSupport::TestCase
 
   def generate_app
     Bundler.with_clean_env do
+      # Sporadic SSL errors keep causing test failures so there are anti-SSL workarounds here
+
       assert system("(gem list rails --installed --version '#{rails_version}' || " \
-                      "gem install rails --version '#{rails_version}') > /dev/null")
+                      "gem install rails --clear-sources --source http://rubygems.org --version '#{rails_version}') > /dev/null")
 
       # Have to shell out otherwise bundler prevents us finding the gem
       version = `ruby -e 'puts Gem::Specification.find_by_name("rails", "#{rails_version}").version'`.chomp
@@ -190,6 +192,11 @@ class AppTest < ActiveSupport::TestCase
       FileUtils.mkdir_p(gem_home)
       FileUtils.mkdir_p(user_home)
       FileUtils.rm_rf("#{app_root}/test/performance/")
+
+      File.write(
+        "#{app_root}/Gemfile",
+        File.read("#{app_root}/Gemfile").sub("https://rubygems.org", "http://rubygems.org")
+      )
     end
   end
 
@@ -198,7 +205,7 @@ class AppTest < ActiveSupport::TestCase
 
     assert system("gem build spring.gemspec 2>/dev/null 1>/dev/null")
 
-    assert_success "gem install ../../../spring-#{Spring::VERSION}.gem"
+    assert_success ["gem install ../../../spring-#{Spring::VERSION}.gem", timeout: nil]
     assert_success ["(gem list bundler | grep bundler) || gem install bundler", timeout: nil]
     assert_success ["bundle check || bundle update", timeout: nil]
 
@@ -367,7 +374,7 @@ class AppTest < ActiveSupport::TestCase
 
       app_run "#{spring} binstub rake"
       app_run "#{spring} binstub rails"
-      assert_success "bin/spring help"
+
       assert_success "bin/rake -T", stdout: "rake db:migrate"
       assert_success "bin/rails runner 'puts %(omg)'", stdout: "omg"
       assert_success "bin/rails server --help", stdout: "Usage: rails server"
@@ -423,6 +430,28 @@ class AppTest < ActiveSupport::TestCase
     assert_success "#{spring} rake -p 'Rails.env'", stdout: "production"
   end
 
+  test "setting env vars with rake" do
+    begin
+      File.write("#{app_root}/lib/tasks/env.rake", <<-'CODE')
+      task :print_rails_env => :environment do
+        puts Rails.env
+      end
+
+      task :print_env do
+        ENV.each { |k, v| puts "#{k}=#{v}" }
+      end
+
+      task(:default).clear.enhance [:print_rails_env]
+      CODE
+
+      assert_success "#{spring} rake RAILS_ENV=test print_rails_env", stdout: "test"
+      assert_success "#{spring} rake FOO=bar print_env", stdout: "FOO=bar"
+      assert_success "#{spring} rake", stdout: "test"
+    ensure
+      FileUtils.rm_f("#{app_root}/lib/tasks/env.rake")
+    end
+  end
+
   test "changing the Gemfile restarts the server" do
     begin
       gemfile = app_root.join("Gemfile")
@@ -440,4 +469,17 @@ class AppTest < ActiveSupport::TestCase
       assert_success "bundle check"
     end
   end
+
+  test "changing the environment between runs" do
+    env["OMG"] = "1"
+    env["FOO"] = "1"
+
+    assert_success %(#{spring} rails runner 'p ENV["OMG"]'), stdout: "1"
+
+    env["OMG"] = "2"
+    env.delete "FOO"
+
+    assert_success %(#{spring} rails runner 'p ENV["OMG"]'), stdout: "2"
+    assert_success %(#{spring} rails runner 'p ENV.key?("FOO")'), stdout: "false"
+  end
 end

data/test/unit/client/help_test.rb

@@ -41,6 +41,8 @@ class HelpTest < ActiveSupport::TestCase
 
   test "formatted_help generates expected output" do
     expected_output = <<-EOF
+Version: #{Spring::VERSION}
+
 Usage: spring COMMAND [ARGS]
 
 Commands for spring itself:

data/test/unit/watcher_test.rb

@@ -127,12 +127,14 @@ module WatcherTests
     watcher.add file
     watcher.start
 
+    io = watcher.to_io
+
     Thread.new {
       sleep LATENCY * 3
       touch file, Time.now
     }
 
-    assert IO.select([watcher], [], [], 1), "IO.select timed out before watcher was readable"
+    assert IO.select([io], [], [], 1), "IO.select timed out before watcher was readable"
     assert watcher.stale?
   end
 

metadata

@@ -1,46 +1,41 @@
 --- !ruby/object:Gem::Specification
 name: spring
 version: !ruby/object:Gem::Version
-  version: 0.0.11
-  prerelease: 
+  version: 0.9.0
 platform: ruby
 authors:
 - Jon Leighton
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-10-09 00:00:00.000000000 Z
+date: 2013-10-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 description: Rails application preloader
@@ -70,10 +65,8 @@ files:
 - lib/spring/client/status.rb
 - lib/spring/client/stop.rb
 - lib/spring/commands.rb
-- lib/spring/commands/cucumber.rb
 - lib/spring/commands/rails.rb
 - lib/spring/commands/rake.rb
-- lib/spring/commands/rspec.rb
 - lib/spring/commands/testunit.rb
 - lib/spring/configuration.rb
 - lib/spring/env.rb
@@ -97,27 +90,26 @@ files:
 - test/unit/watcher_test.rb
 homepage: http://github.com/jonleighton/spring
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 2.1.9
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Rails application preloader
 test_files:
 - test/acceptance/app_test.rb
@@ -127,3 +119,4 @@ test_files:
 - test/unit/commands_test.rb
 - test/unit/process_title_updater_test.rb
 - test/unit/watcher_test.rb
+has_rdoc: 

data/lib/spring/commands/cucumber.rb

@@ -1,15 +0,0 @@
-module Spring
-  module Commands
-    class Cucumber
-      def env(*)
-        "test"
-      end
-
-      def exec_name
-        "cucumber"
-      end
-    end
-
-    Spring.register_command "cucumber", Cucumber.new
-  end
-end

data/lib/spring/commands/rspec.rb

@@ -1,15 +0,0 @@
-module Spring
-  module Commands
-    class RSpec
-      def env(*)
-        "test"
-      end
-
-      def exec_name
-        "rspec"
-      end
-    end
-
-    Spring.register_command "rspec", RSpec.new
-  end
-end