listen 3.0.2 → 3.8.0

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'
@@ -16,9 +18,9 @@ module Listen
 
     class_option :directory,
                  type:    :array,
-                 default: '.',
+                 default: ['.'],
                  aliases: '-d',
-                 banner:  'The directory to listen to'
+                 banner:  'One or more directories to listen to'
 
     class_option :relative,
                  type:    :boolean,
@@ -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
 

data/lib/listen/directory.rb

@@ -1,8 +1,11 @@
+# frozen_string_literal: true
+
 require 'set'
 
 module Listen
   # TODO: refactor (turn it into a normal object, cache the stat, etc)
   class Directory
+    # rubocop:disable Metrics/MethodLength
     def self.scan(snapshot, rel_path, options)
       record = snapshot.record
       dir = Pathname.new(record.root)
@@ -12,40 +15,49 @@ module Listen
 
       # TODO: use children(with_directory: false)
       path = dir + rel_path
-      current = Set.new(path.children)
+      current = Set.new(_children(path))
 
-      Listen::Logger.debug do
+      Listen.logger.debug do
         format('%s: %s(%s): %s -> %s',
                (options[:silence] ? 'Recording' : 'Scanning'),
                rel_path, options.inspect, previous.inspect, current.inspect)
       end
 
-      current.each do |full_path|
-        type = detect_type(full_path)
-        item_rel_path = full_path.relative_path_from(dir).to_s
-        _change(snapshot, type, item_rel_path, options)
+      begin
+        current.each do |full_path|
+          type = ::File.lstat(full_path.to_s).directory? ? :dir : :file
+          item_rel_path = full_path.relative_path_from(dir).to_s
+          _change(snapshot, type, item_rel_path, options)
+        end
+      rescue Errno::ENOENT
+        # The directory changed meanwhile, so rescan it
+        current = Set.new(_children(path))
+        retry
       end
 
       # TODO: this is not tested properly
-      previous = previous.reject { |entry, _| current.include? path + entry }
+      previous = previous.reject { |entry, _| current.include?(path + entry) }
 
       _async_changes(snapshot, Pathname.new(rel_path), previous, options)
-
     rescue Errno::ENOENT, Errno::EHOSTDOWN
       record.unset_path(rel_path)
       _async_changes(snapshot, Pathname.new(rel_path), previous, options)
-
     rescue Errno::ENOTDIR
       # TODO: path not tested
       record.unset_path(rel_path)
       _async_changes(snapshot, path, previous, options)
       _change(snapshot, :file, rel_path, options)
     rescue
-      Listen::Logger.warn do
-        format('scan DIED: %s:%s', $ERROR_INFO, $ERROR_POSITION * "\n")
-      end
+      Listen.logger.warn { format('scan DIED: %s:%s', $ERROR_INFO, $ERROR_POSITION * "\n") }
       raise
     end
+    # rubocop:enable Metrics/MethodLength
+
+    def self.ascendant_of?(base, other)
+      other.ascend do |ascendant|
+        break true if base == ascendant
+      end
+    end
 
     def self._async_changes(snapshot, path, previous, options)
       fail "Not a Pathname: #{path.inspect}" unless path.respond_to?(:children)
@@ -67,14 +79,15 @@ module Listen
       snapshot.invalidate(type, path, opts)
     end
 
-    def self.detect_type(full_path)
-      # TODO: should probably check record first
-      stat = ::File.lstat(full_path.to_s)
-      stat.directory? ? :dir : :file
-    rescue Errno::ENOENT
-      # TODO: ok, it should really check the record here
-      # report as dir for scanning
-      :dir
+    def self._children(path)
+      return path.children unless RUBY_ENGINE == 'jruby'
+
+      # JRuby inconsistency workaround, see:
+      # https://github.com/jruby/jruby/issues/3840
+      exists = path.exist?
+      directory = path.directory?
+      exists && !directory and raise Errno::ENOTDIR, path.to_s
+      path.children
     end
   end
 end

