listen 0.5.3 → 3.7.1

data/lib/listen/event/processor.rb

@@ -0,0 +1,126 @@
+# 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
+
+      # TODO: implement this properly instead of checking the state at arbitrary
+      # points in time
+      def loop_for(latency)
+        @latency = latency
+
+        loop do
+          event = _wait_until_events
+          _check_stopped
+          _wait_until_events_calm_down
+          _wait_until_no_longer_paused
+          _process_changes(event)
+        end
+      rescue Stopped
+        Listen.logger.debug('Processing stopped')
+      end
+
+      private
+
+      class Stopped < RuntimeError
+      end
+
+      def _wait_until_events_calm_down
+        loop do
+          now = MonotonicTime.now
+
+          # Assure there's at least latency between callbacks to allow
+          # for accumulating changes
+          diff = _deadline - now
+          break if diff <= 0
+
+          # give events a bit of time to accumulate so they can be
+          # compressed/optimized
+          _sleep(diff)
+        end
+      end
+
+      def _wait_until_no_longer_paused
+        @listener.wait_for_state(*(Listener.states.keys - [:paused]))
+      end
+
+      def _check_stopped
+        if @listener.stopped?
+          _flush_wakeup_reasons
+          raise Stopped
+        end
+      end
+
+      def _sleep(seconds)
+        _check_stopped
+        config.sleep(seconds)
+        _check_stopped
+
+        _flush_wakeup_reasons do |reason|
+          if reason == :event && !@listener.paused?
+            _remember_time_of_first_unprocessed_event
+          end
+        end
+      end
+
+      def _remember_time_of_first_unprocessed_event
+        @_remember_time_of_first_unprocessed_event ||= MonotonicTime.now
+      end
+
+      def _reset_no_unprocessed_events
+        @_remember_time_of_first_unprocessed_event = nil
+      end
+
+      def _deadline
+        @_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
+        config.event_queue.pop.tap do |_event|
+          @_remember_time_of_first_unprocessed_event ||= MonotonicTime.now
+        end
+      end
+
+      def _flush_wakeup_reasons
+        until @reasons.empty?
+          reason = @reasons.pop
+          yield reason if block_given?
+        end
+      end
+
+      # for easier testing without sleep loop
+      def _process_changes(event)
+        _reset_no_unprocessed_events
+
+        changes = [event]
+        changes << config.event_queue.pop until config.event_queue.empty?
+
+        return unless config.callable?
+
+        hash = config.optimize_changes(changes)
+        result = [hash[:modified], hash[:added], hash[:removed]]
+        return if result.all?(&:empty?)
+
+        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
+    end
+  end
+end

data/lib/listen/event/queue.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'thread'
+
+require 'forwardable'
+
+module Listen
+  module Event
+    class Queue
+      extend Forwardable
+
+      class Config
+        def initialize(relative)
+          @relative = relative
+        end
+
+        def relative?
+          @relative
+        end
+      end
+
+      def initialize(config)
+        @event_queue = ::Queue.new
+        @config = config
+      end
+
+      def <<(args)
+        type, change, dir, path, options = *args
+        fail "Invalid type: #{type.inspect}" unless [:dir, :file].include? type
+        fail "Invalid change: #{change.inspect}" unless change.is_a?(Symbol)
+        fail "Invalid path: #{path.inspect}" unless path.is_a?(String)
+
+        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 close: :@event_queue
+
+      private
+
+      def _safe_relative_from_cwd(dir)
+        dir.relative_path_from(Pathname.pwd)
+      rescue ArgumentError
+        dir
+      end
+    end
+  end
+end

