spring 0.0.10 → 0.0.11

data/lib/spring/client/status.rb

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

data/lib/spring/commands.rb

@@ -31,6 +31,9 @@ module Spring
 
   # Load custom commands, if any.
   # needs to be at the end to allow modification of existing commands.
+  config = File.expand_path("~/.spring.rb")
+  require config if File.exist?(config)
+
   config = File.expand_path("./config/spring.rb")
   require config if File.exist?(config)
 end

data/lib/spring/commands/rails.rb

@@ -28,6 +28,12 @@ module Spring
       end
     end
 
+    class RailsDestroy < Rails
+      def command_name
+        "destroy"
+      end
+    end
+
     class RailsRunner < Rails
       def env(tail)
         previous_option = nil
@@ -48,6 +54,7 @@ module Spring
 
     Spring.register_command "rails_console",  RailsConsole.new
     Spring.register_command "rails_generate", RailsGenerate.new
+    Spring.register_command "rails_destroy",  RailsDestroy.new
     Spring.register_command "rails_runner",   RailsRunner.new
   end
 end

data/lib/spring/configuration.rb

@@ -16,7 +16,7 @@ module Spring
       after_fork_callbacks << block
     end
 
-    def verify_environment!
+    def verify_environment
       application_root_path
     end
 

data/lib/spring/env.rb

@@ -8,10 +8,11 @@ module Spring
   IGNORE_SIGNALS = %w(INT QUIT)
 
   class Env
-    attr_reader :root
+    attr_reader :root, :log_file
 
     def initialize(root = nil)
-      @root = root || Pathname.new(File.expand_path('.'))
+      @root     = root || Pathname.new(File.expand_path('.'))
+      @log_file = File.open(ENV["SPRING_LOG"] || "/dev/null", "a")
     end
 
     def version
@@ -63,6 +64,11 @@ module Spring
       [Bundler.default_lockfile, Bundler.default_gemfile].select(&:exist?).map(&:mtime).max
     end
 
+    def log(message)
+      log_file.puts "[#{Time.now}] #{message}"
+      log_file.flush
+    end
+
     private
 
     def default_tmp_path

data/lib/spring/errors.rb

@@ -1,7 +1,7 @@
 module Spring
   class ClientError < StandardError; end
 
-  class UnknownProject < ClientError
+  class UnknownProject < StandardError
     attr_reader :current_dir
 
     def initialize(current_dir)
@@ -15,6 +15,20 @@ module Spring
     end
   end
 
+  class TmpUnwritable < StandardError
+    attr_reader :tmp_path
+
+    def initialize(tmp_path)
+      @tmp_path = tmp_path
+    end
+
+    def message
+      "Spring is unable to create a socket file at #{tmp_path}. You may need to " \
+        "set the SPRING_TMP_PATH environment variable to use a different path. See " \
+        "the documentation for details."
+    end
+  end
+
   class MissingApplication < ClientError
     attr_reader :project_root
 

data/lib/spring/server.rb

@@ -1,6 +1,7 @@
 require "socket"
 require "thread"
 
+require "spring/configuration"
 require "spring/env"
 require "spring/application_manager"
 require "spring/process_title_updater"
@@ -28,20 +29,33 @@ module Spring
       @mutex        = Mutex.new
     end
 
+    def log(message)
+      env.log "[server] #{message}"
+    end
+
     def boot
+      Spring.verify_environment
+
       write_pidfile
       set_pgid
       ignore_signals
       set_exit_hook
-      redirect_output
       set_process_title
       watch_bundle
+      start_server
+    end
 
+    def start_server
       server = UNIXServer.open(env.socket_name)
+      log "started on #{env.socket_name}"
+    rescue Errno::EPERM
+      raise TmpUnwritable.new(env.tmp_path)
+    else
       loop { serve server.accept }
     end
 
     def serve(client)
+      log "accepted client"
       client.puts env.version
 
       app_client = client.recv_io
@@ -50,13 +64,17 @@ module Spring
       args, default_rails_env = command.values_at('args', 'default_rails_env')
 
       if Spring.command?(args.first)
+        log "running command #{args.first}"
         client.puts
         client.puts @applications[rails_env_for(args, default_rails_env)].run(app_client)
       else
