spring 1.0.0 → 1.3.0

data/lib/spring/commands.rb

@@ -1,4 +1,5 @@
 require "spring/watcher"
+require "spring/command_wrapper"
 
 module Spring
   @commands = {}
@@ -7,8 +8,8 @@ module Spring
     attr_reader :commands
   end
 
-  def self.register_command(name, klass)
-    commands[name] = klass
+  def self.register_command(name, command = nil)
+    commands[name] = CommandWrapper.new(name, command)
   end
 
   def self.command?(name)
@@ -31,8 +32,17 @@ module Spring
   # then we need to be under bundler.
   require "bundler/setup"
 
-  Gem::Specification.map(&:name).grep(/^spring-commands-/).each do |command|
-    require command
+  # Auto-require any spring extensions which are in the Gemfile
+  Gem::Specification.map(&:name).grep(/^spring-/).each do |command|
+    begin
+      require command
+    rescue LoadError => error
+      if error.message.include?(command)
+        require command.gsub("-", "/")
+      else
+        raise
+      end
+    end
   end
 
   config = File.expand_path("./config/spring.rb")

data/lib/spring/configuration.rb

@@ -22,15 +22,24 @@ module Spring
 
     def application_root_path
       @application_root_path ||= begin
-        path = Pathname.new(File.expand_path(application_root || find_project_root))
+        if application_root
+          path = Pathname.new(File.expand_path(application_root))
+        else
+          path = project_root_path
+        end
+
         raise MissingApplication.new(path) unless path.join("config/application.rb").exist?
         path
       end
     end
 
+    def project_root_path
+      @project_root_path ||= find_project_root(Pathname.new(File.expand_path(Dir.pwd)))
+    end
+
     private
 
-    def find_project_root(current_dir = Pathname.new(Dir.pwd))
+    def find_project_root(current_dir)
       if current_dir.join(gemfile).exist?
         current_dir
       elsif current_dir.root?

data/lib/spring/env.rb

@@ -9,31 +9,37 @@ require "spring/configuration"
 
 module Spring
   IGNORE_SIGNALS = %w(INT QUIT)
+  STOP_TIMEOUT = 2 # seconds
 
   class Env
     attr_reader :log_file
 
     def initialize(root = nil)
-      @root     = root
-      @log_file = File.open(ENV["SPRING_LOG"] || "/dev/null", "a")
+      @root         = root
+      @project_root = root
+      @log_file     = File.open(ENV["SPRING_LOG"] || File::NULL, "a")
     end
 
     def root
       @root ||= Spring.application_root_path
     end
 
+    def project_root
+      @project_root ||= Spring.project_root_path
+    end
+
     def version
       Spring::VERSION
     end
 
     def tmp_path
-      path = Pathname.new(Dir.tmpdir + "/spring")
+      path = Pathname.new(File.join(ENV['XDG_RUNTIME_DIR'] || Dir.tmpdir, "spring"))
       FileUtils.mkdir_p(path) unless path.exist?
       path
     end
 
     def application_id
-      Digest::MD5.hexdigest(root.to_s)
+      Digest::MD5.hexdigest(RUBY_VERSION + project_root.to_s)
     end
 
     def socket_path
@@ -60,7 +66,7 @@ module Spring
     end
 
     def server_running?
-      pidfile = pidfile_path.open('r')
+      pidfile = pidfile_path.open('r+')
       !pidfile.flock(File::LOCK_EX | File::LOCK_NB)
     rescue Errno::ENOENT
       false
@@ -71,13 +77,33 @@ module Spring
       end
     end
 
-    def bundle_mtime
-      [Bundler.default_lockfile, Bundler.default_gemfile].select(&:exist?).map(&:mtime).max
-    end
-
     def log(message)
-      log_file.puts "[#{Time.now}] #{message}"
+      log_file.puts "[#{Time.now}] [#{Process.pid}] #{message}"
       log_file.flush
     end
