spring 0.0.6 → 0.0.7

data/lib/spring/commands.rb

@@ -1,5 +1,3 @@
-require 'active_support/core_ext/class/attribute'
-
 module Spring
   @commands = {}
 
@@ -25,8 +23,19 @@ module Spring
 
   module Commands
     class Command
-      class_attribute :preloads
-      self.preloads = []
+      @preloads = []
+
+      def self.preloads
+        @preloads ||= superclass.preloads.dup
+      end
+
+      def self.preloads=(val)
+        @preloads = val
+      end
+
+      def preloads
+        self.class.preloads
+      end
 
       def setup
         preload_files
@@ -50,7 +59,7 @@ MESSAGE
     end
 
     class Test < Command
-      self.preloads += %w(test_helper)
+      preloads << "test_helper"
 
       def env
         "test"
@@ -75,11 +84,15 @@ MESSAGE
           $stderr.puts "you need to specify what test to run: spring test TEST_NAME"
         end
       end
+
+      def description
+        "Execute a Test::Unit test."
+      end
     end
     Spring.register_command "test", Test.new
 
     class RSpec < Command
-      self.preloads += %w(spec_helper)
+      preloads << "spec_helper"
 
       def env
         "test"
@@ -95,6 +108,10 @@ MESSAGE
         $0 = "rspec"
         ::RSpec::Core::Runner.run(args)
       end
+
+      def description
+        "Execute an RSpec spec."
+      end
     end
     Spring.register_command "rspec", RSpec.new
 
@@ -111,6 +128,10 @@ MESSAGE
       def call(args)
         ::Cucumber::Cli::Main.execute(args)
       end
+
+      def description
+        "Execute a Cucumber feature."
+      end
     end
     Spring.register_command "cucumber", Cucumber.new
 
@@ -124,19 +145,27 @@ MESSAGE
         ARGV.replace args
         ::Rake.application.run
       end
+
+      def description
+        "Run a rake task."
+      end
     end
     Spring.register_command "rake", Rake.new
 
 
     class Console < Command
-      def call(args)
-        # This cannot be preloaded as it messes up the IRB prompt on OS X
-        # for unknown reasons. See discussion in issue #34.
+      def setup
         require "rails/commands/console"
+      end
 
+      def call(args)
         ARGV.replace args
         ::Rails::Console.start(::Rails.application)
       end
+
+      def description
+        "Start the Rails console."
+      end
     end
     Spring.register_command "console", Console.new, alias: "c"
 
@@ -150,6 +179,10 @@ MESSAGE
         ARGV.replace args
         require "rails/commands/generate"
       end
+
+      def description
+        "Trigger a Rails generator."
+      end
     end
     Spring.register_command "generate", Generate.new, alias: "g"
 
@@ -159,6 +192,10 @@ MESSAGE
         ARGV.replace args
         require "rails/commands/runner"
       end
+
+      def description
+        "Execute a command with the Rails runner."
+      end
     end
     Spring.register_command "runner", Runner.new, alias: "r"
   end
@@ -167,5 +204,4 @@ MESSAGE
   # needs to be at the end to allow modification of existing commands.
   config = File.expand_path("./config/spring.rb")
   require config if File.exist?(config)
-
 end

data/lib/spring/configuration.rb

@@ -4,6 +4,14 @@ module Spring
   class << self
     attr_accessor :application_root
 
+    def after_fork_callbacks
+      @after_fork_callbacks ||= []
+    end
+
+    def after_fork(&block)
+      after_fork_callbacks << block
+    end
+
     def verify_environment!
       application_root_path
     end

data/lib/spring/env.rb

@@ -25,7 +25,7 @@ module Spring
     end
 
     def socket_path
-      tmp_path.join(SID.sid.to_s)
+      tmp_path.join("spring")
     end
 
     def socket_name
@@ -33,11 +33,14 @@ module Spring
     end
 
     def pidfile_path
-      tmp_path.join("#{SID.sid}.pid")
+      tmp_path.join("spring.pid")
     end
 
     def pid
       pidfile_path.exist? ? pidfile_path.read.to_i : nil
+    rescue Errno::ENOENT
+      # This can happen if the pidfile is removed after we check it
+      # exists
     end
 
     def app_name

data/lib/spring/process_title_updater.rb

