spring 1.0.0 → 1.3.0

data/lib/spring/client/binstub.rb

@@ -1,46 +1,164 @@
+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.
+      #
+      # Parsing the lockfile in this way is pretty nasty but reliable enough
+      # The regex ensures that the match must be between a GEM line and an empty
+      # line, so it won't go on to the next section.
+      SPRING = <<'CODE'
+#!/usr/bin/env ruby
+
+# This file loads spring without using Bundler, in order to be fast
+# It gets overwritten when you run the `spring binstub` command
+
+unless defined?(Spring)
+  require "rubygems"
+  require "bundler"
+
+  if match = Bundler.default_lockfile.read.match(/^GEM$.*?^    (?:  )*spring \((.*?)\)$.*?^$/m)
+    ENV["GEM_PATH"] = ([Bundler.bundle_path.to_s] + Gem.path).join(File::PATH_SEPARATOR)
+    ENV["GEM_HOME"] = nil
+    Gem.paths = ENV
+
+    gem "spring", match[1]
+    require "spring/binstub"
+  end
+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 +167,25 @@ 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
+        case @mode
+        when :add
+          bindir.mkdir unless bindir.exist?
 
-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
-
-        bindir.join(name).chmod 0755
-      end
+          File.write(spring_binstub, SPRING)
+          spring_binstub.chmod 0755
 
-      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

data/lib/spring/client/help.rb

@@ -20,6 +20,8 @@ module Spring
         @spring_commands      = spring_commands      || Spring::Client::COMMANDS.dup
         @application_commands = application_commands || Spring.commands.dup
 
+        @spring_commands.delete_if { |k, v| k.start_with?("-") }
+
         @application_commands["rails"] = @spring_commands.delete("rails")
       end
 
@@ -46,19 +48,9 @@ module Spring
         spring_commands.merge application_commands
       end
 
-      def description_for_command(command)
-        if command.respond_to?(:description)
-          command.description
-        elsif command.respond_to?(:exec_name)
-          "Runs the #{command.exec_name} command"
-        else
-          "No description given."
-        end
-      end
-
       def display(name, command)
-        if description = description_for_command(command)
-          "  #{name.ljust(max_name_width)}  #{description}"
+        if command.description
+          "  #{name.ljust(max_name_width)}  #{command.description}"
         end
       end
 

data/lib/spring/client/rails.rb

@@ -24,9 +24,8 @@ module Spring
         else
           require "spring/configuration"
           ARGV.shift
-          Object.const_set(:APP_PATH, Spring.application_root_path.join("config/application").to_s)
-          require Spring.application_root_path.join("config/boot")
-          require "rails/commands"
+          load Dir.glob(Spring.application_root_path.join("{bin,script}/rails")).first
+          exit
         end
       end
     end

data/lib/spring/client/run.rb

@@ -5,6 +5,12 @@ module Spring
   module Client
     class Run < Command
       FORWARDED_SIGNALS = %w(INT QUIT USR1 USR2 INFO) & Signal.list.keys
+      TIMEOUT = 1
+
+      def initialize(args)
+        super
+        @signal_queue = []
+      end
 
       def log(message)
         env.log "[client] #{message}"
@@ -15,26 +21,54 @@ module Spring
       end
 
       def call
-        boot_server unless env.server_running?
+        if env.server_running?
+          warm_run
+        else
+          cold_run
+        end
+      rescue Errno::ECONNRESET
+        exit 1
+      ensure
+        server.close if @server
+      end
+
+      def warm_run
+        run
+      rescue CommandNotFound
+        require "spring/commands"
+
+        if Spring.command?(args.first)
+          # Command installed since spring started
+          stop_server
+          cold_run
+        else
+          raise
+        end
+      end
+
+      def cold_run
+        boot_server
+        run
+      end
+
+      def run
         verify_server_version
 
         application, client = UNIXSocket.pair
 
+        queue_signals
         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?
 
-        pid = fork {
-          require "spring/server"
-          Spring::Server.boot
-        }
+        pid = Process.spawn(
+          "ruby",
+          "-r", "spring/server",
+          "-e", "Spring::Server.boot"
+        )
 
         until env.socket_path.exist?
           _, status = Process.waitpid2(pid, Process::WNOHANG)
@@ -43,6 +77,12 @@ module Spring
         end
       end
 
+      def stop_server
+        server.close
+        @server = nil
+        env.stop
+      end
+
       def verify_server_version
         server_version = server.gets.chomp
         if server_version != env.version
@@ -59,7 +99,12 @@ ERROR
       def connect_to_application(client)
         server.send_io client
         send_json server, "args" => args, "default_rails_env" => default_rails_env
-        server.gets or raise CommandNotFound
+
+        if IO.select([server], [], [], TIMEOUT)
+          server.gets or raise CommandNotFound
+        else
+          raise "Error connecting to Spring server"
+        end
       end
 
       def run_command(client, application)
@@ -96,14 +141,23 @@ ERROR
         application.close
       end
 
+      def queue_signals
+        FORWARDED_SIGNALS.each do |sig|
+          trap(sig) { @signal_queue << sig }
+        end
+      end
+
       def forward_signals(pid)
