listen 3.0.8 → 3.5.1

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: [
@@ -16,7 +18,7 @@ module Listen
           :rename
           # :link, :revoke
         ]
-      }
+      }.freeze
 
       BUNDLER_DECLARE_GEM = <<-EOS.gsub(/^ {6}/, '')
         Please add the following to your Gemfile to avoid polling for changes:
@@ -38,9 +40,9 @@ module Listen
 
       private
 
-      def _configure(directory, &_callback)
+      def _configure(directory, &callback)
         @worker ||= KQueue::Queue.new
-        @callback = _callback
+        @callback = callback
         # use Record to make a snapshot of dir, so we
         # can detect new files
         _find(directory.to_s) { |path| _watch_file(path, @worker) }
@@ -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,17 +1,16 @@
+# 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
         directories = [Dir.pwd] if directories.to_a.empty?
-        
+
         # TODO: fix (flatten, array, compact?)
         @directories = directories.map do |directory|
           Pathname.new(directory.to_s).realpath

data/lib/listen/adapter/darwin.rb

@@ -1,15 +1,16 @@
-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 }
+      DEFAULTS = { latency: 0.1 }.freeze
 
       INCOMPATIBLE_GEM_VERSION = <<-EOS.gsub(/^ {8}/, '')
         rb-fsevent > 0.9.4 no longer supports OS X 10.6 through 10.8.
@@ -22,66 +23,54 @@ module Listen
       EOS
 
       def self.usable?
+        version = RbConfig::CONFIG['target_os'][OS_REGEXP, :major_version]
+        return false unless version
+        return true if version.to_i >= 13 # darwin13 is OS X 10.9
+
         require 'rb-fsevent'
-        darwin_version = RbConfig::CONFIG['target_os'][OS_REGEXP, :major_version] or return false
-        return true if darwin_version.to_i >= 13 # darwin13 is OS X 10.9
-        return true if Gem::Version.new(FSEvent::VERSION) <= Gem::Version.new('0.9.4')
+        fsevent_version = Gem::Version.new(FSEvent::VERSION)
+        return true if fsevent_version <= Gem::Version.new('0.9.4')
         Kernel.warn INCOMPATIBLE_GEM_VERSION
         false
       end
 
       private
 
-      # NOTE: each directory gets a DIFFERENT callback!
       def _configure(dir, &callback)
-        opts = { latency: options.latency }
-
-        @workers ||= ::Queue.new
-        @workers << FSEvent.new.tap do |worker|
-          _log :debug, "fsevent: watching: #{dir.to_s.inspect}"
-          worker.watch(dir.to_s, opts, &callback)
-        end
+        @callbacks[dir] = callback
       end
 
       def _run
-        first = @workers.pop
-
-        # NOTE: _run is called within a thread, so run every other
-        # worker in it's own thread
-        _run_workers_in_background(_to_array(@workers))
-        _run_worker(first)
+        require 'rb-fsevent'
+        worker = FSEvent.new
+        dirs_to_watch = @callbacks.keys.map(&:to_s)
+        Listen.logger.info { "fsevent: watching: #{dirs_to_watch.inspect}" }
+        worker.watch(dirs_to_watch, { latency: options.latency }, &method(:_process_changes))
+        @worker_thread = Listen::Thread.new("worker_thread") { worker.run }
       end
 
-      def _process_event(dir, event)
-        _log :debug, "fsevent: processing event: #{event.inspect}"
-        event.each do |path|
-          new_path = Pathname.new(path.sub(/\/$/, ''))
-          _log :debug, "fsevent: #{new_path}"
-          # TODO: does this preserve symlinks?
-          rel_path = new_path.relative_path_from(dir).to_s
-          _queue_change(:dir, dir, rel_path, recursive: true)
-        end
-      end
+      def _process_changes(dirs)
+        dirs.each do |dir|
+          dir = Pathname.new(dir.sub(%r{/$}, ''))
 
-      def _run_worker(worker)
-        _log :debug, "fsevent: running worker: #{worker.inspect}"
-        worker.run
-      rescue
-        _log_exception 'fsevent: running worker failed: %s:%s called from: %s', caller
+          @callbacks.each do |watched_dir, callback|
+            if watched_dir.eql?(dir) || Listen::Directory.ascendant_of?(watched_dir, dir)
+              callback.call(dir)
+            end
+          end
+        end
       end
 
-      def _run_workers_in_background(workers)
-        workers.each do |worker|
-          # NOTE: while passing local variables to the block below is not
-          # thread safe, using 'worker' from the enumerator above is ok
-          Listen::Internals::ThreadPool.add { _run_worker(worker) }
-        end
+      def _process_event(dir, path)
+        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 _to_array(queue)
-        workers = []
-        workers << queue.pop until queue.empty?
-        workers
+      def _stop
+        @worker_thread&.kill
+        super
       end
     end
   end

data/lib/listen/adapter/linux.rb

@@ -1,29 +1,32 @@
+# 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
         ],
         wait_for_delay: 0.1
-      }
+      }.freeze
 
       private
 
