spring 1.3.6 → 1.7.2

data/lib/spring/failsafe_thread.rb

@@ -0,0 +1,14 @@
+require 'thread'
+
+module Spring
+  class << self
+    def failsafe_thread
+      Thread.new {
+        begin
+          yield
+        rescue
+        end
+      }
+    end
+  end
+end

data/lib/spring/process_title_updater.rb

@@ -10,7 +10,7 @@ module Spring
     def self.run(&block)
       updater = new(&block)
 
-      Thread.new {
+      Spring.failsafe_thread {
         $0 = updater.value
         loop { $0 = updater.next }
       }

data/lib/spring/server.rb

@@ -10,19 +10,24 @@ require "spring/commands"
 
 module Spring
   class Server
-    def self.boot
-      new.boot
+    def self.boot(options = {})
+      new(options).boot
     end
 
     attr_reader :env
 
-    def initialize(env = Env.new)
-      @env          = env
-      @applications = Hash.new { |h, k| h[k] = ApplicationManager.new(k) }
+    def initialize(options = {})
+      @foreground   = options.fetch(:foreground, false)
+      @env          = options[:env] || default_env
+      @applications = Hash.new { |h, k| h[k] = ApplicationManager.new(k, env) }
       @pidfile      = env.pidfile_path.open('a')
       @mutex        = Mutex.new
     end
 
+    def foreground?
+      @foreground
+    end
+
     def log(message)
       env.log "[server] #{message}"
     end
@@ -31,8 +36,8 @@ module Spring
       Spring.verify_environment
 
       write_pidfile
-      set_pgid
-      ignore_signals
+      set_pgid unless foreground?
+      ignore_signals unless foreground?
       set_exit_hook
       set_process_title
       start_server
@@ -42,6 +47,7 @@ module Spring
       server = UNIXServer.open(env.socket_name)
       log "started on #{env.socket_name}"
       loop { serve server.accept }
+    rescue Interrupt
     end
 
     def serve(client)
@@ -100,7 +106,7 @@ module Spring
         end
       end
 
-      @applications.values.map { |a| Thread.new { a.stop } }.map(&:join)
+      @applications.values.map { |a| Spring.failsafe_thread { a.stop } }.map(&:join)
     end
 
     def write_pidfile
@@ -126,5 +132,19 @@ module Spring
         "spring server | #{env.app_name} | started #{distance} ago"
       }
     end
+
+    private
+
+    def default_env
+      Env.new(log_file: default_log_file)
+    end
+
+    def default_log_file
+      if foreground? && !ENV["SPRING_LOG"]
+        $stdout
+      else
+        nil
+      end
+    end
   end
 end

data/lib/spring/test/acceptance_test.rb

@@ -1,9 +1,8 @@
-# encoding: utf-8
-
 require "io/wait"
 require "timeout"
 require "spring/sid"
 require "spring/client"
+require "active_support/core_ext/string/strip"
 
 module Spring
   module Test
@@ -29,6 +28,10 @@ module Spring
         @app ||= Spring::Test::Application.new("#{Spring::Test.root}/apps/tmp")
       end
 
+      def spring_env
+        app.spring_env
+      end
+
       def assert_output(artifacts, expected)
         expected.each do |stream, output|
           assert artifacts[stream].include?(output),
@@ -48,6 +51,14 @@ module Spring
         assert_output artifacts, expected_output if expected_output
       end
 
+      def refute_output_includes(command, not_expected)
+        artifacts = app.run(*Array(command))
+        not_expected.each do |stream, output|
+          assert !artifacts[stream].include?(output),
+                 "expected #{stream} to not include '#{output}'.\n\n#{app.debug(artifacts)}"
+        end
+      end
+
       def assert_speedup(ratio = DEFAULT_SPEEDUP)
         if ENV['CI']
           yield
@@ -59,6 +70,14 @@ module Spring
         end
       end
 
