listen 2.10.1 → 3.0.0

data/lib/listen/backend.rb

@@ -0,0 +1,41 @@
+require 'listen/adapter'
+require 'listen/adapter/base'
+require 'listen/adapter/config'
+
+# This class just aggregates configuration object to avoid Listener specs
+# from exploding with huge test setup blocks
+module Listen
+  class Backend
+    def initialize(directories, queue, silencer, config)
+      adapter_select_opts = config.adapter_select_options
+
+      adapter_class = Adapter.select(adapter_select_opts)
+
+      # Use default from adapter if possible
+      @min_delay_between_events = config.min_delay_between_events
+      @min_delay_between_events ||= adapter_class::DEFAULTS[:wait_for_delay]
+      @min_delay_between_events ||= 0.1
+
+      adapter_opts = config.adapter_instance_options(adapter_class)
+
+      aconfig = Adapter::Config.new(directories, queue, silencer, adapter_opts)
+      @adapter = adapter_class.new(aconfig)
+    end
+
+    def start
+      adapter.start
+    end
+
+    def stop
+      # TODO: does nothing
+    end
+
+    def min_delay_between_events
+      @min_delay_between_events
+    end
+
+    private
+
+    attr_reader :adapter
+  end
+end

data/lib/listen/change.rb

@@ -2,58 +2,77 @@ require 'listen/file'
 require 'listen/directory'
 
 module Listen
+  # TODO: rename to Snapshot
   class Change
-    include Celluloid
+    # TODO: test this class for coverage
+    class Config
+      def initialize(queue, silencer)
+        @queue = queue
+        @silencer = silencer
+      end
+
+      def silenced?(path, type)
+        @silencer.silenced?(Pathname(path), type)
+      end
+
+      def queue(*args)
+        @queue << args
+      end
+    end
 
-    attr_accessor :listener
+    attr_reader :record
 
-    def initialize(listener)
-      @listener = listener
+    def initialize(config, record)
+      @config = config
+      @record = record
     end
 
-    def change(type, watched_dir, rel_path, options = {})
+    # Invalidate some part of the snapshot/record (dir, file, subtree, etc.)
+    def invalidate(type, rel_path, options)
+      watched_dir = Pathname.new(record.root)
+
       change = options[:change]
       cookie = options[:cookie]
 
-      if !cookie && listener.silencer.silenced?(Pathname(rel_path), type)
-        _log :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
 
-      log_details = options[:silence] && 'recording' || change || 'unknown'
-      _log :debug, "#{log_details}: #{type}:#{path} (#{options.inspect})"
+      Listen::Logger.debug do
+        log_details = options[:silence] && 'recording' || change || 'unknown'
+        "#{log_details}: #{type}:#{path} (#{options.inspect})"
+      end
 
       if change
-        # TODO: move this to Listener to avoid Celluloid overhead
-        # from caller
         options = cookie ? { cookie: cookie } : {}
-        listener.queue(type, change, watched_dir, rel_path, options)
+        config.queue(type, change, watched_dir, rel_path, options)
       else
-        return unless (record = listener.sync(:record))
-
         if type == :dir
-          return unless (change_queue = listener.async(:change_pool))
-          Directory.scan(change_queue, record, watched_dir, rel_path, options)
+          # NOTE: POSSIBLE RECURSION
+          # TODO: fix - use a queue instead
+          Directory.scan(self, rel_path, options)
         else
-          change = File.change(record, watched_dir, rel_path)
+          change = File.change(record, rel_path)
           return if !change || options[:silence]
-          listener.queue(:file, change, watched_dir, rel_path)
+          config.queue(:file, change, watched_dir, rel_path)
         end
       end
-    rescue Celluloid::Task::TerminatedError
-      _log :debug, "Change#change was terminated: #{$ERROR_INFO.inspect}"
-    rescue RuntimeError
-      _log :error, format('Change#change crashed %s:%s', $ERROR_INFO.inspect,
-                          $ERROR_POSITION * "\n")
+    rescue RuntimeError => ex
+      msg = format(
+        '%s#%s crashed %s:%s',
+        self.class,
+        __method__,
+        exinspect,
+        ex.backtrace * "\n")
+      Listen::Logger.error(msg)
       raise
     end
 
     private
 
-    def _log(type, message)
-      Celluloid::Logger.send(type, message)
-    end
+    attr_reader :config
   end
 end

data/lib/listen/cli.rb

@@ -14,12 +14,6 @@ module Listen
                  aliases: '-v',
                  banner:  'Verbose'
 
-    class_option :forward,
-                 type:    :string,
-                 default: '127.0.0.1:4000',
-                 aliases: '-f',
-                 banner:  'The address to forward filesystem events'
-
     class_option :directory,
                  type:    :array,
                  default: '.',
@@ -41,14 +35,13 @@ module Listen
     attr_reader :logger
     def initialize(options)
       @options = options
-      @logger = Logger.new(STDOUT)
-      @logger.level = Logger::INFO
+      @logger = ::Logger.new(STDOUT)
+      @logger.level = ::Logger::INFO
       @logger.formatter = proc { |_, _, _, msg| "#{msg}\n" }
     end
 
     def start
       logger.info 'Starting listen...'
-      address = @options[:forward]
       directory = @options[:directory]
       relative = @options[:relative]
       callback = proc do |modified, added, removed|
@@ -61,13 +54,12 @@ module Listen
 
       listener = Listen.to(
         directory,
-        forward_to: address,
         relative: relative,
         &callback)
 
       listener.start
 
-      sleep 0.5 while listener.listen?
+      sleep 0.5 while listener.processing?
     end
   end
 end

data/lib/listen/directory.rb

@@ -1,78 +1,80 @@
 require 'set'
 
 module Listen
