spring 0.0.6 → 0.0.7

data/.travis.yml

@@ -1,3 +1,4 @@
 language: ruby
 rvm:
   - 1.9.3
+  - 2.0.0

data/README.md

@@ -40,7 +40,17 @@ real shell and a terminal running the rails "commands console".
 
 ## Compatibility
 
-At the moment only MRI 1.9.3 / Rails 3.2 is supported.
+Ruby versions supported:
+
+* MRI 1.9.3
+* MRI 2.0.0
+
+Rails versions supported:
+
+* 3.2
+
+Spring makes extensive use of `Process#fork`, so won't be able to run on
+any platform which doesn't support that (Windows, JRuby).
 
 ## Usage
 
@@ -76,9 +86,11 @@ sys	0m0.066s
 That booted our app in the background:
 
 ```
-$ ps ax | grep spring
-26150 pts/3    Sl     0:00 spring server | rails-3-2 | started 2013-02-01 20:16:40 +0000
-26155 pts/3    Sl     0:02 spring app    | rails-3-2 | started 2013-02-01 20:16:40 +0000 | test mode
+$ 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
 ```
 
 We can see two processes, one is the Spring server, the other is the
@@ -147,9 +159,11 @@ automatically. Let's "edit" `config/application.rb`:
 
 ```
 $ touch config/application.rb
-$ ps ax | grep spring
-26150 pts/3    Sl     0:00 spring server | rails-3-2 | started 2013-02-01 20:16:40 +0000
-26556 pts/3    Sl     0:00 spring app    | rails-3-2 | started 2013-02-01 20:20:07 +0000 | test mode
+$ 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
 ```
 
 The application process detected the change and exited. The server process
@@ -178,10 +192,19 @@ We now have 3 processes: the server, and application in test mode and
 the application in development mode.
 
 ```
-$ ps ax | grep spring
-26150 pts/3    Sl     0:00 spring server | rails-3-2 | started 2013-02-01 20:16:40 +0000
-26556 pts/3    Sl     0:08 spring app    | rails-3-2 | started 2013-02-01 20:20:07 +0000 | test mode
-26707 pts/3    Sl     0:00 spring app    | rails-3-2 | started 2013-02-01 20:22:41 +0000 | development mode
+$ bin/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
+```
+
+To stop the background processes:
+
+```
+$ bin/spring stop
+Spring stopped.
 ```
 
 ## Commands
