spring 0.0.7 → 0.0.8

data/lib/spring/version.rb

@@ -1,3 +1,3 @@
 module Spring
-  VERSION = "0.0.7"
+  VERSION = "0.0.8"
 end

data/lib/spring/watcher.rb

@@ -0,0 +1,28 @@
+require "spring/watcher/abstract"
+require "spring/watcher/listen"
+require "spring/watcher/polling"
+
+module Spring
+  class << self
+    attr_accessor :watch_interval
+    attr_writer :watcher
+  end
+
+  self.watch_interval = 0.2
+
+  def self.watcher
+    @watcher ||= watcher_class.new(Spring.application_root_path, watch_interval)
+  end
+
+  def self.watcher_class
+    if Watcher::Listen.available?
+      Watcher::Listen
+    else
+      Watcher::Polling
+    end
+  end
+
+  def self.watch(*items)
+    watcher.add *items
+  end
+end

data/lib/spring/watcher/abstract.rb

@@ -0,0 +1,83 @@
+require "set"
+require "pathname"
+require "mutex_m"
+
+module Spring
+  module Watcher
+    # A user of a watcher can use IO.select to wait for changes:
+    #
+    #   watcher = MyWatcher.new(root, latency)
+    #   IO.select([watcher]) # watcher is running in background
+    #   watcher.stale? # => true
+    class Abstract
+      include Mutex_m
+
+      attr_reader :files, :directories, :root, :latency
+
+      def initialize(root, latency)
+        super()
+
+        @root        = File.realpath(root)
+        @latency     = latency
+        @files       = Set.new
+        @directories = Set.new
+        @stale       = false
+        @io_listener = nil
+      end
+
+      def add(*items)
+        items = items.flatten.map do |item|
+          item = Pathname.new(item)
+
+          if item.relative?
+            Pathname.new("#{root}/#{item}")
+          else
+            item
+          end
+        end
+
+        items.each do |item|
+          if item.directory?
+            directories << item.realpath.to_s
+          else
+            files << item.realpath.to_s
+          end
+        end
+
+        subjects_changed
+      end
+
+      def stale?
+        @stale
+      end
+
+      def mark_stale
+        @stale = true
+        @io_listener.write "." if @io_listener
+      end
+
+      def to_io
+        read, write = IO.pipe
+        @io_listener = write
+        read
+      end
+
+      def restart
+        stop
+        start
+      end
+
+      def start
+        raise NotImplementedError
+      end
+
+      def stop
+        raise NotImplementedError
+      end
+
+      def subjects_changed
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/spring/watcher/listen.rb

@@ -0,0 +1,54 @@
+module Spring
+  module Watcher
+    class Listen < Abstract
+      attr_reader :listener
+
+      def self.available?
+        require "listen"
+        true
+      rescue LoadError
+        false
+      end
+
+      def start
+        unless @listener
+          @listener = ::Listen::MultiListener.new(*base_directories)
+          @listener.latency(latency)
+          @listener.change(&method(:changed))
+          @listener.start(false)
+        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 }
+      end
+    end
+  end
+end

data/lib/spring/watcher/polling.rb

@@ -0,0 +1,59 @@
+module Spring
+  module Watcher
+    class Polling < Abstract
+      attr_reader :mtime
+
+      def initialize(root, latency)
+        super
+        @mtime  = nil
+        @poller = nil
+      end
+
+      def check_stale
+        synchronize { mark_stale if mtime < compute_mtime }
+      end
+
+      def add(*)
+        check_stale if @poller
+        super
+      end
+
+      def start
+        unless @poller
+          @poller = Thread.new {
+            Thread.current.abort_on_exception = true
+
+            loop do
+              Kernel.sleep latency
+              check_stale
+            end
+          }
+        end
+      end
+
+      def stop
+        if @poller
+          @poller.kill
+          @poller = nil
+        end
+      end
+
+      def subjects_changed
+        @mtime = compute_mtime
+      end
+
+      private
+
+      def compute_mtime
+        expanded_files.map { |f| File.mtime(f).to_f }.max || 0
+      rescue Errno::ENOENT
+        # if a file does no longer exist, the watcher is always stale.
+        Float::MAX
+      end
+
+      def expanded_files
+        files + Dir["{#{directories.map { |d| "#{d}/**/*" }.join(",")}}"]
+      end
+    end
+  end
+end

data/test/acceptance/app_test.rb

@@ -44,10 +44,10 @@ class AppTest < ActiveSupport::TestCase
       )
     end
 
