listen 2.7.5 → 2.7.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f2b1fec6652b9c788556648b883430623b4953d2
-  data.tar.gz: 84e2262d6b7952b3afdb08defa5035604718f2f9
+  metadata.gz: 962fc43324f716a5abe1d8acd8ea5df7c87d3d28
+  data.tar.gz: 84b801baff1f5026d64b15df0c9de5fceac572b7
 SHA512:
-  metadata.gz: 3b7d31da3edbb75296f7bc8f174c192c9317f87295c13eca6081fbac78793b8b28a9d88851e00f9b74dce5cff508d6bf31ab5e552e1fb1f941160589809a8aba
-  data.tar.gz: 6d4df130ce978ecbbb46069030d1a7324aac5624719c2129d570e6fb7b5553035e4c44dd3c5a9618ec07d2bae9bc6a0099b44dbe448c4b90355ac08620d9ddcd
+  metadata.gz: d95876a7d2bd3a39a8130685e2dfa40745ee6ca947646aa303a42b0ab1c4d8bb92347adf2b7e817209840c0a973a813ee5b3d90aafe0db6541361f2fa0d6b5a3
+  data.tar.gz: 3cf94f221c2c4debd84f14a4545ba6caecb45bf6c1d3097ab5482d4ce9e907858aa80d736cc66d54d74e9e100423aca970515ccc0debf89dfb5990f16d169752

data/.travis.yml

@@ -13,7 +13,6 @@ matrix:
 notifications:
   recipients:
     - thibaud@thibaud.gg
-    - remy@rymai.me
 os:
   - linux
   - osx

data/Gemfile

@@ -3,14 +3,35 @@ source 'https://rubygems.org'
 gemspec
 
 require 'rbconfig'
-gem 'wdm', '>= 0.1.0' if RbConfig::CONFIG['target_os'] =~ /mswin|mingw|cygwin/i
 
-if RbConfig::CONFIG['target_os'] =~ /bsd|dragonfly/i
+case RbConfig::CONFIG['target_os']
+
+when /mswin|mingw|cygwin/i
+  gem 'wdm', '>= 0.1.0'
+  Kernel.warn 'NOTE: Known issues for your platform:'
+  Kernel.warn ' * celluloid-io dns resovler bug causes TCP adapter to fail'
+  Kernel.warn ' (fixed celluloid-io requires unreleased celluloid version)'
+  Kernel.warn " * celluloid master branch doesn't work properly on Windows"
+
+  # has fix, but causes above other problems:
+  # gem 'celluloid-io', github: 'celluloid/celluloid-io', ref: 'a72cae2e'
+
+when /bsd|dragonfly/i
+
   gem 'rb-kqueue', '>= 0.2'
-  # Versions not included have known bugs
-  # Even master branches may not work...
+
+  Kernel.warn 'NOTE: BSD is unsupported because:'
+  Kernel.warn "* Ruby threads don't work correctly (Ruby/MRI unit tests)"
+  Kernel.warn "* and because of them, Celluloid doesn't work correctly"
+
+  Kernel.warn '* FFI blows up when libc is a LD script (ac63e07f7)'
   gem 'ffi', github: 'carpetsmoker/ffi', ref: 'ac63e07f7'
+
+  Kernel.warn '* Celluloid core detection blows up (7fdef04)'
   gem 'celluloid', github: 'celluloid/celluloid', ref: '7fdef04'
+
+else
+  # handled by gemspec
 end
 
 group :tool do

data/README.md

@@ -156,7 +156,7 @@ Also, setting the environment variable `LISTEN_GEM_DEBUGGING=1` does the same as
 ## Listen adapters
 
 The Listen gem has a set of adapters to notify it when there are changes.
-There are 4 OS-specific adapters to support Darwin, Linux, ~~*BSD~~ and Windows.
+There are 4 OS-specific adapters to support Darwin, Linux, ~~\*BSD~~ and Windows.
 These adapters are fast as they use some system-calls to implement the notifying function.
 
 There is also a polling adapter which is a cross-platform adapter and it will