data/lib/listen/error.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+# Besides programming error exceptions like ArgumentError,
+# all public interface exceptions should be declared here and inherit from Listen::Error.
+module Listen
+  class Error < RuntimeError
+    class NotStarted < Error; end
+    class SymlinkLoop < Error; end
+    class INotifyMaxWatchesExceeded < Error; end
+  end
+end

data/lib/listen/event/config.rb

@@ -1,12 +1,17 @@
+# frozen_string_literal: true
+
 module Listen
   module Event
     class Config
+      attr_reader :listener, :event_queue, :min_delay_between_events
+
       def initialize(
         listener,
         event_queue,
         queue_optimizer,
         wait_for_delay,
-        &block)
+        &block
+      )
 
         @listener = listener
         @event_queue = event_queue
@@ -15,20 +20,12 @@ module Listen
         @block = block
       end
 
-      def sleep(*args)
-        Kernel.sleep(*args)
+      def sleep(seconds)
+        Kernel.sleep(seconds)
       end
 
       def call(*args)
-        @block.call(*args) if @block
-      end
-
-      def timestamp
-        Time.now.to_f
-      end
-
-      def event_queue
-        @event_queue
+        @block&.call(*args)
       end
 
       def callable?
@@ -38,22 +35,6 @@ module Listen
       def optimize_changes(changes)
         @queue_optimizer.smoosh_changes(changes)
       end
-
-      def min_delay_between_events
-        @min_delay_between_events
-      end
-
-      def stopped?
-        listener.state == :stopped
-      end
-
-      def paused?
-        listener.state == :paused
-      end
-
-      private
-
-      attr_reader :listener
     end
   end
 end

data/lib/listen/event/loop.rb

@@ -1,53 +1,62 @@
+# frozen_string_literal: true
+
+require 'thread'
+
 require 'timeout'
 require 'listen/event/processor'
+require 'listen/thread'
+require 'listen/error'
 
 module Listen
   module Event
     class Loop
-      class Error < RuntimeError
-        class NotStarted < Error
-        end
-      end
+      include Listen::FSM
+
+      Error = ::Listen::Error
+      NotStarted = ::Listen::Error::NotStarted # for backward compatibility
+
+      start_state :pre_start
+      state :pre_start
+      state :starting
+      state :started
+      state :stopped
 
       def initialize(config)
         @config = config
         @wait_thread = nil
-        @state = :paused
-        @reasons = Thread::Queue.new
+        @reasons = ::Queue.new
+        initialize_fsm
       end
 
       def wakeup_on_event
-        return if stopped?
-        return unless processing?
-        return unless wait_thread.alive?
-        _wakeup(:event)
+        if started? && @wait_thread&.alive?
+          _wakeup(:event)
+        end
       end
 
-      def paused?
-        wait_thread && state == :paused
+      def started?
+        state == :started
       end
 
-      def processing?
-        return false if stopped?
-        return false if paused?
-        state == :processing
-      end
+      MAX_STARTUP_SECONDS = 5.0
 
-      def setup
+      # @raises Error::NotStarted if background thread hasn't started in MAX_STARTUP_SECONDS
+      def start
         # TODO: use a Fiber instead?
-        q = Thread::Queue.new
-        @wait_thread = Internals::ThreadPool.add do
-          _wait_for_changes(q, config)
+        return unless state == :pre_start
+
+        transition! :starting
+
+        @wait_thread = Listen::Thread.new("wait_thread") do
+          _process_changes
         end
 
-        Listen::Logger.debug('Waiting for processing to start...')
-        Timeout.timeout(5) { q.pop }
-      end
+        Listen.logger.debug("Waiting for processing to start...")
 
-      def resume
-        fail Error::NotStarted if stopped?
-        return unless wait_thread
-        _wakeup(:resume)
+        wait_for_state(:started, timeout: MAX_STARTUP_SECONDS) or
+          raise Error::NotStarted, "thread didn't start in #{MAX_STARTUP_SECONDS} seconds (in state: #{state.inspect})"
+
+        Listen.logger.debug('Processing started.')
       end
 
       def pause
