spring 1.2.0 → 4.7.0

data/CHANGELOG.md

@@ -1,188 +0,0 @@
-## 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
-  files which it runs. Issue #272.
-* Various issues solved to do with termination / processes hanging around
-  longer than they should. Issue #290.
-
-## 1.1.2
-
-* Detect old binstubs generated with Spring 1.0 and exit with an error.
-  This prevents a situation where you can get stuck in an infinite loop
-  of spring invocations.
-* Avoid `warning: already initialized constant APP_PATH` when running
-  rails commands that do not use spring (e.g. `bin/rails server` would
-  emit this when you ^C to exit)
-* Fix `reload!` in rails console
-* Don't connect/disconnect the database if there are no connections
-  configured. Issue #256.
-
-## 1.1.1
-
-* Fix `$0` so that it is no longer prefixed with "spring ", as doing
-  this cause issues with rspec when running just `rspec` with no
-  arguments.
-* Ensure we're always connected to a tty when preloading the
-  application in the background, in order to avoid loading issues
-  with readline + libedit which affected pry-rails.
-
-## 1.1.0
-
-* A `bin/spring` binstub is now generated. This allows us to load spring
-  correctly if you have it installed locally with a `BUNDLE_PATH`, so
-  it's no longer necessary to install spring system-wide. We also
-  activate the correct version from your Gemfile.lock. Note that you
-  still can't have spring in your Gemfile as a git repository or local
-  path; it must be a proper gem.
-* Various changes to how springified binstubs are implemented. Existing
-  binstubs will continue to work, but it's recommended to run `spring binstub`
-  again to upgrade them to the new format.
-* `spring binstub --remove` option added for removing spring from
-  binstubs. This won't work unless you have upgraded your binstubs to
-  the new format.
-* `config/database.yml` is watched
-* Better application restarts - if you introduce an error, for example
-  by editing `config/application.rb`, spring will now continue to watch
-  your files and will immediately try to restart the application when
-  you edit `config/application.rb` again (hopefully to correct the error).
-  This means that by the time you come to run a command the application
-  may well already be running.
-* Gemfile changes are now gracefully handled. Previously they would
-  cause spring to simply quit, meaning that you'd incur the full startup
-  penalty on the next run. Now spring doesn't quit, and will try to load
-  up your new bundle in the background.
-* Fix support for using spring with Rails engines/plugins
-
-## 1.0.0
-
-* Enterprise ready secret sauce added
-
-## 0.9.2
-
-* Bugfix: environment variables set by bundler (`BUNDLE_GEMFILE`,
-  `RUBYOPT`, etc...) were being removed from the environment.
-* Ensure we only run the code reloader when files have actually changed.
-  This issue became more prominent with Rails 4, since Rails 4 will now
-  reload routes whenever the code is reloaded (see
-  https://github.com/rails/rails/commit/b9b06daa915fdc4d11e8cfe11a7175e5cd8f104f).
-* Allow spring to be used in a descendant directory of the application
-  root
-* Use the system tmpdir for our temporary files. Previously we used
-  `APP_ROOT/tmp/spring`, which caused problems on filesystems which did
-  not support sockets, and also caused problems if `APP_ROOT` was
-  sufficiently deep in the filesystem to exhaust the operating system's
-  socket name limit. Hence we had a `SPRING_TMP_PATH` environment
-  variable for configuration. We now use `/tmp/spring/[md5(APP_ROOT)]`
-  for the socket and `/tmp/spring/[md5(APP_ROOT)].pid` for the pid file.
-  Thanks @Kriechi for the suggestion. Setting `SPRING_TMP_PATH` no longer
-  has any effect.
-
-## 0.9.1
-
-* Environment variables which were created during application startup are no
-  longer overwritten.
-* Support for generating multiple binstubs at once. Use --all to
-  generate all, otherwise you can pass multiple command names to the
-  binstub command.
-* The `testunit` command has been extracted to the
-  `spring-commands-testunit` gem, because it's not necessary in Rails 4,
-  where you can just run `rake test path/to/test`.
-* The `~/.spring.rb` config file is loaded before bundler, so it's a good
-  place to require extra commands which you want to use in all projects,
-  without having to add those commands to the Gemfile of each individual
-  project.
-* Any gems in the bundle with names which start with "spring-commands-"
-  are now autoloaded. This makes it less faffy to add additional
-  commands.
-
-## 0.9.0
-
-* Display spring version in the help message
-* Remove workaround for Rubygems performance issue. This issue is solved
-  with Rubygems 2.1, so we no longer need to generate a "spring" binstub
-  file. We warn users if they are not taking advantage of the Rubygems
-  perf fix (e.g. if they are not on 2.1, or haven't run `gem pristine
-  --all`). To upgrade, delete your `bin/spring` and re-run `spring
-  binstub` for each of your binstubs.
-* Binstubs now fall back to non-spring execution of a command if the
-  spring gem is not present. This might be useful for production
-  environments.
-* The ENV will be replaced on each run to match the ENV which exists
-  when the spring command is actually run (rather than the ENV which
-  exists when spring first starts).
-* Specifying the rails env after the rake command (e.g. `rake
-  RAILS_ENV=test db:migrate`) now works as expected.
-* Provide an explicit way to set the environment to use when running
-  `rake` on its own.
-* The `rspec` and `cucumber` commands are no longer shipped by default.
-  They've been moved to the `spring-commands-rspec` and
-  `spring-commands-cucumber` gems.
-
-## 0.0.11
-
-* Added the `rails destroy` command.
-* Global config file in `~/.spring.rb`
-* Added logging for debugging. Specify a log file with the
-  `SPRING_LOG` environment variable.
-* Fix hang on "Run `bundle install` to install missing gems"
-* Added hack to make backtraces generated when running a command
-  quieter (by stripping out all of the lines relating to spring)
-* Rails 4 is officially supported
-
-## 0.0.10
-
-* Added `Spring.watch_method=` configuration option to switch between
-  polling and the `listen` gem. Previously, we used the `listen` gem if
-  it was available, but this makes the option explicit. Set
-  `Spring.watch_method = :listen` to use the listen gem.
-* Fallback when Process.fork is not available. In such cases, the user
-  will not receive the speedup that Spring provides, but won't receive
-  an error either.
-* Don't preload `test_helper` or `spec_helper` by default. This was
-  causing people subtle problems (for example see #113) and is perhaps
-  surprising behaviour. It may be desirable but it depends on the
-  application, therefore we suggest it to people in the README but no
-  longer do it by default.
-* Don't stay connected to database in the application processes. There's
-  no need to keep a connection open.
-* Avoid using the database in the application processes. Previously,
-  reloading the autoloaded constants would inadvertantly cause a
-  connection to the database, which would then prevent tasks like
-  db:create from running (because at that point the database doesn't
-  exist)
-* Removed ability to specify list of files for a command to preload. We
-  weren't using this any more internally, and this is easy to do by
-  placing requires in suitable locations in the Rails boot process
-  (which is not explained in the README).
-* Seed the random number generator on each run.
-
-## 0.0.9
-
-* Added `Spring::Commands::Rake.environment_matchers` for matching
-  rake tasks to specific environments.
-* Kill the spring server when the `Gemfile` or `Gemfile.lock` is
-  changed. This forces a new server to boot up on the next run, which
-  ensures that you get the correct gems (or the correct error message from
-  bundler if you have forgotten to `bundle install`.)
-* Fixed error when `Spring.watch` is used in `config/spring.rb`
-
-## 0.0.8
-
-* Renamed `spring test` to `spring testunit`.
-* Implemented `spring rails` to replace `spring
-  [console|runner|generate]`.
-* `config/spring.rb` is only loaded in the server process, so you can
-  require stuff from other gems there without performance implications.
-* File watcher no longer pays attention to files outside of your
-  application root directory.
-* You can use the `listen` gem for less CPU intensive file watching. See
-  README.

data/CONTRIBUTING.md

@@ -1,52 +0,0 @@
-# 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
-
-Check out the code and run `bundle install` as usual.
-
-## Running tests
-
-Running `rake` will run all tests. There are both unit tests and
-acceptance tests. You can run them individually with `rake test:unit` or
-`rake test:acceptance`.
-
-If one doesn't already exist, the acceptance tests will generate a dummy
-Rails app in `test/apps/`. On each test run, the dummy app is copied to
-`test/apps/tmp/` so that any changes won't affect the pre-generated app
-(this saves us having to regenerate the app on each run).
-
-If tests are failing and you don't know why, it might be that the
-pre-generated app has become inconsistent in some way. In that case the
-best solution is to purge it with `rm -rf test/apps/*` and then run the
-acceptance tests again, which will generate a new app.
-
-## Testing different Rails versions
-
-You can set the `RAILS_VERSION` environment variable:
-
-```
-$ RAILS_VERSION="~> 3.2.0" rake test:acceptance
-```
-
-The apps in `test/apps` will be named based on the rails version and the
-spring version.
-
-## Testing with your app
-
-You cannot link to a git repo from your Gemfile. Spring doesn't support
-this due to the way that it gets loaded (bypassing bundler for
-performance reasons).
-
-Therefore, to test changes with your app, run `rake install` to properly
-install the gem on your system.
-
-## Submitting a pull request
-
-If your change is a bugfix or feature, please make sure you add to
-`CHANGELOG.md` under the "Next Release" heading (add the heading if
-needed).

data/Gemfile

@@ -1,4 +0,0 @@
-source 'https://rubygems.org'
-
-# Specify your gem's dependencies in spring.gemspec
-gemspec

data/Rakefile

@@ -1,21 +0,0 @@
-require "bundler/gem_tasks"
-require "rake/testtask"
-
-namespace :test do
-  Rake::TestTask.new(:unit) do |t|
-    t.libs << "test"
-    t.test_files = FileList["test/unit/**/*_test.rb"]
-    t.verbose = true
-  end
-
-  Rake::TestTask.new(:acceptance) do |t|
-    t.libs << "test"
-    t.test_files = FileList["test/acceptance_test.rb"]
-    t.verbose = true
-  end
-
-  desc 'run all tests'
-  task all: [:unit, :acceptance]
-end
-
-task default: 'test:all'

data/lib/spring/sid.rb

@@ -1,42 +0,0 @@
-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
-    def self.fiddle_func
-      @fiddle_func ||= Fiddle::Function.new(
-        DL::Handle::DEFAULT['getsid'],
-        [Fiddle::TYPE_INT],
-        Fiddle::TYPE_INT
-      )
-    end
-
-    def self.sid
-      @sid ||= begin
-        if Process.respond_to?(:getsid)
-          # Ruby 2
-          Process.getsid
-        elsif defined?(Fiddle) and defined?(DL)
-          # 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
-      Process.getpgid(sid)
-    end
-  end
-end

data/lib/spring/test/acceptance_test.rb

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