spring-jruby 1.4.3

data/lib/spring-jruby/test/application.rb

@@ -0,0 +1,217 @@
+require "spring-jruby/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)
+      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
+        "#{rails_version.test_command} #{test}"
+      end
+
+      def stop_spring
+        run "#{spring} stop"
+      rescue Errno::ENOENT
+      end
+
+      def test
+        path "test/#{rails_version.controller_tests_dir}/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 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 => e
+        raise e, "Output:\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
+        run! "(gem list bundler | grep bundler) || gem install bundler", timeout: nil, retry: 2
+        run! "bundle check || bundle update --retry=2", timeout: nil
+      end
+
+      private
+
+      def process_alive?(pid)
+        Process.kill 0, pid
+        true
+      rescue Errno::ESRCH
+        false
+      end
+    end
+  end
+end

data/lib/spring-jruby/test/application_generator.rb

@@ -0,0 +1,134 @@
+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
+      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
+        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)
+        skips << "--skip-spring" if version.bundles_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}'")
+
+        if version.needs_testunit?
+          append_to_file(application.gemfile, "gem 'spring-commands-testunit'")
+        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
+
+
+        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
+
+        build_and_install_gems
+
+        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", 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-jruby/test/rails_version.rb

@@ -0,0 +1,40 @@
+module Spring
+  module Test
+    class RailsVersion
+      attr_reader :version
+
+      def initialize(string)
+        @version = Gem::Version.new(string)
+      end
+
+      def rails_3?
+        version < Gem::Version.new("4.0.0")
+      end
+      alias needs_testunit? rails_3?
+
+      def test_command
+        needs_testunit? ? 'bin/testunit' : 'bin/rake test'
+      end
+
+      def controller_tests_dir
+        rails_3? ? 'functional' : 'controllers'
+      end
+
+      def bundles_spring?
+        version.segments.take(2) == [4, 1] || version > Gem::Version.new("4.1")
+      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-jruby/test/watcher_test.rb

@@ -0,0 +1,167 @@
+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
+    end
+  end
+end