spring 0.0.7 → 0.0.8

data/CHANGELOG.md

@@ -0,0 +1,11 @@
+## 0.0.8
+
+* Renamed `spring test` to `spring testunit`.
+* Implemented `spring rails` to replace `spring
+  [console|runner|generate]`.
+* `config/spring.rb` is only loaded in the server process, so you can
+  require stuff from other gems there without performance implications.
+* File watcher no longer pays attention to files outside of your
+  application root directory.
+* You can use the `listen` gem for less CPU intensive file watching. See
+  README.

data/Gemfile

@@ -2,3 +2,7 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in spring.gemspec
 gemspec
+
+gem 'listen', :require => false
+gem 'rb-inotify', :require => false
+gem 'rb-fsevent', :require => false

data/README.md

@@ -67,7 +67,7 @@ cd /path/to/spring/test/apps/rails-3-2
 We can run a test:
 
 ```
-$ time spring test test/functional/posts_controller_test.rb
+$ time spring testunit test/functional/posts_controller_test.rb
 Run options:
 
 # Running tests:
@@ -100,7 +100,7 @@ the processes will be killed automatically.
 Running the test is faster next time:
 
 ```
-$ time spring test test/functional/posts_controller_test.rb
+$ time spring testunit test/functional/posts_controller_test.rb
 Run options:
 
 # Running tests:
@@ -116,25 +116,25 @@ user	0m0.276s
 sys	0m0.059s
 ```
 
-Running `spring test`, `spring rake`, `spring console`, etc gets a bit
+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
-`test` command regularly, run:
+`testunit` command regularly, run:
 
 ```
-$ spring binstub test
+$ spring binstub testunit
 ```
 
-This generates a `bin/spring` and a `bin/test`, which allows you to run
-`spring` and `spring test` in a way that doesn't trigger the Rubygems
+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/test test/functional/posts_controller_test.rb
+$ time bin/testunit test/functional/posts_controller_test.rb
 Run options:
 
 # Running tests:
@@ -150,6 +150,10 @@ 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 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.
@@ -220,12 +224,12 @@ 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.
 
-### `test`
+### `testunit`
 
 Runs a test (e.g. Test::Unit, MiniTest::Unit, etc.) Preloads the `test_helper` file.
 
 This command can also recursively run a directory of tests. For example,
-`spring test test/functional` will run `test/functional/**/*_test.rb`.
+`spring testunit test/functional` will run `test/functional/**/*_test.rb`.
 
 ### `rspec`
 
@@ -240,19 +244,12 @@ Runs a cucumber feature.
 
 Runs a rake task.
 
-### `console`
-
-Boots into the Rails console. Currently this is usable but not perfect,
-for example you can't scroll back through command history. (That will be
-fixed.)
-
-### `generate`
-
-Runs a Rails generator.
-
-### `runner`
+### `rails console`, `rails generate`, `rails runner`
 
-The 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
+pass it through to the underlying `rails` executable (without the
+speed-up).
 
 ## Configuration
 
@@ -279,13 +276,13 @@ preloads for every command:
 
 ```ruby
 # if your test helper is called "helper"
-Commands::Command::Test.preloads = %w(helper)
+Commands::Command::TestUnit.preloads = %w(helper)
 
 # if you don't want to preload spec_helper.rb
 Commands::Command::RSpec.preloads = []
 
 # if you want to preload additional files for the console