+        log "command not found #{args.first}"
         client.close
       end
     rescue SocketError => e
       raise e unless client.eof?
+    ensure
+      redirect_output
     end
 
     def rails_env_for(args, default_rails_env)
@@ -93,7 +111,9 @@ module Spring
       @applications.values.each(&:stop)
 
       [env.socket_path, env.pidfile_path].each do |path|
-        path.unlink if path.exist?
+        if path.exist?
+          path.unlink rescue nil
+        end
       end
     end
 
@@ -107,19 +127,12 @@ module Spring
       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.
+    # We need to redirect STDOUT and STDERR, otherwise the server will
+    # keep the original FDs open which would break piping. (e.g.
+    # `spring rake -T | grep db` would hang forever because the server
+    # would keep the stdout FD open.)
     def redirect_output
-      # ruby doesn't expose ttyname()
-      file = open(STDIN.tty? ? `tty`.chomp : "/dev/null", "a")
-      STDOUT.reopen(file)
-      STDERR.reopen(file)
+      [STDOUT, STDERR].each { |stream| stream.reopen(env.log_file) }
     end
 
     def set_process_title

data/lib/spring/version.rb

@@ -1,3 +1,3 @@
 module Spring
-  VERSION = "0.0.10"
+  VERSION = "0.0.11"
 end

data/lib/spring/watcher.rb

@@ -1,4 +1,5 @@
 require "spring/watcher/abstract"
+require "spring/configuration"
 
 module Spring
   class << self

data/lib/spring/watcher/abstract.rb

@@ -38,15 +38,17 @@ module Spring
 
         items = items.select(&:exist?)
 
-        items.each do |item|
-          if item.directory?
-            directories << item.realpath.to_s
-          else
-            files << item.realpath.to_s
+        synchronize {
+          items.each do |item|
+            if item.directory?
+              directories << item.realpath.to_s
+            else
+              files << item.realpath.to_s
+            end
           end
-        end
 
-        subjects_changed
+          subjects_changed
+        }
       end
 
       def stale?

data/lib/spring/watcher/polling.rb

@@ -5,7 +5,7 @@ module Spring
 
       def initialize(root, latency)
         super
-        @mtime  = nil
+        @mtime  = 0
         @poller = nil
       end
 

data/test/acceptance/app_test.rb

@@ -4,22 +4,31 @@ require 'io/wait'
 require "timeout"
 require "spring/sid"
 require "spring/env"
-require "pty"
 
 class AppTest < ActiveSupport::TestCase
-  # Runtimes on the CI tend to be a bit more volatile, so make
-  # the ratio more permissive
-  DEFAULT_SPEEDUP = ENV['CI'] ? 0.8 : 0.6
+  DEFAULT_SPEEDUP = 0.8
   DEFAULT_TIMEOUT = ENV['CI'] ? 30 : 10
 
+  def rails_version
+    ENV['RAILS_VERSION'] || '~> 4.0.0'
+  end
+
+  def rails_3?
+    rails_version.split(" ").last =~ /^3/
+  end
+
   def app_root
-    Pathname.new("#{TEST_ROOT}/apps/rails-3-2")
+    Pathname.new("#{TEST_ROOT}/apps/rails-#{rails_version.scan(/\d/)[0..1].join("-")}")
   end
 
   def gem_home
     app_root.join "vendor/gems/#{RUBY_VERSION}"
   end
 
+  def user_home
+    app_root.join "user_home"
+  end
+
   def spring
     gem_home.join "bin/spring"
   end
@@ -36,8 +45,19 @@ class AppTest < ActiveSupport::TestCase
     @stderr ||= IO.pipe
   end
 
+  def log_file
+    @log_file ||= File.open("/tmp/spring.log", "w+")
+  end
+
   def env
-    @env ||= {"GEM_HOME" => gem_home.to_s, "GEM_PATH" => ""}
+    @env ||= {
+      "GEM_HOME"   => gem_home.to_s,
+      "GEM_PATH"   => "",
+      "HOME"       => user_home.to_s,
+      "RAILS_ENV"  => nil,
+      "RACK_ENV"   => nil,
+      "SPRING_LOG" => log_file.path
+    }
   end
 
   def app_run(command, opts = {})
@@ -56,107 +76,157 @@ class AppTest < ActiveSupport::TestCase
 
     _, status = Timeout.timeout(opts.fetch(:timeout, DEFAULT_TIMEOUT)) { Process.wait2 }
 
-    stdout, stderr = read_streams
-    puts dump_streams(command, stdout, stderr) if ENV["SPRING_DEBUG"]
+    if pid = spring_env.pid
+      @server_pid = pid
+      lines = `ps -A -o ppid= -o pid= | egrep '^\\s*#{@server_pid}'`.lines
+      @application_pids = lines.map { |l| l.split.last.to_i }
+    end
+
+    output = read_streams
+    puts dump_streams(command, output) if ENV["SPRING_DEBUG"]
 
     @times << (Time.now - start_time) if @times
 
-    {
-      status: status,
-      stdout: stdout,
-      stderr: stderr,
-    }
+    output.merge(status: status, command: command)
   rescue Timeout::Error => e
-    raise e, "Output:\n\n#{dump_streams(command, *read_streams)}"
+    raise e, "Output:\n\n#{dump_streams(command, read_streams)}"
   end
 
   def read_streams
-    [stdout, stderr].map(&:first).map do |stream|
-      output = ""
-      output << stream.readpartial(10240) while IO.select([stream], [], [], 0.5)
-      output
+    {
+      stdout: read_stream(stdout.first),
+      stderr: read_stream(stderr.first),
+      log:    read_stream(log_file)
+    }
+  end
+
+  def read_stream(stream)
+    output = ""
+    while IO.select([stream], [], [], 0.5) && !stream.eof?
+      output << stream.readpartial(10240)
     end
+    output
   end
 
-  def dump_streams(command, stdout, stderr)
+  def dump_streams(command, streams)
     output = "$ #{command}\n"
 
-    unless stdout.chomp.empty?
-      output << "--- stdout ---\n"
-      output << "#{stdout.chomp}\n"
-    end
-
-    unless stderr.chomp.empty?
-      output << "--- stderr ---\n"
-      output << "#{stderr.chomp}\n"
+    streams.each do |name, stream|
+      unless stream.chomp.empty?
+        output << "--- #{name} ---\n"
+        output << "#{stream.chomp}\n"
+      end
     end
 
     output << "\n"
     output
   end
 
+  def alive?(pid)
+    Process.kill 0, pid
+    true
+  rescue Errno::ESRCH
+    false
+  end
+
   def await_reload
-    sleep 0.4
+    raise "no pid" if @application_pids.nil? || @application_pids.empty?
+
+    Timeout.timeout(DEFAULT_TIMEOUT) do
+      sleep 0.1 while @application_pids.any? { |p| alive?(p) }
+    end
+  end
+
+  def debug(artifacts)
+    artifacts = artifacts.dup
+    artifacts.delete :status
+    dump_streams(artifacts.delete(:command), artifacts)
   end
 
   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]}"
+             "expected #{stream} to include '#{output}'.\n\n#{debug(artifacts)}"
     end
   end
 
   def assert_success(command, expected_output = nil)
-    artifacts = app_run(command)
-    assert artifacts[:status].success?, "expected successful exit status\n\n#{dump_streams(command, *artifacts.values_at(:stdout, :stderr))}"
+    artifacts = app_run(*Array(command))
+    assert artifacts[:status].success?, "expected successful exit status\n\n#{debug(artifacts)}"
     assert_output artifacts, expected_output if expected_output
   end
 
   def assert_failure(command, expected_output = nil)
-    artifacts = app_run(command)
-    assert !artifacts[:status].success?, "expected unsuccessful exit status\n\n#{dump_streams(command, *artifacts.values_at(:stdout, :stderr))}"
+    artifacts = app_run(*Array(command))
+    assert !artifacts[:status].success?, "expected unsuccessful exit status\n\n#{debug(artifacts)}"
     assert_output artifacts, expected_output if expected_output
   end
 
   def assert_speedup(ratio = DEFAULT_SPEEDUP)
-    @times = []
-    yield
-    assert (@times.last / @times.first) < ratio, "#{@times.last} was not less than #{ratio} of #{@times.first}"
-    @times = nil
+    if ENV['CI']
+      yield
+    else
+      @times = []
+      yield
+      assert (@times.last / @times.first) < ratio, "#{@times.last} was not less than #{ratio} of #{@times.first}"
+      @times = nil
+    end
   end
 
   def spring_test_command
     "#{spring} testunit #{@test}"
   end
 