+
+    def stop
+      if server_running?
+        timeout = Time.now + STOP_TIMEOUT
+        kill 'TERM'
+        sleep 0.1 until !server_running? || Time.now >= timeout
+
+        if server_running?
+          kill 'KILL'
+          :killed
+        else
+          :stopped
+        end
+      else
+        :not_running
+      end
+    end
+
+    def kill(sig)
+      pid = self.pid
+      Process.kill(sig, pid) if pid
+    rescue Errno::ESRCH
+      # already dead
+    end
   end
 end

data/lib/spring/server.rb

@@ -1,26 +1,13 @@
 module Spring
-  class << self
-    attr_reader :original_env
-  end
-  @original_env = ENV.to_hash
+  ORIGINAL_ENV = ENV.to_hash
 end
 
-require "socket"
-require "thread"
-
-require "spring/configuration"
-require "spring/env"
+require "spring/boot"
 require "spring/application_manager"
-require "spring/process_title_updater"
-require "spring/json"
 
-# Must be last, as it requires bundler/setup
+# Must be last, as it requires bundler/setup, which alters the load path
 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.
-require "readline"
-
 module Spring
   class Server
     def self.boot
@@ -31,7 +18,7 @@ module Spring
 
     def initialize(env = Env.new)
       @env          = env
-      @applications = Hash.new { |h, k| h[k] = ApplicationManager.new(self, k) }
+      @applications = Hash.new { |h, k| h[k] = ApplicationManager.new(k) }
       @pidfile      = env.pidfile_path.open('a')
       @mutex        = Mutex.new
     end
@@ -48,7 +35,6 @@ module Spring
       ignore_signals
       set_exit_hook
       set_process_title
-      watch_bundle
       start_server
     end
 
@@ -82,13 +68,7 @@ module Spring
     end
 
     def rails_env_for(args, default_rails_env)
-      command = Spring.command(args.first)
-
-      if command.respond_to?(:env)
-        env = command.env(args.drop(1))
-      end
-
-      env || default_rails_env
+      Spring.command(args.first).env(args.drop(1)) || default_rails_env
     end
 
     # Boot the server into the process group of the current session.
@@ -101,7 +81,7 @@ module Spring
     # 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") }
+      IGNORE_SIGNALS.each { |sig| trap(sig, "IGNORE") }
     end
 
     def set_exit_hook
@@ -112,13 +92,15 @@ module Spring
     end
 
     def shutdown
-      @applications.values.each(&:stop)
+      log "shutting down"
 
       [env.socket_path, env.pidfile_path].each do |path|
         if path.exist?
           path.unlink rescue nil
         end
       end
+
+      @applications.values.map { |a| Thread.new { a.stop } }.map(&:join)
     end
 
     def write_pidfile
@@ -144,13 +126,5 @@ module Spring
         "spring server | #{env.app_name} | started #{distance} ago"
       }
     end
-
-    def watch_bundle
-      @bundle_mtime = env.bundle_mtime
-    end
-
-    def application_starting
-      @mutex.synchronize { exit if env.bundle_mtime != @bundle_mtime }
-    end
   end
 end

data/lib/spring/sid.rb

@@ -25,7 +25,7 @@ module Spring
         if Process.respond_to?(:getsid)
           # Ruby 2
           Process.getsid
-        elsif defined?(Fiddle)
+        elsif defined?(Fiddle) and defined?(DL)
           # Ruby 1.9.3 compiled with libffi support
           fiddle_func.call(0)
         else

data/lib/spring/test/acceptance_test.rb

