listen 3.2.1 → 3.4.1

data/lib/listen.rb

@@ -1,23 +1,18 @@
+# frozen_string_literal: true
+
 require 'logger'
+require 'weakref'
 require 'listen/logger'
 require 'listen/listener'
 
-require 'listen/internals/thread_pool'
-
-# Always set up logging by default first time file is required
-#
-# NOTE: If you need to clear the logger completely, do so *after*
-# requiring this file. If you need to set a custom logger,
-# require the listen/logger file and set the logger before requiring
-# this file.
-Listen.setup_default_logger_if_unset
-
 # Won't print anything by default because of level - unless you've set
 # LISTEN_GEM_DEBUGGING or provided your own logger with a high enough level
-Listen::Logger.info "Listen loglevel set to: #{Listen.logger.level}"
-Listen::Logger.info "Listen version: #{Listen::VERSION}"
+Listen.logger.info "Listen loglevel set to: #{Listen.logger.level}"
+Listen.logger.info "Listen version: #{Listen::VERSION}"
 
 module Listen
+  @listeners = Queue.new
+
   class << self
     # Listens to file system modifications on a either single directory or
     # multiple directories.
@@ -32,21 +27,21 @@ module Listen
     # @return [Listen::Listener] the listener
     #
     def to(*args, &block)
-      @listeners ||= []
       Listener.new(*args, &block).tap do |listener|
-        @listeners << listener
+        @listeners.enq(WeakRef.new(listener))
       end
     end
 
     # This is used by the `listen` binary to handle Ctrl-C
     #
     def stop
-      Internals::ThreadPool.stop
-      @listeners ||= []
-
-      # TODO: should use a mutex for this
-      @listeners.each(&:stop)
-      @listeners = nil
+      while (listener = @listeners.deq(true))
+        begin
+          listener.stop
+        rescue WeakRef::RefError
+        end
+      end
+    rescue ThreadError
     end
   end
 end

data/lib/listen/adapter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'listen/adapter/base'
 require 'listen/adapter/bsd'
 require 'listen/adapter/darwin'
@@ -9,37 +11,33 @@ module Listen
   module Adapter
     OPTIMIZED_ADAPTERS = [Darwin, Linux, BSD, Windows].freeze
     POLLING_FALLBACK_MESSAGE = 'Listen will be polling for changes.'\
-      'Learn more at https://github.com/guard/listen#listen-adapters.'.freeze
+      'Learn more at https://github.com/guard/listen#listen-adapters.'
 
     class << self
       def select(options = {})
-        _log :debug, 'Adapter: considering polling ...'
+        Listen.logger.debug 'Adapter: considering polling ...'
         return Polling if options[:force_polling]
-        _log :debug, 'Adapter: considering optimized backend...'
+        Listen.logger.debug 'Adapter: considering optimized backend...'
         return _usable_adapter_class if _usable_adapter_class
-        _log :debug, 'Adapter: falling back to polling...'
+        Listen.logger.debug 'Adapter: falling back to polling...'
         _warn_polling_fallback(options)
         Polling
       rescue
-        _log :warn, format('Adapter: failed: %s:%s', $ERROR_POSITION.inspect,
-                           $ERROR_POSITION * "\n")
+        Listen.logger.warn format('Adapter: failed: %s:%s', $ERROR_POSITION.inspect,
+                                  $ERROR_POSITION * "\n")
         raise
       end
 
       private
 
       def _usable_adapter_class
-        OPTIMIZED_ADAPTERS.detect(&:usable?)
+        OPTIMIZED_ADAPTERS.find(&:usable?)
       end
 
       def _warn_polling_fallback(options)
         msg = options.fetch(:polling_fallback_message, POLLING_FALLBACK_MESSAGE)
         Kernel.warn "[Listen warning]:\n  #{msg}" if msg
       end
-
-      def _log(type, message)
-        Listen::Logger.send(type, message)
-      end
     end
   end
 end

