Merge branch 'fxn-master'

3 files changed, 372 insertions, 103 deletions

diff --git a/activesupport/test/file_evented_update_checker_test.rb b/activesupport/test/file_evented_update_checker_test.rb
new file mode 100644
index 0000000000..9d09cbca8f
--- /dev/null
+++ b/activesupport/test/file_evented_update_checker_test.rb
@@ -0,0 +1,121 @@
+require 'abstract_unit'
+require 'pathname'
+require 'file_update_checker_shared_tests'
+
+class FileEventedUpdateCheckerTest < ActiveSupport::TestCase
+  include FileUpdateCheckerSharedTests
+
+  def new_checker(files = [], dirs = {}, &block)
+    ActiveSupport::FileEventedUpdateChecker.new(files, dirs, &block).tap do
+      wait
+    end
+  end
+
+  def teardown
+    super
+    Listen.stop
+  end
+
+  def wait
+    sleep 1
+  end
+
+  def touch(files)
+    super
+    wait # wait for the events to fire
+  end
+
+  def rm_f(files)
+    super
+    wait
+  end
+end
+
+class FileEventedUpdateCheckerPathHelperTest < ActiveSupport::TestCase
+  def pn(path)
+    Pathname.new(path)
+  end
+
+  setup do
+    @ph = ActiveSupport::FileEventedUpdateChecker::PathHelper.new
+  end
+
+  test '#xpath returns the expanded path as a Pathname object' do
+    assert_equal pn(__FILE__).expand_path, @ph.xpath(__FILE__)
+  end
+
+  test '#normalize_extension returns a bare extension as is' do
+    assert_equal 'rb', @ph.normalize_extension('rb')
+  end
+
+  test '#normalize_extension removes a leading dot' do
+    assert_equal 'rb', @ph.normalize_extension('.rb')
+  end
+
+  test '#normalize_extension supports symbols' do
+    assert_equal 'rb', @ph.normalize_extension(:rb)
+  end
+
+  test '#longest_common_subpath finds the longest common subpath, if there is one' do
+    paths = %w(
+      /foo/bar
+      /foo/baz
+      /foo/bar/baz/woo/zoo
+    ).map { |path| pn(path) }
+
+    assert_equal pn('/foo'), @ph.longest_common_subpath(paths)
+  end
+
+  test '#longest_common_subpath returns the root directory as an edge case' do
+    paths = %w(
+      /foo/bar
+      /foo/baz
+      /foo/bar/baz/woo/zoo
+      /wadus
+    ).map { |path| pn(path) }
+
+    assert_equal pn('/'), @ph.longest_common_subpath(paths)
+  end
+
+  test '#longest_common_subpath returns nil for an empty collection' do
+    assert_nil @ph.longest_common_subpath([])
+  end
+
+  test '#existing_parent returns the most specific existing ascendant' do
+    wd = Pathname.getwd
+
+    assert_equal wd, @ph.existing_parent(wd)
+    assert_equal wd, @ph.existing_parent(wd.join('non-existing/directory'))
+    assert_equal pn('/'), @ph.existing_parent(pn('/non-existing/directory'))
+  end
+
+  test '#filter_out_descendants returns the same collection if there are no descendants (empty)' do
+    assert_equal [], @ph.filter_out_descendants([])
+  end
+
+  test '#filter_out_descendants returns the same collection if there are no descendants (one)' do
+    assert_equal ['/foo'], @ph.filter_out_descendants(['/foo'])
+  end
+
+  test '#filter_out_descendants returns the same collection if there are no descendants (several)' do
+    paths = %w(
+      /Rails.root/app/controllers
+      /Rails.root/app/models
+      /Rails.root/app/helpers
+    ).map { |path| pn(path) }
+
+    assert_equal paths, @ph.filter_out_descendants(paths)
+  end
+
+  test '#filter_out_descendants filters out descendants preserving order' do
+    paths = %w(
+      /Rails.root/app/controllers
+      /Rails.root/app/controllers/concerns
+      /Rails.root/app/models
+      /Rails.root/app/models/concerns
+      /Rails.root/app/helpers
+    ).map { |path| pn(path) }
+
+    assert_equal paths.values_at(0, 2, 4), @ph.filter_out_descendants(paths)
+  end
+end
diff --git a/activesupport/test/file_update_checker_shared_tests.rb b/activesupport/test/file_update_checker_shared_tests.rb
new file mode 100644
index 0000000000..6be3ab6047
--- /dev/null
+++ b/activesupport/test/file_update_checker_shared_tests.rb
@@ -0,0 +1,241 @@
+require 'fileutils'
+
+module FileUpdateCheckerSharedTests
+  extend ActiveSupport::Testing::Declarative
+  include FileUtils
+
+  def tmpdir
+    @tmpdir ||= Dir.mktmpdir(nil, __dir__)
+  end
+
+  def tmpfile(name)
+    "#{tmpdir}/#{name}"
+  end
+
+  def tmpfiles
+    @tmpfiles ||= %w(foo.rb bar.rb baz.rb).map { |f| tmpfile(f) }
+  end
+
+  def teardown
+    FileUtils.rm_rf(@tmpdir) if @tmpdir
+  end
+
+  test 'should not execute the block if no paths are given' do
+    i = 0
+
+    checker = new_checker { i += 1 }
+
+    assert !checker.execute_if_updated
+    assert_equal 0, i
+  end
+
+  test 'should not execute the block if no files change' do
+    i = 0
+
+    FileUtils.touch(tmpfiles)
+
+    checker = new_checker(tmpfiles) { i += 1 }
+
+    assert !checker.execute_if_updated
+    assert_equal 0, i
+  end
+
+  test 'should execute the block once when files are created' do
+    i = 0
+
+    checker = new_checker(tmpfiles) { i += 1 }
+
+    touch(tmpfiles)
+
+    assert checker.execute_if_updated
+    assert_equal 1, i
+  end
+
+  test 'should execute the block once when files are modified' do
+    i = 0
+
+    FileUtils.touch(tmpfiles)
+
+    checker = new_checker(tmpfiles) { i += 1 }
+
+    touch(tmpfiles)
+
+    assert checker.execute_if_updated
+    assert_equal 1, i
+  end
+
+  test 'should execute the block once when files are deleted' do
+    i = 0
+
+    FileUtils.touch(tmpfiles)
+
+    checker = new_checker(tmpfiles) { i += 1 }
+
+    rm_f(tmpfiles)
+
+    assert checker.execute_if_updated
+    assert_equal 1, i
+  end
+
+
+  test 'updated should become true when watched files are created' do
+    i = 0
+
+    checker = new_checker(tmpfiles) { i += 1 }
+    assert !checker.updated?
+
+    touch(tmpfiles)
+
+    assert checker.updated?
+  end
+
+
+  test 'updated should become true when watched files are modified' do
+    i = 0
+
+    FileUtils.touch(tmpfiles)
+
+    checker = new_checker(tmpfiles) { i += 1 }
+    assert !checker.updated?
+
+    touch(tmpfiles)
+
+    assert checker.updated?
+  end
+
+  test 'updated should become true when watched files are deleted' do
+    i = 0
+
+    FileUtils.touch(tmpfiles)
+
+    checker = new_checker(tmpfiles) { i += 1 }
+    assert !checker.updated?
+
+    rm_f(tmpfiles)
+
+    assert checker.updated?
+  end
+
+  test 'should be robust to handle files with wrong modified time' do
+    i = 0
+
+    FileUtils.touch(tmpfiles)
+
+    now  = Time.now
+    time = Time.mktime(now.year + 1, now.month, now.day) # wrong mtime from the future
+    File.utime(time, time, tmpfiles[0])
+
+    checker = new_checker(tmpfiles) { i += 1 }
+
+    touch(tmpfiles[1..-1])
+
+    assert checker.execute_if_updated
+    assert_equal 1, i
+  end
+
+  test 'should cache updated result until execute' do
+    i = 0
+
+    checker = new_checker(tmpfiles) { i += 1 }
+    assert !checker.updated?
+
+    touch(tmpfiles)
+
+    assert checker.updated?
+    checker.execute
+    assert !checker.updated?
+  end
+
+  test 'should execute the block if files change in a watched directory one extension' do
+    i = 0
+
+    checker = new_checker([], tmpdir => :rb) { i += 1 }
+
+    touch(tmpfile('foo.rb'))
+
+    assert checker.execute_if_updated
+    assert_equal 1, i
+  end
+
+  test 'should execute the block if files change in a watched directory several extensions' do
+    i = 0
+
+    checker = new_checker([], tmpdir => [:rb, :txt]) { i += 1 }
+
+    touch(tmpfile('foo.rb'))
+
+    assert checker.execute_if_updated
+    assert_equal 1, i
+
+    touch(tmpfile('foo.txt'))
+
+    assert checker.execute_if_updated
+    assert_equal 2, i
+  end
+
+  test 'should not execute the block if the file extension is not watched' do
+    i = 0
+
+    checker = new_checker([], tmpdir => :txt) { i += 1 }
+
+    touch(tmpfile('foo.rb'))
+
+    assert !checker.execute_if_updated
+    assert_equal 0, i
+  end
+
+  test 'does not assume files exist on instantiation' do
+    i = 0
+
+    non_existing = tmpfile('non_existing.rb')
+    checker = new_checker([non_existing]) { i += 1 }
+
+    touch(non_existing)
+
+    assert checker.execute_if_updated
+    assert_equal 1, i
+  end
+
+  test 'detects files in new subdirectories' do
+    i = 0
+
+    checker = new_checker([], tmpdir => :rb) { i += 1 }
+
+    subdir = tmpfile('subdir')
+    mkdir(subdir)
+    wait
+
+    assert !checker.execute_if_updated
+    assert_equal 0, i
+
+    touch("#{subdir}/nested.rb")
+
+    assert checker.execute_if_updated
+    assert_equal 1, i
+  end
+
+  test 'looked up extensions are inherited in subdirectories not listening to them' do
+    i = 0
+
+    subdir = tmpfile('subdir')
+    mkdir(subdir)
+
+    checker = new_checker([], tmpdir => :rb, subdir => :txt) { i += 1 }
+
+    touch(tmpfile('new.txt'))
+
+    assert !checker.execute_if_updated
+    assert_equal 0, i
+
+    # subdir does not look for Ruby files, but its parent tmpdir does.
+    touch("#{subdir}/nested.rb")
+
+    assert checker.execute_if_updated
+    assert_equal 1, i
+
+    touch("#{subdir}/nested.txt")
+
+    assert checker.execute_if_updated
+    assert_equal 2, i
+  end
+end
diff --git a/activesupport/test/file_update_checker_test.rb b/activesupport/test/file_update_checker_test.rb
index bd1df0f858..752f7836cd 100644
--- a/activesupport/test/file_update_checker_test.rb
+++ b/activesupport/test/file_update_checker_test.rb
@@ -1,112 +1,19 @@
 require 'abstract_unit'