data/lib/listen/file.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require 'digest'
+
+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, size: lstat.size }
+
+      record_data = record.file_data(rel_path)
+
+      if record_data.empty?
+        record.update_file(rel_path, data)
+        return :added
+      end
+
+      if data[:mode] != record_data[:mode]
+        record.update_file(rel_path, data)
+        return :modified
+      end
+
+      if data[:mtime] != record_data[:mtime]
+        record.update_file(rel_path, data)
+        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)
+
+      # Check if change happened within 1 second (maybe it's even
+      # too much, e.g. 0.3-0.5 could be sufficient).
+      #
+      # With rb-fsevent, there's a (configurable) latency between
+      # when file was changed and when the event was triggered.
+      #
+      # If a file is saved at ???14.998, by the time the event is
+      # actually received by Listen, the time could already be e.g.
+      # ???15.7.
+      #
+      # And since Darwin adapter uses directory scanning, the file
+      # mtime may be the same (e.g. file was changed at ???14.001,
+      # then at ???14.998, but the fstat time would be ???14.0 in
+      # both cases).
+      #
+      # If change happened at ???14.999997, the mtime is 14.0, so for
+      # an mtime=???14.0 we assume it could even be almost ???15.0
+      #
+      # So if Time.now.to_f is ???15.999998 and stat reports mtime
+      # at ???14.0, then event was due to that file'd change when:
+      #
+      # ???15.999997 - ???14.999998 < 1.0s
+      #
+      # So the "2" is "1 + 1" (1s to cover rb-fsevent latency +
+      # 1s maximum difference between real mtime and that recorded
+      # in the file system)
+      #
+      return if data[:mtime].to_i + 2 <= Time.now.to_f
+
+      sha = Digest::SHA256.file(path).digest
+      record.update_file(rel_path, data.merge(sha: sha))
+      if record_data[:sha] && sha != record_data[:sha]
+        :modified
+      end
+    rescue SystemCallError
+      record.unset_path(rel_path)
+      :removed
+    rescue
+      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
+
+      # Since precision depends on mounted FS (e.g. you can have a FAT partiion
+      # mounted on Linux), check for fields with a remainder to detect this
+
+      [stat.mtime, stat.ctime, stat.atime].map(&:usec).all?(&:zero?)
+    end
+  end
+end

data/lib/listen/fsm.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+# Code copied from https://github.com/celluloid/celluloid-fsm
+
+require 'thread'
+
+module Listen
+  module FSM
+    # Included hook to extend class methods
+    def self.included(klass)
+      klass.send :extend, ClassMethods
+    end
+
+    module ClassMethods
+      # 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?(@start_state) or raise ArgumentError, "`start_state :<state>` must be declared before `new`"
+          @start_state
+        end
+      end
+
+      # 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 on state entry
+      # Options:
+      # * to: a state or array of states this state can transition to
+      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
+
+    # 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
+
+    # Current state of the FSM, stored as a symbol
+    attr_reader :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)
+      wait_for_states.each do |state|
+        state.is_a?(Symbol) or raise ArgumentError, "states must be symbols (got #{state.inspect})"
+      end
+      @mutex.synchronize do
+        if !wait_for_states.include?(@state)
+          @state_changed.wait(@mutex, timeout)
+        end
+        wait_for_states.include?(@state)
+      end
+    end
+
+    private
+
+    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
+
+    # 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
+
+    def validate_and_sanitize_new_state(new_state_name)
+      return nil if @state == new_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 '#{new_state_name}', only to: #{valid}"
+        raise ArgumentError, msg
+      end
+
+      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!(new_state)
+      transition! new_state.name
+      new_state.call(self)
+    end
+
+    def current_state
+      self.class.states[@state]
+    end
+
+    class State
+      attr_reader :name, :transitions
+
+      def initialize(name, transitions, &block)
+        @name = name
+        @block = block
+        @transitions = if transitions
+          Array(transitions).map(&:to_sym)
+        end
+      end
+
+      def call(obj)
+        obj.instance_eval(&@block) if @block
+      end
+
+      def valid_transition?(new_state)
+        # All transitions are allowed if none are expressly declared
+        !@transitions || @transitions.include?(new_state.to_sym)
+      end
+    end
+  end
+end

data/lib/listen/listener/config.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Listen
+  class Listener
+    class Config
+      DEFAULTS = {
+        # Listener options
+        debug: false, # TODO: is this broken?
+        wait_for_delay: nil, # NOTE: should be provided by adapter if possible
+        relative: false,
+
+        # Backend selecting options
+        force_polling: false,
+        polling_fallback_message: nil
+      }.freeze
+
+      def initialize(opts)
+        @options = DEFAULTS.merge(opts)
+        @relative = @options[:relative]
+        @min_delay_between_events = @options[:wait_for_delay]
+        @silencer_rules = @options # silencer will extract what it needs
+      end
+
+      def relative?
+        @relative
+      end
+
+      attr_reader :min_delay_between_events, :silencer_rules
+
+      def adapter_instance_options(klass)
+        valid_keys = klass.const_get('DEFAULTS').keys
+        Hash[@options.select { |key, _| valid_keys.include?(key) }]
+      end
+
+      def adapter_select_options
+        valid_keys = %w[force_polling polling_fallback_message].map(&:to_sym)
+        Hash[@options.select { |key, _| valid_keys.include?(key) }]
+      end
+    end
+  end
+end