@@ -246,6 +269,41 @@ Spring where your app is located:
 Spring.application_root = './test/dummy'
 ```
 
+### preload files
+
+Every Spring command has the ability to preload a set of files. The
+`test` command for example preloads `test_helper` (it also adds the
+`test/` directory to your load path). If the
+defaults don't work for your application you can configure the
+preloads for every command:
+
+```ruby
+# if your test helper is called "helper"
+Commands::Command::Test.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'
+```
+
+### after fork callbacks
+
+You might want to run code after Spring forked off the process but
+before the actual command is run. You might want to use an
+`after_fork` callback if you have to connect to an external service,
+do some general cleanup or set up dynamic configuration.
+
+```ruby
+Spring.after_fork do
+  # run arbitrary code
+end
+```
+
+If you want to register multiple callbacks you can simply call
+`Spring.after_fork` multiple times with different blocks.
+
 ### tmp directory
 
 Spring needs a tmp directory. This will default to `Rails.root.join('tmp', 'spring')`.

data/Rakefile

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

data/lib/spring/application.rb

@@ -19,9 +19,6 @@ module Spring
       @manager = manager
       @watcher = watcher
       @setup   = Set.new
-
-      @stdout = IO.new(STDOUT.fileno)
-      @stderr = IO.new(STDERR.fileno)
     end
 
     def start
@@ -57,30 +54,39 @@ module Spring
     end
 
     def serve(client)
-      redirect_output(client) do
-        stdin       = 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)
-
-        setup command
-
-        ActionDispatch::Reloader.cleanup!
-        ActionDispatch::Reloader.prepare!
-
-        pid = fork {
-          Process.setsid
-          STDIN.reopen(stdin)
-          IGNORE_SIGNALS.each { |sig| trap(sig, "DEFAULT") }
-          command.call(args)
-        }
-
-        manager.puts pid
-        Process.wait pid
-      end
-    ensure
-      client.puts
+      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)
+
+      setup command
+
+      ActionDispatch::Reloader.cleanup!
+      ActionDispatch::Reloader.prepare!
+
+      pid = fork {
+        Process.setsid
+        [STDOUT, STDERR, STDIN].zip(streams).each { |a, b| a.reopen(b) }
+        IGNORE_SIGNALS.each { |sig| trap(sig, "DEFAULT") }
+        invoke_after_fork_callbacks
+        command.call(args)
+      }
+
+      manager.puts pid
+
+      # Wait in a separate thread so we can run multiple commands at once
+      Thread.new {
+        _, status = Process.wait2 pid
+        streams.each(&:close)
+        client.puts(status.exitstatus)
+        client.close
+      }
+
+    rescue => e
+      streams.each(&:close) if streams
+      client.puts(1)
       client.close
+      raise
     end
 
     # The command might need to require some files in the
@@ -99,14 +105,10 @@ module Spring
       end
     end
 
-    def redirect_output(socket)
-      STDOUT.reopen socket.recv_io
-      STDERR.reopen socket.recv_io
-
-      yield
-    ensure
-      STDOUT.reopen @stdout
-      STDERR.reopen @stderr
+    def invoke_after_fork_callbacks
+      Spring.after_fork_callbacks.each do |callback|
+        callback.call
+      end
     end
   end
 end

data/lib/spring/application_manager.rb

@@ -70,7 +70,9 @@ module Spring
         [STDOUT, STDERR].each { |s| s.reopen('/dev/null', 'w') } if silence
         @client.close if @client
         ENV['RAILS_ENV'] = ENV['RACK_ENV'] = app_env
-        $0 = "spring app    | #{spring_env.app_name} | started #{Time.now} | #{app_env} mode"
+        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

@@ -4,13 +4,15 @@ require "spring/client/run"
 require "spring/client/help"
 require "spring/client/binstub"
 require "spring/client/stop"
+require "spring/client/status"
 
 module Spring
   module Client
     COMMANDS = {
       "help"    => Client::Help,
       "binstub" => Client::Binstub,
-      "stop"    => Client::Stop
+      "stop"    => Client::Stop,
+      "status"  => Client::Status
     }
 
     def self.run(args)

data/lib/spring/client/binstub.rb

@@ -3,6 +3,10 @@ module Spring
     class Binstub < Command
       attr_reader :bindir, :name
 
+      def self.description
+        "Generate spring based binstubs."
+      end
+
       def initialize(args)
         super
 

data/lib/spring/client/help.rb

@@ -3,20 +3,76 @@ require "spring/version"
 module Spring
   module Client
     class Help < Command
+      attr_reader :spring_commands, :application_commands
+
+      def self.description
+        "Print available commands."
+      end
+
+      def initialize(args, spring_commands = nil, application_commands = nil)
+        super args
+
+        @spring_commands      = spring_commands       || Spring::Client::COMMANDS
+        @application_commands = application_commands  || Spring.commands
+      end
+
       def call
-        puts <<-EOT
-Usage: spring COMMAND [ARGS]
-
-The most common spring commands are:
- rake        Run a rake task
- console     Start the Rails console
- runner      Execute a command with the Rails runner
- generate    Trigger a Rails generator
-
- test        Execute a Test::Unit test
- rspec       Execute an RSpec spec
- cucumber    Execute a Cucumber feature
-EOT
+        puts formatted_help
+      end
+
+      def formatted_help
+        ["Usage: spring COMMAND [ARGS]\n",
+         *spring_command_help,
+         '',
+         *application_command_help].join("\n")
+      end
+
+      def spring_command_help
+        ["Commands for spring itself:\n",
+        *client_commands.map { |c,n| display_value(c,n) }]
+      end
+
+      def application_command_help
+        ["Commands for your application:\n",
+        *registered_commands.map { |c,n| display_value(c,n) }]
+      end
+
+      private
+
+      def client_commands
+        spring_commands.invert
+      end
+
+      def registered_commands
+        Hash[unique_commands.collect { |c| [c, command_aliases(c)] }]
+      end
+
+      def all_commands
+        @all_commands ||= client_commands.merge(registered_commands)
+      end
+
+      def unique_commands
+        application_commands.collect { |k,v| v }.uniq
+      end
+
+      def command_aliases(command)
+        spring_commands.merge(application_commands).select { |k,v| v == command }.keys
+      end
+
+      def description_for_command(command)
+        if command.respond_to?(:description)
+          command.description
+        else
+          "No description given."
+        end
+      end
+
+      def display_value(command, names)
+        "  #{ Array(names).join(', ').ljust(max_name_width) }  #{ description_for_command(command) }"
+      end
+
+      def max_name_width
+        @max_name_width ||= all_commands.collect { |_,n| Array(n).join(', ').length }.max
       end
     end
   end

data/lib/spring/client/run.rb

@@ -39,18 +39,19 @@ module Spring
           application.write arg
         end
 
-        pid = server.gets.chomp
+        pid = server.gets
+        pid = pid.chomp if pid
 
         # We must not close the client socket until we are sure that the application has
         # received the FD. Otherwise the FD can end up getting closed while it's in the server
         # socket buffer on OS X. This doesn't happen on Linux.
         client.close
 
-        if pid.empty?
-          exit 1
-        else
+        if pid && !pid.empty?
           forward_signals(pid.to_i)
-          application.read # FIXME: receive exit status from server
+          exit application.read.to_i
+        else
+          exit 1
         end
       rescue Errno::ECONNRESET
         exit 1
@@ -59,12 +60,9 @@ module Spring
         server.close if server
       end
 
-      # Boot the server into the process group of the current session.
-      # This will cause it to be automatically killed once the session
-      # ends (i.e. when the user closes their terminal).
       def boot_server
         env.socket_path.unlink if env.socket_path.exist?
-        Process.spawn(*SERVER_COMMAND, pgroup: SID.pgid)
+        Process.spawn(*SERVER_COMMAND)
         sleep 0.1 until env.socket_path.exist?
       end
 

data/lib/spring/client/status.rb

@@ -0,0 +1,30 @@
+module Spring
+  module Client
+    class Status < Command
+      def self.description
+        "Show current status."
+      end
+
+      def call
+        if env.server_running?
+          puts "Spring is running:"
+          puts
+          print_process env.pid
+          application_pids.each { |pid| print_process pid }
+        else
+          puts "Spring is not running."
+        end
+      end
+
+      def print_process(pid)
+        puts `ps -p #{pid} -o pid= -o args=`
+      end
+
+      def application_pids
+        candidates = `ps -o ppid= -o pid=`.lines
+        candidates.select { |l| l =~ /^#{env.pid} / }
+                  .map    { |l| l.split(" ").last   }
+      end
+    end
+  end
+end

data/lib/spring/client/stop.rb

@@ -3,8 +3,34 @@ require "spring/version"
 module Spring
   module Client
     class Stop < Command
+      TIMEOUT = 2 # seconds
+
+      def self.description
+        "Stop all spring processes for this project."
+      end
+
       def call
-        Process.kill('SIGTERM', env.pid) if env.pid
+        if env.server_running?
+          timeout = Time.now + TIMEOUT
+          kill 'TERM'
+          sleep 0.1 until !env.server_running? || Time.now >= timeout
+
+          if env.server_running?
+            STDERR.puts "Spring did not stop; killing forcibly."
+            kill 'KILL'
+          else
+            puts "Spring stopped."
+          end
+        else
+          puts "Spring is not running"
+        end
+      end
+
+      def kill(sig)
+        pid = env.pid
+        Process.kill(sig, pid) if pid
+      rescue Errno::ESRCH
+        # already dead
       end
     end
   end