-    _, status = Timeout.timeout(opts.fetch(:timeout, 5)) { Process.wait2 }
+    _, status = Timeout.timeout(opts.fetch(:timeout, 10)) { Process.wait2 }
 
     stdout, stderr = read_streams
-    puts dump_streams(stdout, stderr) if ENV["SPRING_DEBUG"]
+    puts dump_streams(command, stdout, stderr) if ENV["SPRING_DEBUG"]
 
     @times << (Time.now - start_time) if @times
 
@@ -57,7 +57,7 @@ class AppTest < ActiveSupport::TestCase
       stderr: stderr,
     }
   rescue Timeout::Error => e
-    raise e, "Output:\n\n#{dump_streams(*read_streams)}"
+    raise e, "Output:\n\n#{dump_streams(command, *read_streams)}"
   end
 
   def read_streams
@@ -68,11 +68,19 @@ class AppTest < ActiveSupport::TestCase
     end
   end
 
-  def dump_streams(stdout, stderr)
-    output = "--- stdout ---\n"
-    output << "#{stdout.chomp}\n"
-    output << "--- stderr ---\n"
-    output << "#{stderr.chomp}\n"
+  def dump_streams(command, stdout, stderr)
+    output = "$ #{command}\n"
+
+    unless stdout.chomp.empty?
+      output << "--- stdout ---\n"
+      output << "#{stdout.chomp}\n"
+    end
+
+    unless stderr.chomp.empty?
+      output << "--- stderr ---\n"
+      output << "#{stderr.chomp}\n"
+    end
+
     output << "\n"
     output
   end
@@ -108,7 +116,7 @@ class AppTest < ActiveSupport::TestCase
   end
 
   def spring_test_command
-    "#{spring} test #{@test}"
+    "#{spring} testunit #{@test}"
   end
 
   @@installed = false
@@ -182,29 +190,47 @@ class AppTest < ActiveSupport::TestCase
     end
   end
 
-  test "app gets reloaded when preloaded files change" do
-    begin
-      application = "#{app_root}/config/application.rb"
-      application_contents = File.read(application)
+  def assert_app_reloaded
+    application = "#{app_root}/config/application.rb"
+    application_contents = File.read(application)
 
-      assert_success spring_test_command
+    assert_success spring_test_command
 
-      File.write(application, application_contents + <<-CODE)
-        class Foo
-          def self.omg
-            raise "omg"
-          end
+    File.write(application, application_contents + <<-CODE)
+      class Foo
+        def self.omg
+          raise "omg"
         end
-      CODE
-      File.write(@test, @test_contents.sub("get :index", "Foo.omg"))
+      end
+    CODE
+    File.write(@test, @test_contents.sub("get :index", "Foo.omg"))
 
-      await_reload
+    await_reload
 