-      WIKI_URL = 'https://github.com/guard/listen'\
-        '/wiki/Increasing-the-amount-of-inotify-watchers'
+      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,15 +49,13 @@ 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)
             rel_path = path.dirname.relative_path_from(dir).to_s
-            _queue_change(:dir, dir, rel_path, {})
-          else
-            _queue_change(:dir, dir, rel_path, {})
           end
+          _queue_change(:dir, dir, rel_path, {})
           return
         end
 
@@ -74,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
@@ -101,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,9 +8,9 @@ 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 }
+      DEFAULTS = { latency: 1.0, wait_for_delay: 0.05 }.freeze
 
       private
 
@@ -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

data/lib/listen/adapter/windows.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 module Listen
   module Adapter
     # Adapter implementation for Windows `wdm`.
     #
     class Windows < Base
-      OS_REGEXP = /mswin|mingw|cygwin/i
+      OS_REGEXP = /mswin|mingw|cygwin/i.freeze
 
       BUNDLER_DECLARE_GEM = <<-EOS.gsub(/^ {6}/, '')
         Please add the following to your Gemfile to avoid polling for changes:
@@ -15,8 +17,8 @@ module Listen
         require 'wdm'
         true
       rescue LoadError
-        _log :debug, format('wdm - load failed: %s:%s', $ERROR_INFO,
-                            $ERROR_POSITION * "\n")
+        Listen.logger.debug format('wdm - load failed: %s:%s', $ERROR_INFO,
+                                   $ERROR_POSITION * "\n")
 
         Kernel.warn BUNDLER_DECLARE_GEM
         false
@@ -24,21 +26,20 @@ module Listen
 
       private
 
-      def _configure(dir, &callback)
+      def _configure(dir)
         require 'wdm'
-        _log :debug, 'wdm - starting...'
+        Listen.logger.debug 'wdm - starting...'
         @worker ||= WDM::Monitor.new
         @worker.watch_recursively(dir.to_s, :files) do |change|
-          callback.call([:file, change])
+          yield([:file, change])
         end
 
         @worker.watch_recursively(dir.to_s, :directories) do |change|
-          callback.call([:dir, change])
+          yield([:dir, change])
         end
 
-        events = [:attributes, :last_write]
-        @worker.watch_recursively(dir.to_s, *events) do |change|
-          callback.call([:attr, change])
+        @worker.watch_recursively(dir.to_s, :attributes, :last_write) do |change|
+          yield([:attr, change])
         end
       end
 
@@ -46,8 +47,9 @@ module Listen
         @worker.run!
       end
 
+      # rubocop:disable Metrics/MethodLength
       def _process_event(dir, event)
-        _log :debug, "wdm - callback: #{event.inspect}"
+        Listen.logger.debug "wdm - callback: #{event.inspect}"
 
         type, change = event
 
@@ -65,12 +67,12 @@ module Listen
             _queue_change(:file, dir, rel_path, options)
           end
         when :dir
-          if change.type == :removed
+          case change.type
+          when :removed
             # TODO: check if watched dir?
             _queue_change(:dir, dir, Pathname(rel_path).dirname.to_s, {})
-          elsif change.type == :added
+          when :added
             _queue_change(:dir, dir, rel_path, {})
-          else
             # do nothing - changed directory means either:
             #   - removed subdirs (handled above)
             #   - added subdirs (handled above)
@@ -79,20 +81,15 @@ module Listen
             # so what's left?
           end
         end
-      rescue
-        details = event.inspect
-        _log :error, format('wdm - callback (%): %s:%s', details, $ERROR_INFO,
-                            $ERROR_POSITION * "\n")
-        raise
       end
+      # rubocop:enable Metrics/MethodLength
 
       def _change(type)
         { modified: [:modified, :attrib], # TODO: is attrib really passed?
           added:    [:added, :renamed_new_file],
-          removed:  [:removed, :renamed_old_file] }.each do |change, types|
-          return change if types.include?(type)
+          removed:  [:removed, :renamed_old_file] }.find do |change, types|
+          types.include?(type) and break change
         end
-        nil
       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'
@@ -7,37 +9,35 @@ require 'listen/adapter/windows'
 
 module Listen
   module Adapter
-    OPTIMIZED_ADAPTERS = [Darwin, Linux, BSD, Windows]
+    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.'
 
-    def self.select(options = {})
-      _log :debug, 'Adapter: considering polling ...'
-      return Polling if options[:force_polling]
-      _log :debug, 'Adapter: considering optimized backend...'
-      return _usable_adapter_class if _usable_adapter_class
-      _log :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")
-      raise
-    end
+    class << self
+      def select(options = {})
+        Listen.logger.debug 'Adapter: considering polling ...'
+        return Polling if options[:force_polling]
+        Listen.logger.debug 'Adapter: considering optimized backend...'
+        return _usable_adapter_class if _usable_adapter_class
+        Listen.logger.debug 'Adapter: falling back to polling...'
+        _warn_polling_fallback(options)
+        Polling
+      rescue
+        Listen.logger.warn format('Adapter: failed: %s:%s', $ERROR_POSITION.inspect,
+                                  $ERROR_POSITION * "\n")
+        raise
+      end
 
-    private
+      private
 
-    def self._usable_adapter_class
-      OPTIMIZED_ADAPTERS.detect(&:usable?)
-    end
-
-    def self._warn_polling_fallback(options)
-      msg = options.fetch(:polling_fallback_message, POLLING_FALLBACK_MESSAGE)
-      Kernel.warn "[Listen warning]:\n  #{msg}" if msg
-    end
+      def _usable_adapter_class
+        OPTIMIZED_ADAPTERS.find(&:usable?)
+      end
 
-    def self._log(type, message)
-      Listen::Logger.send(type, message)
+      def _warn_polling_fallback(options)
+        msg = options.fetch(:polling_fallback_message, POLLING_FALLBACK_MESSAGE)
+        Kernel.warn "[Listen warning]:\n  #{msg}" if msg
+      end
     end
   end
 end

data/lib/listen/backend.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'listen/adapter'
 require 'listen/adapter/base'
 require 'listen/adapter/config'
@@ -8,6 +10,8 @@ require 'forwardable'
 # from exploding with huge test setup blocks
 module Listen
   class Backend
+    extend Forwardable
+
     def initialize(directories, queue, silencer, config)
       adapter_select_opts = config.adapter_select_options
 
@@ -24,17 +28,10 @@ module Listen
       @adapter = adapter_class.new(aconfig)
     end
 
-    def start
-      adapter.start
-    end
-
-    def stop
-      adapter.stop
-    end
+    delegate start: :adapter
+    delegate stop: :adapter
 
-    def min_delay_between_events
-      @min_delay_between_events
-    end
+    attr_reader :min_delay_between_events
 
     private
 

data/lib/listen/change.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'listen/file'
 require 'listen/directory'
 
@@ -28,51 +30,40 @@ module Listen
     end
 
     # Invalidate some part of the snapshot/record (dir, file, subtree, etc.)
+    # rubocop:disable Metrics/MethodLength
+    # rubocop:disable Metrics/CyclomaticComplexity
+    # rubocop:disable Metrics/PerceivedComplexity
     def invalidate(type, rel_path, options)
       watched_dir = Pathname.new(record.root)
 
       change = options[:change]
       cookie = options[:cookie]
 
-      if !cookie && config.silenced?(rel_path, type)
-        Listen::Logger.debug {  "(silenced): #{rel_path.inspect}" }
+      if !cookie && @config.silenced?(rel_path, type)
+        Listen.logger.debug { "(silenced): #{rel_path.inspect}" }
         return
       end
 
       path = watched_dir + rel_path
 
-      Listen::Logger.debug do
+      Listen.logger.debug do
         log_details = options[:silence] && 'recording' || change || 'unknown'
         "#{log_details}: #{type}:#{path} (#{options.inspect})"
       end
 
       if change
         options = cookie ? { cookie: cookie } : {}
-        config.queue(type, change, watched_dir, rel_path, options)
-      else
-        if type == :dir
-          # NOTE: POSSIBLE RECURSION
-          # TODO: fix - use a queue instead
-          Directory.scan(self, rel_path, options)
-        else
-          change = File.change(record, rel_path)
-          return if !change || options[:silence]
-          config.queue(:file, change, watched_dir, rel_path)
-        end
+        @config.queue(type, change, watched_dir, rel_path, options)
+      elsif type == :dir
+        # NOTE: POSSIBLE RECURSION
+        # TODO: fix - use a queue instead
+        Directory.scan(self, rel_path, options)
+      elsif (change = File.change(record, rel_path)) && !options[:silence]
+        @config.queue(:file, change, watched_dir, rel_path)
       end
-    rescue RuntimeError => ex
-      msg = format(
-        '%s#%s crashed %s:%s',
-        self.class,
-        __method__,
-        exinspect,
-        ex.backtrace * "\n")
-      Listen::Logger.error(msg)
-      raise
     end
-
-    private
-
-    attr_reader :config
+    # rubocop:enable Metrics/MethodLength
+    # rubocop:enable Metrics/CyclomaticComplexity
+    # rubocop:enable Metrics/PerceivedComplexity
   end
 end

data/lib/listen/cli.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'thor'
 require 'listen'
 require 'logger'
@@ -33,15 +35,16 @@ module Listen
 
   class Forwarder
     attr_reader :logger
+
     def initialize(options)
       @options = options
-      @logger = ::Logger.new(STDOUT)
-      @logger.level = ::Logger::INFO
+      @logger = ::Logger.new(STDOUT, level: ::Logger::INFO)
       @logger.formatter = proc { |_, _, _, msg| "#{msg}\n" }
     end
 
     def start
       logger.info 'Starting listen...'
+
       directory = @options[:directory]
       relative = @options[:relative]
       callback = proc do |modified, added, removed|
@@ -52,10 +55,7 @@ module Listen
         end
       end
 
-      listener = Listen.to(
-        directory,
-        relative: relative,
-        &callback)
+      listener = Listen.to(directory, relative: relative, &callback)
 
       listener.start