listen 2.7.2 → 2.7.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c2b82792fadddb794945b7796d42a8c35d3dabfc
-  data.tar.gz: e5f725bb1c8446f51fd54285c0c48f26d0740a67
+  metadata.gz: 28cb6340a990a1236af6107a77e1d2315f4b0a6d
+  data.tar.gz: 7c84f25f243f6c6dbabfa2744484896a9e5b3f8d
 SHA512:
-  metadata.gz: 7441734e63b119c9139b4272c512a7bd34a6ab7e507dfdf99c7483a70108959fafc96c1e0b489dafe9648b41f77b58141efbb3c91c14889291590d03298319d3
-  data.tar.gz: 0d00f5195e985526a4697dda89d1e1015f2b39f0e2c4c9b776a91f92ecfae13f8ce4e207b0f17ee80bd5e024c3ff75d5b816a6877324d9c6d6f96d8aa9590e6b
+  metadata.gz: 86e66ba1d8d19640984a28c0d5aeeea4fd7cfa06fb35f7815b83e3396882b092cb8ae65ddc8af53eae2f5858810aadea128f4fea95dc92357cc98142b83f6be1
+  data.tar.gz: d6c2c1afe48406ef8db1b15f4d5f52741318728f77a07c7acbf70fdc0b348efb10db1760846edb73e052cb17c32a86c2be537eee779f478640b7571c86371d54

data/README.md

