spring 0.0.7 → 0.0.8

data/lib/spring/client/help.rb

@@ -9,11 +9,18 @@ module Spring
         "Print available commands."
       end
 
+      def self.call(args)
+        require "spring/commands"
+        super
+      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
+        @spring_commands      = spring_commands      || Spring::Client::COMMANDS.dup
+        @application_commands = application_commands || Spring.commands.dup
+
+        @application_commands["rails"] = @spring_commands.delete("rails")
       end
 
       def call
@@ -22,41 +29,20 @@ module Spring
 
       def formatted_help
         ["Usage: spring COMMAND [ARGS]\n",
-         *spring_command_help,
+         *command_help("spring itself", spring_commands),
          '',
-         *application_command_help].join("\n")
+         *command_help("your application", application_commands)].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) }]
+      def command_help(subject, commands)
+        ["Commands for #{subject}:\n",
+        *commands.sort_by(&:first).map { |name, command| display(name, command) }.compact]
       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
+        spring_commands.merge application_commands
       end
 
       def description_for_command(command)
@@ -67,12 +53,14 @@ module Spring
         end
       end
 
-      def display_value(command, names)
-        "  #{ Array(names).join(', ').ljust(max_name_width) }  #{ description_for_command(command) }"
+      def display(name, command)
+        if description = description_for_command(command)
+          "  #{name.ljust(max_name_width)}  #{description}"
+        end
       end
 
       def max_name_width
-        @max_name_width ||= all_commands.collect { |_,n| Array(n).join(', ').length }.max
+        @max_name_width ||= all_commands.keys.map(&:length).max
       end
     end
   end

data/lib/spring/client/rails.rb

@@ -0,0 +1,29 @@
+require "set"
+
+module Spring
+  module Client
+    class Rails < Command
+      COMMANDS = Set.new %w(console runner generate)
+
+      ALIASES = {
+        "c" => "console",
+        "r" => "runner",
+        "g" => "generate"
+      }
+
+      def self.description
+        "Run a rails command. The following sub commands will use spring: #{COMMANDS.to_a.join ', '}."
+      end
+
+      def call
+        command_name = ALIASES[args[1]] || args[1]
+
+        if COMMANDS.include?(command_name)
+          Run.call(["rails_#{command_name}", *args.drop(2)])
+        else
+          exec "bundle", "exec", *args
+        end
+      end
+    end
+  end
+end

data/lib/spring/client/run.rb

@@ -1,43 +1,63 @@
 require "rbconfig"
 require "socket"
-
-require "spring/commands"
+require "json"
 
 module Spring
   module Client
     class Run < Command
-      SERVER_COMMAND = [
-        File.join(*RbConfig::CONFIG.values_at('bindir', 'RUBY_INSTALL_NAME')),
-        "-I", File.expand_path("../../..", __FILE__),
-        "-r", "spring/server",
-        "-r", "bundler/setup",
-        "-e", "Spring::Server.boot"
-      ]
+      FORWARDED_SIGNALS = %w(INT QUIT USR1 USR2 INFO) & Signal.list.keys
 
-      FORWARDED_SIGNALS = %w(INT QUIT USR1 USR2 INFO)
+      def server
+        @server ||= UNIXSocket.open(env.socket_name)
+      end
 
       def call
         Spring.verify_environment!
+
         boot_server unless env.server_running?
+        verify_server_version
 
         application, client = UNIXSocket.pair
 
-        server = UNIXSocket.open(env.socket_name)
+        connect_to_application(client)
+        run_command(client, application)
+      rescue Errno::ECONNRESET
+        exit 1
+      ensure
+        server.close if @server
+      end
+
+      def boot_server
+        env.socket_path.unlink if env.socket_path.exist?
+        Process.spawn("spring", "start")
+        sleep 0.1 until env.socket_path.exist?
+      end
+
+      def verify_server_version
+        server_version = server.gets.chomp
+        if server_version != env.version
+          $stderr.puts <<-ERROR
+There is a version mismatch beween the spring client and the server.
+You should restart the server and make sure to use the same version.
+
+CLIENT: #{env.version}, SERVER: #{server_version}
+ERROR
+          exit 1
+        end
+      end
 
-        verify_server_version(server)
+      def connect_to_application(client)
         server.send_io client
-        server.puts rails_env_for(args.first)
+        send_json server, args: args, env: ENV
+        server.gets or raise CommandNotFound
+      end
 
+      def run_command(client, application)
         application.send_io STDOUT
         application.send_io STDERR
         application.send_io STDIN
 
-        application.puts args.length
-
-        args.each do |arg|
-          application.puts  arg.length
-          application.write arg
-        end
+        send_json application, args
 
         pid = server.gets
         pid = pid.chomp if pid
@@ -53,46 +73,30 @@ module Spring
         else
           exit 1
         end
-      rescue Errno::ECONNRESET
-        exit 1
       ensure
-        application.close if application
-        server.close if server
-      end
-
-      def boot_server
-        env.socket_path.unlink if env.socket_path.exist?
-        Process.spawn(*SERVER_COMMAND)
-        sleep 0.1 until env.socket_path.exist?
+        application.close
       end
 
-      def verify_server_version(server)
-        server_version = server.gets.chomp
-        if server_version != env.version
-          STDERR.puts <<-ERROR
-There is a version mismatch beween the spring client and the server.
-You should restart the server and make sure to use the same version.
-
-CLIENT: #{env.version}, SERVER: #{server_version}
-ERROR
-          exit 1
+      def forward_signals(pid)
+        FORWARDED_SIGNALS.each do |sig|
+          trap(sig) { forward_signal sig, pid }
         end
       end
 
-      def rails_env_for(command_name)
-        command = Spring.command(command_name)
-
-        if command.respond_to?(:env)
-          command.env
-        else
-          ENV['RAILS_ENV'] || ENV['RACK_ENV'] || 'development'
-        end
+      def forward_signal(sig, pid)
+        Process.kill(sig, -Process.getpgid(pid))
+      rescue Errno::ESRCH
+        # If the application process is gone, then don't block the
+        # signal on this process.
+        trap(sig, 'DEFAULT')
+        Process.kill(sig, Process.pid)
       end
 
-      def forward_signals(pid)
-        (FORWARDED_SIGNALS & Signal.list.keys).each do |sig|
-          trap(sig) { Process.kill(sig, -Process.getpgid(pid)) }
-        end
+      def send_json(socket, data)
+        data = JSON.dump(data)
+
+        socket.puts  data.length
+        socket.write data
       end
     end
   end

data/lib/spring/client/start.rb

@@ -0,0 +1,17 @@
+module Spring
+  module Client
+    class Start < Command
+      def self.description
+        "Boot the spring server (this happens automatically when you run a command)"
+      end
+
+      def call
+        # Require spring/server before bundler so that it doesn't have to be in
+        # the bundle
+        require "spring/server"
+        require "bundler/setup"
+        Spring::Server.boot
+      end
+    end
+  end
+end

data/lib/spring/client/status.rb

@@ -21,7 +21,7 @@ module Spring
       end
 
       def application_pids
