listen 3.3.0.pre.2 → 3.3.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 82d32d20751964de477dd8c2ff8af48cc0c70558b323c1043b37d5bf9183c3ba
-  data.tar.gz: fb40a33b41e0bf52ce30303fc88a7fb1dd35a9d56e2e920fccf598fcd7193c17
+  metadata.gz: 6e8a5f611b09b7689da35117369be07e2cb74ed77575dc7d894c12629767ad82
+  data.tar.gz: c7995d9785eb3202fa13528489a0c48e54c70fc201c750cb885777d36151b316
 SHA512:
-  metadata.gz: 14e679e027bb5c100eaf438f10ec96ce5336465366facf7559a19ed6fa23d0c6e89f72eba25fb53a1e689ca08d0572d54399826b3d78d5cb354f2b2c7d105b61
-  data.tar.gz: 4b4f93d99b7519d06a7302152e8d86332edb8a656caef7c1b164596d79c221d539ad0a29481709915070945e46fb1c4661bde3368f0e9c55cd277ffe52bc8b13
+  metadata.gz: fb0d331747afe760ab96a3eecf20d041e1e9fec0a2c49b678289fe56250c2a357a4826c9d4c9da38c9db7f819e7d61f6b9f5245c23a34c4eb9f77868abde2ec0
+  data.tar.gz: 3c7d8b1f91224ea4a10b4f039e334fbb85c0eae14996bf2df9c32a9487325f94a5e1d1ce87abefa23dce2f50b0bac2069950d05ec1f561552fb9c8493c31fd83

data/README.md

@@ -1,8 +1,8 @@
 # Listen
 
-The Listen gem listens to file modifications and notifies you about the changes.
+The `listen` gem listens to file modifications and notifies you about the changes.
 
