listen 2.7.5 → 2.7.6

data/lib/listen/queue_optimizer.rb

@@ -0,0 +1,104 @@
+module Listen
+  module QueueOptimizer
+    private
+
+    def _smoosh_changes(changes)
+      # TODO: adapter could be nil at this point (shutdown)
+      if _adapter_class.local_fs?
+        cookies = changes.group_by do |_, _, _, options|
+          (options || {})[:cookie]
+        end
+        _squash_changes(_reinterpret_related_changes(cookies))
+      else
+        smooshed = { modified: [], added: [], removed: [] }
+        changes.each { |_, change, path, _| smooshed[change] << path.to_s }
+        smooshed.tap { |s| s.each { |_, v| v.uniq! } }
+      end
+    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
+      _log :info, "listen: raw changes: #{actions.inspect}"
+
+      { modified: [], added: [], removed: [] }.tap do |squashed|
+        actions.each do |type, path|
+          squashed[type] << path unless type.nil?
+        end
+        _log :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.detect { |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
+
+      # TODO: avoid checking if path exists and instead assume the events are
+      # in order (if last is :removed, it doesn't exist, etc.)
+      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 |_, changes|
+        file = _detect_possible_editor_save(changes)
+        if file
+          [[:modified, file]]
+        else
+          not_silenced = changes.reject do |type, _, path, _|
+            _silenced?(path, type)
+          end
+          not_silenced.map do |_, change, path, _|
+            [table.fetch(change, change), path]
+          end
+        end
+      end.flatten(1)
+    end
+
+    def _detect_possible_editor_save(changes)
+      return unless changes.size == 2
+
+      from_type = from_change = from = nil
+      to_type = to_change = to = nil
+
+      changes.each do |data|
+        case data[1]
+        when :moved_from
+          from_type, from_change, from, _ = data
+        when :moved_to
+          to_type, to_change, to, _ = data
+        else
+          return nil
+        end
+      end
+
+      return unless from && to
+
+      # Expect an ignored moved_from and non-ignored moved_to
+      # to qualify as an "editor modify"
+      _silenced?(from, from_type) && !_silenced?(to, to_type) ? to : nil
+    end
+  end
+end

data/lib/listen/record.rb

@@ -2,6 +2,7 @@ module Listen
   class Record
     include Celluloid
 
+    # TODO: deprecate
     attr_accessor :paths, :listener
 
     def initialize(listener)
@@ -9,8 +10,8 @@ module Listen
       @paths    = _init_paths
     end
 
-    def set_path(path, data)
-      new_data = file_data(path).merge(data)
+    def set_path(type, path, data = {})
+      new_data = file_data(path).merge(data).merge(type: type)
       @paths[::File.dirname(path)][::File.basename(path)] = new_data
     end
 
@@ -23,15 +24,24 @@ module Listen
     end
 
     def dir_entries(path)
-      @paths[path.to_s]
+      @paths[path.to_s].dup
     end
 
     def build
+      @last_build_at = Time.now
       @paths = _init_paths
       listener.directories.each do |path|
-        options = { type: 'Dir', recursive: true, silence: true }
-        listener.registry[:change_pool].change(path, options)
+        options = { recursive: true, silence: true, build: true }
+        listener.sync(:change_pool).change(:dir, path, options)
       end
+      sleep 0.01 until @last_build_at + 0.1 < Time.now
+    rescue
+      Celluloid.logger.warn "build crashed: #{$!.inspect}"
+      raise
+    end
+
+    def still_building!
+      @last_build_at = Time.now
     end
 
     private

data/lib/listen/silencer.rb

@@ -25,6 +25,15 @@ module Listen
       # Gedit tmp files
       | \.goutputstream-.{6}
 
+      # Intellij files
+      | ___jb_bak___
+      | ___jb_old___
+
+      # Vim swap files and write test
+      | \.sw[px]
+      | \.swpx
+      | ^4913
+
       # other files
       | \.DS_Store
       | \.tmp
@@ -39,29 +48,24 @@ module Listen
       _init_ignore_patterns
     end
 
-    def silenced?(path, type = 'Unknown')
+    def silenced?(path, type)
       silenced = false
 
       relative_path = _relative_path(path)
 
-      if only_patterns && type == 'File'
+      if only_patterns && type == :file
         silenced = !only_patterns.any? { |pattern| relative_path =~ pattern }
       end
 
       silenced || ignore_patterns.any? { |pattern| relative_path =~ pattern }
     end
 
-    def match(args)
-      path, type = args.first
-      silenced?(path, type)
-    end
-
     private
 
     def _init_only_patterns
-      if listener.options[:only]
-        @only_patterns = Array(listener.options[:only])
-      end
+      return unless listener.options[:only]
+
+      @only_patterns = Array(listener.options[:only])
     end
 
     def _init_ignore_patterns

data/lib/listen/tcp.rb

@@ -6,4 +6,3 @@ rescue LoadError
 end
 
 require 'listen/adapter/tcp'
-require 'listen/tcp/listener'

data/lib/listen/tcp/broadcaster.rb

@@ -7,8 +7,6 @@ module Listen
 
       finalizer :finalize
 
-      attr_reader :server, :sockets
-
       # Initializes a Celluloid::IO-powered TCP-broadcaster
       #
       # @param [String] host to broadcast on
@@ -17,8 +15,11 @@ module Listen
       # Note: Listens on all addresses when host is nil
       #
       def initialize(host, port)
-        @server = TCPServer.new(host, port)
         @sockets = []
+        @server = TCPServer.new(host, port)
+      rescue
+        _log :error, "Broadcaster.initialize: #{$!.inspect}:#{$@.join("\n")}"
+        raise
       end
 
       # Asynchronously start accepting connections
@@ -28,42 +29,46 @@ module Listen
 
       # Cleans up sockets and server
       def finalize
-        if @server
-          @sockets.clear
-          @server.close
-          @server = nil
-        end
+        @sockets.map(&:close) if @sockets
+        @sockets = nil
+
+        return unless @server
+        @server.close
+        @server = nil
       end
 
       # Broadcasts given payload to all connected sockets
       def broadcast(payload)
-        @sockets.each do |socket|
-          unicast(socket, payload)
+        active_sockets = @sockets.select do |socket|
+          _unicast(socket, payload)
         end
-      end
-
-      # Unicasts payload to given socket
-      #
-      # @return [Boolean] whether writing to socket was succesful
-      #
-      def unicast(socket, payload)
-        socket.write(payload)
-        true
-      rescue IOError, Errno::ECONNRESET, Errno::EPIPE
-        @sockets.delete(socket)
-        false
+        @sockets.replace(active_sockets)
       end
 
       # Continuously accept and handle incoming connections
       def run
         while socket = @server.accept
-          handle_connection(socket)
+          @sockets << socket
         end
+      rescue Celluloid::Task::TerminatedError
+        _log :debug, "TCP adapter was terminated: #{$!.inspect}"
+      rescue
+        _log :error, "Broadcaster.run: #{$!.inspect}:#{$@.join("\n")}"
+        raise
+      end
+
+      private
+
+      def _log(type, message)
+        Celluloid.logger.send(type, message)
       end
 
-      # Handles incoming socket connection
-      def handle_connection(socket)
-        @sockets << socket
+      def _unicast(socket, payload)
+        socket.write(payload)
+        true
+      rescue IOError, Errno::ECONNRESET, Errno::EPIPE
+        _log :debug, "Broadcaster failed: #{socket.inspect}"
+        false
       end
     end
   end

data/lib/listen/tcp/message.rb

@@ -13,8 +13,8 @@ module Listen
       #
       # @param [Object] object to initialize message with
       #
-      def initialize(object = nil)
-        self.object = object if object
+      def initialize(*args)
+        self.object = args
       end
 
       # Generates message size and payload for given object

data/lib/listen/version.rb

@@ -1,3 +1,3 @@
 module Listen
-  VERSION = '2.7.5'
+  VERSION = '2.7.6'
 end

data/listen.gemspec

@@ -28,6 +28,6 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'bundler', '>= 1.3.5'
   s.add_development_dependency 'celluloid-io', '>= 0.15.0'
   s.add_development_dependency 'rake'
-  s.add_development_dependency 'rspec', '~> 2.14'
+  s.add_development_dependency 'rspec', '~> 3.0.0rc1'
   s.add_development_dependency 'rspec-retry'
 end

data/spec/acceptance/listen_spec.rb

@@ -2,23 +2,16 @@
 require 'spec_helper'
 
 describe 'Listen' do
+  let(:base_options) { { wait_for_delay: 0.1, latency: 0.1 } }
+  let(:polling_options) { {} }
   let(:options) { {} }
+  let(:all_options) { base_options.merge(polling_options).merge(options) }
 
-  let(:callback) do
-    lambda do |modified, added, removed|
-      add_changes(:modified, modified)
-      add_changes(:added, added)
-      add_changes(:removed, removed)
-    end
-  end
-
-  let(:listener) { @listener }
-  before do
-    @listener = setup_listener(options, callback)
-    @listener.start
-  end
+  let(:wrapper) { setup_listener(all_options, :track_changes) }
+  before { wrapper.listener.start }
+  after { wrapper.listener.stop }
 
-  after { listener.stop }
+  subject { wrapper }
 
   context 'with one listen dir' do
     let(:paths) { Pathname.new(Dir.pwd) }
@@ -26,291 +19,210 @@ describe 'Listen' do
 
     context 'with change block raising' do
       let(:callback) { ->(_, _, _) { fail 'foo' } }
+      let(:wrapper) { setup_listener(all_options, callback) }
 
       it 'warns the backtrace' do
         expect(Kernel).to receive(:warn).
           with('[Listen warning]: Change block raised an exception: foo')
         expect(Kernel).to receive(:warn).with(/^Backtrace:.*/)
-        listen { touch 'file.rb' }
+        wrapper.listen { touch 'file.rb' }
       end
     end
 
     [false, true].each do |polling|
       context "force_polling option to #{polling}" do
-        let(:options) { { force_polling: polling, latency: 0.1 } }
+        let(:polling_options) { { force_polling: polling } }
 
-        context 'nothing in listen dir' do
-          it 'listens to file addition' do
-            expect(listen do
-              touch 'file.rb'
-            end).to eq(modified: [], added: ['file.rb'], removed: [])
-          end
+        context 'with default ignore options' do
+          context 'with nothing in listen dir' do
+
+            it { is_expected.to process_addition_of('file.rb') }
+            it { is_expected.to process_addition_of('.hidden') }
 
-          it 'listens to multiple files addition' do
-            result = listen do
-              touch 'file1.rb'
-              touch 'file2.rb'
+            it 'listens to multiple files addition' do
+              result = wrapper.listen do
+                change_fs(:added, 'file1.rb')
+                change_fs(:added, 'file2.rb')
+              end
+
+              expect(result).to eq(modified: [],
+                                   added: %w(file1.rb file2.rb),
+                                   removed: [])
             end
 
-            expect(result).to eq(modified: [],
-                                 added: %w(file1.rb file2.rb),
-                                 removed: [])
+            it 'listens to file moved inside' do
+              touch '../file.rb'
+              expect(wrapper.listen do
+                mv '../file.rb', 'file.rb'
+              end).to eq(modified: [], added: ['file.rb'], removed: [])
+            end
           end
 
-          it 'listens to file moved inside' do
-            touch '../file.rb'
-            expect(listen do
-              mv '../file.rb', 'file.rb'
-            end).to eq(modified: [], added: ['file.rb'], removed: [])
-          end
-        end
+          context 'existing file.rb in listen dir' do
+            around do |example|
+              change_fs(:added, 'file.rb')
+              example.run
+            end
 
-        context 'file in listen dir' do
-          around do |example|
-            touch 'file.rb'
-            example.run
-          end
+            it { is_expected.to process_modification_of('file.rb') }
+            it { is_expected.to process_removal_of('file.rb') }
 
-          it 'listens to file touch' do
-            expect(listen do
-              touch 'file.rb'
-            end).to eq(modified: ['file.rb'], added: [], removed: [])
-          end
+            it 'listens to file.rb moved out' do
+              expect(wrapper.listen do
+                mv 'file.rb', '../file.rb'
+              end).to eq(modified: [], added: [], removed: ['file.rb'])
+            end
 
-          it 'listens to file modification' do
-            expect(listen do
-              open('file.rb', 'w') { |f| f.write('foo') }
-            end).to eq(modified: ['file.rb'], added: [], removed: [])
-          end
+            it 'listens to file mode change' do
+              prev_mode = File.stat('file.rb').mode
 
-          it 'listens to file modification and wait' do
-            expect(listen do
-              open('file.rb', 'w') { |f| f.write('foo') }
-              sleep 0.5
-            end).to eq(modified: ['file.rb'], added: [], removed: [])
-          end
+              result = wrapper.listen do
+                windows? ? `attrib +r file.rb` : chmod(0444, 'file.rb')
+              end
 
-          it 'listens to file echo' do
-            expect(listen do
-              `echo  foo > #{Dir.pwd}/file.rb`
-            end).to eq(modified: ['file.rb'], added: [], removed: [])
-          end
+              new_mode = File.stat('file.rb').mode
+              no_event = result[:modified].empty? && prev_mode == new_mode
 
-          it 'listens to file removal' do
-            expect(listen do
-              rm 'file.rb'
-            end).to eq(modified: [], added: [], removed: ['file.rb'])
-          end
+              # Check if chmod actually works or an attrib event happens,
+              # or expect nothing otherwise
+              #
+              # (e.g. fails for polling+vfat on Linux, but works with
+              # INotify+vfat because you get an event regardless if mode
+              # actually changes)
+              #
+              files = no_event ? [] : ['file.rb']
 
-          it 'listens to file moved out' do
-            expect(listen do
-              mv 'file.rb', '../file.rb'
-            end).to eq(modified: [], added: [], removed: ['file.rb'])
+              expect(result).to eq(modified: files, added: [], removed: [])
+            end
           end
 
-          it 'listens to file mode change' do
-            expect(listen do
-              chmod 0777, 'file.rb'
-            end).to eq(modified: ['file.rb'], added: [], removed: [])
-          end
-        end
+          context 'hidden file in listen dir' do
+            around do |example|
+              change_fs(:added, '.hidden')
+              example.run
+            end
 
-        context 'hidden file in listen dir' do
-          around do |example|
-            touch '.hidden'
-            example.run
+            it { is_expected.to process_modification_of('.hidden') }
           end
 
-          it 'listens to file touch' do
-            expect(listen do
-              touch '.hidden'
-            end).to eq(modified: ['.hidden'], added: [], removed: [])
-          end
-        end
+          context 'dir in listen dir' do
+            around do |example|
+              mkdir_p 'dir'
+              example.run
+            end
 
-        context 'dir in listen dir' do
-          around do |example|
-            mkdir_p 'dir'
-            example.run
+            it { is_expected.to process_addition_of('dir/file.rb') }
           end
 
-          it 'listens to file touch' do
-            expect(listen do
+          context 'dir with file in listen dir' do
+            around do |example|
+              mkdir_p 'dir'
               touch 'dir/file.rb'
-            end).to eq(modified: [], added: ['dir/file.rb'], removed: [])
-          end
-        end
-
-        context 'dir with file in listen dir' do
-          around do |example|
-            mkdir_p 'dir'
-            touch 'dir/file.rb'
-            example.run
-          end
+              example.run
+            end
 
-          it 'listens to file move' do
-            expected = { modified: [],
-                         added: %w(file.rb),
-                         removed: %w(dir/file.rb)
-            }
+            it 'listens to file move' do
+              expected = { modified: [],
+                           added: %w(file.rb),
+                           removed: %w(dir/file.rb)
+              }
 
-            expect(listen do
-              mv 'dir/file.rb', 'file.rb'
-            end).to eq expected
-          end
-        end
-
-        context 'two dirs with files in listen dir' do
-          around do |example|
-            mkdir_p 'dir1'
-            touch 'dir1/file1.rb'
-            mkdir_p 'dir2'
-            touch 'dir2/file2.rb'
-            example.run
+              expect(wrapper.listen do
+                mv 'dir/file.rb', 'file.rb'
+              end).to eq expected
+            end
           end
 
-          it 'listens to multiple file moves' do
-            expected = {
-              modified: [],
-              added: ['dir1/file2.rb', 'dir2/file1.rb'],
-              removed: ['dir1/file1.rb', 'dir2/file2.rb']
-            }
-
-            expect(listen do
-              mv 'dir1/file1.rb', 'dir2/file1.rb'
-              mv 'dir2/file2.rb', 'dir1/file2.rb'
-            end).to eq expected
-          end
+          context 'two dirs with files in listen dir' do
+            around do |example|
+              mkdir_p 'dir1'
+              touch 'dir1/file1.rb'
+              mkdir_p 'dir2'
+              touch 'dir2/file2.rb'
+              example.run
+            end
 
-          it 'listens to dir move' do
-            expected = { modified: [],
-                         added: ['dir2/dir1/file1.rb'],
-                         removed: ['dir1/file1.rb'] }
+            it 'listens to multiple file moves' do
+              expected = {
+                modified: [],
+                added: ['dir1/file2.rb', 'dir2/file1.rb'],
+                removed: ['dir1/file1.rb', 'dir2/file2.rb']
+              }
+
+              expect(wrapper.listen do
+                mv 'dir1/file1.rb', 'dir2/file1.rb'
+                mv 'dir2/file2.rb', 'dir1/file2.rb'
+              end).to eq expected
+            end
 
-            expect(listen do
-              mv 'dir1', 'dir2/'
-            end).to eq expected
-          end
-        end
+            it 'listens to dir move' do
+              expected = { modified: [],
+                           added: ['dir2/dir1/file1.rb'],
+                           removed: ['dir1/file1.rb'] }
 
-        context 'default ignored dir with file in listen dir' do
-          around do |example|
-            mkdir_p '.bundle'
-            touch '.bundle/file.rb'
-            example.run
+              expect(wrapper.listen do
+                mv 'dir1', 'dir2/'
+              end).to eq expected
+            end
           end
 
-          let(:options) { { force_polling: polling, latency: 0.1 } }
+          context 'with .bundle dir ignored by default' do
+            around do |example|
+              mkdir_p '.bundle'
+              example.run
+            end
 
-          it "doesn't listen to file touch" do
-            expect(listen do
-              touch '.bundle/file.rb'
-            end).to eq(modified: [], added: [], removed: [])
+            it { is_expected.not_to process_addition_of('.bundle/file.rb') }
           end
         end
 
-        context 'ignored dir with file in listen dir' do
-          around do |example|
-            mkdir_p 'ignored_dir'
-            touch 'ignored_dir/file.rb'
-            example.run
-          end
+        context 'when :ignore is *ignored_dir*' do
+          context 'ignored dir with file in listen dir' do
+            let(:options) { { ignore: /ignored_dir/ } }
 
-          let(:options) do
-            { force_polling: polling,
-              latency: 0.1,
-              ignore: /ignored_dir/ }
-          end
+            around do |example|
+              mkdir_p 'ignored_dir'
+              example.run
+            end
 
-          it "doesn't listen to file touch" do
-            expect(listen do
-              touch 'ignored_dir/file.rb'
-            end).to eq(modified: [], added: [], removed: [])
+            it { is_expected.not_to process_addition_of('ignored_dir/file.rb') }
           end
-        end
 
-        context 'with ignored file in listen dir' do
-          around do |example|
-            touch 'file.rb'
-            example.run
-          end
-          let(:options) do
-            { force_polling: polling,
-              latency: 0.1,
-              ignore: /\.rb$/ }
-          end
+          context 'when :only is *.rb' do
+            let(:options) { { only: /\.rb$/ } }
 
-          it "doesn't listen to file touch" do
-            expect(listen do
-              touch 'file.rb'
-            end).to eq(modified: [], added: [], removed: [])
+            it { is_expected.to process_addition_of('file.rb') }
+            it { is_expected.not_to process_addition_of('file.txt') }
           end
-        end
 
-        context 'with only option' do
-          let(:options) do
-            { force_polling: polling,
-              latency: 0.1,
-              only: /\.rb$/ }
-          end
+          context 'when :ignore is bar.rb' do
+            context 'when :only is *.rb' do
+              let(:options) { { ignore: /bar\.rb$/, only: /\.rb$/ } }
 
-          it 'listens only to file touch matching with only patterns' do
-            expect(listen do
-              touch 'file.rb'
-              touch 'file.txt'
-            end).to eq(modified: [], added: ['file.rb'], removed: [])
+              it { is_expected.to process_addition_of('file.rb') }
+              it { is_expected.not_to process_addition_of('file.txt') }
+              it { is_expected.not_to process_addition_of('bar.rb') }
+            end
           end
-        end
 
-        context 'with ignore and only option' do
-          let(:options) do
-            { force_polling: polling,
-              latency: 0.1,
-              ignore: /bar\.rb$/, only: /\.rb$/ }
-          end
+          context 'when default ignore is *.rb' do
+            let(:options) { { ignore: /\.rb$/ } }
 
-          it 'listens only to file touch matching with only patterns' do
-            expect(listen do
-              touch 'file.rb'
-              touch 'bar.rb'
-              touch 'file.txt'
-            end).to eq(modified: [], added: ['file.rb'], removed: [])
-          end
-        end
+            it { is_expected.not_to process_addition_of('file.rb') }
 
-        describe '#ignore' do
-          around do |example|
-            touch 'file.rb'
-            example.run
-          end
-          let(:options) do
-            { force_polling: polling,
-              latency: 0.1,
-              ignore: /\.rb$/ }
-          end
+            context 'with #ignore on *.txt mask' do
+              before { wrapper.listener.ignore(/\.txt/) }
 
-          it 'overwrites existing patterns' do
-            expect(listen do
-              listener.ignore(/\.txt/)
-              touch 'file.rb'
-              touch 'file.txt'
-            end).to eq(modified: [], added: [], removed: [])
-          end
-        end
+              it { is_expected.not_to process_addition_of('file.rb') }
+              it { is_expected.not_to process_addition_of('file.txt') }
+            end
 
-        describe '#ignore!' do
-          let(:options) do
-            { force_polling: polling,
-              latency: 0.1,
-              ignore: /\.rb$/ }
-          end
+            context 'with #ignore! on *.txt mask' do
+              before { wrapper.listener.ignore!(/\.txt/) }
 
-          it 'overwrites existing patterns' do
-            expect(listen do
-              listener.ignore!(/\.txt/)
-              touch 'file.rb'
-              touch 'file.txt'
-            end).to eq(modified: [], added: ['file.rb'], removed: [])
+              it { is_expected.to process_addition_of('file.rb') }
+              it { is_expected.not_to process_addition_of('file.txt') }
+            end
           end
         end
       end