@@ -55,60 +64,30 @@ module Listen
         # fail NotImplementedError
       end
 
-      def teardown
-        return unless wait_thread
-        if wait_thread.alive?
-          _wakeup(:teardown)
-          wait_thread.join
-        end
+      def stop
+        transition! :stopped
+
+        @wait_thread&.join
         @wait_thread = nil
       end
 
       def stopped?
-        !wait_thread
+        state == :stopped
       end
 
       private
 
-      attr_reader :config
-      attr_reader :wait_thread
-
-      attr_accessor :state
-
-      def _wait_for_changes(ready_queue, config)
-        processor = Event::Processor.new(config, @reasons)
+      def _process_changes
+        processor = Event::Processor.new(@config, @reasons)
 
-        _wait_until_resumed(ready_queue)
-        processor.loop_for(config.min_delay_between_events)
-      rescue StandardError => ex
-        _nice_error(ex)
-      end
-
-      def _sleep(*args)
-        Kernel.sleep(*args)
-      end
-
-      def _wait_until_resumed(ready_queue)
-        self.state = :paused
-        ready_queue << :ready
-        sleep
-        self.state = :processing
-      end
+        transition! :started
 
-      def _nice_error(ex)
-        indent = "\n -- "
-        msg = format(
-          'exception while processing events: %s Backtrace:%s%s',
-          ex,
-          indent,
-          ex.backtrace * indent
-        )
-        Listen::Logger.error(msg)
+        processor.loop_for(@config.min_delay_between_events)
       end
 
       def _wakeup(reason)
         @reasons << reason
-        wait_thread.wakeup
+        @wait_thread.wakeup
       end
     end
   end

data/lib/listen/event/processor.rb

@@ -1,8 +1,13 @@
+# frozen_string_literal: true
+
+require 'listen/monotonic_time'
+
 module Listen
   module Event
     class Processor
       def initialize(config, reasons)
         @config = config
+        @listener = config.listener
         @reasons = reasons
         _reset_no_unprocessed_events
       end
@@ -13,13 +18,14 @@ module Listen
         @latency = latency
 
         loop do
-          _wait_until_events
+          event = _wait_until_events
+          _check_stopped
           _wait_until_events_calm_down
           _wait_until_no_longer_paused
-          _process_changes
+          _process_changes(event)
         end
       rescue Stopped
-        Listen::Logger.debug('Processing stopped')
+        Listen.logger.debug('Processing stopped')
       end
 
       private
@@ -29,7 +35,7 @@ module Listen
 
       def _wait_until_events_calm_down
         loop do
-          now = _timestamp
+          now = MonotonicTime.now
 
           # Assure there's at least latency between callbacks to allow
           # for accumulating changes
@@ -38,82 +44,80 @@ module Listen
 
           # give events a bit of time to accumulate so they can be
           # compressed/optimized
-          _sleep(:waiting_until_latency, diff)
+          _sleep(diff)
         end
       end
 
       def _wait_until_no_longer_paused
-        # TODO: may not be a good idea?
-        _sleep(:waiting_for_unpause) while config.paused?
+        @listener.wait_for_state(*(Listener.states.keys - [:paused]))
       end
 
       def _check_stopped
-        return unless config.stopped?
-
-        _flush_wakeup_reasons
-        raise Stopped
+        if @listener.stopped?
+          _flush_wakeup_reasons
+          raise Stopped
+        end
       end
 
-      def _sleep(_local_reason, *args)
+      def _sleep(seconds)
         _check_stopped
-        sleep_duration = config.sleep(*args)
+        config.sleep(seconds)
         _check_stopped
 
         _flush_wakeup_reasons do |reason|
-          next unless reason == :event
-          _remember_time_of_first_unprocessed_event unless config.paused?
+          if reason == :event && !@listener.paused?
+            _remember_time_of_first_unprocessed_event
+          end
         end
