listen 2.7.12 → 2.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 65b3168861b5ccc57809689d8ad5849a631db822
-  data.tar.gz: 3640593ce18fa45435a2ff0184e9c7fda77acfce
+  metadata.gz: 5a859a235a28efe17024969a47542ebec79836f9
+  data.tar.gz: 54b831e943a6b7b773aa9da8684041ee55e9a8fe
 SHA512:
-  metadata.gz: 1ba0723ef31cfc026fb71bc89f0d1f951cbd276270bb57329fef1ffa5aae8e982f645a69a2a7bbf39591ae6d8160950fbb71f356417874948c39d010559cca31
-  data.tar.gz: 1203e42ab3497f1c2d1348330398880f92b1932038f60b7f8f2283e67bfc4e04e034f10b35389bb00a0775db352d91228af98243951f702137cbc19a3ffe2ad5
+  metadata.gz: 7058ec4f00876391e3179d8566b6fcce5aa9741f37da3ac32b5f68f08e655520278320f16237e080113a4774a580b7c391f2f08569b4bf4cb3f709787b6334fc
+  data.tar.gz: 8eede032561181f9d5add525343992098c4216a59953d519eafaac11df294d0fc98bdc9dd31a0da6fb10a8c3fced456c57ee260a2ef620d57951051546342d91

data/README.md

@@ -6,6 +6,21 @@
 
 The Listen gem listens to file modifications and notifies you about the changes.
 
+## IMPORTANT NOTE
+
+Got an issue with Listen and you're "in a hurry"? First, try Polling mode as a workaround (described below).
+
+Otherwise ...
+
+Output from using `LISTEN_GEM_DEBUGGING` (debug mode) is often *crucial* to quickly diagnosing and fixing issues.
+
+There are TOO MANY possible and surprising reasons why Listen "doesn't work as expected" (e.g. Dropbox folders, editor settings, system limits) - and the best way to find out is by going through these 3 steps first:
+
+See [TROUBLESHOOTING](https://github.com/guard/listen/blob/master/TROUBLESHOOTING.md)
+
+Once you've reproduced the problem in debug mode (`LISTEN_GEM_DEBUGGING`), paste the output it into a Gist and link it to your issue.
+
+
 ## Features
 
 * Supports watching multiple directories from a single listener.
@@ -25,8 +40,7 @@ Please note that:
 
 ## Pending features / issues
 
-* ~~Non-recursive directory scanning~~ [#111](https://github.com/guard/listen/issues/111)
-* Symlinks support. [#25](https://github.com/guard/listen/issues/25)
+* Ignored directories are actually still scanned [#274](https://github.com/guard/listen/issues/274) (Except when polling)
 * Directory/adapter specific configuration options
 * Support for plugins
 

data/lib/listen/record.rb

@@ -1,7 +1,9 @@
+require 'listen/record/entry'
+require 'listen/record/symlink_detector'
+
 module Listen
   class Record
     include Celluloid
-
     # TODO: one Record object per watched directory?
 
     # TODO: deprecate
@@ -100,34 +102,32 @@ module Listen
       end
     end
 
+    # TODO: test with a file name given
+    # TODO: test other permissions
+    # TODO: test with mixed encoding
     def _fast_build(root)
+      symlink_detector = SymlinkDetector.new
       @paths[root] = _auto_hash
-      left = Queue.new
-      left << '.'
-
-      until left.empty?
-        dirname = left.pop
-        add_dir(root, dirname)
-
-        path = ::File.join(root, dirname)
-        current = Dir.entries(path.to_s) - %w(. ..)
-
-        current.each do |entry|
-          full_path = ::File.join(path, entry)
-
-          if Dir.exist?(full_path)
-            left << (dirname == '.' ? entry : ::File.join(dirname, entry))
-          else
-            begin
-              lstat = ::File.lstat(full_path)
-              data = { mtime: lstat.mtime.to_f, mode: lstat.mode }
-              _fast_update_file(root, dirname, entry, data)
-            rescue SystemCallError
-              _fast_unset_path(root, dirname, entry)
-            end
-          end
-        end
-      end
+      remaining = Queue.new
+      remaining << Entry.new(root, nil, nil)
+      _fast_build_dir(remaining, symlink_detector) until remaining.empty?
+    end
+
+    def _fast_build_dir(remaining, symlink_detector)
+      entry = remaining.pop
+      entry.children.each { |child| remaining << child }
+      symlink_detector.verify_unwatched!(entry)
+      add_dir(entry.root, entry.record_dir_key)
+    rescue Errno::ENOTDIR
+      _fast_try_file(entry)
+    rescue SystemCallError
+      _fast_unset_path(entry.root, entry.relative, entry.name)
+    end
+
+    def _fast_try_file(entry)
+      _fast_update_file(entry.root, entry.relative, entry.name, entry.meta)
+    rescue SystemCallError
+      _fast_unset_path(entry.root, entry.relative, entry.name)
     end
   end
 end

data/lib/listen/record/entry.rb

@@ -0,0 +1,51 @@
+module Listen
+  # @private api
+  class Record
+    # Represents a directory entry (dir or file)
+    class Entry
+      # file: "/home/me/watched_dir", "app/models", "foo.rb"
+      # dir, "/home/me/watched_dir", "."
+      def initialize(root, relative, name = nil)
+        @root, @relative, @name = root, relative, name
+      end
+
+      attr_reader :root, :relative, :name
+
+      def children
+        child_relative = _join
+        (Dir.entries(sys_path) - %w(. ..)).map do |name|
+          Entry.new(@root, child_relative, name)
+        end
+      end
+
+      def meta
+        lstat = ::File.lstat(sys_path)
+        { mtime: lstat.mtime.to_f, mode: lstat.mode }
+      end
+
+      # record hash is e.g.
+      # if @record["/home/me/watched_dir"]["project/app/models"]["foo.rb"]
+      # if @record["/home/me/watched_dir"]["project/app"]["models"]
+      # record_dir_key is "project/app/models"
+      def record_dir_key
+        ::File.join(*[@relative, @name].compact)
+      end
+
+      def sys_path
+        # Use full path in case someone uses chdir
+        ::File.join(*[@root, @relative, @name].compact)
+      end
+
+      def real_path
+        @real_path ||= ::File.realpath(sys_path)
+      end
+
+      private
+
+      def _join
+        args = [@relative, @name].compact
+        args.empty? ? nil : ::File.join(*args)
+      end
+    end
+  end
+end

data/lib/listen/record/symlink_detector.rb

@@ -0,0 +1,59 @@
+require 'set'
+
+module Listen
+  # @private api
+  class Record
+    class SymlinkDetector
+      SYMLINK_LOOP_ERROR = <<-EOS
+        ** ERROR: Listen detected a duplicate directory being watched! **
+
+        (This may be due to symlinks pointing to parent directories).
+
+        Duplicate: %s
+
+        which already is added as: %s
+
+        Listen is refusing to continue, because this may likely result in
+        an infinite loop.
+
+        Suggestions:
+
+          1) (best option) watch only directories you care about, e.g.
+          either symlinked folders or folders with the real directories,
+          but not both.
+
+          2) reorganize your project so that watched directories do not
+          contain symlinked directories
+
+          3) submit patches so that Listen can reliably and quickly (!)
+          detect symlinks to already watched read directories, skip
+          them, and then reasonably choose which symlinked paths to
+          report as changed (if any)
+
+          4) (not worth it) help implement a "reverse symlink lookup"
+          function in Listen, which - given a real directory - would
+          return all the symlinks pointing to that directory
+
+        Issue: https://github.com/guard/listen/issues/259
+      EOS
+
+      def initialize
+        @real_dirs = Set.new
+      end
+
+      def verify_unwatched!(entry)
+        real_path = entry.real_path
+        @real_dirs.add?(real_path) || _fail(entry.sys_path, real_path)
+      end
+
+      private
+
+      def _fail(symlinked, real_path)
+        STDERR.puts format(SYMLINK_LOOP_ERROR, symlinked, real_path)
+
+        # Note Celluloid eats up abort message anyway
+        fail 'Failed due to looped symlinks'
+      end
+    end
+  end
+end

data/lib/listen/version.rb

@@ -1,3 +1,3 @@
 module Listen
-  VERSION = '2.7.12'
+  VERSION = '2.8.0'
 end

data/spec/lib/listen/record_spec.rb

@@ -193,21 +193,24 @@ describe Listen::Record do
     before do
       allow(listener).to receive(:directories) { directories }
 
-      allow(::File).to receive(:lstat) do |path|
-        fail "::File.lstat stub called with: #{path.inspect}"
-      end
-
-      allow(::Dir).to receive(:entries) do |path|
-        fail "::Dir.entries stub called with: #{path.inspect}"
-      end
-
-      allow(::Dir).to receive(:exist?) do |path|
-        fail "::Dir.exist? stub called with: #{path.inspect}"
+      stubs = {
+        ::File => %w(lstat realpath),
+        ::Dir => %w(entries exist?)
+      }
+
+      stubs.each do |klass, meths|
+        meths.each do |meth|
+          allow(klass).to receive(meth.to_sym) do |*args|
+            fail "stub called: #{klass}.#{meth}(#{args.map(&:inspect) * ', '})"
+          end
+        end
       end
     end
 
     it 're-inits paths' do
-      allow(::Dir).to receive(:entries) { [] }
+      allow(::Dir).to receive(:entries).and_return([])
+      allow(::File).to receive(:realpath).with('/dir1').and_return('/dir1')
+      allow(::File).to receive(:realpath).with('/dir2').and_return('/dir2')
 
       record.update_file(dir, 'path/file.rb', mtime: 1.1)
       record.build
@@ -219,18 +222,19 @@ describe Listen::Record do
     let(:bar_stat) { instance_double(::File::Stat, mtime: 2.3, mode: 0755) }
 
     context 'with no subdirs' do
-
       before do
-        expect(::Dir).to receive(:entries).with('/dir1/.') { %w(foo bar) }
-        expect(::Dir).to receive(:exist?).with('/dir1/./foo') { false }
-        expect(::Dir).to receive(:exist?).with('/dir1/./bar') { false }
-        expect(::File).to receive(:lstat).with('/dir1/./foo') { foo_stat }
-        expect(::File).to receive(:lstat).with('/dir1/./bar') { bar_stat }
-
-        expect(::Dir).to receive(:entries).with('/dir2/.') { [] }
+        allow(::Dir).to receive(:entries).with('/dir1') { %w(foo bar) }
+        allow(::Dir).to receive(:entries).with('/dir1/foo').and_raise(Errno::ENOTDIR)
+        allow(::Dir).to receive(:entries).with('/dir1/bar').and_raise(Errno::ENOTDIR)
+        allow(::File).to receive(:lstat).with('/dir1/foo') { foo_stat }
+        allow(::File).to receive(:lstat).with('/dir1/bar') { bar_stat }
+        allow(::Dir).to receive(:entries).with('/dir2') { [] }
+
+        allow(::File).to receive(:realpath).with('/dir1').and_return('/dir1')
+        allow(::File).to receive(:realpath).with('/dir2').and_return('/dir2')
       end
 
-      it 'builds record'  do
+      it 'builds record' do
         record.build
         expect(record.paths.keys).to eq %w( /dir1 /dir2 )
         expect(record.paths['/dir1']).
@@ -242,15 +246,16 @@ describe Listen::Record do
 
     context 'with subdir containing files' do
       before do