+      def without_gem(name)
+        gem_home = app.gem_home.join('gems')
+        FileUtils.mv(gem_home.join(name), app.root)
+        yield
+      ensure
+        FileUtils.mv(app.root.join(name), gem_home)
+      end
+
       setup do
         generator.generate_if_missing
         generator.install_spring
@@ -77,6 +96,25 @@ module Spring
 
       test "help message when called without arguments" do
         assert_success "bin/spring", stdout: 'Usage: spring COMMAND [ARGS]'
+        assert spring_env.server_running?
+      end
+
+      test "shows help" do
+        assert_success "bin/spring help", stdout: 'Usage: spring COMMAND [ARGS]'
+        assert_success "bin/spring -h", stdout: 'Usage: spring COMMAND [ARGS]'
+        assert_success "bin/spring --help", stdout: 'Usage: spring COMMAND [ARGS]'
+        refute spring_env.server_running?
+      end
+
+      test "tells the user that spring is being used when used automatically via binstubs" do
+        assert_success "bin/rails runner ''", stderr: "Running via Spring preloader in process"
+        assert_success app.spring_test_command, stderr: "Running via Spring preloader in process"
+      end
+
+      test "does not tell the user that spring is being used when used automatically via binstubs but quiet is enabled" do
+        File.write("#{app.user_home}/.spring.rb", "Spring.quiet = true")
+        assert_success "bin/rails runner ''"
+        refute_output_includes "bin/rails runner ''", stderr: 'Running via Spring preloader in process'
       end
 
       test "test changes are picked up" do
@@ -111,13 +149,13 @@ module Spring
       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)
+        File.write(app.application_config, app.application_config.read + <<-RUBY.strip_heredoc)
           class Foo
             def self.omg
               raise "omg"
             end
           end
-        CODE
+        RUBY
         File.write(app.test, app.test.read.sub("get :index", "Foo.omg"))
 
         app.await_reload
@@ -150,17 +188,17 @@ module Spring
 
       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 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"
+        assert !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)
+        File.write(app.spring_config, <<-RUBY.strip_heredoc)
           class CustomCommand
             def call
               puts "omg"
@@ -172,7 +210,7 @@ module Spring
           end
 
           Spring.register_command "custom", CustomCommand.new
-        CODE
+        RUBY
 
         assert_success "bin/spring custom", stdout: "omg"
 
@@ -193,53 +231,166 @@ module Spring
         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"
+      test "binstub remove all" do
+        assert_success "bin/spring binstub --remove --all"
+        refute File.exist?(app.path("bin/spring"))
       end
 
