spring 1.1.3 → 1.2.0

data/lib/spring/version.rb

@@ -1,3 +1,3 @@
 module Spring
-  VERSION = "1.1.3"
+  VERSION = "1.2.0"
 end

data/lib/spring/watcher.rb

@@ -9,15 +9,11 @@ module Spring
   end
 
   def self.watch_method=(method)
-    case method
-    when :polling
-      require_relative "watcher/polling"
-      @watch_method = Watcher::Polling
-    when :listen
-      require_relative "watcher/listen"
-      @watch_method = Watcher::Listen
-    else
+    if method.is_a?(Class)
       @watch_method = method
+    else
+      require "spring/watcher/#{method}"
+      @watch_method = Watcher.const_get(method.to_s.gsub(/(^.|_.)/) { $1[-1].upcase })
     end
   end
 

data/lib/spring/watcher/polling.rb

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

data/test/acceptance_test.rb

@@ -0,0 +1,4 @@
+require "helper"
+
+class AcceptanceTest < Spring::Test::AcceptanceTest
+end

data/test/helper.rb

@@ -1,7 +1,7 @@
 $LOAD_PATH.unshift File.expand_path("../../lib", __FILE__)
 
 require "bundler/setup"
-require "active_support/test_case"
 require "minitest/autorun"
 
-TEST_ROOT = File.expand_path('..', __FILE__)
+require "spring/test"
+Spring::Test.root = File.expand_path('..', __FILE__)

data/test/unit/commands_test.rb

@@ -7,7 +7,17 @@ class CommandsTest < ActiveSupport::TestCase
     assert_equal 'test', command.env(['test'])
   end
 
-  test 'console command ignores first argument if it is a flag' do
+  test 'console command sets rails environment from -e option' do
+    command = Spring::Commands::RailsConsole.new
+    assert_equal 'test', command.env(['-e', 'test'])
+  end
+
+  test 'console command sets rails environment from --environment option' do
+    command = Spring::Commands::RailsConsole.new
+    assert_equal 'test', command.env(['--environment=test'])
+  end
+
+  test 'console command ignores first argument if it is a flag except -e and --environment' do
     command = Spring::Commands::RailsConsole.new
     assert_nil command.env(['--sandbox'])
   end

data/test/unit/watcher_test.rb

@@ -1,194 +1,8 @@
 require "helper"
-require "tmpdir"
-require "fileutils"
-require "timeout"
-require "active_support/core_ext/numeric/time"
-require "spring/watcher"
+require "spring/test/watcher_test"
 require "spring/watcher/polling"
-require "spring/watcher/listen"
-
-module WatcherTests
-  LATENCY = 0.001
-  TIMEOUT = 1
-
-  attr_accessor :dir
-
-  def watcher
-    @watcher ||= watcher_class.new(dir, LATENCY)
-  end
-
-  def setup
-    @dir = File.realpath(Dir.mktmpdir)
-  end
-
-  def teardown
-    FileUtils.remove_entry_secure @dir
-    watcher.stop
-  end
-
-  def touch(file, mtime = nil)
-    options = {}
-    options[:mtime] = mtime if mtime
-    FileUtils.touch(file, options)
-  end
-
-  def assert_stale
-    timeout = Time.now + TIMEOUT
-    sleep LATENCY until watcher.stale? || Time.now > timeout
-    assert watcher.stale?
-  end
-
-  def assert_not_stale
-    sleep LATENCY * 10
-    assert !watcher.stale?
-  end
-
-  def test_starting_with_no_file
-    file = "#{@dir}/omg"
-    touch file, Time.now - 2.seconds
-
-    watcher.start
-    watcher.add file
-
-    assert_not_stale
-    touch file, Time.now
-    assert_stale
-  end
-
-  def test_is_stale_when_a_watched_file_is_updated
-    file = "#{@dir}/omg"
-    touch file, Time.now - 2.seconds
-
-    watcher.add file
-    watcher.start
-
-    assert_not_stale
-    touch file, Time.now
-    assert_stale
-  end
-
-  def test_is_stale_when_removing_files
-    file = "#{@dir}/omg"
-    touch file, Time.now
-
-    watcher.add file
-    watcher.start
-
-    assert_not_stale
-    FileUtils.rm(file)
-    assert_stale
-  end
-
-  def test_is_stale_when_files_are_added_to_a_watched_directory
-    subdir = "#{@dir}/subdir"
-    FileUtils.mkdir(subdir)
-
-    watcher.add subdir
-    watcher.start
-
-    assert_not_stale
-    touch "#{subdir}/foo", Time.now - 1.minute
-    assert_stale
-  end
-
-  def test_is_stale_when_a_file_is_changed_in_a_watched_directory
-    subdir = "#{@dir}/subdir"
-    FileUtils.mkdir(subdir)
-    touch "#{subdir}/foo", Time.now - 1.minute
-
-    watcher.add subdir
-    watcher.start
-
-    assert_not_stale
-    touch "#{subdir}/foo", Time.now
-    assert_stale
-  end
-
-  def test_adding_doesnt_wipe_stale_state
-    file = "#{@dir}/omg"
-    file2 = "#{@dir}/foo"
-    touch file, Time.now - 2.seconds
-    touch file2, Time.now - 2.seconds
-
-    watcher.add file
-    watcher.start
-
-    assert_not_stale
-
-    touch file, Time.now
-    watcher.add file2
-
-    assert_stale
-  end
-
-  def test_on_stale
-    file = "#{@dir}/omg"
-    touch file, Time.now - 2.seconds
-
-    stale = false
-    watcher.on_stale { stale = true }
-
-    watcher.add file
-    watcher.start
-
-    touch file, Time.now
-
-    Timeout.timeout(1) { sleep 0.01 until stale }
-    assert stale
-
-    # Check that we only get notified once
-    stale = false
-    sleep LATENCY * 3
-    assert !stale
-  end
-
-  def test_add_relative_path
-    File.write("#{dir}/foo", "foo")
-    watcher.add "foo"
-    assert_equal ["#{dir}/foo"], watcher.files.to_a
-  end
-
-  def test_add_dot_relative_path
-    File.write("#{dir}/foo", "foo")
-    watcher.add "./foo"
-    assert_equal ["#{dir}/foo"], watcher.files.to_a
-  end
-
-  def test_add_non_existant_file
-    watcher.add './foobar'
-    assert watcher.files.empty?
-  end
-end
-
-class ListenWatcherTest < ActiveSupport::TestCase
-  include WatcherTests
-
-  def watcher_class
-    Spring::Watcher::Listen
-  end
-
-  test "root directories" do
-    begin
-      other_dir_1 = File.realpath(Dir.mktmpdir)
-      other_dir_2 = File.realpath(Dir.mktmpdir)
-      File.write("#{other_dir_1}/foo", "foo")
-      File.write("#{dir}/foo", "foo")
-
-      watcher.add "#{other_dir_1}/foo"
-      watcher.add other_dir_2
-      watcher.add "#{dir}/foo"
-
-      assert_equal [dir, other_dir_1, other_dir_2].sort, watcher.base_directories.sort
-    ensure
-      FileUtils.rmdir other_dir_1
-      FileUtils.rmdir other_dir_2
-    end
-  end
-end
-
-class PollingWatcherTest < ActiveSupport::TestCase
-  include WatcherTests
 