@@ -178,11 +178,11 @@ require 'rbconfig'
 gem 'wdm', '>= 0.1.0' if RbConfig::CONFIG['target_os'] =~ /mswin|mingw|cygwin/i
 ```
 
-### On *BSD
+### On \*BSD
 
-**NOTE: *BSD currently is BROKEN with no plans to fix it or support it (see: [#220](https://github.com/guard/listen/issues/220))**
+**NOTE: \*BSD currently is BROKEN with no plans to fix it or support it (see: [#220](https://github.com/guard/listen/issues/220))**
 
-If your are on *BSD you can try to use the [`rb-kqueue`](https://github.com/mat813/rb-kqueue) instead of polling.
+If your are on \*BSD you can try to use the [`rb-kqueue`](https://github.com/mat813/rb-kqueue) instead of polling.
 Please add the following to your Gemfile:
 
 ```ruby
@@ -199,13 +199,10 @@ end
 
 ```
 
-### Issues
-
-Listen traps SIGINT signal to properly finalize listeners. If you plan
-on trapping this signal yourself - make sure to call `Listen.stop` in
-signal handler.
+### Issues and troubleshooting
 
 Sometimes OS-specific adapters don't work. :'(
+
 Here are some things you could try to avoid forcing polling.
 
 * [Update your Dropbox client](http://www.dropbox.com/downloading), if you have Dropbox installed.
@@ -216,7 +213,18 @@ Here are some things you could try to avoid forcing polling.
 
 If your application keeps using the polling-adapter and you can't figure out why, feel free to [open an issue](https://github.com/guard/listen/issues/new) (and be sure to [give all the details](https://github.com/guard/listen/blob/master/CONTRIBUTING.md)).
 
-Also, if you have problems related to receiving the wrong events, too many events or none at all, be sure set the environment variable `LISTEN_GEM_DEBUGGING=1` and include the output when reporting a new issue.
+Also, if you have problems related to receiving the wrong events, too many
+events or none at all, be sure set the environment variable
+`LISTEN_GEM_DEBUGGING=1` and include the output when reporting a new issue.
+
+If the listener works and then stops listening at some point and no errors are
+shown with `LISTEN_GEM_DEBUGGING=1`, set `LISTEN_GEM_DEBUGGING=2` for full
+logging.
+
+Listen traps SIGINT signal to properly finalize listeners. If you plan
+on trapping this signal yourself - make sure to call `Listen.stop` in
+signal handler.
+
 
 ## Forwarding file events over TCP
 

data/lib/listen.rb

@@ -25,8 +25,7 @@ module Listen
       @stopping = false
       options = args.last.is_a?(Hash) ? args.last : {}
       if target = options.delete(:forward_to)
-        require 'listen/tcp'
-        TCP::Listener.new(target, :broadcaster, *args, &block)
+        Listener.new(target, :broadcaster, *args, &block)
       else
         Listener.new(*args, &block)
       end
@@ -53,8 +52,7 @@ module Listen
     # @return [Listen::Listener] the listener
     #
     def on(target, *args, &block)
-      require 'listen/tcp'
-      TCP::Listener.new(target, :recipient, *args, &block)
+      Listener.new(target, :recipient, *args, &block)
     end
 
     private

data/lib/listen/adapter.rb

@@ -7,29 +7,38 @@ require 'listen/adapter/windows'
 
 module Listen
   module Adapter
-    OPTIMIZED_ADAPTERS = %w(Darwin Linux BSD Windows)
+    OPTIMIZED_ADAPTERS = [Darwin, Linux, BSD, Windows]
     POLLING_FALLBACK_MESSAGE = 'Listen will be polling for changes.'\
       'Learn more at https://github.com/guard/listen#polling-fallback.'
 
     def self.select(options = {})
+      _log :debug, 'Adapter: considering TCP ...'
       return TCP if options[:force_tcp]
+      _log :debug, 'Adapter: considering polling ...'
       return Polling if options[:force_polling]
+      _log :debug, 'Adapter: considering optimized backend...'
       return _usable_adapter_class if _usable_adapter_class
-
+      _log :debug, 'Adapter: falling back to polling...'
       _warn_polling_fallback(options)
       Polling
+    rescue
+      _log :warn, "Adapter: failed: #{$!.inspect}:#{$@.join("\n")}"
+      raise
     end
 
     private
 
     def self._usable_adapter_class
-      adapters = OPTIMIZED_ADAPTERS.map { |adapter| Adapter.const_get(adapter) }
-      adapters.detect { |adapter| adapter.send(:usable?) }
+      OPTIMIZED_ADAPTERS.detect(&:usable?)
     end
 
     def self._warn_polling_fallback(options)
       msg = options.fetch(:polling_fallback_message, POLLING_FALLBACK_MESSAGE)
       Kernel.warn "[Listen warning]:\n  #{msg}" if msg
     end
+
+    def self._log(type, message)
+      Celluloid.logger.send(type, message)
+    end
   end
 end

data/lib/listen/adapter/base.rb

@@ -3,41 +3,58 @@ module Listen
     class Base
       include Celluloid
 
-      # The default delay between checking for changes.
-      DEFAULT_LATENCY = 0.1
-
       attr_accessor :listener
 
       def initialize(listener)
         @listener = listener
-      end
-
-      def self.usable?
-        fail NotImplementedError
+      rescue
+        _log :error, "adapter config failed: #{$!}:#{$@.join("\n")}"
+        raise
       end
 
       def start
-        fail NotImplementedError
+        _configure
+        Thread.new do
+          begin
+            _run
+          rescue
+            _log :error, "run() in thread failed: #{$!}:#{$@.join("\n")}"
+            raise
+          end
+        end
       end
 
       def self.local_fs?
         true
       end
 
+      def self.usable?
+        const_get('OS_REGEXP') =~ RbConfig::CONFIG['target_os']
+      end
+
       private
 
-      def _latency
-        listener.options[:latency] || DEFAULT_LATENCY
+      def _configure
       end
 
-      def _directories_path
-        listener.directories.map(&:to_s)
+      def _directories
+        listener.directories
+      end
+
+      def _notify_change(type, path, options = {})
+        unless (worker = listener.async(:change_pool))
+          _log :warn, 'Failed to allocate worker from change pool'
+          return
+        end
+
+        worker.change(type, path, options)
+      rescue RuntimeError
+        _log :error, "_notify_change crashed: #{$!}:#{$@.join("\n")}"
+        raise
       end
 
-      def _notify_change(path, options)
-        sleep 0.01 until listener.registry[:change_pool]
-        pool = listener.registry[:change_pool]
-        pool.async.change(path, options) if listener.listen?
+      def _log(type, message)
+        Celluloid.logger.send(type, message)
       end
     end
   end

data/lib/listen/adapter/bsd.rb

@@ -5,18 +5,14 @@
 module Listen
   module Adapter
     class BSD < Base
-      # Watched kqueue events
-      #
-      EVENTS = [:delete, :write, :extend, :attrib, :rename] # :link, :revoke
+      OS_REGEXP = /bsd|dragonfly/i
 
-      BSD_OS_REGEXP = /bsd|dragonfly/i
+      EVENTS = [:delete, :write, :extend, :attrib, :rename] # :link, :revoke
 
-      # The message to show when wdm gem isn't available
-      #
       BUNDLER_DECLARE_GEM = <<-EOS.gsub(/^ {6}/, '')
         Please add the following to your Gemfile to avoid polling for changes:
           require 'rbconfig'
-          if RbConfig::CONFIG['target_os'] =~ #{BSD_OS_REGEXP}
+          if RbConfig::CONFIG['target_os'] =~ #{OS_REGEXP}
             gem 'rb-kqueue', '>= 0.2'
 
             # Base versions have known conflicts/bugs
@@ -39,56 +35,47 @@ module Listen
       EOS
 
       def self.usable?
-        if RbConfig::CONFIG['target_os'] =~ BSD_OS_REGEXP
-          Kernel.warn BSD_EXPERIMENTAL
-          require 'rb-kqueue'
-          require 'find'
-          true
-        end
+        return false unless super
+        Kernel.warn BSD_EXPERIMENTAL
+        require 'rb-kqueue'
+        require 'find'
+        true
       rescue LoadError
         Kernel.warn BUNDLER_DECLARE_GEM
         false
       end
 
-      def start
-        worker = _init_worker
-        Thread.new { worker.run }
-      end
-
       private
 
-      # Initializes a kqueue Queue and adds a watcher for each files in
-      # the directories passed to the adapter.
-      #
-      # @return [INotify::Notifier] initialized kqueue
-      #
-      def _init_worker
-        KQueue::Queue.new.tap do |queue|
-          _directories_path.each do |path|
-            # use Record to make a snapshot of dir, so we
-            # can detect new files
-            _find(path) { |file_path| _watch_file(file_path, queue) }
-          end
+      def _configure
+        @worker = KQueue::Queue.new
+        _directories.each do |path|
+          # use Record to make a snapshot of dir, so we
+          # can detect new files
+          _find(path.to_s) { |file_path| _watch_file(file_path, @worker) }
         end
       end
 
+      def _run
+        @worker.run
+      end
+
       def _worker_callback
         lambda do |event|
-          change = _change(event.flags)
           path = _event_path(event)
           if path.directory?
             # Force dir content tracking to kick in, or we won't have
             # names of added files
-            _notify_change(path, type: 'Directory', recursive: true)
+            _notify_change(:dir, path, recursive: true)
           else
-            _notify_change(path, type: 'File', change: change)
+            _notify_change(:file, path, change: _change(event.flags))
           end
 
           # If it is a directory, and it has a write flag, it means a
           # file has been added so find out which and deal with it.
           # No need to check for removed files, kqueue will forget them
           # when the vfs does.
-          _watch_for_new_file(event) if _new_file_added?(event)
+          _watch_for_new_file(event) if path.directory?
         end
       end
 
@@ -106,10 +93,6 @@ module Listen
         Pathname.new(event.watcher.path)
       end
 
-      def _new_file_added?(event)
-        ::File.directory?(event.watcher.path) && event.flags.include?(:write)
-      end
-
       def _watch_for_new_file(event)
         queue = event.watcher.queue
         _find(_event_path(event).to_s) do |file_path|

data/lib/listen/adapter/darwin.rb

@@ -3,39 +3,31 @@ module Listen
     # Adapter implementation for Mac OS X `FSEvents`.
     #
     class Darwin < Base
-      def self.usable?
-        RbConfig::CONFIG['target_os'] =~ /darwin(1.+)?$/i
-      end
+      OS_REGEXP = /darwin(1.+)?$/i
 
-      def initialize(listener)
-        require 'rb-fsevent'
-        super
-      end
-
-      def start
-        worker = _init_worker
-        Thread.new { worker.run }
-      end
+      # The default delay between checking for changes.
+      DEFAULT_LATENCY = 0.1
 
       private
 
-      # Initializes a FSEvent worker and adds a watcher for
-      # each directory listened.
-      #
-      def _init_worker
-        FSEvent.new.tap do |worker|
-          worker.watch(_directories_path, latency: _latency) do |changes|
-            paths = _changes_path(changes)
-            paths.each { |path| _notify_change(path, type: 'Dir') }
+      def _configure
+        require 'rb-fsevent'
+        @worker = FSEvent.new
+        @worker.watch(_directories.map(&:to_s), latency: _latency) do |changes|
+          changes.each do |path|
+            new_path = Pathname.new(path.sub(/\/$/, ''))
+            _log :debug, "fsevent: #{new_path}"
+            _notify_change(:dir, new_path)
           end
         end
       end
 
-      def _changes_path(changes)
-        changes.map do |path|
-          path.sub!(/\/$/, '')
-          Pathname.new(path)
-        end
+      def _run
+        @worker.run
+      end
+
+      def _latency
+        listener.options[:latency] || DEFAULT_LATENCY
       end
     end
   end

data/lib/listen/adapter/linux.rb

@@ -1,17 +1,13 @@
 module Listen
   module Adapter
     # Listener implementation for Linux `inotify`.
+    # @see https://github.com/nex3/rb-inotify
     #
     class Linux < Base
-      # Watched inotify events
-      #
-      # @see http://www.tin.org/bin/man.cgi?section=7&topic=inotify
-      # @see https://github.com/nex3/rb-inotify
-      #
+      OS_REGEXP = /linux/i
+
       EVENTS = [:recursive, :attrib, :create, :delete, :move, :close_write]
 
-      # The message to show when the limit of inotify watchers is not enough
-      #
       WIKI_URL = 'https://github.com/guard/listen'\
         '/wiki/Increasing-the-amount-of-inotify-watchers'
 
@@ -22,53 +18,49 @@ module Listen
         for information on how to solve this issue.
       EOS
 
-      def self.usable?
-        RbConfig::CONFIG['target_os'] =~ /linux/i
-      end
+      private
 
-      def initialize(listener)
+      def _configure
         require 'rb-inotify'
-        super
-      end
-
-      def start
-        worker = _init_worker
-        Thread.new { worker.run }
+        @worker = INotify::Notifier.new
+        _directories.each do |path|
+          @worker.watch(path.to_s, *EVENTS, &_callback)
+        end
       rescue Errno::ENOSPC
+        # workaround - Celluloid catches abort and prints nothing
         STDERR.puts INOTIFY_LIMIT_MESSAGE
         STDERR.flush
         abort(INOTIFY_LIMIT_MESSAGE)
       end
 
-      private
-
-      # Initializes a INotify worker and adds a watcher for
-      # each directory passed to the adapter.
-      #
-      # @return [INotify::Notifier] initialized worker
-      #
-      def _init_worker
-        INotify::Notifier.new.tap do |worker|
-          _directories_path.each do |path|
-            worker.watch(path, *EVENTS, &_worker_callback)
-          end
-        end
+      def _run
+        @worker.run
       end
 
-      def _worker_callback
+      def _callback
         lambda do |event|
-          next if _skip_event?(event)
-
-          path = _event_path(event)
-          cookie_opts = event.cookie.zero? ? {} : { cookie: event.cookie }
-
-          _log(event)
-
-          if _dir_event?(event)
-            _notify_change(path, { type: 'Dir' }.merge(cookie_opts))
+          # NOTE: avoid using event.absolute_name since new API
+          # will need to have a custom recursion implemented
+          # to properly match events to configured directories
+          path = Pathname.new(event.watcher.path) + event.name
+
+          _log :debug, "inotify: #{event.name} #{path} (#{event.flags.inspect})"
+
+          if /1|true/ =~ ENV['LISTEN_GEM_SIMULATE_FSEVENT']
+            if (event.flags & [:moved_to, :moved_from]) || _dir_event?(event)
+              _notify_change(:dir, path.dirname)
+            else
+              _notify_change(:dir, path)
+            end
           else
-            options = { type: 'File', change: _change(event.flags) }
-            _notify_change(path, options.merge(cookie_opts))
+            next if _skip_event?(event)
+            cookie_opts = event.cookie.zero? ? {} : { cookie: event.cookie }
+            if _dir_event?(event)
+              _notify_change(:dir, path, cookie_opts)
+            else
+              options = { change: _change(event.flags) }
+              _notify_change(:file, path, options.merge(cookie_opts))
+            end
           end
         end
       end
@@ -97,16 +89,6 @@ module Listen
       def _dir_event?(event)
         event.flags.include?(:isdir)
       end
-
-      def _event_path(event)
-        Pathname.new(event.absolute_name)
-      end
-
-      def _log(event)
-        name = event.name
-        flags = event.flags.inspect
-        Celluloid.logger.info "inotify event: #{flags}: #{name}"
-      end
     end
   end
 end