@@ -0,0 +1,65 @@
+module Spring
+  # Yes, I know this reimplements a bunch of stuff in Active Support, but
+  # I don't want the spring client to depend on AS, in order to keep its
+  # load time down.
+  class ProcessTitleUpdater
+    SECOND = 1
+    MINUTE = 60
+    HOUR   = 60*60
+
+    def self.run(&block)
+      updater = new(&block)
+
+      Thread.new {
+        $0 = updater.value
+        loop { $0 = updater.next }
+      }
+    end
+
+    attr_reader :block
+
+    def initialize(start = Time.now, &block)
+      @start = start
+      @block = block
+    end
+
+    def interval
+      distance = Time.now - @start
+
+      if distance < MINUTE
+        SECOND
+      elsif distance < HOUR
+        MINUTE
+      else
+        HOUR
+      end
+    end
+
+    def next
+      sleep interval
+      value
+    end
+
+    def value
+      block.call(distance_in_words)
+    end
+
+    def distance_in_words(now = Time.now)
+      distance = now - @start
+
+      if distance < MINUTE
+        pluralize(distance, "sec")
+      elsif distance < HOUR
+        pluralize(distance / MINUTE, "min")
+      else
+        pluralize(distance / HOUR, "hour")
+      end
+    end
+
+    private
+
+    def pluralize(amount, unit)
+      "#{amount.to_i} #{amount.to_i == 1 ? unit : "#{unit}s"}"
+    end
+  end
+end

data/lib/spring/server.rb

@@ -2,6 +2,11 @@ require "socket"
 
 require "spring/env"
 require "spring/application_manager"
+require "spring/process_title_updater"
+
+# readline must be required before we setpgid, otherwise the require may hang,
+# if readline has been built against libedit. See issue #70.
+require "readline"
 
 module Spring
   class Server
@@ -18,14 +23,19 @@ 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_exit_hook
       write_pidfile
-
-      $0 = "spring server | #{env.app_name} | started #{Time.now}"
+      redirect_output
+      set_process_title
 
       server = UNIXServer.open(env.socket_name)
       loop { serve server.accept }
@@ -62,9 +72,30 @@ module Spring
         @pidfile.write("#{Process.pid}\n")
         @pidfile.fsync
       else
-        STDERR.puts "#{file.path} is locked; it looks like a server is already running"
+        $stderr.puts "#{@pidfile.path} is locked; it looks like a server is already running"
         exit 1
       end
     end
+
+    # We can't leave STDOUT, STDERR as they as because then they will
+    # never get closed for the lifetime of the server. This means that
+    # piping, e.g. "spring rake -T | grep db" won't work correctly
+    # because grep will hang while waiting for its stdin to reach EOF.
+    #
+    # However we do want server output to go to the terminal in case
+    # there are exceptions etc, so we just open the current terminal
+    # device directly.
+    def redirect_output
+      # ruby doesn't expose ttyname()
+      file = open(STDIN.tty? ? `tty`.chomp : "/dev/null", "a")
+      STDOUT.reopen(file)
+      STDERR.reopen(file)
+    end
+
+    def set_process_title
+      ProcessTitleUpdater.run { |distance|
+        "spring server | #{env.app_name} | started #{distance} ago"
+      }
+    end
   end
 end

data/lib/spring/sid.rb

@@ -1,15 +1,38 @@
-require 'fiddle'
+begin
+  # If rubygems is present, keep it out of the way when loading fiddle,
+  # otherwise if fiddle is not installed then rubygems will load all
+  # gemspecs in its (futile) search for fiddle, which is slow.
+  if respond_to?(:gem_original_require, true)
+    gem_original_require 'fiddle'
+  else
+    require 'fiddle'
+  end
+rescue LoadError
+end
 
 module Spring
   module SID
-    FUNC = Fiddle::Function.new(
-      DL::Handle::DEFAULT['getsid'],
-      [Fiddle::TYPE_INT],
-      Fiddle::TYPE_INT
-    )
+    def self.fiddle_func
+      @fiddle_func ||= Fiddle::Function.new(
+        DL::Handle::DEFAULT['getsid'],
+        [Fiddle::TYPE_INT],
+        Fiddle::TYPE_INT
+      )
+    end
 
-    def self.sid(pid = 0)
-      FUNC.call(pid)
+    def self.sid
+      @sid ||= begin
+        if Process.respond_to?(:getsid)
+          # Ruby 2
+          Process.getsid
+        elsif defined?(Fiddle)
+          # Ruby 1.9.3 compiled with libffi support
+          fiddle_func.call(0)
+        else
+          # last resort: shell out
+          `ps -p #{Process.pid} -o sess=`.to_i
+        end
+      end
     end
 
     def self.pgid

