spring 2.0.2 → 2.1.0

data/lib/spring/test/application.rb

@@ -1,229 +0,0 @@
-require "spring/env"
-
-module Spring
-  module Test
-    class Application
-      DEFAULT_TIMEOUT = ENV['CI'] ? 30 : 10
-
-      attr_reader :root, :spring_env
-
-      def initialize(root)
-        @root       = Pathname.new(root)
-        @spring_env = Spring::Env.new(root: root)
-        @times      = nil
-      end
-
-      def exists?
-        root.exist?
-      end
-
-      def stdout
-        @stdout ||= IO.pipe
-      end
-
-      def stderr
-        @stderr ||= IO.pipe
-      end
-
-      def log_file
-        @log_file ||= path("tmp/spring.log").open("w+")
-      end
-
-      def env
-        @env ||= {
-          "GEM_HOME"   => gem_home.to_s,
-          "GEM_PATH"   => gem_home.to_s,
-          "HOME"       => user_home.to_s,
-          "RAILS_ENV"  => nil,
-          "RACK_ENV"   => nil,
-          "SPRING_LOG" => log_file.path
-        }
-      end
-
-      def path(addition)
-        root.join addition
-      end
-
-      def gemfile
-        path "Gemfile"
-      end
-
-      def gem_home
-        path "../gems/#{RUBY_VERSION}"
-      end
-
-      def user_home
-        path "user_home"
-      end
-
-      def spring
-        gem_home.join "bin/spring"
-      end
-
-      def rails_version
-        @rails_version ||= RailsVersion.new(gemfile.read.match(/gem 'rails', '(.*)'/)[1])
-      end
-
-      def spring_test_command
-        "bin/rake test #{test}"
-      end
-
-      def stop_spring
-        run "#{spring} stop"
-      rescue Errno::ENOENT
-      end
-
-      def test
-        path "test/controllers/posts_controller_test.rb"
-      end
-
-      def controller
-        path "app/controllers/posts_controller.rb"
-      end
-
-      def application_config
-        path "config/application.rb"
-      end
-
-      def spring_config
-        path "config/spring.rb"
-      end
-
-      def spring_client_config
-        path "config/spring_client.rb"
-      end
-
-      def run(command, opts = {})
-        start_time = Time.now
-
-        Bundler.with_clean_env do
-          Process.spawn(
-            env,
-            command.to_s,
-            out:   stdout.last,
-            err:   stderr.last,
-            in:    :close,
-            chdir: root.to_s,
-          )
-        end
-
-        _, status = Timeout.timeout(opts.fetch(:timeout, DEFAULT_TIMEOUT)) { Process.wait2 }
-
-        if pid = spring_env.pid
-          @server_pid = pid
-          lines = `ps -A -o ppid= -o pid= | egrep '^\\s*#{@server_pid}'`.lines
-          @application_pids = lines.map { |l| l.split.last.to_i }
-        end
-
-        output = read_streams
-        puts dump_streams(command, output) if ENV["SPRING_DEBUG"]
-
-        @times << (Time.now - start_time) if @times
-
-        output.merge(status: status, command: command)
-      rescue Timeout::Error
-        raise Timeout::Error, "While running command:\n\n#{dump_streams(command, read_streams)}"
-      end
-
-      def with_timing
-        @times = []
-        yield
-      ensure
-        @times = nil
-      end
-
-      def last_time
-        @times.last
-      end
-
-      def first_time
-        @times.first
-      end
-
-      def timing_ratio
-        last_time / first_time
-      end
-
-      def read_streams
-        {
-          stdout: read_stream(stdout.first),
-          stderr: read_stream(stderr.first),
-          log:    read_stream(log_file)
-        }
-      end
-
-      def read_stream(stream)
-        output = ""
-        while IO.select([stream], [], [], 0.5) && !stream.eof?
-          output << stream.readpartial(10240)
-        end
-        output
-      end
-
-      def dump_streams(command, streams)
-        output = "$ #{command}\n"
-
-        streams.each do |name, stream|
-          unless stream.chomp.empty?
-            output << "--- #{name} ---\n"
-            output << "#{stream.chomp}\n"
-          end
-        end
-
-        output << "\n"
-        output
-      end
-
-      def debug(artifacts)
-        artifacts = artifacts.dup
-        artifacts.delete :status
-        dump_streams(artifacts.delete(:command), artifacts)
-      end
-
-      def await_reload
-        raise "no pid" if @application_pids.nil? || @application_pids.empty?
-
-        Timeout.timeout(DEFAULT_TIMEOUT) do
-          sleep 0.1 while @application_pids.any? { |p| process_alive?(p) }
-        end
-      end
-
-      def run!(command, options = {})
-        attempts  = (options.delete(:retry) || 0) + 1
-        artifacts = nil
-
-        until attempts == 0 || artifacts && artifacts[:status].success?
-          artifacts = run(command, options)
-          attempts -= 1
-        end
-
-        if artifacts[:status].success?
-          artifacts
-        else
-          raise "command failed\n\n#{debug(artifacts)}"
-        end
-      end
-
-      def bundle
-        # Version restriction is a workaround for https://github.com/bundler/bundler/pull/4981
-        # The problem breaks our tests on Ruby 2.2
-        # We can remove once it's fixed
-        run! "(gem list bundler | grep bundler) || gem install bundler --version '~> 1.12.0'", timeout: nil, retry: 2
-        run! "bundle check || bundle update --retry=2", timeout: nil
-      end
-
-      def insert_into_test(code)
-        File.write(test, test.read.sub(/^\s*get .+$/, code))
-      end
-
-      private
-
-      def process_alive?(pid)
-        Process.kill 0, pid
-        true
-      rescue Errno::ESRCH
-        false
-      end
-    end
-  end
-end

