spring 1.0.0 → 1.1.0.beta2

data/test/acceptance/helper.rb

@@ -0,0 +1,333 @@
+require "spring/env"
+
+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 >= Gem::Version.new("4.1.0.beta1")
+      end
+
+      def major
+        version.segments[0]
+      end
+
+      def minor
+        version.segments[1]
+      end
+    end
+
+    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_path
+        path("tmp/spring.log")
+      end
+
+      def log_file
+        @log_file ||= log_file_path.open("w+")
+      end
+
+      def env
+        @env ||= {
+          "GEM_HOME"   => gem_home.to_s,
+          "GEM_PATH"   => "",
+          "HOME"       => user_home.to_s,
+          "RAILS_ENV"  => nil,
+          "RACK_ENV"   => nil,
+          "SPRING_LOG" => log_file_path.to_s
+        }
+      end
+
+      def path(addition)
+        root.join addition
+      end
+
+      def gemfile
+        path "Gemfile"
+      end
+
+      def gem_home
+        path "vendor/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!(*args)
+        artifacts = run(*args)
+        unless artifacts[:status].success?
+          raise "command failed\n\n#{debug(artifacts)}"
+        end
+        artifacts
+      end
+
+      def bundle
+        run! "(gem list bundler | grep bundler) || gem install bundler", timeout: nil
+        run! "bundle update", timeout: nil
+      end
+
+      private
+
+      def process_alive?(pid)
+        Process.kill 0, pid
+        true
+      rescue Errno::ESRCH
+        false
+      end
+    end
+
+    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 root
+        "#{TEST_ROOT}/apps/rails-#{version.major}-#{version.minor}-spring-#{Spring::VERSION}"
+      end
+
+      def system(command)
+        Kernel.system("#{command} > /dev/null") or raise "command failed: #{command}"
+      end
+
+      def bundle
+        return if @bundled
+        application.bundle
+        @bundled = true
+      end
+
+      # Sporadic SSL errors keep causing test failures so there are anti-SSL workarounds here
+      def generate
+        Bundler.with_clean_env do
+          system("(gem list rails --installed --version '#{version_constraint}' || " \
+                    "gem install rails --clear-sources --source http://rubygems.org --version '#{version_constraint}')")
+
+          skips = %w(--skip-bundle --skip-javascript --skip-sprockets)
+          skips << "--skip-spring" if version.bundles_spring?
+
+          system("rails '_#{version_constraint}_' new #{application.root} #{skips.join(' ')}")
+
+          FileUtils.mkdir_p(application.gem_home)
+          FileUtils.mkdir_p(application.user_home)
+          FileUtils.rm_rf(application.path("test/performance"))
+
+          File.write(application.gemfile, "#{application.gemfile.read}gem 'spring', '#{Spring::VERSION}'\n")
+
+          if version.needs_testunit?
+            File.write(application.gemfile, "#{application.gemfile.read}gem 'spring-commands-testunit'\n")
+          end
+
+          File.write(application.gemfile, application.gemfile.read.sub("https://rubygems.org", "http://rubygems.org"))
+
+          if application.path("bin").exist?
+            FileUtils.cp_r(application.path("bin"), application.path("bin_original"))
+          end
+        end
+
+        bundle
+        application.run! "bundle exec rails g scaffold post title:string"
+        application.run! "bundle exec rake db:migrate db:test:clone"
+      end
+
+      def generate_if_missing
+        generate unless application.exists?
+      end
+
+      def install_spring
+        unless @installed
+          # Need to do this here too because the app may have been generated with
+          # a different ruby
+          bundle
+
+          system("gem build spring.gemspec 2>/dev/null")
+          application.run! "gem install ../../../spring-#{Spring::VERSION}.gem", timeout: nil
+
+          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
+      end
+
+      def copy_to(path)
+        FileUtils.rm_rf(path.to_s)
+        FileUtils.cp_r(application.root.to_s, path.to_s)
+      end
+    end
+  end
+end

data/test/unit/client/version_test.rb

@@ -0,0 +1,14 @@
+require 'helper'
+require 'spring/client'
+
+class VersionTest < ActiveSupport::TestCase
+  test "outputs current version number" do
+    version = Spring::Client::Version.new 'version'
+
+    out, err = capture_io do
+      version.call
+    end
+
+    assert_equal "Spring version #{Spring::VERSION}", out.chomp
+  end
+end

data/test/unit/watcher_test.rb

@@ -1,6 +1,7 @@
 require "helper"
 require "tmpdir"
 require "fileutils"
+require "timeout"
 require "active_support/core_ext/numeric/time"
 require "spring/watcher"
 require "spring/watcher/polling"
@@ -120,22 +121,25 @@ module WatcherTests
     assert_stale
   end
 
-  def test_can_io_select
+  def test_on_stale
     file = "#{@dir}/omg"
     touch file, Time.now - 2.seconds
 
     watcher.add file
     watcher.start
 
-    io = watcher.to_io
+    stale = false
+    watcher.on_stale { stale = true }
 
-    Thread.new {
-      sleep LATENCY * 3
-      touch file, Time.now
-    }
+    touch file, Time.now
 
-    assert IO.select([io], [], [], 1), "IO.select timed out before watcher was readable"
-    assert watcher.stale?
+    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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: spring
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0.beta2
 platform: ruby
 authors:
 - Jon Leighton
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-11-19 00:00:00.000000000 Z
+date: 2014-01-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -55,7 +55,10 @@ files:
 - Rakefile
 - bin/spring
 - lib/spring/application.rb
+- lib/spring/application/boot.rb
 - lib/spring/application_manager.rb
+- lib/spring/binstub.rb
+- lib/spring/boot.rb
 - lib/spring/client.rb
 - lib/spring/client/binstub.rb
 - lib/spring/client/command.rb
@@ -64,6 +67,8 @@ files:
 - lib/spring/client/run.rb
 - lib/spring/client/status.rb
 - lib/spring/client/stop.rb
+- lib/spring/client/version.rb
+- lib/spring/command_wrapper.rb
 - lib/spring/commands.rb
 - lib/spring/commands/rails.rb
 - lib/spring/commands/rake.rb
@@ -81,13 +86,15 @@ files:
 - lib/spring/watcher/polling.rb
 - spring.gemspec
 - test/acceptance/app_test.rb
+- test/acceptance/helper.rb
 - test/apps/.gitignore
 - test/helper.rb
 - test/unit/client/help_test.rb
+- test/unit/client/version_test.rb
 - test/unit/commands_test.rb
 - test/unit/process_title_updater_test.rb
 - test/unit/watcher_test.rb
-homepage: http://github.com/jonleighton/spring
+homepage: http://github.com/rails/spring
 licenses:
 - MIT
 metadata: {}
@@ -102,9 +109,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - '>'
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.1.9
@@ -113,9 +120,12 @@ specification_version: 4
 summary: Rails application preloader
 test_files:
 - test/acceptance/app_test.rb
+- test/acceptance/helper.rb
 - test/apps/.gitignore
 - test/helper.rb
 - test/unit/client/help_test.rb
+- test/unit/client/version_test.rb
 - test/unit/commands_test.rb
 - test/unit/process_title_updater_test.rb
 - test/unit/watcher_test.rb
+has_rdoc: