Merge branch 'fxn-master'

13 files changed, 581 insertions, 105 deletions

diff --git a/Gemfile b/Gemfile
index 260604f570..b9fc37cba2 100644
--- a/Gemfile
+++ b/Gemfile
@@ -45,6 +45,7 @@ end
 
 # Active Support.
 gem 'dalli', '>= 2.2.1'
+gem 'listen', '~> 3.0.4'
 
 # Active Job.
 group :job do
diff --git a/Gemfile.lock b/Gemfile.lock
index 4d58065000..0f5a48e524 100644
--- a/Gemfile.lock
+++ b/Gemfile.lock
@@ -212,6 +212,9 @@ GEM
       delayed_job (>= 3.0, < 5)
     erubis (2.7.0)
     execjs (2.6.0)
+    ffi (1.9.10)
+    ffi (1.9.10-x64-mingw32)
+    ffi (1.9.10-x86-mingw32)
     hitimes (1.2.3)
     hitimes (1.2.3-x86-mingw32)
     i18n (0.7.0)
@@ -219,6 +222,9 @@ GEM
     kindlerb (0.1.1)
       mustache
       nokogiri
+    listen (3.0.4)
+      rb-fsevent (>= 0.9.3)
+      rb-inotify (>= 0.9)
     loofah (2.0.3)
       nokogiri (>= 1.5.9)
     metaclass (0.0.4)
@@ -252,6 +258,9 @@ GEM
     rails-html-sanitizer (1.0.2)
       loofah (~> 2.0)
     rake (10.4.2)
+    rb-fsevent (0.9.6)
+    rb-inotify (0.9.5)
+      ffi (>= 0.5.0)
     rdoc (4.2.0)
     redcarpet (3.2.3)
     redis (3.2.1)
@@ -333,6 +342,7 @@ DEPENDENCIES
   jquery-rails!
   json
   kindlerb (= 0.1.1)
+  listen (~> 3.0.4)
   mail!
   minitest (< 5.3.4)
   mocha (~> 0.14)