-        expect(::Dir).to receive(:entries).with('/dir1/.') { %w(foo) }
-        expect(::Dir).to receive(:exist?).with('/dir1/./foo') { true }
-
-        expect(::Dir).to receive(:entries).with('/dir1/foo') { %w(bar) }
-
-        expect(::Dir).to receive(:exist?).with('/dir1/foo/bar') { false }
-        expect(::File).to receive(:lstat).with('/dir1/foo/bar') { bar_stat }
-
-        expect(::Dir).to receive(:entries).with('/dir2/.') { [] }
+        allow(::Dir).to receive(:entries).with('/dir1') { %w(foo) }
+        allow(::Dir).to receive(:entries).with('/dir1/foo') { %w(bar) }
+        allow(::Dir).to receive(:entries).with('/dir1/foo/bar').and_raise(Errno::ENOTDIR)
+        allow(::File).to receive(:lstat).with('/dir1/foo/bar') { bar_stat }
+        allow(::Dir).to receive(:entries).with('/dir2') { [] }
+
+        allow(::File).to receive(:realpath).with('/dir1').and_return('/dir1')
+        allow(::File).to receive(:realpath).with('/dir2').and_return('/dir2')
+        allow(::File).to receive(:realpath).with('/dir1/foo').
+          and_return('/dir1/foo')
       end
 
       it 'builds record'  do
@@ -264,18 +269,12 @@ describe Listen::Record do
 
     context 'with subdir containing dirs' do
       before do
-        expect(::Dir).to receive(:entries).with('/dir1/.') { %w(foo) }
-        expect(::Dir).to receive(:exist?).with('/dir1/./foo') { true }
-
-        expect(::Dir).to receive(:entries).with('/dir1/foo') { %w(bar baz) }
-
-        expect(::Dir).to receive(:exist?).with('/dir1/foo/bar') { true }
-        expect(::Dir).to receive(:entries).with('/dir1/foo/bar') { [] }
-
-        expect(::Dir).to receive(:exist?).with('/dir1/foo/baz') { true }
-        expect(::Dir).to receive(:entries).with('/dir1/foo/baz') { [] }
-
-        expect(::Dir).to receive(:entries).with('/dir2/.') { [] }
+        allow(::File).to receive(:realpath) { |path| path }
+        allow(::Dir).to receive(:entries).with('/dir1') { %w(foo) }
+        allow(::Dir).to receive(:entries).with('/dir1/foo') { %w(bar baz) }
+        allow(::Dir).to receive(:entries).with('/dir1/foo/bar') { [] }
+        allow(::Dir).to receive(:entries).with('/dir1/foo/baz') { [] }
+        allow(::Dir).to receive(:entries).with('/dir2') { [] }
       end
 
       it 'builds record'  do
@@ -290,5 +289,22 @@ describe Listen::Record do
         expect(record.paths['/dir2']).to eq({})
       end
     end
+
+    context 'with subdir containing symlink to parent' do
+      subject { record.paths }
+      before do
+        allow(::Dir).to receive(:entries).with('/dir1') { %w(foo) }
+        allow(::Dir).to receive(:entries).with('/dir1/foo') { %w(foo) }
+        allow(::File).to receive(:realpath).with('/dir1').and_return('/bar')
+        allow(::File).to receive(:realpath).with('/dir1/foo').and_return('/bar')
+      end
+
+      it 'shows message and aborts with error' do
+        expect(STDERR).to receive(:puts).with(/detected a duplicate directory/)
+
+        expect { record.build }.to raise_error(RuntimeError,
+                                               /Failed due to looped symlinks/)
+      end
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: listen
 version: !ruby/object:Gem::Version
-  version: 2.7.12
+  version: 2.8.0
 platform: ruby
 authors:
 - Thibaud Guillaume-Gentil
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-13 00:00:00.000000000 Z
+date: 2014-11-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: celluloid
@@ -165,6 +165,8 @@ files:
 - lib/listen/options.rb
 - lib/listen/queue_optimizer.rb
 - lib/listen/record.rb
+- lib/listen/record/entry.rb
+- lib/listen/record/symlink_detector.rb
 - lib/listen/silencer.rb
 - lib/listen/tcp.rb
 - lib/listen/tcp/broadcaster.rb