listen 2.7.6 → 2.7.7

data/lib/listen/adapter/windows.rb

@@ -25,14 +25,21 @@ module Listen
 
       private
 
-      def _configure
+      def _configure(dir, &callback)
+        require 'wdm'
         _log :debug, 'wdm - starting...'
-        @worker = WDM::Monitor.new
-        _directories.each do |path|
-          @worker.watch_recursively(path.to_s, :files, &_file_callback)
-          @worker.watch_recursively(path.to_s, :directories, &_dir_callback)
-          @worker.watch_recursively(path.to_s, :attributes, :last_write,
-                                    &_attr_callback)
+        @worker ||= WDM::Monitor.new
+        @worker.watch_recursively(dir.to_s, :files) do |change|
+          callback.call([:file, change])
+        end
+
+        @worker.watch_recursively(dir.to_s, :directories) do |change|
+          callback.call([:dir, change])
+        end
+
+        events = [:attributes, :last_write]
+        @worker.watch_recursively(dir.to_s, *events) do |change|
+          callback.call([:attr, change])
         end
       end
 
@@ -40,62 +47,43 @@ module Listen
         @worker.run!
       end
 
-      def _file_callback
-        lambda do |change|
-          begin
-            path = _path(change.path)
-            _log :debug, "wdm - FILE callback: #{change.inspect}"
-            options = { change: _change(change.type) }
-            _notify_change(:file, path, options)
-          rescue
-            _log :error, "wdm - callback failed: #{$!}:#{$@.join("\n")}"
-            raise
-          end
-        end
-      end
+      def _process_event(dir, event)
+        _log :debug, "wdm - callback: #{event.inspect}"
 
-      def _attr_callback
-        lambda do |change|
-          begin
-            path = _path(change.path)
-            return if path.directory?
+        type, change = event
 
-            _log :debug, "wdm - ATTR callback: #{change.inspect}"
-            options = { change: _change(change.type) }
-            _notify_change(:file, _path(change.path), options)
-          rescue
-            _log :error, "wdm - callback failed: #{$!}:#{$@.join("\n")}"
-            raise
-          end
-        end
-      end
+        full_path = Pathname(change.path)
+
+        rel_path = full_path.relative_path_from(dir).to_s
 
-      def _dir_callback
-        lambda do |change|
-          begin
-            path = _path(change.path)
-            _log :debug, "wdm - DIR callback: #{change.inspect}"
-            if change.type == :removed
-              _notify_change(:dir, path.dirname)
-            elsif change.type == :added
-              _notify_change(:dir, path)
-            else
-              # do nothing - changed directory means either:
-              #   - removed subdirs (handled above)
-              #   - added subdirs (handled above)
-              #   - removed files (handled by _file_callback)
-              #   - added files (handled by _file_callback)
-              # so what's left?
-            end
-          rescue
-            _log :error, "wdm - callback failed: #{$!}:#{$@.join("\n")}"
-            raise
+        options = { change: _change(change.type) }
+
+        case type
+        when :file
+          _queue_change(:file, dir, rel_path, options)
+        when :attr
+          unless full_path.directory?
+            _queue_change(:file, dir, rel_path, options)
+          end
+        when :dir
+          if change.type == :removed
+            # TODO: check if watched dir?
+            _queue_change(:dir, dir, Pathname(rel_path).dirname.to_s, {})
+          elsif change.type == :added
+            _queue_change(:dir, dir, rel_path, {})
+          else
+            # do nothing - changed directory means either:
+            #   - removed subdirs (handled above)
+            #   - added subdirs (handled above)
+            #   - removed files (handled by _file_callback)
+            #   - added files (handled by _file_callback)
+            # so what's left?
           end
         end
-      end
-
-      def _path(path)
-        Pathname.new(path)
+      rescue
+        details = event.inspect
+        _log :error, "wdm - callback (#{details}): #{$!}:#{$@.join("\n")}"
+        raise
       end
 
       def _change(type)

data/lib/listen/change.rb

@@ -11,31 +11,35 @@ module Listen
       @listener = listener
     end
 
-    def change(type, path, options = {})
+    def change(type, watched_dir, rel_path, options = {})
       change = options[:change]
       cookie = options[:cookie]
 
-      if !cookie && listener.silencer.silenced?(path, type)
-        _log :debug, "(silenced): #{path.inspect}"
+      if !cookie && listener.silencer.silenced?(Pathname(rel_path), type)
+        _log :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})"
 
       if change
-        listener.queue(type, change, path, cookie ? { cookie: cookie } : {})
+        # TODO: move this to Listener to avoid Celluloid overhead
+        # from caller
+        options = cookie ? { cookie: cookie } : {}
+        listener.queue(type, change, watched_dir, rel_path, options)
       else
         return unless (record = listener.sync(:record))
-        record.async.still_building! if options[:build]
 
         if type == :dir
           return unless (change_queue = listener.async(:change_pool))
-          Directory.scan(change_queue, record, path, options)
+          Directory.scan(change_queue, record, watched_dir, rel_path, options)
         else
-          change = File.change(record, path)
+          change = File.change(record, watched_dir, rel_path)
           return if !change || options[:silence]
-          listener.queue(:file, change, path)
+          listener.queue(:file, change, watched_dir, rel_path)
         end
       end
     rescue Celluloid::Task::TerminatedError

data/lib/listen/directory.rb

@@ -2,61 +2,69 @@ require 'set'
 
 module Listen
   class Directory
-    def self.scan(queue, sync_record, path, options = {})
+    def self.scan(queue, sync_record, dir, rel_path, options)
       return unless (record = sync_record.async)
 
-      previous = sync_record.dir_entries(path)
+      previous = sync_record.dir_entries(dir, rel_path)
 
-      record.set_path(:dir, path)
+      record.add_dir(dir, rel_path)
+
+      # TODO: use children(with_directory: false)
+      path = dir + rel_path
       current = Set.new(path.children)
 
       if options[:silence]
-        _log :debug, "Recording: #{path}: #{options.inspect}"\
+        _log :debug, "Recording: #{rel_path}: #{options.inspect}"\
           " [#{previous.inspect}] -> (#{current.inspect})"
       else
-        _log :debug, "Scanning: #{path}: #{options.inspect}"\
+        _log :debug, "Scanning: #{rel_path}: #{options.inspect}"\
           " [#{previous.inspect}] -> (#{current.inspect})"
       end
 
       current.each do |full_path|
-        if full_path.directory?
-          _change(queue, :dir, full_path, options)
-        else
-          _change(queue, :file, full_path, options)
-        end
+        type = full_path.directory? ? :dir : :file
+        item_rel_path = full_path.relative_path_from(dir).to_s
+        _change(queue, type, dir, item_rel_path, options)
       end
 
+      # TODO: this is not tested properly
       previous.reject! { |entry, _| current.include? path + entry }
-      _async_changes(path, queue, previous, options)
+
+      _async_changes(dir, rel_path, queue, previous, options)
 
     rescue Errno::ENOENT
-      record.unset_path(path)
-      _async_changes(path, queue, previous, options)
+      record.unset_path(dir, rel_path)
+      _async_changes(dir, rel_path, queue, previous, options)
 
     rescue Errno::ENOTDIR
       # TODO: path not tested
-      record.unset_path(path)
-      _async_changes(path, queue, previous, options)
-      _change(queue, :file, path, options)
+      record.unset_path(dir, rel_path)
+      _async_changes(dir, path, queue, previous, options)
+      _change(queue, :file, dir, rel_path, options)
     rescue
       _log :warn, "scanning DIED: #{$!}:#{$@.join("\n")}"
       raise
     end
 
-    def self._async_changes(path, queue, previous, options)
+    def self._async_changes(dir, path, queue, previous, options)
       previous.each do |entry, data|
-        _change(queue, data[:type], path + entry, options)
+        # TODO: this is a hack with insufficient testing
+        type = data.key?(:mtime) ? :file : :dir
+        _change(queue, type, dir, (Pathname(path) + entry).to_s, options)
       end
     end
 
-    def self._change(queue, type, full_path, options)
-      return queue.change(type, full_path, options) if type == :dir
+    def self._change(queue, type, dir, path, options)
+      return queue.change(type, dir, 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, full_path)
+        queue.change(type, dir, path)
       else
-        queue.change(type, full_path, opts)
+        queue.change(type, dir, path, opts)
       end
     end
 

data/lib/listen/file.rb

@@ -1,24 +1,25 @@
 module Listen
   class File
-    def self.change(record, path)
+    def self.change(record, dir, rel_path)
+      path = dir + rel_path
       lstat = path.lstat
 
       data = { mtime: lstat.mtime.to_f, mode: lstat.mode }
 
-      record_data = record.file_data(path)
+      record_data = record.file_data(dir, rel_path)
 
       if record_data.empty?
-        record.async.set_path(:file, path, data)
+        record.async.update_file(dir, rel_path, data)
         return :added
       end
 
       if data[:mode] != record_data[:mode]
-        record.async.set_path(:file, path, data)
+        record.async.update_file(dir, rel_path, data)
         return :modified
       end
 
       if data[:mtime] != record_data[:mtime]
-        record.async.set_path(:file, path, data)
+        record.async.update_file(dir, rel_path, data)
         return :modified
       end
 
@@ -54,7 +55,7 @@ module Listen
           if data[:mtime].to_i + 2 > Time.now.to_f
             begin
               md5 = Digest::MD5.file(path).digest
-              record.async.set_path(:file, path, data.merge(md5: md5))
+              record.async.update_file(dir, rel_path, data.merge(md5: md5))
               :modified if record_data[:md5] && md5 != record_data[:md5]
 
             rescue SystemCallError