-        candidates = `ps -o ppid= -o pid=`.lines
+        candidates = `ps -a -o ppid= -o pid=`.lines
         candidates.select { |l| l =~ /^#{env.pid} / }
                   .map    { |l| l.split(" ").last   }
       end

data/lib/spring/client/stop.rb

@@ -16,7 +16,7 @@ module Spring
           sleep 0.1 until !env.server_running? || Time.now >= timeout
 
           if env.server_running?
-            STDERR.puts "Spring did not stop; killing forcibly."
+            $stderr.puts "Spring did not stop; killing forcibly."
             kill 'KILL'
           else
             puts "Spring stopped."

data/lib/spring/commands.rb

@@ -1,3 +1,7 @@
+# If the config/spring.rb contains requires for commands from other gems,
+# then we need to be under bundler.
+require "bundler/setup"
+
 module Spring
   @commands = {}
 
@@ -5,12 +9,8 @@ module Spring
     attr_reader :commands
   end
 
-  def self.register_command(name, klass, options = {})
+  def self.register_command(name, klass)
     commands[name] = klass
-
-    if options[:alias]
-      commands[options[:alias]] = klass
-    end
   end
 
   def self.command?(name)
@@ -58,10 +58,10 @@ MESSAGE
       end
     end
 
-    class Test < Command
+    class TestUnit < Command
       preloads << "test_helper"
 
-      def env
+      def env(*)
         "test"
       end
 
@@ -89,19 +89,20 @@ MESSAGE
         "Execute a Test::Unit test."
       end
     end
-    Spring.register_command "test", Test.new
+    Spring.register_command "testunit", TestUnit.new
 
     class RSpec < Command
       preloads << "spec_helper"
 
-      def env
+      def env(*)
         "test"
       end
 
       def setup
         $LOAD_PATH.unshift "spec"
-        super
         require 'rspec/core'
+        ::RSpec::Core::Runner.disable_autorun!
+        super
       end
 
       def call(args)
@@ -116,7 +117,7 @@ MESSAGE
     Spring.register_command "rspec", RSpec.new
 
     class Cucumber < Command
-      def env
+      def env(*)
         "test"
       end
 
@@ -152,8 +153,11 @@ MESSAGE
     end
     Spring.register_command "rake", Rake.new
 
+    class RailsConsole < Command
+      def env(tail)
+        tail.first if tail.first && !tail.first.index("-")
+      end
 
-    class Console < Command
       def setup
         require "rails/commands/console"
       end
@@ -164,12 +168,12 @@ MESSAGE
       end
 
       def description
-        "Start the Rails console."
+        nil
       end
     end
-    Spring.register_command "console", Console.new, alias: "c"
+    Spring.register_command "rails_console", RailsConsole.new
 
-    class Generate < Command
+    class RailsGenerate < Command
       def setup
         super
         Rails.application.load_generators
@@ -181,12 +185,24 @@ MESSAGE
       end
 
       def description
-        "Trigger a Rails generator."
+        nil
       end
     end
-    Spring.register_command "generate", Generate.new, alias: "g"
+    Spring.register_command "rails_generate", RailsGenerate.new
+
+    class RailsRunner < Command
+      def env(tail)
+        previous_option = nil
+        tail.reverse.each do |option|
+          case option
+          when /--environment=(\w+)/ then return $1
+          when '-e' then return previous_option
+          end
+          previous_option = option
+        end
+        nil
+      end
 
-    class Runner < Command
       def call(args)
         Object.const_set(:APP_PATH, Rails.root.join('config/application'))
         ARGV.replace args
@@ -194,10 +210,10 @@ MESSAGE
       end
 
       def description
-        "Execute a command with the Rails runner."
+        nil
       end
     end
-    Spring.register_command "runner", Runner.new, alias: "r"
+    Spring.register_command "rails_runner", RailsRunner.new
   end
 
   # Load custom commands, if any.

data/lib/spring/errors.rb

@@ -30,4 +30,7 @@ module Spring
         "config/spring.rb."
     end
   end
+
+  class CommandNotFound < ClientError
+  end
 end

data/lib/spring/server.rb

@@ -3,6 +3,7 @@ require "socket"
 require "spring/env"
 require "spring/application_manager"
 require "spring/process_title_updater"
+require "spring/commands"
 
 # readline must be required before we setpgid, otherwise the require may hang,
 # if readline has been built against libedit. See issue #70.
@@ -23,15 +24,8 @@ module Spring
     end
 
     def boot
-      # 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).
-      Process.setpgid(0, SID.pgid)
-
-      # Ignore SIGINT and SIGQUIT otherwise the user typing ^C or ^\ on the command line
-      # will kill the server/application.
-      IGNORE_SIGNALS.each { |sig| trap(sig,  "IGNORE") }
-
+      set_pgid
+      ignore_signals
       set_exit_hook
       write_pidfile
       redirect_output
@@ -43,14 +37,44 @@ module Spring
 
     def serve(client)
       client.puts env.version
-      app_client = client.recv_io
-      rails_env  = client.gets.chomp
 
-      client.puts @applications[rails_env].run(app_client)
+      app_client       = client.recv_io
+      command          = JSON.parse(client.read(client.gets.to_i))
+      args, client_env = command.values_at('args', 'env')
+
+      if Spring.command?(args.first)
+        client.puts
+        client.puts @applications[rails_env_for(args, client_env)].run(app_client)
+      else
+        client.close
+      end
     rescue SocketError => e
       raise e unless client.eof?
     end
 
+    def rails_env_for(args, client_env)
+      command = Spring.command(args.first)
+
+      if command.respond_to?(:env)
+        env = command.env(args.drop(1))
+      end
+
+      env || client_env['RAILS_ENV'] || client_env['RACK_ENV'] || 'development'
+    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 set_pgid
+      Process.setpgid(0, SID.pgid)
+    end
+
+    # Ignore SIGINT and SIGQUIT otherwise the user typing ^C or ^\ on the command line
+    # will kill the server/application.
+    def ignore_signals
+      IGNORE_SIGNALS.each { |sig| trap(sig,  "IGNORE") }
+    end
+
     def set_exit_hook
       server_pid = Process.pid