diff --git a/activesupport/CHANGELOG.md b/activesupport/CHANGELOG.md
index 97ffdd88c1..faa4a3d6fc 100644
--- a/activesupport/CHANGELOG.md
+++ b/activesupport/CHANGELOG.md
@@ -1,3 +1,14 @@
+*   Implements an evented file system monitor to asynchronously detect changes
+    in the application source code, routes, locales, etc.
+
+    To opt-in load the [listen](https://github.com/guard/listen) gem in `Gemfile`:
+
+        group :development do
+          gem 'listen', '~> 3.0.4'
+        end
+
+    *Puneet Agarwal* and *Xavier Noria*
+
 * Added `Time#days_in_year` to return the number of days in the given year, or the
   current year if no argument is provided.
 
diff --git a/activesupport/lib/active_support.rb b/activesupport/lib/active_support.rb
index 63277a65b4..3a2a7d28cb 100644
--- a/activesupport/lib/active_support.rb
+++ b/activesupport/lib/active_support.rb
@@ -34,6 +34,7 @@ module ActiveSupport
   autoload :Dependencies
   autoload :DescendantsTracker
   autoload :FileUpdateChecker
+  autoload :FileEventedUpdateChecker
   autoload :LogSubscriber
   autoload :Notifications
 
diff --git a/activesupport/lib/active_support/file_evented_update_checker.rb b/activesupport/lib/active_support/file_evented_update_checker.rb
new file mode 100644
index 0000000000..ae500d697f
--- /dev/null
+++ b/activesupport/lib/active_support/file_evented_update_checker.rb
@@ -0,0 +1,145 @@
+require 'listen'
+require 'set'
+require 'pathname'
+
+module ActiveSupport
+  class FileEventedUpdateChecker #:nodoc: all
+    def initialize(files, dirs = {}, &block)
+      @ph    = PathHelper.new
+      @files = files.map { |f| @ph.xpath(f) }.to_set
+
+      @dirs = {}
+      dirs.each do |dir, exts|
+        @dirs[@ph.xpath(dir)] = Array(exts).map { |ext| @ph.normalize_extension(ext) }
+      end
+
+      @block   = block
+      @updated = false
+      @lcsp    = @ph.longest_common_subpath(@dirs.keys)
+
+      if (dtw = directories_to_watch).any?
+        Listen.to(*dtw, &method(:changed)).start
+      end
+    end
+
+    def updated?
+      @updated
+    end
+
+    def execute
+      @block.call
+    ensure
+      @updated = false
+    end
+
+    def execute_if_updated
+      if updated?
+        execute
+        true
+      end
+    end
+
+    private
+
+      def changed(modified, added, removed)
+        unless updated?
+          @updated = (modified + added + removed).any? { |f| watching?(f) }
+        end
+      end
+
+      def watching?(file)
+        file = @ph.xpath(file)
+
+        if @files.member?(file)
+          true
+        elsif file.directory?
+          false
+        else
+          ext = @ph.normalize_extension(file.extname)
+
+          file.dirname.ascend do |dir|
+            if @dirs.fetch(dir, []).include?(ext)
+              break true
+            elsif dir == @lcsp || dir.root?
+              break false
+            end
+          end
+        end
+      end
+
+      def directories_to_watch
+        dtw = (@files + @dirs.keys).map { |f| @ph.existing_parent(f) }
+        dtw.compact!
+        dtw.uniq!
+
+        @ph.filter_out_descendants(dtw)
+      end
+
+    class PathHelper
+      using Module.new {
+        refine Pathname do
+          def ascendant_of?(other)
+            other.to_s =~ /\A#{Regexp.quote(to_s)}#{Pathname::SEPARATOR_PAT}?/
+          end
+        end
+      }
+
+      def xpath(path)
+        Pathname.new(path).expand_path
+      end
+
+      def normalize_extension(ext)
+        ext.to_s.sub(/\A\./, '')
+      end
+
+      # Given a collection of Pathname objects returns the longest subpath
+      # common to all of them, or +nil+ if there is none.
+      def longest_common_subpath(paths)
+        return if paths.empty?
+
+        lcsp = Pathname.new(paths[0])
+
+        paths[1..-1].each do |path|
+          until lcsp.ascendant_of?(path)
+            if lcsp.root?
+              # If we get here a root directory is not an ascendant of path.
+              # This may happen if there are paths in different drives on
+              # Windows.
+              return
+            else
+              lcsp = lcsp.parent
+            end
+          end
+        end
+
+        lcsp
+      end
+
+      # Returns the deepest existing ascendant, which could be the argument itself.
+      def existing_parent(dir)
+        dir.ascend do |ascendant|
+          break ascendant if ascendant.directory?
+        end
+      end
+
+      # Filters out directories which are descendants of others in the collection (stable).
+      def filter_out_descendants(directories)
+        return directories if directories.length < 2
+
+        sorted_by_nparts = directories.sort_by { |dir| dir.each_filename.to_a.length }
+        descendants = []
+
+        until sorted_by_nparts.empty?
+          dir = sorted_by_nparts.shift
+
+          descendants.concat sorted_by_nparts.select { |possible_descendant|
+            dir.ascendant_of?(possible_descendant)
+          }
+        end
+
+        # Array#- preserves order.
+        directories - descendants
+      end
+    end
+  end
+end
diff --git a/activesupport/lib/active_support/file_update_checker.rb b/activesupport/lib/active_support/file_update_checker.rb
index 78b627c286..1fa9335080 100644
--- a/activesupport/lib/active_support/file_update_checker.rb
+++ b/activesupport/lib/active_support/file_update_checker.rb
@@ -35,7 +35,7 @@ module ActiveSupport
     # This method must also receive a block that will be called once a path
     # changes. The array of files and list of directories cannot be changed
     # after FileUpdateChecker has been initialized.
-    def initialize(files, dirs={}, &block)
+    def initialize(files, dirs = {}, &block)
       @files = files.freeze
       @glob  = compile_glob(dirs)
       @block = block
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
diff --git a/guides/source/configuring.md b/guides/source/configuring.md
index 28388e4957..ee3f742367 100644
--- a/guides/source/configuring.md
+++ b/guides/source/configuring.md
@@ -1149,3 +1149,25 @@ Disallow: /
 
 To block just specific pages, it's necessary to use a more complex syntax. Learn
 it on the [official documentation](http://www.robotstxt.org/robotstxt.html).
+
+Evented File System Monitor
+---------------------------
+
+If the [listen gem](https://github.com/guard/listen) is loaded Rails uses an
+evented file system monitor to detect changes when `config.cache_classes` is
+false:
+
+```ruby
+group :development do
+  gem 'listen', '~> 3.0.4'
+end
+```
+
+Otherwise, in every request Rails walks the application tree to check if
+anything has changed.
+
+On Linux and Mac OS X no additional gems are needed, but some are required
+[for *BSD](https://github.com/guard/listen#on-bsd) and
+[for Windows](https://github.com/guard/listen#on-windows).
+
+Note that [some setups are unsupported](https://github.com/guard/listen#issues--limitations).
diff --git a/railties/CHANGELOG.md b/railties/CHANGELOG.md
index 6980ba94e2..2fedeac292 100644
--- a/railties/CHANGELOG.md
+++ b/railties/CHANGELOG.md
@@ -1,3 +1,8 @@
+*   Generated `Gemfile`s for new applications include a new dependency on
+    [listen](https://github.com/guard/listen) commented out.
+
+    *Puneet Agarwal* and *Xavier Noria*
+
 *   Deprecate `serve_static_files` in favor of `public_file_server.enabled`.
 
     Unifies the static asset options under `public_file_server`.
diff --git a/railties/lib/rails/application/configuration.rb b/railties/lib/rails/application/configuration.rb
index 785671f70b..6d89caf514 100644
--- a/railties/lib/rails/application/configuration.rb
+++ b/railties/lib/rails/application/configuration.rb
@@ -44,7 +44,7 @@ module Rails
         @railties_order                = [:all]
         @relative_url_root             = ENV["RAILS_RELATIVE_URL_ROOT"]
         @reload_classes_only_on_change = true
-        @file_watcher                  = ActiveSupport::FileUpdateChecker
+        @file_watcher                  = file_update_checker
         @exceptions_app                = nil
         @autoflush_log                 = true
         @log_formatter                 = ActiveSupport::Logger::SimpleFormatter.new
@@ -181,6 +181,14 @@ module Rails
       end
 
       private
+        def file_update_checker
+          if defined?(Listen) && Listen::Adapter.select() != Listen::Adapter::Polling
+            ActiveSupport::FileEventedUpdateChecker
+          else
+            ActiveSupport::FileUpdateChecker
+          end
+        end
+
         class Custom #:nodoc:
           def initialize
             @configurations = Hash.new
diff --git a/railties/lib/rails/generators/rails/app/templates/Gemfile b/railties/lib/rails/generators/rails/app/templates/Gemfile
index 975be07622..4f3f59cc22 100644
--- a/railties/lib/rails/generators/rails/app/templates/Gemfile
+++ b/railties/lib/rails/generators/rails/app/templates/Gemfile
@@ -48,6 +48,10 @@ group :development do
   # Spring speeds up development by keeping your application running in the background. Read more: https://github.com/rails/spring
   gem 'spring'
 <% end -%>
+
+  # Loading the listen gem enables an evented file system monitor. Check
+  # https://github.com/guard/listen#listen-adapters if on Windows or *BSD.
+  # gem 'listen', '~> 3.0.4'
 end
 <% end -%>