-  @@installed = false
+  def generate_app
+    Bundler.with_clean_env do
+      assert system("(gem list rails --installed --version '#{rails_version}' || " \
+                      "gem install rails --version '#{rails_version}') > /dev/null")
 
-  setup do
-    @test                = "#{app_root}/test/functional/posts_controller_test.rb"
-    @test_contents       = File.read(@test)
-    @spec                = "#{app_root}/spec/dummy_spec.rb"
-    @spec_contents       = File.read(@spec)
-    @controller          = "#{app_root}/app/controllers/posts_controller.rb"
-    @controller_contents = File.read(@controller)
+      # Have to shell out otherwise bundler prevents us finding the gem
+      version = `ruby -e 'puts Gem::Specification.find_by_name("rails", "#{rails_version}").version'`.chomp
+
+      assert system("rails _#{version}_ new #{app_root} --skip-bundle --skip-javascript --skip-sprockets > /dev/null")
 
-    unless @@installed
       FileUtils.mkdir_p(gem_home)
-      system "gem build spring.gemspec 2>/dev/null 1>/dev/null"
-      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
+      FileUtils.mkdir_p(user_home)
+      FileUtils.rm_rf("#{app_root}/test/performance/")
+    end
+  end
+
+  def install
+    generate_app unless app_root.exist?
+
+    assert system("gem build spring.gemspec 2>/dev/null 1>/dev/null")
+
+    assert_success "gem install ../../../spring-#{Spring::VERSION}.gem"
+    assert_success ["(gem list bundler | grep bundler) || gem install bundler", timeout: nil]
+    assert_success ["bundle check || bundle update", timeout: nil]
+
+    unless File.exist?(@controller)
+      assert_success "bundle exec rails g scaffold post title:string"
     end
 
-    FileUtils.rm_rf "#{app_root}/bin"
+    assert_success "bundle exec rake db:migrate db:test:clone"
+    @@installed = true
+  end
+
+  @@installed = false
+
+  setup do
+    @test       = "#{app_root}/test/#{rails_3? ? 'functional' : 'controllers'}/posts_controller_test.rb"
+    @controller = "#{app_root}/app/controllers/posts_controller.rb"
+
+    install unless @@installed
+
+    @test_contents       = File.read(@test)
+    @controller_contents = File.read(@controller)
   end
 
   teardown do
     app_run "#{spring} stop"
-    File.write(@test,       @test_contents)
-    File.write(@spec,       @spec_contents)
+    File.write(@test, @test_contents)
     File.write(@controller, @controller_contents)
+    FileUtils.rm_f("#{app_root}/config/spring.rb")
   end
 
   test "basic" do
@@ -219,15 +289,13 @@ class AppTest < ActiveSupport::TestCase
     File.write(@test, @test_contents.sub("get :index", "Foo.omg"))
 
     await_reload
-
-    assert_speedup do
-      2.times { assert_failure spring_test_command, stdout: "RuntimeError: omg" }
-    end
+    assert_failure spring_test_command, stdout: "RuntimeError: omg"
   ensure
     File.write(application, application_contents)
   end
 
   test "app gets reloaded when preloaded files change (polling watcher)" do
+    env["RAILS_ENV"] = "test"
     assert_success "#{spring} rails runner 'puts Spring.watcher.class'", stdout: "Polling"
     assert_app_reloaded
   end
@@ -236,18 +304,17 @@ class AppTest < ActiveSupport::TestCase
     begin
       gemfile = app_root.join("Gemfile")
       gemfile_contents = gemfile.read