data/lib/spring/test/application_generator.rb

@@ -1,144 +0,0 @@
-module Spring
-  module Test
-    class ApplicationGenerator
-      attr_reader :version_constraint, :version, :application
-
-      def initialize(version_constraint)
-        @version_constraint = version_constraint
-        @version            = RailsVersion.new(version_constraint.split(' ').last)
-        @application        = Application.new(root)
-        @bundled            = false
-        @installed          = false
-      end
-
-      def test_root
-        Pathname.new Spring::Test.root
-      end
-
-      def root
-        test_root.join("apps/rails-#{version.major}-#{version.minor}-spring-#{Spring::VERSION}")
-      end
-
-      def system(command)
-        if ENV["SPRING_DEBUG"]
-          puts "$ #{command}\n"
-        else
-          command = "(#{command}) > /dev/null"
-        end
-
-        Kernel.system(command) or raise "command failed: #{command}"
-        puts if ENV["SPRING_DEBUG"]
-      end
-
-      def generate
-        Bundler.with_clean_env { generate_files }
-        install_spring
-        generate_scaffold
-      end
-
-      # Sporadic SSL errors keep causing test failures so there are anti-SSL workarounds here
-      def generate_files
-        if RUBY_VERSION == "1.9.3"
-          system("gem list '^mime-types$' --installed --version '~> 2' || " \
-                   "gem install mime-types --clear-sources --source http://rubygems.org --version '~> 2'")
-        end
-
-        system("gem list '^rails$' --installed --version '#{version_constraint}' || " \
-                 "gem install rails --clear-sources --source http://rubygems.org --version '#{version_constraint}'")
-
-        @version = RailsVersion.new(`ruby -e 'puts Gem::Specification.find_by_name("rails", "#{version_constraint}").version'`.chomp)
-
-        skips = %w(--skip-bundle --skip-javascript --skip-sprockets --skip-spring)
-
-        system("rails _#{version}_ new #{application.root} #{skips.join(' ')}")
-        raise "application generation failed" unless application.exists?
-
-        FileUtils.mkdir_p(application.gem_home)
-        FileUtils.mkdir_p(application.user_home)
-        FileUtils.rm_rf(application.path("test/performance"))
-
-        append_to_file(application.gemfile, "gem 'spring', '#{Spring::VERSION}'")
-
-        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
-
-
-        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
-
-      def install_spring
-        return if @installed
-
-        if RUBY_VERSION < "2.2.2"
-          application.run! "gem install activesupport --version '#{version}'"
-        end
-
-        build_and_install_gems
-
-        # TO prevent nokogiri install error in application.bundle.
-        if RUBY_VERSION < "2.1.0"
-          append_to_file(application.gemfile, "gem 'nokogiri', '~> 1.6.8'")
-        end
-
-        application.bundle
-
-        FileUtils.rm_rf application.path("bin")
-
-        if application.path("bin_original").exist?
-          FileUtils.cp_r application.path("bin_original"), application.path("bin")
-        end
-
-        application.run! "#{application.spring} binstub --all"
-        @installed = true
-      end
-
-      def manually_built_gems
-        %w(spring)
-      end
-
-      def build_and_install_gems
-        manually_built_gems.each do |name|
-          spec = Gem::Specification.find_by_name(name)
-
-          FileUtils.cd(spec.gem_dir) do
-            FileUtils.rm(Dir.glob("#{name}-*.gem"))
-            system("gem build #{name}.gemspec 2>&1")
-          end
-
-          application.run! "gem install #{spec.gem_dir}/#{name}-*.gem --no-ri --no-rdoc", timeout: nil
-        end
-      end
-
-      def copy_to(path)
-        system("rm -rf #{path}")
-        system("cp -r #{application.root} #{path}")
-      end
-
-      def generate_scaffold
-        application.run! "bundle exec rails g scaffold post title:string"
-        application.run! "bundle exec rake db:migrate db:test:clone"
-      end
-
-      def gemspec(name)
-        "#{Gem::Specification.find_by_name(name).gem_dir}/#{name}.gemspec"
-      end
-    end
-  end
-end