-      assert_speedup do
-        2.times { assert_failure spring_test_command, stdout: "RuntimeError: omg" }
-      end
+    assert_speedup do
+      2.times { assert_failure spring_test_command, stdout: "RuntimeError: omg" }
+    end
+  ensure
+    File.write(application, application_contents)
+  end
+
+  test "app gets reloaded when preloaded files change (polling watcher)" do
+    assert_success "#{spring} rails runner 'puts Spring.watcher.class'", stdout: "Polling"
+    assert_app_reloaded
+  end
+
+  test "app gets reloaded when preloaded files change (listen watcher)" do
+    begin
+      gemfile = app_root.join("Gemfile")
+      gemfile_contents = gemfile.read
+      File.write(gemfile, gemfile_contents.sub(%{# gem 'listen'}, %{gem 'listen'}))
+      app_run "bundle install", timeout: nil
+
+      assert_success "#{spring} rails runner 'puts Spring.watcher.class'", stdout: "Listen"
+      assert_app_reloaded
     ensure
-      File.write(application, application_contents)
+      File.write(gemfile, gemfile_contents)
+      assert_success "bundle check"
     end
   end
 
@@ -241,14 +267,12 @@ class AppTest < ActiveSupport::TestCase
     assert_success "#{spring} custom", stdout: "omg"
   end
 
-  test "runner alias" do
-    assert_success "#{spring} r 'puts 1'", stdout: "1"
-  end
-
   test "binstubs" do
     app_run "#{spring} binstub rake"
+    app_run "#{spring} binstub rails"
     assert_success "bin/spring help"
     assert_success "bin/rake -T", stdout: "rake db:migrate"
+    assert_success "bin/rails runner 'puts %(omg)'", stdout: "omg"
   end
 
   test "after fork callback" do
@@ -257,7 +281,7 @@ class AppTest < ActiveSupport::TestCase
       config_contents = File.read(config_path)
 
       File.write(config_path, config_contents + "\nSpring.after_fork { puts '!callback!' }")
-      assert_success "#{spring} r 'puts 2'", stdout: "!callback!\n2"
+      assert_success "#{spring} rails runner 'puts 2'", stdout: "!callback!\n2"
     ensure
       File.write(config_path, config_contents)
     end
@@ -278,7 +302,13 @@ class AppTest < ActiveSupport::TestCase
 
   test "status" do
     assert_success "#{spring} status", stdout: "Spring is not running"
-    app_run "#{spring} runner ''"
+    app_run "#{spring} rails runner ''"
     assert_success "#{spring} status", stdout: "Spring is running"
   end
+
+  test "runner command sets Rails environment from command-line options" do
+    # Not using "test" environment here to avoid false positives on Travis (where "test" is default)
+    assert_success "#{spring} rails runner -e staging 'puts Rails.env'", stdout: "staging"
+    assert_success "#{spring} rails runner --environment=staging 'puts Rails.env'", stdout: "staging"
+  end
 end

data/test/apps/rails-3-2/Gemfile

@@ -2,3 +2,8 @@ source 'https://rubygems.org'
 
 gem 'rails', '~> 3.2.0'
 gem 'sqlite3'
+
+# gem 'listen'
+gem 'rb-inotify', :require => false  # linux
+gem 'rb-fsevent', :require => false  # mac os x
+gem 'rb-kqueue',  :require => false  # bsd

data/test/unit/client/help_test.rb

@@ -4,28 +4,35 @@ require "spring/client/command"
 require 'spring/client/help'
 require 'spring/client'
 
-class RandomSpringCommand
-  def self.description
-    'Random Spring Command'
-  end
-end
-
-class RandomApplicationCommand
-  def description
-    'Random Application Command'
-  end
-end
-
 class HelpTest < ActiveSupport::TestCase
   def spring_commands
-    { 'command' => RandomSpringCommand }
+    {
+      'command' => Class.new {
+        def self.description
+          'Random Spring Command'
+        end
+      },
+      'rails' => Class.new {
+        def self.description
+          "omg"
+        end
+      }
+    }
   end
 
   def application_commands
-    @application_commands ||= begin
-                                command = RandomApplicationCommand.new
-                                { 'random' => command, 'r' => command }
-                              end
+    {
+      'random' => Class.new {
+        def description
+          'Random Application Command'
+        end
+      }.new,
+      'hidden' => Class.new {
+        def description
+          nil
+        end
+      }.new
+    }
   end
 
   def setup
@@ -38,11 +45,12 @@ Usage: spring COMMAND [ARGS]
 
 Commands for spring itself:
 
-  command    Random Spring Command
+  command  Random Spring Command
 
 Commands for your application:
 
-  random, r  Random Application Command
+  rails    omg
+  random   Random Application Command
     EOF
 
     assert_equal expected_output.chomp, @help.formatted_help