@@ -0,0 +1,346 @@
+# encoding: utf-8
+
+require "io/wait"
+require "timeout"
+require "spring/sid"
+require "spring/client"
+
+module Spring
+  module Test
+    class AcceptanceTest < ActiveSupport::TestCase
+      runnables.delete self # prevent Minitest running this class
+
+      DEFAULT_SPEEDUP = 0.8
+
+      def rails_version
+        ENV['RAILS_VERSION'] || '~> 4.2.0'
+      end
+
+      # Extension point for spring-watchers-listen
+      def generator_klass
+        Spring::Test::ApplicationGenerator
+      end
+
+      def generator
+        @@generator ||= generator_klass.new(rails_version)
+      end
+
+      def app
+        @app ||= Spring::Test::Application.new("#{Spring::Test.root}/apps/tmp")
+      end
+
+      def assert_output(artifacts, expected)
+        expected.each do |stream, output|
+          assert artifacts[stream].include?(output),
+                 "expected #{stream} to include '#{output}'.\n\n#{app.debug(artifacts)}"
+        end
+      end
+
+      def assert_success(command, expected_output = nil)
+        artifacts = app.run(*Array(command))
+        assert artifacts[:status].success?, "expected successful exit status\n\n#{app.debug(artifacts)}"
+        assert_output artifacts, expected_output if expected_output
+      end
+
+      def assert_failure(command, expected_output = nil)
+        artifacts = app.run(*Array(command))
+        assert !artifacts[:status].success?, "expected unsuccessful exit status\n\n#{app.debug(artifacts)}"
+        assert_output artifacts, expected_output if expected_output
+      end
+
+      def assert_speedup(ratio = DEFAULT_SPEEDUP)
+        if ENV['CI']
+          yield
+        else
+          app.with_timing do
+            yield
+            assert app.timing_ratio < ratio, "#{app.last_time} was not less than #{ratio} of #{app.first_time}"
+          end
+        end
+      end
+
+      setup do
+        generator.generate_if_missing
+        generator.install_spring
+        generator.copy_to(app.root)
+      end
+
+      teardown do
+        app.stop_spring
+      end
+
+      test "basic" do
+        assert_speedup do
+          2.times { app.run app.spring_test_command }
+        end
+      end
+
+      test "help message when called without arguments" do
+        assert_success "bin/spring", stdout: 'Usage: spring COMMAND [ARGS]'
+      end
+
+      test "test changes are picked up" do
+        assert_speedup do
+          assert_success app.spring_test_command, stdout: "0 failures"
+
+          File.write(app.test, app.test.read.sub("get :index", "raise 'omg'"))
+          assert_failure app.spring_test_command, stdout: "RuntimeError: omg"
+        end
+      end
+
+      test "code changes are picked up" do
+        assert_speedup do
+          assert_success app.spring_test_command, stdout: "0 failures"
+
+          File.write(app.controller, app.controller.read.sub("@posts = Post.all", "raise 'omg'"))
+          assert_failure app.spring_test_command, stdout: "RuntimeError: omg"
+        end
+      end
+
+      test "code changes in pre-referenced app files are picked up" do
+        File.write(app.path("config/initializers/load_posts_controller.rb"), "PostsController\n")
+
+        assert_speedup do
+          assert_success app.spring_test_command, stdout: "0 failures"
+
+          File.write(app.controller, app.controller.read.sub("@posts = Post.all", "raise 'omg'"))
+          assert_failure app.spring_test_command, stdout: "RuntimeError: omg"
+        end
+      end
+
+      test "app gets reloaded when preloaded files change" do
+        assert_success app.spring_test_command
+
+        File.write(app.application_config, app.application_config.read + <<-CODE)
+          class Foo
+            def self.omg
+              raise "omg"
+            end
+          end
+        CODE
+        File.write(app.test, app.test.read.sub("get :index", "Foo.omg"))
+
+        app.await_reload
+        assert_failure app.spring_test_command, stdout: "RuntimeError: omg"
+      end
+
+      test "app gets reloaded even with a ton of boot output" do
+        limit = UNIXSocket.pair.first.getsockopt(:SOCKET, :SNDBUF).int
+
+        assert_success app.spring_test_command
+        File.write(app.path("config/initializers/verbose.rb"), "#{limit}.times { puts 'x' }")
+
+        app.await_reload
+        assert_success app.spring_test_command
+      end
+
+      test "app recovers when a boot-level error is introduced" do
+        config = app.application_config.read
+
+        assert_success app.spring_test_command
+
+        File.write(app.application_config, "#{config}\nomg")
+        app.await_reload
+
+        assert_failure app.spring_test_command
+
+        File.write(app.application_config, config)
+        assert_success app.spring_test_command
+      end
+
+      test "stop command kills server" do
+        app.run app.spring_test_command
+        assert app.spring_env.server_running?, "The server should be running but it isn't"
+
+        assert_success "bin/spring stop"
+        assert !app.spring_env.server_running?, "The server should not be running but it is"
+      end
+
+      test "custom commands" do
+        # Start spring before setting up the command, to test that it gracefully upgrades itself
+        assert_success "bin/rails runner ''"
+
+        File.write(app.spring_config, <<-CODE)
+          class CustomCommand
+            def call
+              puts "omg"
+            end
+
+            def exec_name
+              "rake"
+            end
+          end
+
+          Spring.register_command "custom", CustomCommand.new
+        CODE
+
+        assert_success "bin/spring custom", stdout: "omg"
+
+        assert_success "bin/spring binstub custom"
+        assert_success "bin/custom", stdout: "omg"
+
+        app.env["DISABLE_SPRING"] = "1"
+        assert_success %{bin/custom -e 'puts "foo"'}, stdout: "foo"
+      end
+
+      test "binstub" do
+        assert_success "bin/rails server --help", stdout: "Usage: rails server" # rails command fallback
+
+        assert_success "#{app.spring} binstub rake", stdout: "bin/rake: spring already present"
+
+        assert_success "#{app.spring} binstub --remove rake", stdout: "bin/rake: spring removed"
+        assert !app.path("bin/rake").read.include?(Spring::Client::Binstub::LOADER)
+        assert_success "bin/rake -T", stdout: "rake db:migrate"
+      end
+
+      test "binstub when spring is uninstalled" do
+        app.run! "gem uninstall --ignore-dependencies spring"
+        File.write(app.gemfile, app.gemfile.read.gsub(/gem 'spring.*/, ""))
+        assert_success "bin/rake -T", stdout: "rake db:migrate"
+      end
+
+      test "binstub upgrade" do
+        File.write(app.path("bin/rake"), <<CODE)
+#!/usr/bin/env ruby
+
+if !Process.respond_to?(:fork) || Gem::Specification.find_all_by_name("spring").empty?
+  exec "bundle", "exec", "rake", *ARGV
+else
+  ARGV.unshift "rake"
+  load Gem.bin_path("spring", "spring")
+end
+CODE
+
+        File.write(app.path("bin/rails"), <<CODE)
+#!/usr/bin/env ruby
+
+if !Process.respond_to?(:fork) || Gem::Specification.find_all_by_name("spring").empty?
+  APP_PATH = File.expand_path('../../config/application',  __FILE__)
+  require_relative '../config/boot'
+  require 'rails/commands'
+else
+  ARGV.unshift "rails"
+  load Gem.bin_path("spring", "spring")
+end
+CODE
+
+        assert_success "bin/spring binstub --all", stdout: "upgraded"
+
+        assert_equal app.path("bin/rake").read, <<CODE
+#!/usr/bin/env ruby
+#{Spring::Client::Binstub::LOADER.strip}
+require 'bundler/setup'
+load Gem.bin_path('rake', 'rake')
+CODE
+
+    assert_equal app.path("bin/rails").read, <<CODE
+#!/usr/bin/env ruby
+#{Spring::Client::Binstub::LOADER.strip}
+APP_PATH = File.expand_path('../../config/application',  __FILE__)
+require_relative '../config/boot'
+require 'rails/commands'
+CODE
+      end
+
+      test "after fork callback" do
+        File.write(app.spring_config, "Spring.after_fork { puts '!callback!' }")
+        assert_success "bin/rails runner 'puts 2'", stdout: "!callback!\n2"
+      end
+
+      test "global config file evaluated" do
+        File.write("#{app.user_home}/.spring.rb", "Spring.after_fork { puts '!callback!' }")
+        assert_success "bin/rails runner 'puts 2'", stdout: "!callback!\n2"
+      end
+
+      test "missing config/application.rb" do
+        app.application_config.delete
+        assert_failure "bin/rake -T", stderr: "unable to find your config/application.rb"
+      end
+
+      test "piping" do
+        assert_success "bin/rake -T | grep db", stdout: "rake db:migrate"
+      end
+
+      test "status" do
+        assert_success "bin/spring status", stdout: "Spring is not running"
+        assert_success "bin/rails runner ''"
+        assert_success "bin/spring status", stdout: "Spring is running"
+      end
+
+      test "runner command sets Rails environment from command-line options" do
+        assert_success "bin/rails runner -e test 'puts Rails.env'", stdout: "test"
+        assert_success "bin/rails runner --environment=test 'puts Rails.env'", stdout: "test"
+      end
+
+      test "forcing rails env via environment variable" do
+        app.env['RAILS_ENV'] = 'test'
+        assert_success "bin/rake -p 'Rails.env'", stdout: "test"
+      end
+
+      test "setting env vars with rake" do
+        File.write(app.path("lib/tasks/env.rake"), <<-'CODE')
+          task :print_rails_env => :environment do
+            puts Rails.env
+          end
+
+          task :print_env do
+            ENV.each { |k, v| puts "#{k}=#{v}" }
+          end
+
+          task(:default).clear.enhance [:print_rails_env]
+        CODE
+
+        assert_success "bin/rake RAILS_ENV=test print_rails_env", stdout: "test"
+        assert_success "bin/rake FOO=bar print_env", stdout: "FOO=bar"
+        assert_success "bin/rake", stdout: "test"
+      end
+
+      test "changing the Gemfile works" do
+        assert_success %(bin/rails runner 'require "sqlite3"')
+
+        File.write(app.gemfile, app.gemfile.read.sub(%{gem 'sqlite3'}, %{# gem 'sqlite3'}))
+        app.await_reload
+
+        assert_failure %(bin/rails runner 'require "sqlite3"'), stderr: "sqlite3"
+      end
+
+      test "changing the Gemfile works when spring calls into itself" do
+        File.write(app.path("script.rb"), <<-CODE)
+          gemfile = Rails.root.join("Gemfile")
+          File.write(gemfile, "\#{gemfile.read}gem 'devise'\\n")
+          Bundler.with_clean_env do
+            system(#{app.env.inspect}, "bundle install")
+          end
+          output = `\#{Rails.root.join('bin/rails')} runner 'require "devise"; puts "done";'`
+          exit output == "done\n"
+        CODE
+
+        assert_success [%(bin/rails runner 'load Rails.root.join("script.rb")'), timeout: 60]
+      end
+
+      test "changing the environment between runs" do
+        File.write(app.application_config, "#{app.application_config.read}\nENV['BAR'] = 'bar'")
+
+        app.env["OMG"] = "1"
+        app.env["FOO"] = "1"
+        app.env["RUBYOPT"] = "-rubygems"
+
+        assert_success %(bin/rails runner 'p ENV["OMG"]'), stdout: "1"
+        assert_success %(bin/rails runner 'p ENV["BAR"]'), stdout: "bar"
+        assert_success %(bin/rails runner 'p ENV.key?("BUNDLE_GEMFILE")'), stdout: "true"
+        assert_success %(bin/rails runner 'p ENV["RUBYOPT"]'), stdout: "bundler"
+
+        app.env["OMG"] = "2"
+        app.env.delete "FOO"
+
+        assert_success %(bin/rails runner 'p ENV["OMG"]'), stdout: "2"
+        assert_success %(bin/rails runner 'p ENV.key?("FOO")'), stdout: "false"
+      end
+
+      test "Kernel.raise remains private" do
+        expr = "p Kernel.private_instance_methods.include?(:raise)"
+        assert_success %(bin/rails runner '#{expr}'), stdout: "true"
+      end
+    end
+  end
+end