-require 'fileutils'
-require 'thread'
+require 'file_update_checker_shared_tests'
 
-MTIME_FIXTURES_PATH = File.expand_path("../fixtures", __FILE__)
+class FileUpdateCheckerTest < ActiveSupport::TestCase
+  include FileUpdateCheckerSharedTests
 
-class FileUpdateCheckerWithEnumerableTest < ActiveSupport::TestCase
-  FILES = %w(1.txt 2.txt 3.txt)
-
-  def setup
-    FileUtils.mkdir_p("tmp_watcher")
-    FileUtils.touch(FILES)
-  end
-
-  def teardown
-    FileUtils.rm_rf("tmp_watcher")
-    FileUtils.rm_rf(FILES)
-  end
-
-  def test_should_not_execute_the_block_if_no_paths_are_given
-    i = 0
-    checker = ActiveSupport::FileUpdateChecker.new([]){ i += 1 }
-    checker.execute_if_updated
-    assert_equal 0, i
-  end
-
-  def test_should_not_invoke_the_block_if_no_file_has_changed
-    i = 0
-    checker = ActiveSupport::FileUpdateChecker.new(FILES){ i += 1 }
-    5.times { assert !checker.execute_if_updated }
-    assert_equal 0, i
-  end
-
-  def test_should_invoke_the_block_if_a_file_has_changed
-    i = 0
-    checker = ActiveSupport::FileUpdateChecker.new(FILES){ i += 1 }
-    sleep(1)
-    FileUtils.touch(FILES)
-    assert checker.execute_if_updated
-    assert_equal 1, i
-  end
-
-  def test_should_be_robust_enough_to_handle_deleted_files
-    i = 0
-    checker = ActiveSupport::FileUpdateChecker.new(FILES){ i += 1 }
-    FileUtils.rm(FILES)
-    assert checker.execute_if_updated
-    assert_equal 1, i
-  end
-
-  def test_should_be_robust_to_handle_files_with_wrong_modified_time
-    i = 0
-    now = Time.now
-    time = Time.mktime(now.year + 1, now.month, now.day) # wrong mtime from the future
-    File.utime time, time, FILES[2]
-
-    checker = ActiveSupport::FileUpdateChecker.new(FILES){ i += 1 }
-
-    sleep(1)
-    FileUtils.touch(FILES[0..1])
-
-    assert checker.execute_if_updated
-    assert_equal 1, i
-  end
-
-  def test_should_cache_updated_result_until_execute
-    i = 0
-    checker = ActiveSupport::FileUpdateChecker.new(FILES){ i += 1 }
-    assert !checker.updated?
-
-    sleep(1)
-    FileUtils.touch(FILES)
-
-    assert checker.updated?
-    checker.execute
-    assert !checker.updated?
-  end
-
-  def test_should_invoke_the_block_if_a_watched_dir_changed_its_glob
-    i = 0
-    checker = ActiveSupport::FileUpdateChecker.new([], "tmp_watcher" => [:txt]){ i += 1 }
-    FileUtils.cd "tmp_watcher" do
-      FileUtils.touch(FILES)
-    end
-    assert checker.execute_if_updated
-    assert_equal 1, i
+  def new_checker(files = [], dirs = {}, &block)
+    ActiveSupport::FileUpdateChecker.new(files, dirs, &block)
   end
 
-  def test_should_not_invoke_the_block_if_a_watched_dir_changed_its_glob
-    i = 0
-    checker = ActiveSupport::FileUpdateChecker.new([], "tmp_watcher" => :rb){ i += 1 }
-    FileUtils.cd "tmp_watcher" do
-      FileUtils.touch(FILES)
-    end
-    assert !checker.execute_if_updated
-    assert_equal 0, i
+  def wait
+    # noop
   end
 
-  def test_should_not_block_if_a_strange_filename_used
-    FileUtils.mkdir_p("tmp_watcher/valid,yetstrange,path,")
-    FileUtils.touch(FILES.map { |file_name| "tmp_watcher/valid,yetstrange,path,/#{file_name}" })
-
-    test = Thread.new do
-      ActiveSupport::FileUpdateChecker.new([],"tmp_watcher/valid,yetstrange,path," => :txt) { i += 1 }
-      Thread.exit
-    end
-    test.priority = -1
-    test.join(5)
-
-    assert !test.alive?
+  def touch(files)
+    sleep 1 # let's wait a bit to ensure there's a new mtime
+    super
   end
 end