-
-        sleep_duration
       end
 
       def _remember_time_of_first_unprocessed_event
-        @first_unprocessed_event_time ||= _timestamp
+        @_remember_time_of_first_unprocessed_event ||= MonotonicTime.now
       end
 
       def _reset_no_unprocessed_events
-        @first_unprocessed_event_time = nil
+        @_remember_time_of_first_unprocessed_event = nil
       end
 
       def _deadline
-        @first_unprocessed_event_time + @latency
+        @_remember_time_of_first_unprocessed_event + @latency
       end
 
+      # blocks until event is popped
+      # returns the event or `nil` when the event_queue is closed
       def _wait_until_events
-        # TODO: long sleep may not be a good idea?
-        _sleep(:waiting_for_events) while config.event_queue.empty?
-        @first_unprocessed_event_time ||= _timestamp
+        config.event_queue.pop.tap do |_event|
+          @_remember_time_of_first_unprocessed_event ||= MonotonicTime.now
+        end
       end
 
       def _flush_wakeup_reasons
-        reasons = @reasons
-        until reasons.empty?
-          reason = reasons.pop
+        until @reasons.empty?
+          reason = @reasons.pop
           yield reason if block_given?
         end
       end
 
-      def _timestamp
-        config.timestamp
-      end
-
       # for easier testing without sleep loop
-      def _process_changes
+      def _process_changes(event)
         _reset_no_unprocessed_events
 
-        changes = []
+        changes = [event]
         changes << config.event_queue.pop until config.event_queue.empty?
 
-        callable = config.callable?
-        return unless callable
+        return unless config.callable?
 
         hash = config.optimize_changes(changes)
         result = [hash[:modified], hash[:added], hash[:removed]]
         return if result.all?(&:empty?)
 
-        block_start = _timestamp
-        config.call(*result)
-        Listen::Logger.debug "Callback took #{_timestamp - block_start} sec"
+        block_start = MonotonicTime.now
+        exception_note = " (exception)"
+        ::Listen::Thread.rescue_and_log('_process_changes') do
+          config.call(*result)
+          exception_note = nil
+        end
+        Listen.logger.debug "Callback#{exception_note} took #{MonotonicTime.now - block_start} sec"
       end
 
       attr_reader :config

data/lib/listen/event/queue.rb

@@ -1,6 +1,14 @@
+# frozen_string_literal: true
+
+require 'thread'
+
+require 'forwardable'
+
 module Listen
   module Event
     class Queue
+      extend Forwardable
+
       class Config
         def initialize(relative)
           @relative = relative
@@ -11,9 +19,8 @@ module Listen
         end
       end
 
-      def initialize(config, &block)
-        @event_queue = Thread::Queue.new
-        @block = block
+      def initialize(config)
+        @event_queue = ::Queue.new
         @config = config
       end
 
@@ -23,28 +30,21 @@ module Listen
         fail "Invalid change: #{change.inspect}" unless change.is_a?(Symbol)
         fail "Invalid path: #{path.inspect}" unless path.is_a?(String)
 
-        dir = _safe_relative_from_cwd(dir)
-        event_queue.public_send(:<<, [type, change, dir, path, options])
-
-        block.call(args) if block
+        dir = if @config.relative?
+          _safe_relative_from_cwd(dir)
+        else
+          dir
+        end
+        @event_queue << [type, change, dir, path, options]
       end
 
-      def empty?
-        event_queue.empty?
-      end
-
-      def pop
-        event_queue.pop
-      end
+      delegate empty?: :@event_queue
+      delegate pop: :@event_queue
+      delegate close: :@event_queue
 
       private
 
-      attr_reader :event_queue
-      attr_reader :block
-      attr_reader :config
-
       def _safe_relative_from_cwd(dir)
-        return dir unless config.relative?
         dir.relative_path_from(Pathname.pwd)
       rescue ArgumentError
         dir