@@ -64,10 +65,10 @@ module Listen
         end
       end
     rescue SystemCallError
-      record.async.unset_path(path)
+      record.async.unset_path(dir, rel_path)
       :removed
     rescue
-      Celluloid::Logger.debug "lstat failed for: #{path} (#{$!})"
+      Celluloid::Logger.debug "lstat failed for: #{rel_path} (#{$!})"
       raise
     end
 

data/lib/listen/listener.rb

@@ -13,6 +13,8 @@ module Listen
 
     attr_accessor :block
 
+    attr_reader :silencer
+
     # TODO: deprecate
     attr_reader :options, :directories
     attr_reader :registry, :supervisor
@@ -35,6 +37,9 @@ module Listen
       Celluloid.logger.level = _debug_level
       _log :info, "Celluloid loglevel set to: #{Celluloid.logger.level}"
 
+      @silencer = Silencer.new
+      _reconfigure_silencer({})
+
       @tcp_mode = nil
       if [:recipient, :broadcaster].include? args[1]
         target = args.shift
@@ -145,24 +150,21 @@ module Listen
       @registry[type]
     end
 
-    def queue(type, change, path, options = {})
+    def queue(type, change, dir, path, options = {})
       fail "Invalid type: #{type.inspect}" unless [:dir, :file].include? type
       fail "Invalid change: #{change.inspect}" unless change.is_a?(Symbol)
-      @queue << [type, change, path, options]
+      fail "Invalid path: #{path.inspect}" unless path.is_a?(String)
+      @queue << [type, change, dir, path, options]
 
       @last_queue_event_time = Time.now.to_f
       _wakeup_wait_thread unless state == :paused
 
       return unless @tcp_mode == :broadcaster
 
-      message = TCP::Message.new(type, change, path, options)
+      message = TCP::Message.new(type, change, dir, path, options)
       registry[:broadcaster].async.broadcast(message.payload)
     end
 
-    def silencer
-      @registry[:silencer]
-    end
-
     private
 
     def _init_options(options = {})
@@ -191,7 +193,6 @@ module Listen
 
     def _init_actors
       @supervisor = Celluloid::SupervisionGroup.run!(registry)
-      supervisor.add(Silencer, as: :silencer, args: self)
       supervisor.add(Record, as: :record, args: self)
       supervisor.pool(Change, as: :change_pool, args: self)
 
@@ -205,7 +206,8 @@ module Listen
         registry[:broadcaster].start
       end
 
-      supervisor.add(_adapter_class, as: :adapter, args: self)
+      options = [mq: self, directories: directories]
+      supervisor.add(_adapter_class, as: :adapter, args: options)
     end
 
     def _wait_for_changes
@@ -236,12 +238,13 @@ module Listen
     end
 
     def _silenced?(path, type)
-      sync(:silencer).silenced?(path, type)
+      @silencer.silenced?(path, type)
     end
 
     def _start_adapter
       # Don't run async, because configuration has to finish first
-      sync(:adapter).start
+      adapter = sync(:adapter)
+      adapter.start
     end
 
     def _log(type, message)
@@ -294,7 +297,13 @@ module Listen
 
     def _reconfigure_silencer(extra_options)
       @options.merge!(extra_options)
-      registry[:silencer] = Silencer.new(self)
+
+      # TODO: this should be directory specific
+      rules = [:only, :ignore, :ignore!].map do |option|
+        [option, @options[option]] if @options.key? option
+      end
+
+      @silencer.configure(Hash[rules.compact])
     end
 
     def _start_wait_thread
@@ -313,5 +322,19 @@ module Listen
       end
       @wait_thread = nil
     end
+
+    def _queue_raw_change(type, dir, rel_path, options)
+      _log :debug, "raw queue: #{[type, dir, rel_path, options].inspect}"
+
+      unless (worker = async(:change_pool))
+        _log :warn, 'Failed to allocate worker from change pool'
+        return
+      end
+
+      worker.change(type, dir, rel_path, options)
+    rescue RuntimeError
+      _log :error, "#{__method__} crashed: #{$!}:#{$@.join("\n")}"
+      raise
+    end
   end
 end

data/lib/listen/options.rb

@@ -0,0 +1,23 @@
+module Listen
+  class Options
+    def initialize(opts, defaults)
+      @options = {}
+      given_options = opts.dup
+      defaults.keys.each do |key|
+        @options[key] = given_options.delete(key) || defaults[key]
+      end
+
+      return if given_options.empty?
+
+      msg = "Unknown options: #{given_options.inspect}"
+      Celluloid::Logger.warn msg
+      fail msg
+    end
+
+    def method_missing(name, *_)
+      return @options[name] if @options.key?(name)
+      msg = "Bad option: #{name.inspect} (valid:#{@options.keys.inspect})"
+      fail NameError, msg
+    end
+  end
+end