spring 1.1.3 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6828395a6b2b9a2d02ec15c9baba9305f36dbec9
-  data.tar.gz: 62af73ac2056ca5a62ed440c0e9220f115c82830
+  metadata.gz: 0bae3c5f77134086e25e77df5d700895438e16ba
+  data.tar.gz: 882c5139fed3fe573bb75136e683ca8ee3744069
 SHA512:
-  metadata.gz: 73d982d8d66de05071338ea45fd59b042c5f05a5cb2eb32a10143777e0ec8e120a8b0ecd6d02e18570ee8515b4c18079dc67f12a74c5523f5f6586e93ba3b54c
-  data.tar.gz: 54cc11c7135f91337199ee65d4062516ceec762c87f943bdb823b58b646e10d16d48cc5248b33cabcf68b517319fb7397c469e1d3ce3f75a378152cca30256db
+  metadata.gz: c5d7a1655a09f56c5663024af741c3c58fe9542418603a59dddb0c19ee24203a1527911a4626f6a5eedd5daf5b6e19b1107582fdc2c7528563af1878034cf1a7
+  data.tar.gz: d143cad1d9b6f15440d80aa300b566a4fa19c0c90deada7fa627e3b230f9199ed56eae911c0005fa2ff83814bf3e66190777a42e0bb4cf5ee6d997df9d06b297

data/.gitignore

@@ -16,3 +16,4 @@ spec/reports
 test/tmp
 test/version_tmp
 tmp
+.ruby-version

data/CHANGELOG.md

@@ -1,3 +1,12 @@
+## 1.2.0
+
+* Accept -e and --environment options for `rails console`.
+* Watch `config/secrets.yml` by default. #289 - @morgoth
+* Change monkey-patched `Kernel.raise` from public to private (to match default Ruby behavior) #351 - @mattbrictson
+* Let application_id also respect RUBY_VERSION for the use case of switching between Ruby versions for a given Rails app - @methodmissing
+* Extract the 'listen' watcher to a separate `spring-watcher-listen`
+  gem. This allows it to be developed/maintained separately.
+
 ## 1.1.3
 
 * The `rails runner` command no longer passes environment switches to

data/CONTRIBUTING.md

@@ -1,3 +1,8 @@
+# Don't use the issue tracker to ask questions
+
+Please use Stack Overflow or similar. If you subsequently feel that the
+documentation is inadequate then plase submit a pull request to fix it.
+
 # Contributing guide
 
 ## Getting set up

data/Gemfile

@@ -2,5 +2,3 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in spring.gemspec
 gemspec
-
-gem 'listen', "~> 1.0", :require => false

data/README.md

@@ -7,8 +7,6 @@ Spring is a Rails application preloader. It speeds up development by
 keeping your application running in the background so you don't need to
 boot it every time you run a test, rake task or migration.
 
-**Upgrading to 1.1? It's recommended to run `bundle exec spring binstub --all` to regenerate your binstubs.**
-
 ## Features
 
 * Totally automatic; no need to explicitly start and stop the background process
@@ -61,8 +59,10 @@ will just be silently ignored and the lines after it will be executed as
 normal.
 
 If you don't want to prefix every command you type with `bin/`, you
-can [use direnv](https://github.com/zimbatm/direnv) to automatically add
-`./bin` to your `PATH` when you `cd` into your application.
+can [use direnv](https://github.com/zimbatm/direnv#the-stdlib) to
+automatically add `./bin` to your `PATH` when you `cd` into your application.
+Simply create an `.envrc` file with the command `PATH_add bin` in your
+Rails directory.
 
 ### Usage
 
@@ -179,6 +179,17 @@ To remove spring:
 * 'Unspring' your bin/ executables: `bin/spring binstub --remove --all`
 * Remove spring from your Gemfile
 
+### Deployment
+
+You must not install Spring on your production environment. To prevent it from
+being installed, provide the `--without development test` argument to the
+`bundle install` command which is used to install gems on your production
+machines:
+
+```
+$ bundle install --without development test
+```
+
 ## Commands
 
 ### `rake`
@@ -333,13 +344,10 @@ Spring.watch "config/some_config_file.yml"
 
 By default Spring polls the filesystem for changes once every 0.2 seconds. This
 method requires zero configuration, but if you find that it's using too
-much CPU, then you can turn on event-based file system listening:
-
-```ruby
-Spring.watch_method = :listen
-```
-
-You may need to add the [`listen` gem](https://github.com/guard/listen) to your `Gemfile`.
+much CPU, then you can use event-based file system listening by
+installing the
+[spring-watcher-listen](https://github.com/jonleighton/spring-watcher-listen)
+gem.
 
 ## Troubleshooting
 

data/Rakefile

@@ -10,7 +10,7 @@ namespace :test do
 
   Rake::TestTask.new(:acceptance) do |t|
     t.libs << "test"
-    t.test_files = FileList["test/acceptance/*_test.rb"]
+    t.test_files = FileList["test/acceptance_test.rb"]
     t.verbose = true
   end
 

data/lib/spring/application.rb

@@ -108,6 +108,9 @@ module Spring
       if defined?(Rails) && Rails.application
         watcher.add Rails.application.paths["config/initializers"]
         watcher.add Rails.application.paths["config/database"]
+        if secrets_path = Rails.application.paths["config/secrets"]
+          watcher.add secrets_path
+        end
       end
     end
 
@@ -267,6 +270,7 @@ module Spring
             end
           end
         end
+        private :raise
       end
     end
 

data/lib/spring/client/binstub.rb

@@ -36,7 +36,7 @@ unless defined?(Spring)
   require "rubygems"
   require "bundler"
 
-  if match = Bundler.default_lockfile.read.match(/^GEM$.*?^    spring \((.*?)\)$.*?^$/m)
+  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"] = ""
     Gem.paths = ENV

data/lib/spring/commands.rb

@@ -32,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/commands/rails.rb

@@ -13,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

data/lib/spring/env.rb

@@ -32,13 +32,13 @@ module Spring
     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(project_root.to_s)
+      Digest::MD5.hexdigest(RUBY_VERSION + project_root.to_s)
     end
 
     def socket_path

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.rb

@@ -0,0 +1,15 @@
+require "active_support/test_case"
+
+module Spring
+  module Test
+    class << self
+      attr_accessor :root
+    end
+
+    require "spring/test/application"
+    require "spring/test/application_generator"
+    require "spring/test/rails_version"
+    require "spring/test/watcher_test"
+    require "spring/test/acceptance_test"
+  end
+end

data/lib/spring/test/acceptance_test.rb

@@ -0,0 +1,333 @@
+# 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.0.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 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
+        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