@@ -148,6 +148,9 @@ debug: true                                     # Enable Celluloid logger
                                                 # default: false
 ```
 
+Also, setting the environment variable `LISTEN_GEM_DEBUGGING=1` does the same as `debug: true` above.
+
+
 ## Listen adapters
 
 The Listen gem has a set of adapters to notify it when there are changes.
@@ -200,6 +203,8 @@ Here are some things you could try to avoid forcing polling.
 
 If your application keeps using the polling-adapter and you can't figure out why, feel free to [open an issue](https://github.com/guard/listen/issues/new) (and be sure to [give all the details](https://github.com/guard/listen/blob/master/CONTRIBUTING.md)).
 
+Also, if you have problems related to receiving the wrong events, too many events or none at all, be sure set the environment variable `LISTEN_GEM_DEBUGGING=1` and include the output when reporting a new issue.
+
 ## Forwarding file events over TCP
 
 Listen is capable of forwarding file events over the network using a messaging protocol. This can be useful for virtualized development environments when file events are unavailable, as is the case with [Vagrant](https://github.com/mitchellh/vagrant).

data/lib/listen/adapter/linux.rb

@@ -55,10 +55,15 @@ module Listen
         lambda do |event|
           next if _skip_event?(event)
 
+          path = _event_path(event)
+          cookie_opts = event.cookie.zero? ? {} : { cookie: event.cookie }
+
+          Celluloid.logger.info "listen: inotify event: #{event.flags.inspect}: #{event.name}"
+
           if _dir_event?(event)
-            _notify_change(_event_path(event), type: 'Dir')
+            _notify_change(path, { type: 'Dir'}.merge(cookie_opts))
           else
-            _notify_change(_event_path(event), type: 'File', change: _change(event.flags))
+            _notify_change(path, { type: 'File', change: _change(event.flags)}.merge(cookie_opts))
           end
         end
       end
@@ -74,9 +79,11 @@ module Listen
       end
 
       def _change(event_flags)
-        { modified: [:attrib],
-          added:    [:moved_to, :create],
-          removed:  [:moved_from, :delete] }.each do |change, flags|
+        { modified:   [:attrib, :close_write],
+          moved_to:   [:moved_to],
+          moved_from: [:moved_from],
+          added:      [:create],
+          removed:    [:delete] }.each do |change, flags|
           return change unless (flags & event_flags).empty?
         end
         nil

data/lib/listen/change.rb

@@ -12,10 +12,16 @@ module Listen
     end
 
     def change(path, options)
-      return if _silencer.silenced?(path, options[:type])
+      change = options[:change]
+      cookie = options[:cookie]
 
-      if change = options[:change]
-        _notify_listener(change, path)
+      unless cookie
+        #TODO: remove silencing here (it's done later)
+        return if _silencer.silenced?(path, options[:type])
+      end
+
+      if change
+        _notify_listener(change, path, cookie ? { cookie: cookie } : {})
       else
         send("_#{options[:type].downcase}_change", path, options)
       end
@@ -34,8 +40,8 @@ module Listen
       Directory.new(listener, path, options).scan
     end
 
-    def _notify_listener(change, path)
-      listener.changes << { change => path }
+    def _notify_listener(change, path, options = {})
+      listener.changes << { change => path }.merge(options)
     end
 
     def _silencer

data/lib/listen/listener.rb

@@ -117,10 +117,10 @@ module Listen
     end
 
     def _init_debug
-      if options[:debug]
+      if options[:debug] || ENV['LISTEN_GEM_DEBUGGING'] =~ /true|1/i
         Celluloid.logger.level = Logger::INFO
       else
-        Celluloid.logger = nil
+        Celluloid.logger.level = Logger::FATAL
       end
     end
 
@@ -156,15 +156,97 @@ module Listen
 
     def _pop_changes
       popped = []
-      popped << @changes.pop until @changes.empty?
+      popped << @changes.shift until @changes.empty?
       popped
     end
 
     def _smoosh_changes(changes)
-      smooshed = { modified: [], added: [], removed: [] }
-      changes.each { |h| type = h.keys.first; smooshed[type] << h[type].to_s }
-      smooshed.each { |_, v| v.uniq! }
-      smooshed
+      if _local_fs?
+        cookies = changes.group_by { |x| x[:cookie] }
+        _squash_changes(_reinterpret_related_changes(cookies))
+      else
+        smooshed = { modified: [], added: [], removed: [] }
+        changes.each { |h| type = h.keys.first; smooshed[type] << h[type].to_s }
+        smooshed.each { |_, v| v.uniq! }
+        smooshed
+      end
+    end
+
+    def _local_fs?
+      !registry[:adapter].is_a?(Adapter::TCP)
+    end
+
+    def _squash_changes(changes)
+      actions = changes.group_by(&:last).map do |path, action_list|
+        [_logical_action_for(path, action_list.map(&:first)), path.to_s]
+      end
+      Celluloid.logger.info "listen: raw changes: #{actions.inspect}"
+
+      { modified: [], added: [], removed: [] }.tap do |squashed|
+        actions.each do |type, path|
+          squashed[type] << path unless type.nil?
+        end
+        Celluloid.logger.info "listen: final changes: #{squashed.inspect}"
+      end
+    end
+
+    def _logical_action_for(path, actions)
+      actions << :added if actions.delete(:moved_to)
+      actions << :removed if actions.delete(:moved_from)
+
+      modified = actions.find { |x| x == :modified }
+      _calculate_add_remove_difference(actions, path, modified)
+    end
+
+    def _calculate_add_remove_difference(actions, path, default_if_exists)
+      added = actions.count { |x| x == :added }
+      removed = actions.count { |x| x == :removed }
+      diff = added - removed
+
+      if path.exist?
+        if diff > 0
+          :added
+        elsif diff.zero? && added > 0
+          :modified
+        else
+          default_if_exists
+        end
+      else
+        diff < 0 ? :removed : nil
+      end
+    end
+
+    # remove extraneous rb-inotify events, keeping them only if it's a possible
+    # editor rename() call (e.g. Kate and Sublime)
+    def _reinterpret_related_changes(cookies)
+      table = { moved_to: :added, moved_from: :removed }
+      cookies.map do |cookie, changes|
+        file = _detect_possible_editor_save(changes)
+        if file
+          [[:modified, file]]
+        else
+          changes.map(&:first).reject do |type, path|
+            _silenced?(path)
+          end.map { |type, path| [table.fetch(type, type), path] }
+        end
+      end.flatten(1)
+    end
+
+    def _detect_possible_editor_save(changes)
+      return unless changes.size == 2
+
+      from, to = changes.sort { |x,y| x.keys.first <=> y.keys.first }
+      from, to = from[:moved_from], to[:moved_to]
+      return unless from and to
+
+      # Expect an ignored moved_from and non-ignored moved_to
+      # to qualify as an "editor modify"
+      _silenced?(from) && !_silenced?(to) ? to : nil
+    end
+
+    def _silenced?(path)
+      type = path.directory? ? 'Dir' : 'File'
+      registry[:silencer].silenced?(path, type)
     end
   end
 end

data/lib/listen/version.rb

@@ -1,3 +1,3 @@
 module Listen
-  VERSION = '2.7.2'
+  VERSION = '2.7.3'
 end

data/spec/lib/listen/adapter/linux_spec.rb

@@ -20,7 +20,7 @@ describe Listen::Adapter::Linux do
 
     # workaround: Celluloid ignores SystemExit exception messages
     describe "inotify limit message" do
-      let(:adapter) { described_class.new(listener) }
+      let!(:adapter) { described_class.new(listener) }
       let(:expected_message) { described_class.const_get('INOTIFY_LIMIT_MESSAGE') }
 
       before do
@@ -37,6 +37,40 @@ describe Listen::Adapter::Linux do
         expect{adapter.start}.to raise_error RuntimeError, expected_message
       end
     end
+
+    describe '_worker_callback' do
+
+      let(:expect_change) {
+        ->(change) {
+          allow_any_instance_of(Listen::Adapter::Base).to receive(:_notify_change).with(Pathname.new('path/foo.txt'), type: 'File', change: change, cookie: 123)
+        }
+      }
+
+      let(:event_callback) {
+        ->(flags) {
+          callback = adapter.send(:_worker_callback)
+          callback.call double(:event, name: 'foo.txt', flags: flags, absolute_name: 'path/foo.txt', cookie: 123)
+        }
+      }
+
+      # use case: close_write is the only way to detect changes
+      # on ecryptfs
+      it 'recognizes close_write as modify' do
+        expect_change.(:modified)
+        event_callback.([:close_write])
+      end
+
+      it 'recognizes moved_to as moved_to' do
+        expect_change.(:moved_to)
+        event_callback.([:moved_to])
+      end
+
+      it 'recognizes moved_from as moved_from' do
+        expect_change.(:moved_from)
+        event_callback.([:moved_from])
+      end
+    end
+
   end
 
   if darwin?

data/spec/lib/listen/change_spec.rb

@@ -16,8 +16,8 @@ describe Listen::Change do
     context "file path" do
       context "with known change" do
         it "notifies change directly to listener" do
-          expect(listener_changes).to receive(:<<).with(modified: 'file_path')
-          change.change('file_path', type: 'File', change: :modified)
+          expect(listener_changes).to receive(:<<).with(modified: Pathname.new('file_path'))
+          change.change(Pathname.new('file_path'), type: 'File', change: :modified)
         end
 
         it "doesn't notify to listener if path is silenced" do
@@ -25,7 +25,7 @@ describe Listen::Change do
           expect(silencer).to receive(:silenced?).and_return(true)
           expect(listener_changes).to_not receive(:<<)
 
-          change.change('file_path', type: 'File', change: :modified)
+          change.change(Pathname.new('file_path'), type: 'File', change: :modified)
         end
       end
 
@@ -34,16 +34,16 @@ describe Listen::Change do
         before { Listen::File.stub(:new) { file } }
 
         it "calls Listen::File#change" do
-          expect(Listen::File).to receive(:new).with(listener, 'file_path') { file }
+          expect(Listen::File).to receive(:new).with(listener, Pathname.new('file_path')) { file }
           expect(file).to receive(:change)
-          change.change('file_path', type: 'File')
+          change.change(Pathname.new('file_path'), type: 'File')
         end
 
         it "doesn't call Listen::File#change if path is silenced" do
-          expect(silencer).to receive(:silenced?).with('file_path', 'File').and_return(true)
+          expect(silencer).to receive(:silenced?).with(Pathname.new('file_path'), 'File').and_return(true)
           expect(Listen::File).to_not receive(:new)
 
-          change.change('file_path', type: 'File')
+          change.change(Pathname.new('file_path'), type: 'File')
         end
 
         context "that returns a change" do
@@ -53,14 +53,15 @@ describe Listen::Change do
             before { listener.stub(:listen?) { true } }
 
             it "notifies change to listener" do
-              expect(listener_changes).to receive(:<<).with(modified: 'file_path')
-              change.change('file_path', type: 'File')
+              file_path = double(Pathname, to_s: 'file_path', exist?: true)
+              expect(listener_changes).to receive(:<<).with(modified: file_path)
+              change.change(file_path, type: 'File')
             end
 
             context "silence option" do
               it "notifies change to listener" do
                 expect(listener_changes).to_not receive(:<<)
-                change.change('file_path', type: 'File', silence: true)
+                change.change(Pathname.new('file_path'), type: 'File', silence: true)
               end
             end
           end
@@ -70,7 +71,7 @@ describe Listen::Change do
 
             it "notifies change to listener" do
               expect(listener_changes).to_not receive(:<<)
-              change.change('file_path', type: 'File')
+              change.change(Pathname.new('file_path'), type: 'File')
             end
           end
         end
@@ -80,7 +81,7 @@ describe Listen::Change do
 
           it "doesn't notifies no change" do
             expect(listener_changes).to_not receive(:<<)
-            change.change('file_path', type: 'File')
+            change.change(Pathname.new('file_path'), type: 'File')
           end
         end
       end
@@ -92,9 +93,9 @@ describe Listen::Change do
       before { Listen::Directory.stub(:new) { dir } }
 
       it "calls Listen::Directory#scan" do
-        expect(Listen::Directory).to receive(:new).with(listener, 'dir_path', dir_options) { dir }
+        expect(Listen::Directory).to receive(:new).with(listener, Pathname.new('dir_path'), dir_options) { dir }
         expect(dir).to receive(:scan)
-        change.change('dir_path', dir_options)
+        change.change(Pathname.new('dir_path'), dir_options)
       end
     end
   end

data/spec/lib/listen/listener_spec.rb

@@ -61,6 +61,7 @@ describe Listen::Listener do
   describe "#start" do
     before {
       adapter.stub_chain(:async, :start)
+      silencer.stub(:silenced?) { false }
     }
 
     it "registers silencer" do
@@ -109,7 +110,8 @@ describe Listen::Listener do
     end
 
     it "calls block on changes" do
-      listener.changes = [{ modified: 'foo' }]
+      foo = double(Pathname, to_s: 'foo', exist?: true, directory?: false)
+      listener.changes = [{ modified: foo }]
       block_stub = double('block')
       listener.block = block_stub
       expect(block_stub).to receive(:call).with(['foo'], [], [])
@@ -270,6 +272,7 @@ describe Listen::Listener do
 
   describe '_wait_for_changes' do
     it 'gets two changes and calls the block once' do
+      silencer.stub(:silenced?) { false }
 
       fake_time = 0
       listener.stub(:sleep) { |sec| fake_time += sec; listener.stopping = true if fake_time > 1 }
@@ -279,6 +282,9 @@ describe Listen::Listener do
         expect(added).to eql(['bar.txt'])
       }
 
+      foo = double(Pathname, to_s: 'foo.txt', exist?: true, directory?: false)
+      bar = double(Pathname, to_s: 'bar.txt', exist?: true, directory?: false)
+
       i = 0
       listener.stub(:_pop_changes) do
         i+=1
@@ -286,9 +292,9 @@ describe Listen::Listener do
           when 1
             []
           when 2
-            [{modified: 'foo.txt'}]
+            [{modified: foo}]
           when 3
-            [{added: 'bar.txt'}]
+            [{added: bar}]
           else
             []
         end
@@ -298,4 +304,95 @@ describe Listen::Listener do
     end
   end
 
+  describe '_smoosh_changes' do
+    it 'recognizes rename from temp file' do
+      path = double(Pathname, to_s: 'foo', exist?: true, directory?: false)
+      changes = [
+        { modified: path },
+        { removed: path },
+        { added: path },
+        { modified: path }
+      ]
+      silencer.stub(:silenced?) { false }
+      smooshed = listener.send :_smoosh_changes, changes
+      expect(smooshed).to eq(modified: ['foo'], added: [], removed: [])
+    end
+
+    it 'recognizes deleted temp file' do
+      path = double(Pathname, to_s: 'foo', exist?: false, directory?: false)
+      changes = [
+        { added: path },
+        { modified: path },
+        { removed: path },
+        { modified: path }
+      ]
+      silencer.stub(:silenced?) { false }
+      smooshed = listener.send :_smoosh_changes, changes
+      expect(smooshed).to eq(modified: [], added: [], removed: [])
+    end
+
+    it 'recognizes double move as modification' do
+      # e.g. "mv foo x && mv x foo" is like "touch foo"
+      path = double(Pathname, to_s: 'foo', exist?: true, directory?: false)
+      changes = [
+        { removed: path },
+        { added: path }
+      ]
+      silencer.stub(:silenced?) { false }
+      smooshed = listener.send :_smoosh_changes, changes
+      expect(smooshed).to eq(modified: ['foo'], added: [], removed: [])
+    end
+
+    context "with cookie" do
+
+      it 'recognizes single moved_to as add' do
+        foo = double(Pathname, to_s: 'foo', exist?: true, directory?: false)
+        changes = [
+          { moved_to: foo , cookie: 4321 },
+        ]
+        expect(silencer).to receive(:silenced?).with(foo, 'File').and_return(false)
+        smooshed = listener.send :_smoosh_changes, changes
+        expect(smooshed).to eq(modified: [], added: ['foo'], removed: [])
+      end
+
+      it 'recognizes related moved_to as add' do
+        foo = double(:foo, to_s: 'foo', exist?: true, directory?: false)
+        bar = double(:bar, to_s: 'bar', exist?: true, directory?: false)
+        changes = [
+          { moved_from: foo , cookie: 4321 },
+          { moved_to: bar, cookie: 4321 },
+        ]
+        expect(silencer).to receive(:silenced?).twice.with(foo, 'File').and_return(false)
+        expect(silencer).to receive(:silenced?).with(bar, 'File').and_return(false)
+        smooshed = listener.send :_smoosh_changes, changes
+        expect(smooshed).to eq(modified: [], added: ['bar'], removed: [])
+      end
+
+      # Scenario with workaround for editors using rename()
+      it 'recognizes related moved_to with ignored moved_from as modify' do
+        ignored = double(Pathname, to_s: 'foo', exist?: true, directory?: false)
+        foo = double(Pathname, to_s: 'foo', exist?: true, directory?: false)
+        changes = [
+          { moved_from: ignored, cookie: 4321 },
+          { moved_to: foo , cookie: 4321 },
+        ]
+        expect(silencer).to receive(:silenced?).with(ignored, 'File').and_return(true)
+        expect(silencer).to receive(:silenced?).with(foo, 'File').and_return(false)
+        smooshed = listener.send :_smoosh_changes, changes
+        expect(smooshed).to eq(modified: ['foo'], added: [], removed: [])
+      end
+    end
+
+    context "with no cookie" do
+      it 'recognizes properly ignores files' do
+        ignored = double(Pathname, to_s: 'foo', exist?: true, directory?: false)
+        changes = [
+          { modified: ignored },
+        ]
+        expect(silencer).to receive(:silenced?).with(ignored, 'File') { true }
+        smooshed = listener.send :_smoosh_changes, changes
+        expect(smooshed).to eq(modified: [], added: [], removed: [])
+      end
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: listen
 version: !ruby/object:Gem::Version
-  version: 2.7.2
+  version: 2.7.3
 platform: ruby
 authors:
 - Thibaud Guillaume-Gentil
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-25 00:00:00.000000000 Z
+date: 2014-04-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: celluloid