data/lib/spring/test/rails_version.rb

@@ -1,23 +0,0 @@
-module Spring
-  module Test
-    class RailsVersion
-      attr_reader :version
-
-      def initialize(string)
-        @version = Gem::Version.new(string)
-      end
-
-      def major
-        version.segments[0]
-      end
-
-      def minor
-        version.segments[1]
-      end
-
-      def to_s
-        version.to_s
-      end
-    end
-  end
-end

data/lib/spring/test/watcher_test.rb

@@ -1,194 +0,0 @@
-require "tmpdir"
-require "fileutils"
-require "timeout"
-require "active_support/core_ext/numeric/time"
-
-module Spring
-  module Test
-    class WatcherTest < ActiveSupport::TestCase
-      runnables.delete self # prevent Minitest running this class
-
-      LATENCY = 0.001
-      TIMEOUT = 1
-
-      attr_accessor :dir
-
-      def watcher_class
-        raise NotImplementedError
-      end
-
-      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
-
-      test "starting with no file" do
-        file = "#{@dir}/omg"
-        touch file, Time.now - 2.seconds
-
-        watcher.start
-        watcher.add file
-
-        assert_not_stale
-        touch file, Time.now
-        assert_stale
-      end
-
-      test "is stale when a watched file is updated" do
-        file = "#{@dir}/omg"
-        touch file, Time.now - 2.seconds
-
-        watcher.add file
-        watcher.start
-
-        assert_not_stale
-        touch file, Time.now
-        assert_stale
-      end
-
-      test "is stale when removing files" do
-        file = "#{@dir}/omg"
-        touch file, Time.now
-
-        watcher.add file
-        watcher.start
-
-        assert_not_stale
-        FileUtils.rm(file)
-        assert_stale
-      end
-
-      test "is stale when files are added to a watched directory" do
-        subdir = "#{@dir}/subdir"
-        FileUtils.mkdir(subdir)
-
-        watcher.add subdir
-        watcher.start
-
-        assert_not_stale
-        touch "#{subdir}/foo", Time.now - 1.minute
-        assert_stale
-      end
-
-      test "is stale when a file is changed in a watched directory" do
-        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
-
-      test "adding doesn't wipe stale state" do
-        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
-
-      test "on stale" do
-        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
-
-      test "add relative path" do
-        File.write("#{dir}/foo", "foo")
-        watcher.add "foo"
-        assert_equal ["#{dir}/foo"], watcher.files.to_a
-      end
-
-      test "add dot relative path" do
-        File.write("#{dir}/foo", "foo")
-        watcher.add "./foo"
-        assert_equal ["#{dir}/foo"], watcher.files.to_a
-      end
-
-      test "add non existent file" do
-        watcher.add './foobar'
-        assert watcher.files.empty?
-      end
-
-      test "add symlink" do
-        File.write("#{dir}/bar", "bar")
-        File.symlink("#{dir}/bar", "#{dir}/foo")
-        watcher.add './foo'
-        assert_equal ["#{dir}/bar"], watcher.files.to_a
-      end
-
-      test "add dangling symlink" do
-        File.symlink("#{dir}/bar", "#{dir}/foo")
-        watcher.add './foo'
-        assert watcher.files.empty?
-      end
-
-      test "add directory with dangling symlink" do
-        subdir = "#{@dir}/subdir"
-        FileUtils.mkdir(subdir)
-        File.symlink("dangling", "#{subdir}/foo")
-
-        watcher.add subdir
-        assert_not_stale
-
-        # Adding a new file should mark as stale despite the dangling symlink.
-        File.write("#{subdir}/new-file", "new")
-        watcher.check_stale
-        assert_stale
-      end
-    end
-  end
-end