+        @signal_queue.each { |sig| kill sig, pid }
+
         FORWARDED_SIGNALS.each do |sig|
           trap(sig) { forward_signal sig, pid }
         end
+      rescue Errno::ESRCH
       end
 
       def forward_signal(sig, pid)
-        Process.kill(sig, -Process.getpgid(pid))
+        kill(sig, pid)
       rescue Errno::ESRCH
         # If the application process is gone, then don't block the
         # signal on this process.
@@ -111,6 +165,10 @@ ERROR
         Process.kill(sig, Process.pid)
       end
 
+      def kill(sig, pid)
+        Process.kill(sig, -Process.getpgid(pid))
+      end
+
       def send_json(socket, data)
         data = JSON.dump(data)
 

data/lib/spring/client/status.rb

@@ -17,11 +17,11 @@ module Spring
       end
 
       def print_process(pid)
-        puts `ps -p #{pid} -o pid= -o args=`
+        puts `ps -p #{pid} -o pid= -o command=`
       end
 
       def application_pids
-        candidates = `ps -A -o ppid= -o pid=`.lines
+        candidates = `ps -ax -o ppid= -o pid=`.lines
         candidates.select { |l| l =~ /^(\s+)?#{env.pid} / }
                   .map    { |l| l.split(" ").last   }
       end

data/lib/spring/client/stop.rb

@@ -3,35 +3,20 @@ 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
-        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
+        case env.stop
+        when :stopped
+          puts "Spring stopped."
+        when :killed
+          $stderr.puts "Spring did not stop; killing forcibly."
+        when :not_running
           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
 end

data/lib/spring/client/version.rb

@@ -0,0 +1,11 @@
+require "spring/version"
+
+module Spring
+  module Client
+    class Version < Command
+      def call
+        puts "Spring version #{Spring::VERSION}"
+      end
+    end
+  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/command_wrapper.rb

@@ -0,0 +1,82 @@
+require "spring/configuration"
+
+module Spring
+  class CommandWrapper
+    attr_reader :name, :command
+
+    def initialize(name, command = nil)
+      @name    = name
+      @command = command
+      @setup   = false
+    end
+
+    def description
+      if command.respond_to?(:description)
+        command.description
+      else
+        "Runs the #{name} command"
+      end
+    end
+
+    def setup?
+      @setup
+    end
+
+    def setup
+      if !setup? && command.respond_to?(:setup)
+        command.setup
+        @setup = true
+        return true
+      else
+        @setup = true
+        return false
+      end
+    end
+
+    def call
+      if command.respond_to?(:call)
+        command.call
+      else
+        load exec
+      end
+    end
+
+    def gem_name
+      if command.respond_to?(:gem_name)
+        command.gem_name
+      else
+        exec_name
+      end
+    end
+
+    def exec_name
+      if command.respond_to?(:exec_name)
+        command.exec_name
+      else
+        name
+      end
+    end
+
+    def binstub
+      Spring.application_root_path.join(binstub_name)
+    end
+
+    def binstub_name
+      "bin/#{name}"
+    end
+
+    def exec
+      if binstub.exist?
+        binstub.to_s
+      else
+        Gem.bin_path(gem_name, exec_name)
+      end
+    end
+
+    def env(args)
+      if command.respond_to?(:env)
+        command.env(args)
+      end
+    end
+  end
+end

data/lib/spring/commands/rails.rb

@@ -3,8 +3,7 @@ module Spring
     class Rails
       def call
         ARGV.unshift command_name
-        Object.const_set(:APP_PATH, ::Rails.root.join('config/application'))
-        require "rails/commands"
+        load Dir.glob(::Rails.root.join("{bin,script}/rails")).first
       end
 
       def description
@@ -14,7 +13,19 @@ module Spring
 
     class RailsConsole < Rails
       def env(args)
-        args.first if args.first && !args.first.index("-")
+        return args.first if args.first && !args.first.index("-")
+
+        environment = nil
+
+        args.each.with_index do |arg, i|
+          if arg =~ /--environment=(\w+)/
+            environment = $1
+          elsif i > 0 && args[i - 1] == "-e"
+            environment = arg
+          end
+        end
+
+        environment
       end
 
       def command_name
@@ -35,21 +46,41 @@ module Spring
     end
 
     class RailsRunner < Rails
-      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
+      def call
+        ARGV.replace extract_environment(ARGV).first
+        super
+      end
+
+      def env(args)
+        extract_environment(args).last
       end
 
       def command_name
         "runner"
       end
+
+      def extract_environment(args)
+        environment = nil
+
+        args = args.select.with_index { |arg, i|
+          case arg
+          when "-e"
+            false
+          when /--environment=(\w+)/
+            environment = $1
+            false
+          else
+            if i > 0 && args[i - 1] == "-e"
+              environment = arg
+              false
+            else
+              true
+            end
+          end
+        }
+
+        [args, environment]
+      end
     end
 
     Spring.register_command "rails_console",  RailsConsole.new

data/lib/spring/commands/rake.rb

@@ -23,10 +23,6 @@ module Spring
 
         nil
       end
-
-      def exec_name
-        "rake"
-      end
     end
 
     Spring.register_command "rake", Rake.new