data/lib/spring/version.rb

@@ -1,3 +1,3 @@
 module Spring
-  VERSION = "0.0.6"
+  VERSION = "0.0.7"
 end

data/test/acceptance/app_test.rb

@@ -3,26 +3,23 @@ require 'io/wait'
 require "timeout"
 require "spring/sid"
 require "spring/env"
+require "pty"
 
 class AppTest < ActiveSupport::TestCase
   def app_root
     Pathname.new("#{TEST_ROOT}/apps/rails-3-2")
   end
 
-  def server_pidfile
-    "#{app_root}/tmp/spring/#{Spring::SID.sid}.pid"
+  def gem_home
+    app_root.join "vendor/gems/#{RUBY_VERSION}"
   end
 
-  def spring_env
-    @spring_env ||= Spring::Env.new(app_root)
-  end
-
-  def server_pid
-    spring_env.pid
+  def spring
+    gem_home.join "bin/spring"
   end
 
-  def server_running?
-    spring_env.server_running?
+  def spring_env
+    @spring_env ||= Spring::Env.new(app_root)
   end
 
   def stdout
@@ -38,90 +35,83 @@ class AppTest < ActiveSupport::TestCase
 
     Bundler.with_clean_env do
       Process.spawn(
-        {
-          "GEM_HOME" => "#{app_root}/vendor/gems",
-          "GEM_PATH" => "",
-          "PATH"     => "#{app_root}/vendor/gems/bin:#{ENV["PATH"]}"
-        },
-        command,
+        { "GEM_HOME" => gem_home.to_s, "GEM_PATH" => "" },
+        command.to_s,
         out:   stdout.last,
         err:   stderr.last,
+        in:    :close,
         chdir: app_root.to_s,
       )
     end
 
     _, status = Timeout.timeout(opts.fetch(:timeout, 5)) { Process.wait2 }
 
-    out, err = read_streams
+    stdout, stderr = read_streams
+    puts dump_streams(stdout, stderr) if ENV["SPRING_DEBUG"]
 
     @times << (Time.now - start_time) if @times
 
-    print_streams(out, err) if ENV["SPRING_DEBUG"]
-
-    [status, out, err]
-  rescue Timeout::Error
-    print_streams *read_streams
-    raise
+    {
+      status: status,
+      stdout: stdout,
+      stderr: stderr,
+    }
+  rescue Timeout::Error => e
+    raise e, "Output:\n\n#{dump_streams(*read_streams)}"
   end
 
-  def print_streams(out, err)
-    puts "---"
-    puts out
-    puts "***"
-    puts err
-    puts "---"
+  def read_streams
+    [stdout, stderr].map(&:first).map do |stream|
+      output = ""
+      output << stream.readpartial(10240) while IO.select([stream], [], [], 0.1)
+      output
+    end
   end
 
-  def read_streams
-    [stdout, stderr].map(&:first).map { |s| s.ready? ? s.readpartial(10240) : "" }
+  def dump_streams(stdout, stderr)
+    output = "--- stdout ---\n"
+    output << "#{stdout.chomp}\n"
+    output << "--- stderr ---\n"
+    output << "#{stderr.chomp}\n"
+    output << "\n"
+    output
   end
 
   def await_reload
     sleep 0.4
   end
 
-  def assert_successful_run(*args)
-    status, _, _ = app_run(*args)
-    assert status.success?, "The run should be successful but it wasn't"
-  end
-
-  def assert_unsuccessful_run(*args)
-    status, _, _ = app_run(*args)
-    assert !status.success?, "The run should not be successful but it was"
-  end
-
-  def assert_stdout(command, expected)
-    _, stdout, _ = app_run(command)
-    assert stdout.include?(expected), "expected '#{expected}' to be printed to stdout. But it wasn't, the stdout is:\n#{stdout}"
+  def assert_output(artifacts, expected)
+    expected.each do |stream, output|
+      assert artifacts[stream].include?(output),
+             "expected #{stream} to include '#{output}', but it was:\n\n#{artifacts[stream]}"
+    end
   end
 
-  def assert_stderr(command, expected)
-    _, _, stderr = app_run(command)
-    assert stderr.include?(expected), "expected '#{expected}' to be printed to stderr. But it wasn't, the stderr is:\n#{stderr}"
+  def assert_success(command, expected_output = nil)
+    artifacts = app_run(command)
+    assert artifacts[:status].success?, "expected successful exit status"
+    assert_output artifacts, expected_output if expected_output
   end
 
