listen 3.2.0 → 3.3.1

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,33 +42,31 @@ 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?
+        return unless @listener.stopped?
 
         _flush_wakeup_reasons
         raise Stopped
       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
@@ -79,16 +81,17 @@ module Listen
         @first_unprocessed_event_time + @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|
+          @first_unprocessed_event_time ||= _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
 
@@ -31,17 +32,15 @@ module Listen
 
         dir = _safe_relative_from_cwd(dir)
         event_queue.public_send(:<<, [type, change, dir, path, options])
-
-        block.call(args) if block
       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)

data/lib/listen/file.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'digest/md5'
 
 module Listen
@@ -6,7 +8,7 @@ module Listen
       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 +27,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,7 +71,7 @@ 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
 

data/lib/listen/fsm.rb

@@ -1,120 +1,120 @@
+# frozen_string_literal: true
+
 # Code copied from https://github.com/celluloid/celluloid-fsm
+
+require 'thread'
+
 module Listen
   module FSM
-    DEFAULT_STATE = :default # Default state name unless one is explicitly set
-
     # Included hook to extend class methods
     def self.included(klass)
       klass.send :extend, ClassMethods
     end
 
     module ClassMethods
-      # Obtain or set the default state
-      # Passing a state name sets the default state
-      def default_state(new_default = nil)
-        if new_default
-          @default_state = new_default.to_sym
+      # Obtain or set the start state
+      # Passing a state name sets the start state
+      def start_state(new_start_state = nil)
+        if new_start_state
+          new_start_state.is_a?(Symbol) or raise ArgumentError, "state name must be a Symbol (got #{new_start_state.inspect})"
+          @start_state = new_start_state
         else
-          defined?(@default_state) ? @default_state : DEFAULT_STATE
+          defined?(@start_state) or raise ArgumentError, "`start_state :<state>` must be declared before `new`"
+          @start_state
         end
       end
 
-      # Obtain the valid states for this FSM
+      # The valid states for this FSM, as a hash with state name symbols as keys and State objects as values.
       def states
         @states ||= {}
       end
 
-      # Declare an FSM state and optionally provide a callback block to fire
+      # Declare an FSM state and optionally provide a callback block to fire on state entry
       # Options:
       # * to: a state or array of states this state can transition to
-      def state(*args, &block)
-        if args.last.is_a? Hash
-          # Stringify keys :/
-          options = args.pop.each_with_object({}) { |(k, v), h| h[k.to_s] = v }
-        else
-          options = {}
-        end
-
-        args.each do |name|
-          name = name.to_sym
-          default_state name if options['default']
-          states[name] = State.new(name, options['to'], &block)
-        end
+      def state(state_name, to: nil, &block)
+        state_name.is_a?(Symbol) or raise ArgumentError, "state name must be a Symbol (got #{state_name.inspect})"
+        states[state_name] = State.new(state_name, to, &block)
       end
     end
 
-    # Be kind and call super if you must redefine initialize
-    def initialize
-      @state = self.class.default_state
+    # Note: including classes must call initialize_fsm from their initialize method.
+    def initialize_fsm
+      @fsm_initialized = true
+      @state = self.class.start_state
+      @mutex = ::Mutex.new
+      @state_changed = ::ConditionVariable.new
     end
 
-    # Obtain the current state of the FSM
+    # Current state of the FSM, stored as a symbol
     attr_reader :state
 
-    def transition(state_name)
-      new_state = validate_and_sanitize_new_state(state_name)
-      return unless new_state
-      transition_with_callbacks!(new_state)
+    # checks for one of the given states to wait for
+    # if not already, waits for a state change (up to timeout seconds--`nil` means infinite)
+    # returns truthy iff the transition to one of the desired state has occurred
+    def wait_for_state(*wait_for_states, timeout: nil)
+      @mutex.synchronize do
+        if !wait_for_states.include?(@state)
+          @state_changed.wait(@mutex, timeout)
+        end
+        wait_for_states.include?(@state)
+      end
     end
 
-    # Immediate state transition with no checks, or callbacks. "Dangerous!"
-    def transition!(state_name)
-      @state = state_name
-    end
+    private
 
-    protected
+    def transition(new_state_name)
+      new_state_name.is_a?(Symbol) or raise ArgumentError, "state name must be a Symbol (got #{new_state_name.inspect})"
+      if (new_state = validate_and_sanitize_new_state(new_state_name))
+        transition_with_callbacks!(new_state)
+      end
+    end
 
-    def validate_and_sanitize_new_state(state_name)
-      state_name = state_name.to_sym
+    # Low-level, immediate state transition with no checks or callbacks.
+    def transition!(new_state_name)
+      new_state_name.is_a?(Symbol) or raise ArgumentError, "state name must be a Symbol (got #{new_state_name.inspect})"
+      @fsm_initialized or raise ArgumentError, "FSM not initialized. You must call initialize_fsm from initialize!"
+      @mutex.synchronize do
+        yield if block_given?
+        @state = new_state_name
+        @state_changed.broadcast
+      end
+    end
 