data/lib/listen/adapter/base.rb

@@ -1,17 +1,18 @@
+# frozen_string_literal: true
+
 require 'listen/options'
 require 'listen/record'
 require 'listen/change'
+require 'listen/thread'
 
 module Listen
   module Adapter
     class Base
-      attr_reader :options
+      attr_reader :options, :config
 
       # TODO: only used by tests
       DEFAULTS = {}.freeze
 
-      attr_reader :config
-
       def initialize(config)
         @started = false
         @config = config
@@ -28,9 +29,10 @@ module Listen
       end
 
       # TODO: it's a separate method as a temporary workaround for tests
+      # rubocop:disable Metrics/MethodLength
       def configure
         if @configured
-          _log(:warn, 'Adapter already configured!')
+          Listen.logger.warn('Adapter already configured!')
           return
         end
 
@@ -54,6 +56,7 @@ module Listen
           @snapshots[dir] = snapshot
         end
       end
+      # rubocop:enable Metrics/MethodLength
 
       def started?
         @started
@@ -63,48 +66,39 @@ module Listen
         configure
 
         if started?
-          _log(:warn, 'Adapter already started!')
+          Listen.logger.warn('Adapter already started!')
           return
         end
 
         @started = true
 
-        calling_stack = caller.dup
-        Listen::Internals::ThreadPool.add do
-          begin
-            @snapshots.values.each do |snapshot|
-              _timed('Record.build()') { snapshot.record.build }
-            end
-            _run
-          rescue
-            msg = 'run() in thread failed: %s:\n'\
-              ' %s\n\ncalled from:\n %s'
-            _log_exception(msg, calling_stack)
-            raise # for unit tests mostly
+        @run_thread = Listen::Thread.new("run_thread") do
+          @snapshots.each_value do |snapshot|
+            _timed('Record.build()') { snapshot.record.build }
           end
+          _run
         end
       end
 
       def stop
         _stop
-      end
-
-      def self.usable?
-        const_get('OS_REGEXP') =~ RbConfig::CONFIG['target_os']
+        config.queue.close # this causes queue.pop to return `nil` to the front-end
       end
 
       private
 
       def _stop
+        @run_thread&.kill
+        @run_thread = nil
       end
 
       def _timed(title)
-        start = Time.now.to_f
+        start = MonotonicTime.now
         yield
-        diff = Time.now.to_f - start
-        Listen::Logger.info format('%s: %.05f seconds', title, diff)
+        diff = MonotonicTime.now - start
+        Listen.logger.info format('%s: %.05f seconds', title, diff)
       rescue
-        Listen::Logger.warn "#{title} crashed: #{$ERROR_INFO.inspect}"
+        Listen.logger.warn "#{title} crashed: #{$ERROR_INFO.inspect}"
         raise
       end
 
@@ -114,10 +108,6 @@ module Listen
         @snapshots[dir].invalidate(type, rel_path, options)
       end
 
-      def _log(*args, &block)
-        self.class.send(:_log, *args, &block)
-      end
-
       def _log_exception(msg, caller_stack)
         formatted = format(
           msg,
@@ -126,14 +116,12 @@ module Listen
           caller_stack * "\n"
         )
 
-        _log(:error, formatted)
+        Listen.logger.error(formatted)
       end
 
       class << self
-        private
-
-        def _log(*args, &block)
-          Listen::Logger.send(*args, &block)
+        def usable?
+          const_get('OS_REGEXP') =~ RbConfig::CONFIG['target_os']
         end
       end
     end

data/lib/listen/adapter/bsd.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Listener implementation for BSD's `kqueue`.
 # @see http://www.freebsd.org/cgi/man.cgi?query=kqueue
 # @see https://github.com/mat813/rb-kqueue/blob/master/lib/rb-kqueue/queue.rb
@@ -5,7 +7,7 @@
 module Listen
   module Adapter
     class BSD < Base
