listen 3.2.1 → 3.3.2

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,18 @@ 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
+        @block&.call(*args)
       end
 
       def timestamp
         Time.now.to_f
       end
 
-      attr_reader :event_queue
-
       def callable?
         @block
       end
@@ -36,20 +39,6 @@ module Listen
       def optimize_changes(changes)
         @queue_optimizer.smoosh_changes(changes)
       end
-
-      attr_reader :min_delay_between_events
-
-      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,55 +1,61 @@
+# frozen_string_literal: true
+
 require 'thread'
 
 require 'timeout'
 require 'listen/event/processor'
+require 'listen/thread'
 
 module Listen
   module Event
     class Loop
+      include Listen::FSM
+
       class Error < RuntimeError
-        class NotStarted < Error
-        end
+        class NotStarted < Error; end
       end
 
+      start_state :pre_start
+      state :pre_start
+      state :starting
+      state :started
+      state :stopped
+
       def initialize(config)
         @config = config
         @wait_thread = nil
-        @state = :paused
         @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
+      def start
         # TODO: use a Fiber instead?
-        q = ::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...")
+
+        wait_for_state(:started, MAX_STARTUP_SECONDS) or
+          raise Error::NotStarted, "thread didn't start in #{MAX_STARTUP_SECONDS} seconds (in state: #{state.inspect})"
 
-      def resume
-        fail Error::NotStarted if stopped?
-        return unless wait_thread
-        _wakeup(:resume)
+        Listen.logger.debug('Processing started.')
       end
 
       def pause
@@ -57,60 +63,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 _process_changes
+        processor = Event::Processor.new(@config, @reasons)
 
-      def _wait_for_changes(ready_queue, config)
-        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,11 @@
+# frozen_string_literal: true
+
 module Listen
   module Event
     class Processor
       def initialize(config, reasons)
         @config = config
+        @listener = config.listener
         @reasons = reasons
         _reset_no_unprocessed_events
       end
@@ -13,13 +16,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
@@ -38,57 +42,56 @@ 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 ||= _timestamp
       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 ||= _timestamp
+        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
@@ -98,22 +101,25 @@ module Listen
       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"
+        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 #{_timestamp - block_start} sec"
       end
 
       attr_reader :config

data/lib/listen/event/queue.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'thread'
 
 require 'forwardable'
@@ -17,9 +19,8 @@ module Listen
         end
       end
 
-      def initialize(config, &block)
+      def initialize(config)
         @event_queue = ::Queue.new
-        @block = block
         @config = config
       end
 
@@ -29,23 +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
 
-      delegate empty?: :event_queue
-      delegate pop: :event_queue
+      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

data/lib/listen/file.rb

@@ -1,12 +1,17 @@
+# frozen_string_literal: true
+
 require 'digest/md5'
 
 module Listen
   class File
+    # rubocop:disable Metrics/MethodLength
+    # rubocop:disable Metrics/CyclomaticComplexity
+    # rubocop:disable Metrics/PerceivedComplexity
     def self.change(record, rel_path)
       path = Pathname.new(record.root) + rel_path
       lstat = path.lstat
 
-      data = { mtime: lstat.mtime.to_f, mode: lstat.mode }
+      data = { mtime: lstat.mtime.to_f, mode: lstat.mode, size: lstat.size }
 
       record_data = record.file_data(rel_path)
 
@@ -25,6 +30,11 @@ module Listen
         return :modified
       end
 
+      if data[:size] != record_data[:size]
+        record.update_file(rel_path, data)
+        return :modified
+      end
+
       return if /1|true/ =~ ENV['LISTEN_GEM_DISABLE_HASHING']
       return unless inaccurate_mac_time?(lstat)
 
@@ -64,9 +74,12 @@ module Listen
       record.unset_path(rel_path)
       :removed
     rescue
-      Listen::Logger.debug "lstat failed for: #{rel_path} (#{$ERROR_INFO})"
+      Listen.logger.debug "lstat failed for: #{rel_path} (#{$ERROR_INFO})"
       raise
     end
+    # rubocop:enable Metrics/MethodLength
+    # rubocop:enable Metrics/CyclomaticComplexity
+    # rubocop:enable Metrics/PerceivedComplexity
 
     def self.inaccurate_mac_time?(stat)
       # 'mac' means Modified/Accessed/Created