listen 2.7.11 → 2.7.12

data/lib/listen/internals/logging.rb

@@ -0,0 +1,31 @@
+require 'celluloid/logger'
+
+module Listen
+  module Internals
+    module Logging
+      def _info(*args)
+        _log(:info, *args)
+      end
+
+      def _warn(*args)
+        _log(:warn, *args)
+      end
+
+      def _debug(*args)
+        _log(:debug, *args)
+      end
+
+      def _log(*args)
+        Celluloid::Logger.send(*args)
+      end
+
+      def _format_error(fmt)
+        format(fmt, $ERROR_INFO, ", Backtrace: \n" + $ERROR_POSITION * "\n")
+      end
+
+      def _error_exception(fmt)
+        _log :error, _format_error(fmt)
+      end
+    end
+  end
+end

data/lib/listen/internals/thread_pool.rb

@@ -0,0 +1,19 @@
+module Listen
+  # @private api
+  module Internals
+    # Just a wrapper for tests to avoid interfereing with Celluloid's threads
+    module ThreadPool
+      def self.add(&block)
+        (@threads ||= Queue.new) << Thread.new { block.call }
+      end
+
+      def self.stop
+        return unless @threads ||= nil
+
+        killed = Queue.new
+        killed << @threads.pop.kill until @threads.empty?
+        killed.pop.join until killed.empty?
+      end
+    end
+  end
+end

data/lib/listen/listener.rb

@@ -1,4 +1,6 @@
 require 'pathname'
+
+require 'listen/version'
 require 'listen/adapter'
 require 'listen/change'
 require 'listen/record'
@@ -6,6 +8,8 @@ require 'listen/silencer'
 require 'listen/queue_optimizer'
 require 'English'
 
+require 'listen/internals/logging'
+
 module Listen
   class Listener
     include Celluloid::FSM
@@ -39,7 +43,8 @@ module Listen
       # Setup logging first
       if Celluloid.logger
         Celluloid.logger.level = _debug_level
-        _log :info, "Celluloid loglevel set to: #{Celluloid.logger.level}"
+        _info "Celluloid loglevel set to: #{Celluloid.logger.level}"
+        _info "Listen version: #{Listen::VERSION}"
       end
 
       @silencer = Silencer.new
@@ -172,6 +177,8 @@ module Listen
 
     private
 
+    include Internals::Logging
+
     def _init_options(options = {})
       { debug: false,
         latency: nil,
@@ -239,8 +246,7 @@ module Listen
         _process_changes unless state == :paused
       end
     rescue RuntimeError
-      Kernel.warn "[Listen warning]: Change block raised an exception: #{$!}"
-      Kernel.warn "Backtrace:\n\t#{$@.join("\n\t")}"
+      Kernel.warn _format_error('exception while processing events: %s %s')
     end
 
     def _silenced?(path, type)
@@ -253,10 +259,6 @@ module Listen
       adapter.start
     end
 
-    def _log(type, message)
-      Celluloid::Logger.send(type, message)
-    end
-
     def _adapter_class
       @adapter_class ||= Adapter.select(options)
     end
@@ -268,9 +270,7 @@ module Listen
       @last_queue_event_time = nil
 
       changes = []
-      while !@queue.empty?
-        changes << @queue.pop
-      end
+      changes << @queue.pop until @queue.empty?
 
       return if block.nil?
 
@@ -280,7 +280,7 @@ module Listen
       block_start = Time.now.to_f
       # TODO: condition not tested, but too complex to test ATM
       block.call(*result) unless result.all?(&:empty?)
-      _log :debug, "Callback took #{Time.now.to_f - block_start} seconds"
+      _debug "Callback took #{Time.now.to_f - block_start} seconds"
     end
 
     attr_reader :wait_thread
@@ -332,16 +332,16 @@ module Listen
     end
 
     def _queue_raw_change(type, dir, rel_path, options)
-      _log :debug, "raw queue: #{[type, dir, rel_path, options].inspect}"
+      _debug "raw queue: #{[type, dir, rel_path, options].inspect}"
 
       unless (worker = async(:change_pool))
-        _log :warn, 'Failed to allocate worker from change pool'
+        _warn 'Failed to allocate worker from change pool'
         return
       end
 
       worker.change(type, dir, rel_path, options)
     rescue RuntimeError
-      _log :error, "#{__method__} crashed: #{$!}:#{$@.join("\n")}"
+      _error_exception "_queue_raw_change exception %s:\n%s:\n"
       raise
     end
   end

data/lib/listen/record.rb

@@ -67,7 +67,7 @@ module Listen
 
       Celluloid::Logger.info "Record.build(): #{Time.now.to_f - start} seconds"
     rescue
-      Celluloid::Logger.warn "build crashed: #{$!.inspect}"
+      Celluloid::Logger.warn "build crashed: #{$ERROR_INFO.inspect}"
       raise
     end
 
@@ -105,7 +105,7 @@ module Listen
       left = Queue.new
       left << '.'
 
-      while !left.empty?
+      until left.empty?
         dirname = left.pop
         add_dir(root, dirname)
 

data/lib/listen/silencer.rb

@@ -15,8 +15,8 @@ module Listen
     )(/|$)}x
 
     # The default list of files that get ignored.
-    DEFAULT_IGNORED_EXTENSIONS  = %r{(?:
-      # Kate's tmp/swp files
+    DEFAULT_IGNORED_EXTENSIONS  = /(?:
+      # Kate's tmp\/swp files
       \..*\d+\.new
       | \.kate-swp
 
@@ -36,7 +36,7 @@ module Listen
       | \.DS_Store
       | \.tmp
       | ~
-    )$}x
+    )$/x
 
     attr_accessor :only_patterns, :ignore_patterns
 

data/lib/listen/tcp/broadcaster.rb

@@ -16,10 +16,12 @@ module Listen
       #
       def initialize(host, port)
         @sockets = []
-        _log :debug, "Broadcaster: starting tcp server: #{host}:#{port}"
+        _log :debug, format('Broadcaster: tcp server listening on: %s:%s',
+                            host, port)
         @server = TCPServer.new(host, port)
       rescue
-        _log :error, "Broadcaster.initialize: #{$!.inspect}:#{$@.join("\n")}"
+        _log :error, format('Broadcaster.initialize: %s:%s', $ERROR_INFO,
+                            $ERROR_POSITION * "\n")
         raise
       end
 
@@ -48,13 +50,14 @@ module Listen
 
       # Continuously accept and handle incoming connections
       def run
-        while socket = @server.accept
+        while (socket = @server.accept)
           @sockets << socket
         end
       rescue Celluloid::Task::TerminatedError
-        _log :debug, "TCP adapter was terminated: #{$!.inspect}"
+        _log :debug, "TCP adapter was terminated: #{$ERROR_INFO}"
       rescue
-        _log :error, "Broadcaster.run: #{$!.inspect}:#{$@.join("\n")}"
+        _log :error, format('Broadcaster.run: %s:%s', $ERROR_INFO,
+                            $ERROR_POSITION * "\n")
         raise
       end
 

data/lib/listen/version.rb

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

data/listen.gemspec

@@ -14,8 +14,8 @@ Gem::Specification.new do |s|
   s.description = 'The Listen gem listens to file modifications and '\
     'notifies you about the changes. Works everywhere!'
 
-  s.files        = `git ls-files`.split($/)
-  s.test_files   = s.files.grep(%r{^spec/})
+  s.files        = `git ls-files`.split($INPUT_RECORD_SEPARATOR)
+  s.test_files   = s.files.grep(/^spec\//)
   s.executable   = 'listen'
   s.require_path = 'lib'
 

data/spec/acceptance/listen_spec.rb

@@ -23,8 +23,7 @@ describe 'Listen' do
 
       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:.*/)
+          with(/exception while processing events: foo .*Backtrace:/)
         wrapper.listen { touch 'file.rb' }
       end
     end

data/spec/acceptance/tcp_spec.rb