-      OS_REGEXP = /bsd|dragonfly/i
+      OS_REGEXP = /bsd|dragonfly/i.freeze
 
       DEFAULTS = {
         events: [
@@ -71,8 +73,7 @@ module Listen
       def _change(event_flags)
         { modified: [:attrib, :extend],
           added:    [:write],
-          removed:  [:rename, :delete]
-        }.each do |change, flags|
+          removed:  [:rename, :delete] }.each do |change, flags|
           return change unless (flags & event_flags).empty?
         end
         nil
@@ -85,7 +86,7 @@ module Listen
       def _watch_for_new_file(event)
         queue = event.watcher.queue
         _find(_event_path(event).to_s) do |file_path|
-          unless queue.watchers.detect { |_, v| v.path == file_path.to_s }
+          unless queue.watchers.find { |_, v| v.path == file_path.to_s }
             _watch_file(file_path, queue)
           end
         end
@@ -94,7 +95,7 @@ module Listen
       def _watch_file(path, queue)
         queue.watch_file(path, *options.events, &@callback)
       rescue Errno::ENOENT => e
-        _log :warn, "kqueue: watch file failed: #{e.message}"
+        Listen.logger.warn "kqueue: watch file failed: #{e.message}"
       end
 
       # Quick rubocop workaround

data/lib/listen/adapter/config.rb

@@ -1,12 +1,11 @@
+# frozen_string_literal: true
+
 require 'pathname'
 
 module Listen
   module Adapter
     class Config
-      attr_reader :directories
-      attr_reader :silencer
-      attr_reader :queue
-      attr_reader :adapter_options
+      attr_reader :directories, :silencer, :queue, :adapter_options
 
       def initialize(directories, queue, silencer, adapter_options)
         # Default to current directory if no directories are supplied

data/lib/listen/adapter/darwin.rb

@@ -1,12 +1,13 @@
-require 'thread'
-require 'listen/internals/thread_pool'
+# frozen_string_literal: true
+
+require 'listen/thread'
 
 module Listen
   module Adapter
     # Adapter implementation for Mac OS X `FSEvents`.
     #
     class Darwin < Base
-      OS_REGEXP = /darwin(?<major_version>1\d+)/i
+      OS_REGEXP = /darwin(?<major_version>(1|2)\d+)/i.freeze
 
       # The default delay between checking for changes.
       DEFAULTS = { latency: 0.1 }.freeze
@@ -43,14 +44,14 @@ module Listen
         require 'rb-fsevent'
         worker = FSEvent.new
         dirs_to_watch = @callbacks.keys.map(&:to_s)
-        _log(:info) { "fsevent: watching: #{dirs_to_watch.inspect}" }
+        Listen.logger.info { "fsevent: watching: #{dirs_to_watch.inspect}" }
         worker.watch(dirs_to_watch, { latency: options.latency }, &method(:_process_changes))
-        Listen::Internals::ThreadPool.add { _run_worker(worker) }
+        @worker_thread = Listen::Thread.new("worker_thread") { worker.run }
       end
 
       def _process_changes(dirs)
         dirs.each do |dir|
-          dir = Pathname.new(dir.sub(%r{\/$}, ''))
+          dir = Pathname.new(dir.sub(%r{/$}, ''))
 
           @callbacks.each do |watched_dir, callback|
             if watched_dir.eql?(dir) || Listen::Directory.ascendant_of?(watched_dir, dir)
@@ -61,18 +62,15 @@ module Listen
       end
 
       def _process_event(dir, path)
-        _log(:debug) { "fsevent: processing path: #{path.inspect}" }
+        Listen.logger.debug { "fsevent: processing path: #{path.inspect}" }
         # TODO: does this preserve symlinks?
         rel_path = path.relative_path_from(dir).to_s
         _queue_change(:dir, dir, rel_path, recursive: true)
       end
 
-      def _run_worker(worker)
-        _log(:debug) { "fsevent: running worker: #{worker.inspect}" }
-        worker.run
-      rescue
-        format_string = 'fsevent: running worker failed: %s:%s called from: %s'
-        _log_exception format_string, caller
+      def _stop
+        @worker_thread&.kill
+        super
       end
     end
   end

data/lib/listen/adapter/linux.rb

@@ -1,14 +1,17 @@
+# frozen_string_literal: true
+
 module Listen
   module Adapter
     # @see https://github.com/nex3/rb-inotify
     class Linux < Base
-      OS_REGEXP = /linux/i
+      OS_REGEXP = /linux/i.freeze
 
       DEFAULTS = {
         events: [
           :recursive,
           :attrib,
           :create,
+          :modify,
           :delete,
           :move,
           :close_write
@@ -18,12 +21,12 @@ module Listen
 
       private
 
-      WIKI_URL = 'https://github.com/guard/listen'\
-        '/wiki/Increasing-the-amount-of-inotify-watchers'.freeze
+      README_URL = 'https://github.com/guard/listen'\
+        '/blob/master/README.md#increasing-the-amount-of-inotify-watchers'
 
-      INOTIFY_LIMIT_MESSAGE = <<-EOS.gsub(/^\s*/, '')
+      INOTIFY_LIMIT_MESSAGE = <<-EOS
         FATAL: Listen error: unable to monitor directories for changes.
-        Visit #{WIKI_URL} for info on how to fix this.
+        Visit #{README_URL} for info on how to fix this.
       EOS
 
       def _configure(directory, &callback)
@@ -35,11 +38,10 @@ module Listen
       end
 
       def _run
-        Thread.current[:listen_blocking_read_thread] = true
         @worker.run
-        Thread.current[:listen_blocking_read_thread] = false
       end
 
+      # rubocop:disable Metrics/MethodLength
       def _process_event(dir, event)
         # NOTE: avoid using event.absolute_name since new API
         # will need to have a custom recursion implemented
@@ -47,7 +49,7 @@ module Listen
         path = Pathname.new(event.watcher.path) + event.name
         rel_path = path.relative_path_from(dir).to_s
 
-        _log(:debug) { "inotify: #{rel_path} (#{event.flags.inspect})" }
+        Listen.logger.debug { "inotify: #{rel_path} (#{event.flags.inspect})" }
 
         if /1|true/ =~ ENV['LISTEN_GEM_SIMULATE_FSEVENT']
           if (event.flags & [:moved_to, :moved_from]) || _dir_event?(event)
@@ -72,6 +74,7 @@ module Listen
 
         _queue_change(:file, dir, rel_path, params)
       end
+      # rubocop:enable Metrics/MethodLength
 
       def _skip_event?(event)
         # Event on root directory
@@ -99,7 +102,9 @@ module Listen
       end
 
       def _stop
-        @worker && @worker.close
+        @worker&.close
+
+        super
       end
     end
   end

data/lib/listen/adapter/polling.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Listen
   module Adapter
     # Polling Adapter that works cross-platform and
@@ -6,7 +8,7 @@ module Listen
     # file IO than the other implementations.
     #
     class Polling < Base
-      OS_REGEXP = // # match every OS
+      OS_REGEXP = //.freeze # match every OS
 
       DEFAULTS = { latency: 1.0, wait_for_delay: 0.05 }.freeze
 
@@ -19,12 +21,13 @@ module Listen
 
       def _run
         loop do
-          start = Time.now.to_f
+          start = MonotonicTime.now
           @polling_callbacks.each do |callback|
             callback.call(nil)
-            nap_time = options.latency - (Time.now.to_f - start)
-            # TODO: warn if nap_time is negative (polling too slow)
-            sleep(nap_time) if nap_time > 0
+            if (nap_time = options.latency - (MonotonicTime.now - start)) > 0
+              # TODO: warn if nap_time is negative (polling too slow)
+              sleep(nap_time)
+            end
           end
         end
       end