-Commands::Command::Console.preloads << 'extenstions/console_helper'
+Commands::Command::RailsConsole.preloads << 'extenstions/console_helper'
 ```
 
 ### after fork callbacks
@@ -308,3 +305,31 @@ If you want to register multiple callbacks you can simply call
 
 Spring needs a tmp directory. This will default to `Rails.root.join('tmp', 'spring')`.
 You can set your own configuration directory by setting the `SPRING_TMP_PATH` environment variable.
+
+### Watching files and directories
+
+As mentioned above, Spring will automatically detect file changes to any file loaded when the server
+boots. If you would like to watch additional files or directories, use
+`Spring.watch`:
+
+```ruby
+Spring.watch "#{Rails.root}/spec/factories"
+```
+
+### Filesystem polling
+
+By default Spring will check 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 by
+adding the following to to your `Gemfile`:
+
+```ruby
+group :development, :test do
+  gem 'listen'
+  gem 'rb-inotify', :require => false  # linux
+  gem 'rb-fsevent', :require => false  # mac os x
+  gem 'rb-kqueue',  :require => false  # bsd
+end
+```
+
+Note that this make the initial application startup slightly slower.

data/lib/spring/application.rb

@@ -1,24 +1,21 @@
-require "spring/configuration"
-require "spring/application_watcher"
-require "spring/commands"
 require "set"
+require "json"
 
-module Spring
-  class << self
-    attr_accessor :application_watcher
-  end
-
-  self.application_watcher = ApplicationWatcher.new
+require "spring/configuration"
+require "spring/watcher"
 
+module Spring
   class Application
-    WATCH_INTERVAL = 0.2
-
     attr_reader :manager, :watcher
 
-    def initialize(manager, watcher = Spring.application_watcher)
+    def initialize(manager, watcher = Spring.watcher)
       @manager = manager
       @watcher = watcher
       @setup   = Set.new
+
+      # Workaround for GC bug in Ruby 2 which causes segfaults if watcher.to_io
+      # instances get dereffed.
+      @fds = [manager, watcher.to_io]
     end
 
     def start
@@ -33,31 +30,33 @@ module Spring
 
       require Spring.application_root_path.join("config", "environment")
 
-      watcher.add_files $LOADED_FEATURES
-      watcher.add_files ["Gemfile", "Gemfile.lock"].map { |f| "#{Rails.root}/#{f}" }
-      watcher.add_globs Rails.application.paths["config/initializers"].map { |p| "#{Rails.root}/#{p}/*.rb" }
+      watcher.add loaded_application_features
+      watcher.add "Gemfile", "Gemfile.lock"
+      watcher.add Rails.application.paths["config/initializers"]
 
       run
     end
 
     def run
+      watcher.start
+
       loop do
-        watch_application
-        serve manager.recv_io(UNIXSocket)
-      end
-    end
+        IO.select(@fds)
 
-    def watch_application
-      until IO.select([manager], [], [], WATCH_INTERVAL)
-        exit if watcher.stale?
+        if watcher.stale?
+          exit
+        else
+          serve manager.recv_io(UNIXSocket)
+        end
       end
     end
 
     def serve(client)
-      streams     = 3.times.map { client.recv_io }
-      args_length = client.gets.to_i
-      args        = args_length.times.map { client.read(client.gets.to_i) }
-      command     = Spring.command(args.shift)
+      manager.puts
+
+      streams = 3.times.map { client.recv_io }
+      args    = JSON.parse(client.read(client.gets.to_i))
+      command = Spring.command(args.shift)
 
       setup command
 
@@ -92,16 +91,13 @@ module Spring
     # The command might need to require some files in the
     # main process so that they are cached. For example a test command wants to
     # load the helper file once and have it cached.
-    #
-    # FIXME: The watcher.add_files will reset the watcher, which may mean that
-    #        previous changes to already-loaded files are missed.
     def setup(command)
       return if @setup.include?(command.class)
       @setup << command.class
 
       if command.respond_to?(:setup)
         command.setup
-        watcher.add_files $LOADED_FEATURES # loaded features may have changed
+        watcher.add loaded_application_features # loaded features may have changed
       end
     end
 
@@ -110,5 +106,9 @@ module Spring
         callback.call
       end
     end
+
+    def loaded_application_features
+      $LOADED_FEATURES.select { |f| f.start_with?(File.realpath(Rails.root)) }
+    end
   end
 end

data/lib/spring/application_manager.rb

@@ -1,11 +1,9 @@
 require "socket"
+require "thread"
 require "spring/application"
-require "mutex_m"
 
 module Spring
   class ApplicationManager
-    include Mutex_m
-
     attr_reader :pid, :child, :app_env, :spring_env
 
     def initialize(app_env)
@@ -13,6 +11,16 @@ module Spring
 
       @app_env    = app_env
       @spring_env = Env.new
+      @mutex      = Mutex.new
+    end
+
+    # We're not using @mutex.synchronize to avoid the weird "<internal:prelude>:10"
+    # line which messes with backtraces in e.g. rspec
+    def synchronize
+      @mutex.lock
+      yield
+    ensure
+      @mutex.unlock
     end
 
     def start
@@ -31,31 +39,36 @@ module Spring
       @pid
     end
 
-    # Returns the pid of the process running the command, or nil if the application process died.
-    def run(client)
-      @client = client
-
+    def with_child
       synchronize do
         if alive?
           begin
-            child.send_io @client
-          rescue Errno::EPIPE
-            # EPIPE indicates child has died but has not been collected by the wait thread yet
+            yield
+          rescue Errno::ECONNRESET, Errno::EPIPE
+            # The child has died but has not been collected by the wait thread yet,
+            # so start a new child and try again.
             start
-            child.send_io @client
+            yield
           end
         else
           start
-          child.send_io @client
+          yield
         end
       end
+    end
+
+    # Returns the pid of the process running the command, or nil if the application process died.
+    def run(client)
+      with_child do
+        child.send_io client
+        child.gets
+      end
 
       child.gets.chomp.to_i # get the pid
     rescue Errno::ECONNRESET, Errno::EPIPE
       nil
     ensure
-      @client.close
-      @client = nil
+      client.close
     end
 
     def stop
@@ -68,11 +81,17 @@ module Spring
       @child, child_socket = UNIXSocket.pair
       @pid = fork {
         [STDOUT, STDERR].each { |s| s.reopen('/dev/null', 'w') } if silence
-        @client.close if @client
+
+        (ObjectSpace.each_object(IO).to_a - [STDOUT, STDERR, STDIN, child_socket])
+          .reject(&:closed?)
+          .each(&:close)
+
         ENV['RAILS_ENV'] = ENV['RACK_ENV'] = app_env
+
         ProcessTitleUpdater.run { |distance|
           "spring app    | #{spring_env.app_name} | started #{distance} ago | #{app_env} mode"
         }
+
         Application.new(child_socket).start
       }
       child_socket.close

data/lib/spring/client.rb

@@ -3,31 +3,33 @@ require "spring/client/command"
 require "spring/client/run"
 require "spring/client/help"
 require "spring/client/binstub"
+require "spring/client/start"
 require "spring/client/stop"
 require "spring/client/status"
+require "spring/client/rails"
 
 module Spring
   module Client
     COMMANDS = {
       "help"    => Client::Help,
       "binstub" => Client::Binstub,
+      "start"   => Client::Start,
       "stop"    => Client::Stop,
-      "status"  => Client::Status
+      "status"  => Client::Status,
+      "rails"   => Client::Rails
     }
 
     def self.run(args)
       command_for(args.first).call(args)
+    rescue CommandNotFound
+      Client::Help.call(args)
     rescue ClientError => e
-      STDERR.puts e.message
+      $stderr.puts e.message
       exit 1
     end
 
     def self.command_for(name)
-      if Spring.command?(name)
-        Client::Run
-      else
-        COMMANDS.fetch(name) { Client::Help }
-      end
+      COMMANDS[name] || Client::Run
     end
   end
 end

data/lib/spring/client/binstub.rb

@@ -7,6 +7,11 @@ module Spring
         "Generate spring based binstubs."
       end
 
+      def self.call(args)
+        require "spring/commands"
+        super
+      end
+
       def initialize(args)
         super
 
@@ -15,12 +20,12 @@ module Spring
       end
 
       def call
-        if Spring.command?(name)
+        if Spring.command?(name) || name == "rails"
           bindir.mkdir unless bindir.exist?
           generate_spring_binstub
           generate_command_binstub
         else
-          STDERR.puts "The '#{name}' command is not known to spring."
+          $stderr.puts "The '#{name}' command is not known to spring."
           exit 1
         end
       end
@@ -50,7 +55,7 @@ if spec
   spec.activate
   load spec.bin_file("spring")
 else
-  STDERR.puts "Could not find spring gem in #{Gem::Specification.dirs.join(", ")}."
+  $stderr.puts "Could not find spring gem in #{Gem::Specification.dirs.join(", ")}."
   exit 1
 end
 CODE