-      File.write(gemfile, gemfile_contents.sub(%{# gem 'listen'}, %{gem 'listen'}))
+      File.write(gemfile, gemfile_contents + "\ngem 'listen', '~> 1.0'")
 
-      config_path = "#{app_root}/config/spring.rb"
-      config_contents = File.read(config_path)
-      File.write(config_path,config_contents + "\nSpring.watch_method = :listen")
+      File.write("#{app_root}/config/spring.rb", "Spring.watch_method = :listen")
 
-      app_run "bundle install", timeout: nil
+      assert_success ["bundle install", timeout: nil]
 
+      env["RAILS_ENV"] = "test"
       assert_success "#{spring} rails runner 'puts Spring.watcher.class'", stdout: "Listen"
+
       assert_app_reloaded
     ensure
-      File.write(config_path,config_contents)
       File.write(gemfile, gemfile_contents)
       assert_success "bundle check"
     end
@@ -266,8 +333,6 @@ class AppTest < ActiveSupport::TestCase
       assert_failure spring_test_command
 
       File.write(application, application_contents)
-      await_reload
-
       assert_success spring_test_command
     ensure
       File.write(application, application_contents)
@@ -283,32 +348,55 @@ class AppTest < ActiveSupport::TestCase
   end
 
   test "custom commands" do
+    File.write("#{app_root}/config/spring.rb", <<-CODE)
+      class CustomCommand
+        def call
+          puts "omg"
+        end
+      end
+
+      Spring.register_command "custom", CustomCommand.new
+    CODE
+
     assert_success "#{spring} custom", stdout: "omg"
   end
 
   test "binstubs" do
-    app_run "#{spring} binstub rake"
-    app_run "#{spring} binstub rails"
-    assert_success "bin/spring help"
-    assert_success "bin/rake -T", stdout: "rake db:migrate"
-    assert_success "bin/rails runner 'puts %(omg)'", stdout: "omg"
+    begin
+      FileUtils.mv "#{app_root}/bin", "#{app_root}/bin~" if File.exist?("#{app_root}/bin")
+
+      app_run "#{spring} binstub rake"
+      app_run "#{spring} binstub rails"
+      assert_success "bin/spring help"
+      assert_success "bin/rake -T", stdout: "rake db:migrate"
+      assert_success "bin/rails runner 'puts %(omg)'", stdout: "omg"
+      assert_success "bin/rails server --help", stdout: "Usage: rails server"
+    ensure
+      if File.exist?("#{app_root}/bin~")
+        FileUtils.rm_rf "#{app_root}/bin"
+        FileUtils.mv "#{app_root}/bin~", "#{app_root}/bin"
+      end
+    end
   end
 
   test "after fork callback" do
-    begin
-      config_path = "#{app_root}/config/spring.rb"
-      config_contents = File.read(config_path)
+    File.write("#{app_root}/config/spring.rb", "Spring.after_fork { puts '!callback!' }")
+    assert_success "#{spring} rails runner 'puts 2'", stdout: "!callback!\n2"
+  end
 
-      File.write(config_path, config_contents + "\nSpring.after_fork { puts '!callback!' }")
+  test "global config file evaluated" do
+    begin
+      File.write("#{user_home}/.spring.rb", "Spring.after_fork { puts '!callback!' }")
       assert_success "#{spring} rails runner 'puts 2'", stdout: "!callback!\n2"
     ensure
-      File.write(config_path, config_contents)
+      FileUtils.rm_r("#{user_home}/.spring.rb")
     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_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")
@@ -335,24 +423,18 @@ class AppTest < ActiveSupport::TestCase
     assert_success "#{spring} rake -p 'Rails.env'", stdout: "production"
   end
 
-  test "exit code for failing specs" do
-    assert_success "#{spring} rspec"
-    File.write(@spec, @spec_contents.sub("true.should be_true", "false.should be_true"))
-    assert_failure "#{spring} rspec"
-  end
-
   test "changing the Gemfile restarts the server" do
     begin
       gemfile = app_root.join("Gemfile")
       gemfile_contents = gemfile.read
 
-      assert_success %(#{spring} rails runner 'require "rspec"')
+      assert_success %(#{spring} rails runner 'require "sqlite3"')
 
-      File.write(gemfile, gemfile_contents.sub(%{gem 'rspec'}, %{# gem 'rspec'}))
+      File.write(gemfile, gemfile_contents.sub(%{gem 'sqlite3'}, %{# gem 'sqlite3'}))
       app_run "bundle check"
 
       await_reload
-      assert_failure %(#{spring} rails runner 'require "rspec"'), stderr: "cannot load such file -- rspec"
+      assert_failure %(#{spring} rails runner 'require "sqlite3"'), stderr: "sqlite3"
     ensure
       File.write(gemfile, gemfile_contents)
       assert_success "bundle check"