-      return if current_state_name == state_name
+    def validate_and_sanitize_new_state(new_state_name)
+      return nil if @state == new_state_name
 
-      if current_state && !current_state.valid_transition?(state_name)
+      if current_state && !current_state.valid_transition?(new_state_name)
         valid = current_state.transitions.map(&:to_s).join(', ')
-        msg = "#{self.class} can't change state from '#{@state}'"\
-          " to '#{state_name}', only to: #{valid}"
-        fail ArgumentError, msg
+        msg = "#{self.class} can't change state from '#{@state}' to '#{new_state_name}', only to: #{valid}"
+        raise ArgumentError, msg
       end
 
-      new_state = states[state_name]
-
-      unless new_state
-        return if state_name == default_state
-        fail ArgumentError, "invalid state for #{self.class}: #{state_name}"
+      unless (new_state = self.class.states[new_state_name])
+        new_state_name == self.class.start_state or raise ArgumentError, "invalid state for #{self.class}: #{new_state_name}"
       end
 
       new_state
     end
 
-    def transition_with_callbacks!(state_name)
-      transition! state_name.name
-      state_name.call(self)
-    end
-
-    def states
-      self.class.states
-    end
-
-    def default_state
-      self.class.default_state
+    def transition_with_callbacks!(new_state)
+      transition! new_state.name
+      new_state.call(self)
     end
 
     def current_state
-      states[@state]
-    end
-
-    def current_state_name
-      current_state && current_state.name || ''
+      self.class.states[@state]
     end
 
     class State
       attr_reader :name, :transitions
 
-      def initialize(name, transitions = nil, &block)
+      def initialize(name, transitions, &block)
         @name = name
         @block = block
-        @transitions = nil
-        @transitions = Array(transitions).map(&:to_sym) if transitions
+        @transitions = if transitions
+                         Array(transitions).map(&:to_sym)
+                       end
       end
 
       def call(obj)
@@ -122,10 +122,8 @@ module Listen
       end
 
       def valid_transition?(new_state)
-        # All transitions are allowed unless expressly
-        return true unless @transitions
-
-        @transitions.include? new_state.to_sym
+        # All transitions are allowed if none are expressly declared
+        !@transitions || @transitions.include?(new_state.to_sym)
       end
     end
   end

data/lib/listen/listener.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'English'
 
 require 'listen/version'
@@ -19,7 +21,6 @@ require 'listen/listener/config'
 
 module Listen
   class Listener
-    # TODO: move the state machine's methods private
     include Listen::FSM
 
     # Initializes the directories listener.
@@ -38,7 +39,7 @@ module Listen
       @config = Config.new(options)
 
       eq_config = Event::Queue::Config.new(@config.relative?)
-      queue = Event::Queue.new(eq_config) { @processor.wakeup_on_event }
+      queue = Event::Queue.new(eq_config)
 
       silencer = Silencer.new
       rules = @config.silencer_rules
@@ -57,41 +58,42 @@ module Listen
 
       @processor = Event::Loop.new(pconfig)
 
-      super() # FSM
+      initialize_fsm
     end
 
-    default_state :initializing
+    start_state :initializing
 
     state :initializing, to: [:backend_started, :stopped]
 
-    state :backend_started, to: [:frontend_ready, :stopped] do
-      backend.start
-    end
-
-    state :frontend_ready, to: [:processing_events, :stopped] do
-      processor.setup
+    state :backend_started, to: [:processing_events, :stopped] do
+      @backend.start
     end
 
     state :processing_events, to: [:paused, :stopped] do
-      processor.resume
+      @processor.start
     end
 
     state :paused, to: [:processing_events, :stopped] do
-      processor.pause
+      @processor.pause
     end
 
     state :stopped, to: [:backend_started] do
-      backend.stop # should be before processor.teardown to halt events ASAP
-      processor.teardown
+      @backend.stop # halt events ASAP
+      @processor.stop
     end
 
     # Starts processing events and starts adapters
     # or resumes invoking callbacks if paused
     def start
-      transition :backend_started if state == :initializing
-      transition :frontend_ready if state == :backend_started
-      transition :processing_events if state == :frontend_ready
-      transition :processing_events if state == :paused
+      case state
+      when :initializing
+        transition :backend_started
+        transition :processing_events
+      when :paused
+        transition :processing_events
+      else
+        raise ArgumentError, "cannot start from state #{state.inspect}"
+      end
     end
 
     # Stops both listening for events and processing them
@@ -113,6 +115,10 @@ module Listen
       state == :paused
     end
 
+    def stopped?
+      state == :stopped
+    end
+
     def ignore(regexps)
       @silencer_controller.append_ignores(regexps)
     end
@@ -124,10 +130,5 @@ module Listen
     def only(regexps)
       @silencer_controller.replace_with_only(regexps)
     end
-
-    private
-
-    attr_reader :processor
-    attr_reader :backend
   end
 end