@@ -6,7 +6,10 @@ describe Listen::Listener do
   let(:broadcast_options) { { forward_to: port } }
   let(:paths) { Pathname.new(Dir.pwd) }
 
-  around { |example| fixtures { example.run } }
+  around do |example|
+    fixtures { example.run }
+    Listen.stop
+  end
 
   modes = if !windows? || Celluloid::VERSION > '0.15.2'
             [:recipient, :broadcaster]

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

@@ -1,5 +1,8 @@
 require 'spec_helper'
 
+# This is just so stubs work
+require 'rb-fsevent'
+
 require 'listen/adapter/darwin'
 
 include Listen
@@ -34,4 +37,109 @@ describe Adapter::Darwin do
       it { should eq 1234 }
     end
   end
+
+  describe 'multiple dirs' do
+    subject do
+      dirs = config.keys.map { |p| Pathname(p.to_s) }
+      described_class.new(directories: dirs)
+    end
+
+    let(:foo1) { double('foo1') }
+    let(:foo2) { double('foo2') }
+    let(:foo3) { double('foo3') }
+
+    before do
+      allow(FSEvent).to receive(:new).and_return(*config.values, nil)
+      config.each do |dir, obj|
+        allow(obj).to receive(:watch).with(dir.to_s, latency: 0.1)
+      end
+      subject.configure
+    end
+
+    describe 'configuration' do
+      context 'with 1 directory' do
+        let(:config) { { dir1: foo1 } }
+
+        it 'configures directory' do
+          expect(foo1).to have_received(:watch).with('dir1', latency: 0.1)
+        end
+      end
+
+      context 'with 2 directories' do
+        let(:config) { { dir1: foo1, dir2: foo2 } }
+
+        it 'configures directories' do
+          expect(foo1).to have_received(:watch).with('dir1', latency: 0.1)
+          expect(foo2).to have_received(:watch).with('dir2', latency: 0.1)
+        end
+      end
+
+      context 'with 3 directories' do
+        let(:config) { { dir1: foo1, dir2: foo2, dir3: foo3 } }
+
+        it 'configures directories' do
+          expect(foo1).to have_received(:watch).with('dir1', latency: 0.1)
+          expect(foo2).to have_received(:watch).with('dir2', latency: 0.1)
+          expect(foo3).to have_received(:watch).with('dir3', latency: 0.1)
+        end
+      end
+    end
+
+    describe 'running threads' do
+      let(:running) { [] }
+
+      before do
+        started = Queue.new
+        threads = Queue.new
+        left = Queue.new
+
+        # NOTE: Travis has a hard time creating threads on OSX
+        thread_start_overhead = 3
+        max_test_time = 3 * thread_start_overhead
+        block_time = max_test_time + thread_start_overhead
+
+        config.each do |name, obj|
+          left << name # anything, we're just counting
+          allow(obj).to receive(:run).once do
+            threads << Thread.current
+            started << name
+            left.pop
+            sleep block_time
+          end
+        end
+
+        Timeout.timeout(max_test_time) do
+          subject.start
+          running << started.pop until left.empty?
+        end
+
+        running << started.pop until started.empty?
+
+        killed = Queue.new
+        killed << threads.pop.kill until threads.empty?
+        killed.pop.join until killed.empty?
+      end
+
+      context 'with 1 directory' do
+        let(:config) { { dir1: foo1 } }
+        it 'runs all the workers without blocking' do
+          expect(running.sort).to eq(config.keys)
+        end
+      end
+
+      context 'with 2 directories' do
+        let(:config) { { dir1: foo1, dir2: foo2 } }
+        it 'runs all the workers without blocking' do
+          expect(running.sort).to eq(config.keys)
+        end
+      end
+
+      context 'with 3 directories' do
+        let(:config) { { dir1: foo1, dir2: foo2, dir3: foo3 } }
+        it 'runs all the workers without blocking' do
+          expect(running.sort).to eq(config.keys)
+        end
+      end
+    end
+  end
 end

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

@@ -26,6 +26,7 @@ describe Adapter::Polling do
       t = Thread.new { subject.start }
       sleep 0.25
       t.kill
+      t.join
     end
   end
 