-      test "binstub upgrade" do
-        File.write(app.path("bin/rake"), <<CODE)
-#!/usr/bin/env ruby
+      test "binstub when spring gem is missing" do
+        without_gem "spring-#{Spring::VERSION}" do
+          File.write(app.gemfile, app.gemfile.read.gsub(/gem 'spring.*/, ""))
+          assert_success "bin/rake -T", stdout: "rake db:migrate"
+        end
+      end
 
-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
+      test "binstub when spring binary is missing" do
+        begin
+          File.rename(app.path("bin/spring"), app.path("bin/spring.bak"))
+          assert_success "bin/rake -T", stdout: "rake db:migrate"
+        ensure
+          File.rename(app.path("bin/spring.bak"), app.path("bin/spring"))
+        end
+      end
+
+      test "binstub upgrade with old binstub" do
+        File.write(app.path("bin/rake"), <<-RUBY.strip_heredoc)
+          #!/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
+        RUBY
+
+        File.write(app.path("bin/rails"), <<-RUBY.strip_heredoc)
+          #!/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
+        RUBY
 
         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
+        expected = <<-RUBY.gsub(/^          /, "")
+          #!/usr/bin/env ruby
+          #{Spring::Client::Binstub::LOADER.strip}
+          require 'bundler/setup'
+          load Gem.bin_path('rake', 'rake')
+        RUBY
+        assert_equal expected, app.path("bin/rake").read
+
+        expected = <<-RUBY.gsub(/^          /, "")
+          #!/usr/bin/env ruby
+          #{Spring::Client::Binstub::LOADER.strip}
+          APP_PATH = File.expand_path('../../config/application',  __FILE__)
+          require_relative '../config/boot'
+          require 'rails/commands'
+        RUBY
+        assert_equal expected, app.path("bin/rails").read
+      end
+
+      test "binstub upgrade with new binstub variations" do
+        expected = <<-RUBY.gsub(/^          /, "")
+          #!/usr/bin/env ruby
+          #{Spring::Client::Binstub::LOADER.strip}
+          require 'bundler/setup'
+          load Gem.bin_path('rake', 'rake')
+        RUBY
+
+        # older variation with double quotes
+        File.write(app.path("bin/rake"), <<-RUBY.strip_heredoc)
+          #!/usr/bin/env ruby
+          begin
+            load File.expand_path("../spring", __FILE__)
+          rescue LoadError
+          end
+          require 'bundler/setup'
+          load Gem.bin_path('rake', 'rake')
+        RUBY
+
+        assert_success "bin/spring binstub rake", stdout: "bin/rake: upgraded"
+        assert_equal expected, app.path("bin/rake").read
+
+        # newer variation with single quotes
+        File.write(app.path("bin/rake"), <<-RUBY.strip_heredoc)
+          #!/usr/bin/env ruby
+          begin
+            load File.expand_path('../spring', __FILE__)
+          rescue LoadError
+          end
+          require 'bundler/setup'
+          load Gem.bin_path('rake', 'rake')
+        RUBY
+
+        assert_success "bin/spring binstub rake", stdout: "bin/rake: upgraded"
+        assert_equal expected, app.path("bin/rake").read
+
+        # newer variation which checks end of exception message
+        File.write(app.path("bin/rake"), <<-RUBY.strip_heredoc)
+          #!/usr/bin/env ruby
+          begin
+            spring_bin_path = File.expand_path('../spring', __FILE__)
+            load spring_bin_path
+          rescue LoadError => e
+            raise unless e.message.end_with? spring_bin_path, 'spring/binstub'
+          end
+          require 'bundler/setup'
+          load Gem.bin_path('rake', 'rake')
+        RUBY
 
-    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
+        assert_success "bin/spring binstub rake", stdout: "bin/rake: upgraded"
+        assert_equal expected, app.path("bin/rake").read
+      end
+
+      test "binstub remove with new binstub variations" do
+        # older variation with double quotes
+        File.write(app.path("bin/rake"), <<-RUBY.strip_heredoc)
+          #!/usr/bin/env ruby
+          begin
+            load File.expand_path("../spring", __FILE__)
+          rescue LoadError
+          end
+          require 'bundler/setup'
+          load Gem.bin_path('rake', 'rake')
+        RUBY
+
+        # newer variation with single quotes
+        File.write(app.path("bin/rails"), <<-RUBY.strip_heredoc)
+          #!/usr/bin/env ruby
+          begin
+            load File.expand_path('../spring', __FILE__)
+          rescue LoadError
+          end
+          APP_PATH = File.expand_path('../../config/application',  __FILE__)
+          require_relative '../config/boot'
+          require 'rails/commands'
+        RUBY
+
+        assert_success "bin/spring binstub --remove rake", stdout: "bin/rake: spring removed"
+        assert_success "bin/spring binstub --remove rails", stdout: "bin/rails: spring removed"
+
+        expected = <<-RUBY.strip_heredoc
+          #!/usr/bin/env ruby
+          require 'bundler/setup'
+          load Gem.bin_path('rake', 'rake')
+        RUBY
+        assert_equal expected, app.path("bin/rake").read
+
+        expected = <<-RUBY.strip_heredoc
+          #!/usr/bin/env ruby
+          APP_PATH = File.expand_path('../../config/application',  __FILE__)
+          require_relative '../config/boot'
+          require 'rails/commands'
+        RUBY
+        assert_equal expected, app.path("bin/rails").read
       end
 
       test "after fork callback" do
@@ -252,6 +403,13 @@ CODE
         assert_success "bin/rails runner 'puts 2'", stdout: "!callback!\n2"
       end
 
+      test "can define client tasks" do
+        File.write("#{app.spring_client_config}", <<-RUBY)
+          Spring::Client::COMMANDS["foo"] = lambda { |args| puts "bar -- \#{args.inspect}" }
+        RUBY
+        assert_success "bin/spring foo --baz", stdout: "bar -- [\"foo\", \"--baz\"]\n"
+      end
+
       test "missing config/application.rb" do
         app.application_config.delete
         assert_failure "bin/rake -T", stderr: "unable to find your config/application.rb"
@@ -278,17 +436,17 @@ CODE
       end
 
       test "setting env vars with rake" do
-        File.write(app.path("lib/tasks/env.rake"), <<-'CODE')
+        File.write(app.path("lib/tasks/env.rake"), <<-RUBY.strip_heredoc)
           task :print_rails_env => :environment do
             puts Rails.env
           end
 
           task :print_env do
-            ENV.each { |k, v| puts "#{k}=#{v}" }
+            ENV.each { |k, v| puts "\#{k}=\#{v}" }
           end
 
           task(:default).clear.enhance [:print_rails_env]
-        CODE
+        RUBY
 
         assert_success "bin/rake RAILS_ENV=test print_rails_env", stdout: "test"
         assert_success "bin/rake FOO=bar print_env", stdout: "FOO=bar"
@@ -305,15 +463,15 @@ CODE
       end
 
       test "changing the Gemfile works when spring calls into itself" do
-        File.write(app.path("script.rb"), <<-CODE)
+        File.write(app.path("script.rb"), <<-RUBY.strip_heredoc)
           gemfile = Rails.root.join("Gemfile")
-          File.write(gemfile, "\#{gemfile.read}gem 'devise'\\n")
+          File.write(gemfile, "\#{gemfile.read}gem 'text'\\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
+          output = `\#{Rails.root.join('bin/rails')} runner 'require "text"; puts "done";'`
+          exit output.include? "done\n"
+        RUBY
 
         assert_success [%(bin/rails runner 'load Rails.root.join("script.rb")'), timeout: 60]
       end
@@ -341,6 +499,41 @@ CODE
         expr = "p Kernel.private_instance_methods.include?(:raise)"
         assert_success %(bin/rails runner '#{expr}'), stdout: "true"
       end
+
+      test "custom bundle path" do
+        bundle_path = app.path(".bundle/#{Bundler.ruby_scope}")
+        bundle_path.dirname.mkpath
+
+        FileUtils.cp_r "#{app.gem_home}/", bundle_path.to_s
+
+        app.run! "bundle install --path .bundle --clean --local"
+
+        assert_speedup do
+          2.times { assert_success "bundle exec rails runner ''" }
+        end
+      end
+
+      test "booting a foreground server" do
+        FileUtils.cd(app.root) do
+          assert !spring_env.server_running?
+          assert_success "bin/spring server &"
+
+          Timeout.timeout(10) do
+            sleep 0.1 until spring_env.server_running? && spring_env.socket_path.exist?
+          end
+
+          assert_success app.spring_test_command
+        end
+      end
+
+      test "server boot timeout" do
+        app.env["SPRING_SERVER_COMMAND"] = "sleep 1"
+        File.write("#{app.spring_client_config}", %(
+          Spring::Client::Run.const_set(:BOOT_TIMEOUT, 0.1)
+        ))
+
+        assert_failure "bin/rails runner ''", stderr: "timed out"
+      end
     end
   end
 end

data/lib/spring/test/application.rb

@@ -9,7 +9,8 @@ module Spring
 
       def initialize(root)
         @root       = Pathname.new(root)
-        @spring_env = Spring::Env.new(root)
+        @spring_env = Spring::Env.new(root: root)
+        @times      = nil
       end
 
       def exists?
@@ -48,7 +49,7 @@ module Spring
       end
 
       def gem_home
-        path "vendor/gems/#{RUBY_VERSION}"
+        path "../gems/#{RUBY_VERSION}"
       end
 
       def user_home
@@ -88,6 +89,10 @@ module Spring
         path "config/spring.rb"
       end
 
+      def spring_client_config
+        path "config/spring_client.rb"
+      end
+
       def run(command, opts = {})
         start_time = Time.now
 
@@ -116,8 +121,8 @@ module Spring
         @times << (Time.now - start_time) if @times
 
         output.merge(status: status, command: command)
-      rescue Timeout::Error => e
-        raise e, "Output:\n\n#{dump_streams(command, read_streams)}"
+      rescue Timeout::Error
+        raise Timeout::Error, "While running command:\n\n#{dump_streams(command, read_streams)}"
       end
 
       def with_timing

data/lib/spring/test/application_generator.rb

@@ -8,6 +8,7 @@ module Spring
         @version            = RailsVersion.new(version_constraint.split(' ').last)
         @application        = Application.new(root)
         @bundled            = false
+        @installed          = false
       end
 
       def test_root
@@ -52,19 +53,36 @@ module Spring
         FileUtils.mkdir_p(application.user_home)
         FileUtils.rm_rf(application.path("test/performance"))
 
-        File.write(application.gemfile, "#{application.gemfile.read}gem 'spring', '#{Spring::VERSION}'\n")
+        append_to_file(application.gemfile, "gem 'spring', '#{Spring::VERSION}'")
 
         if version.needs_testunit?
-          File.write(application.gemfile, "#{application.gemfile.read}gem 'spring-commands-testunit'\n")
+          append_to_file(application.gemfile, "gem 'spring-commands-testunit'")
+        end
+
+        if RUBY_VERSION == "1.9.3"
+          append_to_file(application.gemfile, "gem 'mime-types', '~> 2'")
+        end
+
+        rewrite_file(application.gemfile) do |c|
+          c.sub!("https://rubygems.org", "http://rubygems.org")
+          c.gsub!(/(gem '(byebug|web-console|sdoc|jbuilder)')/, "# \\1")
+          c
         end
 
-        File.write(application.gemfile, application.gemfile.read.sub("https://rubygems.org", "http://rubygems.org"))
 
         if application.path("bin").exist?
           FileUtils.cp_r(application.path("bin"), application.path("bin_original"))
         end
       end
 
+      def rewrite_file(file)
+        File.write(file, yield(file.read))
+      end
+
+      def append_to_file(file, add)
+        rewrite_file(file) { |c| c << "#{add}\n" }
+      end
+
       def generate_if_missing
         generate unless application.exists?
       end
@@ -99,7 +117,7 @@ module Spring
             system("gem build #{name}.gemspec 2>&1")
           end
 
-          application.run! "gem install #{spec.gem_dir}/#{name}-*.gem", timeout: nil
+          application.run! "gem install #{spec.gem_dir}/#{name}-*.gem --no-ri --no-rdoc", timeout: nil
         end
       end
 

data/lib/spring/version.rb

@@ -1,3 +1,3 @@
 module Spring
-  VERSION = "1.3.6"
+  VERSION = "1.7.2"
 end

data/lib/spring/watcher/polling.rb

@@ -1,5 +1,3 @@
-require "spring/watcher"
-
 module Spring
   module Watcher
     class Polling < Abstract

data/lib/spring/watcher.rb

@@ -25,6 +25,6 @@ module Spring
   end
 
   def self.watch(*items)
-    watcher.add *items
+    watcher.add(*items)
   end
 end