+class PollingWatcherTest < Spring::Test::WatcherTest
   def watcher_class
     Spring::Watcher::Polling
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: spring
 version: !ruby/object:Gem::Version
-  version: 1.1.3
+  version: 1.2.0
 platform: ruby
 authors:
 - Jon Leighton
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-13 00:00:00.000000000 Z
+date: 2014-11-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -80,14 +80,18 @@ files:
 - lib/spring/process_title_updater.rb
 - lib/spring/server.rb
 - lib/spring/sid.rb
+- lib/spring/test.rb
+- lib/spring/test/acceptance_test.rb
+- lib/spring/test/application.rb
+- lib/spring/test/application_generator.rb
+- lib/spring/test/rails_version.rb
+- lib/spring/test/watcher_test.rb
 - lib/spring/version.rb
 - lib/spring/watcher.rb
 - lib/spring/watcher/abstract.rb
-- lib/spring/watcher/listen.rb
 - lib/spring/watcher/polling.rb
 - spring.gemspec
-- test/acceptance/app_test.rb
-- test/acceptance/helper.rb
+- test/acceptance_test.rb
 - test/apps/.gitignore
 - test/helper.rb
 - test/unit/client/help_test.rb
@@ -120,8 +124,7 @@ signing_key:
 specification_version: 4
 summary: Rails application preloader
 test_files:
-- test/acceptance/app_test.rb
-- test/acceptance/helper.rb
+- test/acceptance_test.rb
 - test/apps/.gitignore
 - test/helper.rb
 - test/unit/client/help_test.rb

data/lib/spring/watcher/listen.rb

@@ -1,52 +0,0 @@
-gem "listen", "~> 1.0"
-require "listen"
-require "listen/version"
-
-module Spring
-  module Watcher
-    class Listen < Abstract
-      attr_reader :listener
-
-      def start
-        unless @listener
-          @listener = ::Listen.to(*base_directories, relative_paths: false)
-          @listener.latency(latency)
-          @listener.change(&method(:changed))
-          @listener.start
-        end
-      end
-
-      def stop
-        if @listener
-          @listener.stop
-          @listener = nil
-        end
-      end
-
-      def subjects_changed
-        if @listener && @listener.directories.sort != base_directories.sort
-          restart
-        end
-      end
-
-      def watching?(file)
-        files.include?(file) || file.start_with?(*directories)
-      end
-
-      def changed(modified, added, removed)
-        synchronize do
-          if (modified + added + removed).any? { |f| watching? f }
-            mark_stale
-          end
-        end
-      end
-
-      def base_directories
-        ([root] +
-          files.reject       { |f| f.start_with? root }.map { |f| File.expand_path("#{f}/..") } +
-          directories.reject { |d| d.start_with? root }
-        ).uniq
-      end
-    end
-  end
-end

data/test/acceptance/app_test.rb

@@ -1,334 +0,0 @@
-# encoding: utf-8
-require "helper"
-require "acceptance/helper"
-require "io/wait"
-require "timeout"
-require "spring/sid"
-require "spring/client"
-
-class AppTest < ActiveSupport::TestCase
-  DEFAULT_SPEEDUP = 0.8
-
-  def rails_version
-    ENV['RAILS_VERSION'] || '~> 4.0.0'
-  end
-
-  def generator
-    @@generator ||= Spring::Test::ApplicationGenerator.new(rails_version)
-  end
-
-  def app
-    @app ||= Spring::Test::Application.new("#{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
-
-  def assert_app_reloaded
-    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
-
-  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 (polling watcher)" do
-    app.env["RAILS_ENV"] = "test"
-    assert_success "bin/rails runner 'puts Spring.watcher.class'", stdout: "Polling"
-    assert_app_reloaded
-  end
-
-  test "app gets reloaded when preloaded files change (listen watcher)" do
-    File.write(app.gemfile, "#{app.gemfile.read}gem 'listen', '~> 1.0'")
-    File.write(app.spring_config, "Spring.watch_method = :listen")
-    app.bundle
-
-    app.env["RAILS_ENV"] = "test"
-    assert_success "bin/rails runner 'puts Spring.watcher.class'", stdout: "Listen"
-    assert_app_reloaded
-  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
-end