-  def assert_speedup(opts = {})
-    ratio  = opts.fetch(:ratio, 0.5)
-    from   = opts.fetch(:from, 0)
-    first  = @times[from]
-    second = @times[from + 1]
-
-    assert (second / first) < ratio, "#{second} was not less than #{ratio} of #{first}"
+  def assert_failure(command, expected_output = nil)
+    artifacts = app_run(command)
+    assert !artifacts[:status].success?, "expected unsuccessful exit status"
+    assert_output artifacts, expected_output if expected_output
   end
 
-  def assert_server_running(*args)
-    assert server_running?, "The server should be running but it isn't"
-  end
-
-  def assert_server_not_running(*args)
-    assert !server_running?, "The server should not be running but it is"
+  def assert_speedup(ratio = 0.6)
+    @times = []
+    yield
+    assert (@times.last / @times.first) < ratio, "#{@times.last} was not less than #{ratio} of #{@times.first}"
+    @times = nil
   end
 
-  def test_command
-    "spring test #{@test}"
+  def spring_test_command
+    "#{spring} test #{@test}"
   end
 
-  @@installed_spring = false
+  @@installed = false
 
   setup do
     @test                = "#{app_root}/test/functional/posts_controller_test.rb"
@@ -129,59 +119,51 @@ class AppTest < ActiveSupport::TestCase
     @controller          = "#{app_root}/app/controllers/posts_controller.rb"
     @controller_contents = File.read(@controller)
 
-    @spring_env          = Spring::Env.new(app_root)
-
-    unless @@installed_spring
+    unless @@installed
+      FileUtils.mkdir_p(gem_home)
       system "gem build spring.gemspec 2>/dev/null 1>/dev/null"
-      app_run "gem install ../../../spring-*.gem"
-      @@installed_spring = true
+      app_run "gem install ../../../spring-#{Spring::VERSION}.gem"
+      app_run "(gem list bundler | grep bundler) || gem install bundler #{'--pre' if RUBY_VERSION >= "2.0"}", timeout: nil
+      app_run "bundle check || bundle update", timeout: nil
+      app_run "bundle exec rake db:migrate db:test:clone"
+      @@installed = true
     end
 
     FileUtils.rm_rf "#{app_root}/bin"
-    app_run "(gem list bundler | grep bundler) || gem install bundler", timeout: nil
-    app_run "bundle check || bundle update", timeout: nil
-    app_run "bundle exec rake db:migrate"
-
-    @times = []
   end
 
   teardown do
-    if pid = server_pid
-      Process.kill('TERM', pid)
-    end
-
+    app_run "#{spring} stop"
     File.write(@test,       @test_contents)
     File.write(@controller, @controller_contents)
   end
 
   test "basic" do
-    assert_successful_run test_command
-    assert File.exist?(server_pidfile)
-
-    assert_successful_run test_command
-    assert_speedup
+    assert_speedup do
+      2.times { app_run spring_test_command }
+    end
   end
 
   test "help message when called without arguments" do
-    assert_stdout "spring", 'Usage: spring COMMAND [ARGS]'
+    assert_success spring, stdout: 'Usage: spring COMMAND [ARGS]'
   end
 
   test "test changes are picked up" do
-    assert_successful_run test_command
-
-    File.write(@test, @test_contents.sub("get :index", "raise 'omg'"))
-    assert_stdout test_command, "RuntimeError: omg"
+    assert_speedup do
+      assert_success spring_test_command, stdout: "0 failures"
 
-    assert_speedup
+      File.write(@test, @test_contents.sub("get :index", "raise 'omg'"))
+      assert_failure spring_test_command, stdout: "RuntimeError: omg"
+    end
   end
 
   test "code changes are picked up" do
-    assert_successful_run test_command
+    assert_speedup do
+      assert_success spring_test_command, stdout: "0 failures"
 
-    File.write(@controller, @controller_contents.sub("@posts = Post.all", "raise 'omg'"))
-    assert_stdout test_command, "RuntimeError: omg"
-
-    assert_speedup
+      File.write(@controller, @controller_contents.sub("@posts = Post.all", "raise 'omg'"))
+      assert_failure spring_test_command, stdout: "RuntimeError: omg"
+    end
   end
 
   test "code changes in pre-referenced app files are picked up" do