data/spec/lib/listen/file_spec.rb

@@ -6,7 +6,7 @@ describe Listen::File do
       Listen::Record,
       add_dir: true,
       update_file: true,
-      unset_path: true,
+      unset_path: true
     )
   end
 
@@ -116,17 +116,17 @@ describe Listen::File do
             let(:record_mtime) { stat_mtime.to_f }
 
             context 'with accurate stat times' do
-              let(:stat_mtime) { Time.at(1401235714.123) }
-              let(:stat_atime) { Time.at(1401235714.123) }
-              let(:stat_ctime) { Time.at(1401235714.123) }
+              let(:stat_mtime) { Time.at(1_401_235_714.123) }
+              let(:stat_atime) { Time.at(1_401_235_714.123) }
+              let(:stat_ctime) { Time.at(1_401_235_714.123) }
               let(:record_mtime) { stat_mtime.to_f }
               it { should be_nil }
             end
 
             context 'with inaccurate stat times' do
-              let(:stat_mtime) { Time.at(1401235714.0) }
-              let(:stat_atime) { Time.at(1401235714.0) }
-              let(:stat_ctime) { Time.at(1401235714.0) }
+              let(:stat_mtime) { Time.at(1_401_235_714.0) }
+              let(:stat_atime) { Time.at(1_401_235_714.0) }
+              let(:stat_ctime) { Time.at(1_401_235_714.0) }
 
               let(:record_mtime) { stat_mtime.to_f }
 
@@ -135,7 +135,7 @@ describe Listen::File do
 
                 # NOTE: if real mtime is ???14.99, the
                 # saved mtime is ???14.0
-                let(:now) { Time.at(1401235716.00) }
+                let(:now) { Time.at(1_401_235_716.00) }
                 it { should be_nil }
               end
 
@@ -144,17 +144,17 @@ describe Listen::File do
                 # so saved mtime at ???14.0 means it could be
                 # ???14.999, so ???15.999 could still be within 1 second
                 # range
-                let(:now) { Time.at(1401235715.999999) }
+                let(:now) { Time.at(1_401_235_715.999999) }
 
                 before { allow(Time).to receive(:now) { now } }
 
                 context 'without available md5' do
                   let(:md5) { fail Errno::ENOENT }
 
-                  # Treat is as an ignored file, because chances are ...  ...
+                  # Treat it as a removed file, because chances are ...
                   # whatever is listening for changes won't be able to deal
                   # with the file either (e.g. because of permissions)
-                  it { should be nil }
+                  it { should be :removed }
 
                   it 'should not unset record' do
                     expect(async_record).to_not receive(:unset_path)
@@ -229,23 +229,23 @@ describe Listen::File do
     subject { Listen::File.inaccurate_mac_time?(stat) }
 
     context 'with no accurate times' do
-      let(:mtime) { Time.at(1234567.0) }
-      let(:atime) { Time.at(1234567.0) }
-      let(:ctime) { Time.at(1234567.0) }
+      let(:mtime) { Time.at(1_234_567.0) }
+      let(:atime) { Time.at(1_234_567.0) }
+      let(:ctime) { Time.at(1_234_567.0) }
       it { should be_truthy }
     end
 
     context 'with all accurate times' do
-      let(:mtime) { Time.at(1234567.89) }
-      let(:atime) { Time.at(1234567.89) }
-      let(:ctime) { Time.at(1234567.89) }
+      let(:mtime) { Time.at(1_234_567.89) }
+      let(:atime) { Time.at(1_234_567.89) }
+      let(:ctime) { Time.at(1_234_567.89) }
       it { should be_falsey }
     end
 
     context 'with one accurate time' do
-      let(:mtime) { Time.at(1234567.0) }
-      let(:atime) { Time.at(1234567.89) }
-      let(:ctime) { Time.at(1234567.0) }
+      let(:mtime) { Time.at(1_234_567.0) }
+      let(:atime) { Time.at(1_234_567.89) }
+      let(:ctime) { Time.at(1_234_567.0) }
       it { should be_falsey }
     end
   end