-:exclamation: Listen is currently accepting more maintainers. Please [read this](https://github.com/guard/guard/wiki/Maintainers) if you're interested in joining the team.
+:exclamation: `Listen` is currently accepting more maintainers. Please [read this](https://github.com/guard/guard/wiki/Maintainers) if you're interested in joining the team.
 
 [![Development Status](https://github.com/guard/listen/workflows/Development/badge.svg)](https://github.com/guard/listen/actions?workflow=Development)
 [![Gem Version](https://badge.fury.io/rb/listen.svg)](http://badge.fury.io/rb/listen)
@@ -16,7 +16,7 @@ The Listen gem listens to file modifications and notifies you about the changes.
 * You can watch multiple directories.
 * Regexp-patterns for ignoring paths for more accuracy and speed
 * Increased change detection accuracy on OS X HFS and VFAT volumes.
-* Tested on selected Ruby environments via [Travis CI](https://travis-ci.org/guard/listen). (See [.travis.yml](https:///github.com/guard/listen/master/.travis.yml) for supported/tested Ruby Versions),
+* Continuous Integration: tested on selected Ruby environments via [Github Workflows](https:///github.com/guard/listen/master/.github/workflows).
 
 ## Issues / limitations
 
@@ -25,37 +25,81 @@ The Listen gem listens to file modifications and notifies you about the changes.
   * Symlinked directories pointing within a watched directory are not supported ([#273](https://github.com/guard/listen/pull/273)- see [Duplicate directory errors](https://github.com/guard/listen/wiki/Duplicate-directory-errors)).
 * No directory/adapter-specific configuration options.
 * Support for plugins planned for future.
-* TCP functionality was removed in Listen [3.0.0](https://github.com/guard/listen/releases/tag/v3.0.0) ([#319](https://github.com/guard/listen/issues/319), [#218](https://github.com/guard/listen/issues/218)). There are plans to extract this feature to separate gems ([#258](https://github.com/guard/listen/issues/258)), until this is finished, you can use by locking the `listen` gem to version `'~> 2.10'`.
+* TCP functionality was removed in `listen` [3.0.0](https://github.com/guard/listen/releases/tag/v3.0.0) ([#319](https://github.com/guard/listen/issues/319), [#218](https://github.com/guard/listen/issues/218)). There are plans to extract this feature to separate gems ([#258](https://github.com/guard/listen/issues/258)), until this is finished, you can use by locking the `listen` gem to version `'~> 2.10'`.
 * Some filesystems won't work without polling (VM/Vagrant Shared folders, NFS, Samba, sshfs, etc.).
 * Specs suite on JRuby and Rubinius aren't reliable on Travis CI, but should work.
 * Windows and \*BSD adapter aren't continuously and automatically tested.
 * OSX adapter has some performance limitations ([#342](https://github.com/guard/listen/issues/342)).
-* Ruby < 2.2.x is no longer supported - upgrade to Ruby 2.2 or 2.3.
+* FreeBSD users need patched version of rb-kqueue (as of 2020/11). See #475 for the issue, mat813/rb-kqueue#12 for the patch, and Bug 250432 in bugzilla.
 * Listeners do not notify across forked processes, if you wish for multiple processes to receive change notifications you must [listen inside of each process](https://github.com/guard/listen/issues/398#issuecomment-223957952).
 
 Pull requests or help is very welcome for these.
 
 ## Install
 
-The simplest way to install Listen is to use [Bundler](http://bundler.io).
+The simplest way to install `listen` is to use [Bundler](http://bundler.io).
 
 ```ruby
-gem 'listen', '~> 3.0' # NOTE: for TCP functionality, use '~> 2.10' for now
+gem 'listen', '~> 3.3' # NOTE: for TCP functionality, use '~> 2.10' for now
+```
+
+## Complete Example
+Here is a complete example of using the `listen` gem:
+```ruby
+require 'listen'
+
+listener = Listen.to('/srv/app') do |modified, added, removed|
+  puts(modified: modified, added: added, removed: removed)
+end
+listener.start
+sleep
+```
+Running the above in the background, you can see the callback block being called in response to each command:
+```
+$ cd /srv/app
+$ touch a.txt
+{:modified=>[], :added=>["/srv/app/a.txt"], :removed=>[]}
+
+$ echo more >> a.txt
+{:modified=>["/srv/app/a.txt"], :added=>[], :removed=>[]}
+
+$ mv a.txt b.txt
+{:modified=>[], :added=>["/srv/app/b.txt"], :removed=>["/srv/app/a.txt"]}
+
+$ vi b.txt
+# add a line to this new file and press ZZ to save and exit
+{:modified=>["/srv/app/b.txt"], :added=>[], :removed=>[]}
+
+$ vi c.txt
+# add a line and press ZZ to save and exit
+{:modified=>[], :added=>["/srv/app/c.txt"], :removed=>[]}
+
+$ rm b.txt c.txt
+{:modified=>[], :added=>[], :removed=>["/srv/app/b.txt", "/srv/app/c.txt"]}
 ```
 
 ## Usage
 
-Call `Listen.to` with either a single directory or multiple directories, then define the "changes" callback in a block.
+Call `Listen.to` with one or more directories and the "changes" callback passed as a block.
 
 ``` ruby
 listener = Listen.to('dir/to/listen', 'dir/to/listen2') do |modified, added, removed|
-  puts "modified absolute path: #{modified}"
-  puts "added absolute path: #{added}"
-  puts "removed absolute path: #{removed}"
+  puts "modified absolute path array: #{modified}"
+  puts "added absolute path array: #{added}"
+  puts "removed absolute path array: #{removed}"
 end
-listener.start # not blocking
+listener.start # starts a listener thread--does not block
+
+# do whatever you want here...just don't exit the process :)
+
 sleep
 ```
+## Changes Callback
+
+Changes to the listened-to directories are reported by the listener thread in a callback.
+The callback receives **three** array parameters: `modified`, `added` and `removed`, in that order.
+Each of these three is always an array with 0 or more entries.
+Each array entry is an absolute path.
 
 ### Pause / unpause / stop
 
@@ -76,13 +120,14 @@ listener.unpause # resumes processing changes ("start" would do the same)
 listener.stop    # stop both listening to changes and processing them
 ```
 
-  Note: While paused, Listen keeps on collecting changes in the background - to clear them, call "stop"
+  Note: While paused, `listen` keeps on collecting changes in the background - to clear them, call `stop`.
 
-  Note: You should keep track of all started listeners and stop them properly on finish.
+  Note: You should keep track of all started listeners and `stop` them properly on finish.
 
 ### Ignore / ignore!
 
-Listen ignores some directories and extensions by default (See DEFAULT_IGNORED_DIRECTORIES and DEFAULT_IGNORED_EXTENSIONS in Listen::Silencer), you can add ignoring patterns with the `ignore` option/method or overwrite default with `ignore!` option/method.
+`Listen` ignores some directories and extensions by default (See DEFAULT_IGNORED_DIRECTORIES and DEFAULT_IGNORED_EXTENSIONS in Listen::Silencer).
+You can add ignoring patterns with the `ignore` option/method or overwrite default with `ignore!` option/method.
 
 ``` ruby
 listener = Listen.to('dir/path/to/listen', ignore: /\.txt/) { |modified, added, removed| # ... }
@@ -94,11 +139,11 @@ sleep
 
 Note: `:ignore` regexp patterns are evaluated against relative paths.
 
-Note: Ignoring paths does not improve performance, except when Polling ([#274](https://github.com/guard/listen/issues/274))
+Note: Ignoring paths does not improve performance, except when Polling ([#274](https://github.com/guard/listen/issues/274)).
 
 ### Only
 
-Listen catches all files (less the ignored ones) by default. If you want to only listen to a specific type of file (i.e., just `.rb` extension), you should use the `only` option/method.
+`Listen` watches all files (less the ignored ones) by default. If you want to only listen to a specific type of file (i.e., just `.rb` extension), you should use the `only` option/method.
 
 ``` ruby
 listener = Listen.to('dir/path/to/listen', only: /\.rb$/) { |modified, added, removed| # ... }
@@ -110,35 +155,6 @@ sleep
 Note: `:only` regexp patterns are evaluated only against relative **file** paths.
 
 
-## Changes callback
-
-Changes to the listened-to directories gets reported back to the user in a callback.
-The registered callback gets invoked, when there are changes, with **three** parameters:
-`modified`, `added` and `removed` paths, in that particular order.
-Paths are always returned in their absolute form.
-
-Example:
-
-```ruby
-listener = Listen.to('path/to/app') do |modified, added, removed|
-  # This block will be called when there are changes.
-end
-listener.start
-sleep
-```
-
-or ...
-
-```ruby
-# Create a callback
-callback = Proc.new do |modified, added, removed|
-  # This proc will be called when there are changes.
-end
-listener = Listen.to('dir', &callback)
-listener.start
-sleep
-```
-
 ## Options
 
 All the following options can be set through the `Listen.to` after the directory path(s) params.
@@ -168,16 +184,42 @@ polling_fallback_message: 'custom message'      # Set a custom polling fallback
                                                 # default: "Listen will be polling for changes. Learn more at https://github.com/guard/listen#listen-adapters."
 ```
 
-## Debugging
+## Logging and Debugging
+
+`Listen` logs its activity to `Listen.logger`.
+This is the primary method of debugging.
+
+### Custom Logger
+You can call `Listen.logger =` to set a custom `listen` logger for the process. For example:
+```
+Listen.logger = Rails.logger
+```
 
-Setting the environment variable `LISTEN_GEM_DEBUGGING=1` sets up the INFO level logger, while `LISTEN_GEM_DEBUGGING=2` sets up the DEBUG level logger.
+### Default Logger
+If no custom logger is set, a default `listen` logger which logs to to `STDERR` will be created and assigned to `Listen.logger`.
 
-You can also set `Listen.logger` to a custom logger.
+The default logger defaults to the `error` logging level (severity).
+You can override the logging level by setting the environment variable `LISTEN_GEM_DEBUGGING=<level>`.
+For `<level>`, all standard `::Logger` levels are supported, with any mix of upper-/lower-case:
+```
+export LISTEN_GEM_DEBUGGING=debug # or 2 [deprecated]
+export LISTEN_GEM_DEBUGGING=info  # or 1 or true or yes [deprecated]
+export LISTEN_GEM_DEBUGGING=warn
+export LISTEN_GEM_DEBUGGING=fatal
+export LISTEN_GEM_DEBUGGING=error
+```
+The default of `error` will be used if an unsupported value is set.
 
+Note: The alternate values `1`, `2`, `true` and `yes` shown above are deprecated and will be removed from `listen` v4.0.
 
-## Listen adapters
+### Disabling Logging
+If you want to disable `listen` logging, set
+```
+Listen.logger = ::Logger.new('/dev/null')
+```
+## Listen Adapters
 
-The Listen gem has a set of adapters to notify it when there are changes.
+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.
 These adapters are fast as they use some system-calls to implement the notifying function.
@@ -185,9 +227,9 @@ These adapters are fast as they use some system-calls to implement the notifying
 There is also a polling adapter - although it's much slower than other adapters,
 it works on every platform/system and scenario (including network filesystems such as VM shared folders).
 
-The Darwin and Linux adapters are dependencies of the Listen gem so they work out of the box. For other adapters a specific gem will have to be added to your Gemfile, please read below.
+The Darwin and Linux adapters are dependencies of the `listen` gem so they work out of the box. For other adapters a specific gem will have to be added to your Gemfile, please read below.
 
-The Listen gem will choose the best adapter automatically, if present. If you
+The `listen` gem will choose the best adapter automatically, if present. If you
 want to force the use of the polling adapter, use the `:force_polling` option
 while initializing the listener.
 
@@ -219,31 +261,33 @@ end
 
 Please visit the [installation section of the Listen WIKI](https://github.com/guard/listen/wiki#installation) for more information and options for potential fixes.
 
-### Issues and troubleshooting
+### Issues and Troubleshooting
+
+If the gem doesn't work as expected, start by setting `LISTEN_GEM_DEBUGGING=debug` or `LISTEN_GEM_DEBUGGING=info` as described above in [Logging and Debugging](#logging-and-debugging).
 
-*NOTE: without providing the output after setting the `LISTEN_GEM_DEBUGGING=1` environment variable, it can be almost impossible to guess why listen is not working as expected.*
+*NOTE: without providing the output after setting the `LISTEN_GEM_DEBUGGING=debug` environment variable, it is usually impossible to guess why `listen` is not working as expected.*
 
 See [TROUBLESHOOTING](https://github.com/guard/listen/wiki/Troubleshooting)
 
 ## Performance
 
-If Listen seems slow or unresponsive, make sure you're not using the Polling adapter (you should see a warning upon startup if you are).
+If `listen` seems slow or unresponsive, make sure you're not using the Polling adapter (you should see a warning upon startup if you are).
 
 Also, if the directories you're watching contain many files, make sure you're:
 
 * not using Polling (ideally)
 * using `:ignore` and `:only` options to avoid tracking directories you don't care about (important with Polling and on MacOS)
-* running Listen with the `:latency` and `:wait_for_delay` options not too small or too big (depends on needs)
+* running `listen` with the `:latency` and `:wait_for_delay` options not too small or too big (depends on needs)
 * not watching directories with log files, database files or other frequently changing files
-* not using a version of Listen prior to 2.7.7
-* not getting silent crashes within Listen (see LISTEN_GEM_DEBUGGING=2)
-* not running multiple instances of Listen in the background
+* not using a version of `listen` prior to 2.7.7
+* not getting silent crashes within `listen` (see `LISTEN_GEM_DEBUGGING=debug`)
+* not running multiple instances of `listen` in the background
 * using a file system with atime modification disabled (ideally)
 * not using a filesystem with inaccurate file modification times (ideally), e.g. HFS, VFAT
 * not buffering to a slow terminal (e.g. transparency + fancy font + slow gfx card + lots of output)
 * ideally not running a slow encryption stack, e.g. btrfs + ecryptfs
 
-When in doubt, LISTEN_GEM_DEBUGGING=2 can help discover the actual events and time they happened.
+When in doubt, `LISTEN_GEM_DEBUGGING=debug` can help discover the actual events and time they happened.
 
 See also [Tips and Techniques](https://github.com/guard/listen/wiki/Tips-and-Techniques).
 

data/bin/listen

@@ -1,12 +1,11 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
 require 'listen'
 require 'listen/cli'
 
-unless defined?(JRUBY_VERSION)
-  if Signal.list.keys.include?('INT')
-    Signal.trap('INT') { Thread.new { Listen.stop } }
-  end
+if !defined?(JRUBY_VERSION) && Signal.list.keys.include?('INT')
+  Signal.trap('INT') { Thread.new { Listen.stop } }
 end
 
 Listen::CLI.start

data/lib/listen/adapter.rb

@@ -11,7 +11,7 @@ module Listen
   module Adapter
     OPTIMIZED_ADAPTERS = [Darwin, Linux, BSD, Windows].freeze
     POLLING_FALLBACK_MESSAGE = 'Listen will be polling for changes.'\
-      'Learn more at https://github.com/guard/listen#listen-adapters.'.freeze
+      'Learn more at https://github.com/guard/listen#listen-adapters.'
 
     class << self
       def select(options = {})
@@ -24,14 +24,14 @@ module Listen
         Polling
       rescue
         Listen.logger.warn format('Adapter: failed: %s:%s', $ERROR_POSITION.inspect,
-                           $ERROR_POSITION * "\n")
+                                  $ERROR_POSITION * "\n")
         raise
       end
 
       private
 
       def _usable_adapter_class
-        OPTIMIZED_ADAPTERS.detect(&:usable?)
+        OPTIMIZED_ADAPTERS.find(&:usable?)
       end
 
       def _warn_polling_fallback(options)

data/lib/listen/adapter/base.rb

@@ -8,13 +8,11 @@ require 'listen/thread'
 module Listen
   module Adapter
     class Base
-      attr_reader :options
+      attr_reader :options, :config
 
       # TODO: only used by tests
       DEFAULTS = {}.freeze
 
-      attr_reader :config
-
       def initialize(config)
         @started = false
         @config = config
@@ -31,6 +29,7 @@ module Listen
       end
 
       # TODO: it's a separate method as a temporary workaround for tests
+      # rubocop:disable Metrics/MethodLength
       def configure
         if @configured
           Listen.logger.warn('Adapter already configured!')
@@ -57,6 +56,7 @@ module Listen
           @snapshots[dir] = snapshot
         end
       end
+      # rubocop:enable Metrics/MethodLength
 
       def started?
         @started
@@ -73,7 +73,7 @@ module Listen
         @started = true
 
         @run_thread = Listen::Thread.new("run_thread") do
-          @snapshots.values.each do |snapshot|
+          @snapshots.each_value do |snapshot|
             _timed('Record.build()') { snapshot.record.build }
           end
           _run

data/lib/listen/adapter/bsd.rb

@@ -7,7 +7,7 @@
 module Listen
   module Adapter
     class BSD < Base
-      OS_REGEXP = /bsd|dragonfly/i
+      OS_REGEXP = /bsd|dragonfly/i.freeze
 
       DEFAULTS = {
         events: [
@@ -73,8 +73,7 @@ module Listen
       def _change(event_flags)
         { modified: [:attrib, :extend],
           added:    [:write],
-          removed:  [:rename, :delete]
-        }.each do |change, flags|
+          removed:  [:rename, :delete] }.each do |change, flags|
           return change unless (flags & event_flags).empty?
         end
         nil
@@ -87,7 +86,7 @@ module Listen
       def _watch_for_new_file(event)
         queue = event.watcher.queue
         _find(_event_path(event).to_s) do |file_path|
-          unless queue.watchers.detect { |_, v| v.path == file_path.to_s }
+          unless queue.watchers.find { |_, v| v.path == file_path.to_s }
             _watch_file(file_path, queue)
           end
         end

data/lib/listen/adapter/config.rb

@@ -5,10 +5,7 @@ require 'pathname'
 module Listen
   module Adapter
     class Config
-      attr_reader :directories
-      attr_reader :silencer
-      attr_reader :queue
-      attr_reader :adapter_options
+      attr_reader :directories, :silencer, :queue, :adapter_options
 
       def initialize(directories, queue, silencer, adapter_options)
         # Default to current directory if no directories are supplied

data/lib/listen/adapter/darwin.rb

@@ -7,7 +7,7 @@ module Listen
     # Adapter implementation for Mac OS X `FSEvents`.
     #
     class Darwin < Base
-      OS_REGEXP = /darwin(?<major_version>(1|2)\d+)/i
+      OS_REGEXP = /darwin(?<major_version>(1|2)\d+)/i.freeze
 
       # The default delay between checking for changes.
       DEFAULTS = { latency: 0.1 }.freeze
@@ -51,7 +51,7 @@ module Listen
 
       def _process_changes(dirs)
         dirs.each do |dir|
-          dir = Pathname.new(dir.sub(%r{\/$}, ''))
+          dir = Pathname.new(dir.sub(%r{/$}, ''))
 
           @callbacks.each do |watched_dir, callback|
             if watched_dir.eql?(dir) || Listen::Directory.ascendant_of?(watched_dir, dir)

data/lib/listen/adapter/linux.rb

@@ -4,13 +4,14 @@ module Listen
   module Adapter
     # @see https://github.com/nex3/rb-inotify
     class Linux < Base
-      OS_REGEXP = /linux/i
+      OS_REGEXP = /linux/i.freeze
 
       DEFAULTS = {
         events: [
           :recursive,
           :attrib,
           :create,
+          :modify,
           :delete,
           :move,
           :close_write
@@ -21,7 +22,7 @@ module Listen
       private
 
       WIKI_URL = 'https://github.com/guard/listen'\
-        '/wiki/Increasing-the-amount-of-inotify-watchers'.freeze
+        '/wiki/Increasing-the-amount-of-inotify-watchers'
 
       INOTIFY_LIMIT_MESSAGE = <<-EOS.gsub(/^\s*/, '')
         FATAL: Listen error: unable to monitor directories for changes.
@@ -40,6 +41,7 @@ module Listen
         @worker.run
       end
 
+      # rubocop:disable Metrics/MethodLength
       def _process_event(dir, event)
         # NOTE: avoid using event.absolute_name since new API
         # will need to have a custom recursion implemented
@@ -72,6 +74,7 @@ module Listen
 
         _queue_change(:file, dir, rel_path, params)
       end
+      # rubocop:enable Metrics/MethodLength
 
       def _skip_event?(event)
         # Event on root directory