@@ -189,12 +171,12 @@ class AppTest < ActiveSupport::TestCase
       initializer = "#{app_root}/config/initializers/load_posts_controller.rb"
       File.write(initializer, "PostsController\n")
 
-      assert_successful_run test_command
-
-      File.write(@controller, @controller_contents.sub("@posts = Post.all", "raise 'omg'"))
-      assert_stdout test_command, "RuntimeError: omg"
+      assert_speedup do
+        assert_success spring_test_command, stdout: "0 failures"
 
-      assert_speedup
+        File.write(@controller, @controller_contents.sub("@posts = Post.all", "raise 'omg'"))
+        assert_failure spring_test_command, stdout: "RuntimeError: omg"
+      end
     ensure
       FileUtils.rm_f(initializer)
     end
@@ -205,7 +187,7 @@ class AppTest < ActiveSupport::TestCase
       application = "#{app_root}/config/application.rb"
       application_contents = File.read(application)
 
-      assert_successful_run test_command
+      assert_success spring_test_command
 
       File.write(application, application_contents + <<-CODE)
         class Foo
@@ -218,10 +200,9 @@ class AppTest < ActiveSupport::TestCase
 
       await_reload
 
-      assert_stdout test_command, "RuntimeError: omg"
-      assert_stdout test_command, "RuntimeError: omg"
-
-      assert_speedup from: 1
+      assert_speedup do
+        2.times { assert_failure spring_test_command, stdout: "RuntimeError: omg" }
+      end
     ensure
       File.write(application, application_contents)
     end
@@ -232,50 +213,72 @@ class AppTest < ActiveSupport::TestCase
       application = "#{app_root}/config/application.rb"
       application_contents = File.read(application)
 
-      assert_successful_run test_command
+      assert_success spring_test_command
 
       File.write(application, application_contents + "\nomg")
       await_reload
 
-      assert_unsuccessful_run test_command
+      assert_failure spring_test_command
 
       File.write(application, application_contents)
       await_reload
 
-      assert_successful_run test_command
+      assert_success spring_test_command
     ensure
       File.write(application, application_contents)
     end
   end
 
   test "stop command kills server" do
-    assert_successful_run test_command
-    assert_server_running
+    app_run spring_test_command
+    assert spring_env.server_running?, "The server should be running but it isn't"
 
-    assert_successful_run 'spring stop'
-    assert_server_not_running
+    assert_success "#{spring} stop"
+    assert !spring_env.server_running?, "The server should not be running but it is"
   end
 
   test "custom commands" do
-    assert_stdout "spring custom", "omg"
+    assert_success "#{spring} custom", stdout: "omg"
   end
 
   test "runner alias" do
-    assert_stdout "spring r 'puts 1'", "1"
+    assert_success "#{spring} r 'puts 1'", stdout: "1"
   end
 
   test "binstubs" do
-    app_run "spring binstub rake"
-    assert_successful_run "bin/spring help"
-    assert_stdout "bin/rake -T", "rake db:migrate"
+    app_run "#{spring} binstub rake"
+    assert_success "bin/spring help"
+    assert_success "bin/rake -T", stdout: "rake db:migrate"
+  end
+
+  test "after fork callback" do
+    begin
+      config_path = "#{app_root}/config/spring.rb"
+      config_contents = File.read(config_path)
+
+      File.write(config_path, config_contents + "\nSpring.after_fork { puts '!callback!' }")
+      assert_success "#{spring} r 'puts 2'", stdout: "!callback!\n2"
+    ensure
+      File.write(config_path, config_contents)
+    end
   end
 
   test "missing config/application.rb" do
     begin
       FileUtils.mv app_root.join("config/application.rb"), app_root.join("config/application.rb.bak")
-      assert_stderr "spring rake -T", "unable to find your config/application.rb"
+      assert_failure "#{spring} rake -T", stderr: "unable to find your config/application.rb"
     ensure
       FileUtils.mv app_root.join("config/application.rb.bak"), app_root.join("config/application.rb")
     end
   end
+
+  test "piping" do
+    assert_success "#{spring} rake -T | grep db", stdout: "rake db:migrate"
+  end
+
+  test "status" do
+    assert_success "#{spring} status", stdout: "Spring is not running"
+    app_run "#{spring} runner ''"
+    assert_success "#{spring} status", stdout: "Spring is running"
+  end
 end