+  # TODO: refactor (turn it into a normal object, cache the stat, etc)
   class Directory
-    def self.scan(queue, sync_record, dir, rel_path, options)
-      return unless (record = sync_record.async)
+    def self.scan(snapshot, rel_path, options)
+      record = snapshot.record
+      dir = Pathname.new(record.root)
+      previous = record.dir_entries(rel_path)
 
-      previous = sync_record.dir_entries(dir, rel_path)
-
-      record.add_dir(dir, rel_path)
+      record.add_dir(rel_path)
 
       # TODO: use children(with_directory: false)
       path = dir + rel_path
       current = Set.new(path.children)
 
-      _log(: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 = full_path.directory? ? :dir : :file
+        type = detect_type(full_path)
         item_rel_path = full_path.relative_path_from(dir).to_s
-        _change(queue, type, dir, item_rel_path, options)
+        _change(snapshot, type, item_rel_path, options)
       end
 
       # TODO: this is not tested properly
       previous = previous.reject { |entry, _| current.include? path + entry }
 
-      _async_changes(dir, rel_path, queue, previous, options)
+      _async_changes(snapshot, Pathname.new(rel_path), previous, options)
 
     rescue Errno::ENOENT, Errno::EHOSTDOWN
-      record.unset_path(dir, rel_path)
-      _async_changes(dir, rel_path, queue, previous, options)
+      record.unset_path(rel_path)
+      _async_changes(snapshot, Pathname.new(rel_path), previous, options)
 
     rescue Errno::ENOTDIR
       # TODO: path not tested
-      record.unset_path(dir, rel_path)
-      _async_changes(dir, path, queue, previous, options)
-      _change(queue, :file, dir, rel_path, options)
+      record.unset_path(rel_path)
+      _async_changes(snapshot, path, previous, options)
+      _change(snapshot, :file, rel_path, options)
     rescue
-      _log(:warn) do
+      Listen::Logger.warn do
         format('scan DIED: %s:%s', $ERROR_INFO, $ERROR_POSITION * "\n")
       end
       raise
     end
 
-    def self._async_changes(dir, path, queue, previous, options)
+    def self._async_changes(snapshot, path, previous, options)
+      fail "Not a Pathname: #{path.inspect}" unless path.respond_to?(:children)
       previous.each do |entry, data|
         # TODO: this is a hack with insufficient testing
         type = data.key?(:mtime) ? :file : :dir
-        _change(queue, type, dir, (Pathname(path) + entry).to_s, options)
+        rel_path_s = (path + entry).to_s
+        _change(snapshot, type, rel_path_s, options)
       end
     end
 
-    def self._change(queue, type, dir, path, options)
-      return queue.change(type, dir, path, options) if type == :dir
+    def self._change(snapshot, type, path, options)
+      return snapshot.invalidate(type, path, options) if type == :dir
 
       # Minor param cleanup for tests
       # TODO: use a dedicated Event class
       opts = options.dup
       opts.delete(:recursive)
-      if opts.empty?
-        queue.change(type, dir, path)
-      else
-        queue.change(type, dir, path, opts)
-      end
+      snapshot.invalidate(type, path, opts)
     end
 
-    def self._log(type, &block)
-      return unless Celluloid.logger
-      Celluloid.logger.send(type) do
-        block.call
-      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
     end
   end
 end

data/lib/listen/event/config.rb

@@ -0,0 +1,59 @@
+module Listen
+  module Event
+    class Config
+      def initialize(
+        listener,
+        event_queue,
+        queue_optimizer,
+        wait_for_delay,
+        &block)
+
+        @listener = listener
+        @event_queue = event_queue
+        @queue_optimizer = queue_optimizer
+        @min_delay_between_events = wait_for_delay
+        @block = block
+      end
+
+      def sleep(*args)
+        Kernel.sleep(*args)
+      end
+
+      def call(*args)
+        @block.call(*args) if @block
+      end
+
+      def timestamp
+        Time.now.to_f
+      end
+
+      def event_queue
+        @event_queue
+      end
+
+      def callable?
+        @block
+      end
+
+      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

@@ -0,0 +1,113 @@
+require 'listen/event/processor'
+
+module Listen
+  module Event
+    class Loop
+      class Error < RuntimeError
+        class NotStarted < Error
+        end
+      end
+
+      def initialize(config)
+        @config = config
+        @wait_thread = nil
+        @state = :paused
+        @reasons = Thread::Queue.new
+      end
+
+      def wakeup_on_event
+        return if stopped?
+        return unless processing?
+        return unless wait_thread.alive?
+        _wakeup(:event)
+      end
+
+      def paused?
+        wait_thread && state == :paused
+      end
+
+      def processing?
+        return false if stopped?
+        return false if paused?
+        state == :processing
+      end
+
+      def setup
+        # TODO: use a Fiber instead?
+        q = Thread::Queue.new
+        @wait_thread = Internals::ThreadPool.add do
+          _wait_for_changes(q, config)
+        end
+
+        Listen::Logger.debug('Waiting for processing to start...')
+        Timeout.timeout(5) { q.pop }
+      end
+
+      def resume
+        fail Error::NotStarted if stopped?
+        return unless wait_thread
+        _wakeup(:resume)
+      end
+
+      def pause
+        fail NotImplementedError
+      end
+
+      def teardown
+        return unless wait_thread
+        if wait_thread.alive?
+          _wakeup(:teardown)
+          wait_thread.join
+        end
+        @wait_thread = nil
+      end
+
+      def stopped?
+        !wait_thread
+      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)
+
+        _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
+
+      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)
+      end
+
+      def _wakeup(reason)
+        @reasons << reason
+        wait_thread.wakeup
+      end
+    end
+  end
+end