listen 3.2.1 → 3.4.1

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
@@ -26,7 +28,7 @@ module Listen
 
       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|
           yield([:file, change])
@@ -36,8 +38,7 @@ module Listen
           yield([:dir, change])
         end
 
-        events = [:attributes, :last_write]
-        @worker.watch_recursively(dir.to_s, *events) do |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,10 +67,11 @@ 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, {})
             # do nothing - changed directory means either:
             #   - removed subdirs (handled above)
@@ -78,20 +81,15 @@ module Listen
             # so what's left?
           end
         end
-      rescue
-        details = event.inspect
-        _log :error, format('wdm - callback (%s): %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/backend.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'listen/adapter'
 require 'listen/adapter/base'
 require 'listen/adapter/config'

data/lib/listen/change.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'listen/file'
 require 'listen/directory'
 
@@ -28,49 +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)
+        @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)
-      else
-        change = File.change(record, rel_path)
-        return if !change || options[:silence]
-        config.queue(:file, change, watched_dir, rel_path)
+      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
 

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)
@@ -14,7 +17,7 @@ module Listen
       path = dir + rel_path
       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)
@@ -36,22 +39,19 @@ module Listen
       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|
@@ -86,8 +86,8 @@ module Listen
       # https://github.com/jruby/jruby/issues/3840
       exists = path.exist?
       directory = path.directory?
-      return path.children unless exists && !directory
-      raise Errno::ENOTDIR, path.to_s
+      exists && !directory and raise Errno::ENOTDIR, path.to_s
+      path.children
     end
   end
 end

data/lib/listen/error.rb

@@ -0,0 +1,10 @@
+# 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
+  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,14 @@ 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
+        @block&.call(*args)
       end
 
-      attr_reader :event_queue
-
       def callable?
         @block
       end
@@ -36,20 +35,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,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 = ::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 = ::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
@@ -57,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