listen 2.2.0 → 2.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c1becf59266f1a4dfdae77c1fe433948ddf3906b
-  data.tar.gz: d76d3ef28a4c8ac95661b21c6bbf604ecab56869
+  metadata.gz: e8644cb90075a5b296441b6e04044258dc64c738
+  data.tar.gz: 09212d8aafd577ab7ce6181b99798d43d69d6f44
 SHA512:
-  metadata.gz: 6cd16d944719dac5cda7bfae7254b47cbd77c2e32083305ebecaeb115d200ef246fc5366a923d413424549bc875891075f200fb4e0a6a3bfcac850bf642f80db
-  data.tar.gz: 9119e9c3995d0b74d668132722971926bbd10dda5a76d223fe828c234461dcb036185de06a72408b24f8fef9599cacdddfdb532db071a90c8b3c941cab4d54bb
+  metadata.gz: a016d2f3551965258853b077f249f1b19d5f6f3bccce6707f5f9aba4be054faf18a08f2c9f491fb6fd8afeda25fd4481fb041c90489739ce34bd7e5bdeef0c06
+  data.tar.gz: 0448bb8714d6ad0209a7db76ef3ceef29075d8e464f3d26d3e8bb5830173423b48b2c665c6eb7b0ff69881b1e976e750da57fbc2f6950b2dc4a7433f981149d2

data/Guardfile

@@ -1,4 +1,4 @@
-guard :rspec, bundler: false do
+guard :rspec do
   watch(%r{^spec/.+_spec\.rb$})
   watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
   watch(%r{^spec/support/*})    { 'spec' }

data/README.md

@@ -7,7 +7,7 @@ The Listen gem listens to file modifications and notifies you about the changes.
 ## Features
 
 * Supports watching multiple directories from a single listener.
-* OS-specific adapters on MRI for Mac OS X 10.6+, Linux, *BSD and Windows, [more info](#listen-adapters) bellow.
+* OS-specific adapters on MRI for Mac OS X 10.6+, Linux, *BSD and Windows, [more info](#listen-adapters) below.
 * Detects file modification, addition and removal.
 * Allows supplying regexp-patterns to ignore paths for better results.
 * File content checksum comparison for modifications made under the same second (OS X only).
@@ -48,7 +48,7 @@ sleep
 
 ### Pause / unpause / stop
 
-Listener can also be easily paused/unpaused:
+Listeners can also be easily paused/unpaused:
 
 ``` ruby
 listener = Listen.to('dir/path/to/listen') { |modified, added, removed| # ... }
@@ -62,18 +62,31 @@ listener.stop    # stop completely the listener
 
 ### Ignore / ignore!
 
-Liste ignore some folder 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| # ... }
 listener.start
-listener.ignore! /\.pkg/  # overwrite all patterns and only ignore pkg extension.
-listener.ignore /\.rb/    # ignore rb extension in addition of pkg.
+listener.ignore! /\.pkg/ # overwrite all patterns and only ignore pkg extension.
+listener.ignore /\.rb/   # ignore rb extension in addition of pkg.
 sleep
 ```
 
   Note: Ignoring regexp patterns are evaluated against relative paths.
 
+### Only
+
+Listen catches all files (less the ignored once) by default, if you want to only listen to a specific type of file (ie: just rb extension) you should use the `only` option/method.
+
+``` ruby
+listener = Listen.to('dir/path/to/listen', only: /\.rb$/) { |modified, added, removed| # ... }
+listener.start
+listener.only /_spec\.rb$/ # overwrite all existing only patterns.
+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.
@@ -113,6 +126,9 @@ ignore: [%r{/foo/bar}, /\.pid$/, /\.coffee$/]   # Ignore a list of paths
 
 ignore!: %r{/foo/bar}                           # Same as ignore options, but overwrite default ignored paths.
 
+only: %r{.rb$}                                  # Only listen to specific files
+                                                # default: none
+
 latency: 0.5                                    # Set the delay (**in seconds**) between checking for changes
                                                 # default: 0.25 sec (1.0 sec for polling)
 
@@ -138,15 +154,15 @@ These adapters are fast as they use some system-calls to implement the notifying
 There is also a polling adapter which is a cross-platform adapter and it will
 work on any system. This adapter is slower than the rest of the adapters.
 
-Darwin and Linux adapter are dependencies of the Listen gem so they work out of the box. For other adapters a specific gem need to be added to your Gemfile, please read bellow.
+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 choose the good adapter (if present) automatically. If you
-want to force the use of the polling adapter use the `:force_polling` option
+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.
 
 ### On Windows
 
-If your are on Windows you can try to use the [`wdm`](https://github.com/Maher4Ever/wdm) instead of polling.
+If your are on Windows, you can try to use the [`wdm`](https://github.com/Maher4Ever/wdm) instead of polling.
 Please add the following to your Gemfile:
 
 ```ruby
@@ -166,11 +182,11 @@ gem 'rb-kqueue', '>= 0.2' if RbConfig::CONFIG['target_os'] =~ /freebsd/i
 
 ### Issues
 
-Sometimes OS-specific adapter doesn't work, :'(
+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 used).
-* Move or rename the listened folder.
+* [Update your Dropbox client](http://www.dropbox.com/downloading), if you have Dropbox installed.
+* Move or rename the listened directory.
 * Update/reboot your OS.
 * Increase latency.
 

data/lib/listen/adapter.rb

@@ -10,14 +10,7 @@ module Listen
     OPTIMIZED_ADAPTERS = %w[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.new(listener)
-      adapter_class = _select(listener.options)
-      adapter_class.new(listener)
-    end
-
-    private
-
-    def self._select(options)
+    def self.select(options = {})
       return Polling if options[:force_polling]
       return _usable_adapter_class if _usable_adapter_class
 
@@ -25,6 +18,8 @@ module Listen
       Polling
     end
 
+    private
+
     def self._usable_adapter_class
       adapters = OPTIMIZED_ADAPTERS.map { |adapter| Adapter.const_get(adapter) }
       adapters.detect { |adapter| adapter.send(:usable?) }

data/lib/listen/adapter/base.rb

@@ -32,7 +32,8 @@ module Listen
       end
 
       def _notify_change(path, options)
-        Actor[:listen_change_pool].async.change(path, options) if listener.listen?
+        sleep 0.01 until listener.registry[:change_pool]
+        listener.registry[:change_pool].async.change(path, options) if listener.listen?
       end
     end
 

data/lib/listen/adapter/bsd.rb

@@ -52,7 +52,7 @@ module Listen
 
       def _worker_callback
         lambda do |event|
-           _notify_change(_event_path(event), type: 'file', change: _change(event.flags))
+           _notify_change(_event_path(event), type: 'File', change: _change(event.flags))
 
             # 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.

data/lib/listen/adapter/linux.rb

@@ -56,7 +56,7 @@ module Listen
           if _dir_event?(event)
             _notify_change(_event_path(event), type: 'Dir')
           else
-            _notify_change(_event_path(event), type: 'file', change: _change(event.flags))
+            _notify_change(_event_path(event), type: 'File', change: _change(event.flags))
           end
         end
       end

data/lib/listen/adapter/windows.rb

@@ -43,7 +43,7 @@ module Listen
 
       def _worker_callback
         lambda do |change|
-            _notify_change(_path(change.path), type: 'file', change: _change(change.type))
+            _notify_change(_path(change.path), type: 'File', change: _change(change.type))
         end
       end
 

data/lib/listen/change.rb

@@ -12,7 +12,8 @@ module Listen
     end
 
     def change(path, options)
-      return if _silencer.silenced?(path)
+      return if _silencer.silenced?(path, options[:type])
+
       if change = options[:change]
         _notify_listener(change, path)
       else
@@ -23,14 +24,14 @@ module Listen
     private
 
     def _file_change(path, options)
-      change = File.new(path).change
+      change = File.new(listener, path).change
       if change && listener.listen? && !options[:silence]
         _notify_listener(change, path)
       end
     end
 
     def _dir_change(path, options)
-      Directory.new(path, options).scan
+      Directory.new(listener, path, options).scan
     end
 
     def _notify_listener(change, path)
@@ -38,7 +39,7 @@ module Listen
     end
 
     def _silencer
-      Celluloid::Actor[:listen_silencer]
+      listener.registry[:silencer]
     end
 
   end

data/lib/listen/directory.rb

@@ -1,8 +1,9 @@
 module Listen
   class Directory
-    attr_accessor :path, :options
+    attr_accessor :listener, :path, :options
 
-    def initialize(path, options = {})
+    def initialize(listener, path, options = {})
+      @listener    = listener
       @path    = path
       @options = options
     end
@@ -11,7 +12,8 @@ module Listen
       _update_record
       _all_entries.each do |entry_path, data|
         case data[:type]
-        when 'File' then _async_change(entry_path, options.merge(type: 'File'))
+        when 'File'
+          _async_change(entry_path, options.merge(type: 'File'))
         when 'Dir'
           _async_change(entry_path, options.merge(type: 'Dir')) if _recursive_scan?(entry_path)
         end
@@ -34,6 +36,7 @@ module Listen
 
     def _entries
       return {} unless ::Dir.exists?(path)
+
       entries = ::Dir.entries(path) - %w[. ..]
       entries = entries.map { |entry| [entry, type: _entry_type(entry)] }
       Hash[*entries.flatten]
@@ -54,11 +57,11 @@ module Listen
     end
 
     def _record
-      Celluloid::Actor[:listen_record]
+      listener.registry[:record]
     end
 
     def _change_pool
-      Celluloid::Actor[:listen_change_pool]
+      listener.registry[:change_pool]
     end
 
     def _recursive_scan?(path)

data/lib/listen/file.rb

@@ -1,8 +1,9 @@
 module Listen
   class File
-    attr_accessor :path, :data
+    attr_accessor :listener, :path, :data
 
-    def initialize(path)
+    def initialize(listener, path)
+      @listener = listener
       @path = path
       @data = { type: 'File' }
     end
@@ -78,7 +79,7 @@ module Listen
     end
 
     def _record
-      Celluloid::Actor[:listen_record]
+      listener.registry[:record]
     end
 
     def _mtime

data/lib/listen/listener.rb

@@ -7,6 +7,7 @@ require 'listen/silencer'
 module Listen
   class Listener
     attr_accessor :options, :directories, :paused, :changes, :block, :thread
+    attr_accessor :registry, :supervisor
 
     RELATIVE_PATHS_WITH_MULTIPLE_DIRECTORIES_WARNING_MESSAGE = "The relative_paths option doesn't work when listening to multiple diretories."
 
@@ -25,6 +26,8 @@ module Listen
       @directories = args.flatten.map { |path| Pathname.new(path).realpath }
       @changes     = []
       @block       = block
+      @registry    = Celluloid::Registry.new
+      @supervisor  = Celluloid::SupervisionGroup.run!(@registry)
       _init_debug
     end
 
@@ -36,7 +39,7 @@ module Listen
       _signals_trap
       _init_actors
       unpause
-      Celluloid::Actor[:listen_adapter].async.start
+      registry[:adapter].async.start
       @thread = Thread.new { _wait_for_changes }
     end
 
@@ -56,7 +59,7 @@ module Listen
     # Unpauses listening callback
     #
     def unpause
-      Celluloid::Actor[:listen_record].build
+      registry[:record].build
       @paused = false
     end
 
@@ -78,21 +81,30 @@ module Listen
 
     # Adds ignore patterns to the existing one (See DEFAULT_IGNORED_DIRECTORIES and DEFAULT_IGNORED_EXTENSIONS in Listen::Silencer)
     #
-    # @param [Regexp, Hash<Regexp>] new ignoring patterns.
+    # @param [Regexp, Array<Regexp>] new ignoring patterns.
     #
     def ignore(regexps)
       @options[:ignore] = [options[:ignore], regexps]
-      Celluloid::Actor[:listen_silencer] = Silencer.new(self)
+      registry[:silencer] = Silencer.new(self)
     end
 
     # Overwrites ignore patterns (See DEFAULT_IGNORED_DIRECTORIES and DEFAULT_IGNORED_EXTENSIONS in Listen::Silencer)
     #
-    # @param [Regexp, Hash<Regexp>] new ignoring patterns.
+    # @param [Regexp, Array<Regexp>] new ignoring patterns.
     #
     def ignore!(regexps)
       @options.delete(:ignore)
       @options[:ignore!] = regexps
-      Celluloid::Actor[:listen_silencer] = Silencer.new(self)
+      registry[:silencer] = Silencer.new(self)
+    end
+
+    # Sets only patterns, to listen only to specific regexps
+    #
+    # @param [Regexp, Array<Regexp>] new ignoring patterns.
+    #
+    def only(regexps)
+      @options[:only] = regexps
+      registry[:silencer] = Silencer.new(self)
     end
 
     private
@@ -114,10 +126,12 @@ module Listen
     end
 
     def _init_actors
-      Celluloid::Actor[:listen_silencer]    = Silencer.new(self)
-      Celluloid::Actor[:listen_change_pool] = Change.pool(args: self)
-      Celluloid::Actor[:listen_adapter]     = Adapter.new(self)
-      Celluloid::Actor[:listen_record]      = Record.new(self)
+      supervisor.add(Silencer, as: :silencer, args: self)
+      supervisor.add(Record, as: :record, args: self)
+      supervisor.pool(Change, as: :change_pool, args: self)
+
+      adapter_class = Adapter.select(options)
+      supervisor.add(adapter_class, as: :adapter, args: self)
     end
 
     def _signals_trap
@@ -138,8 +152,7 @@ module Listen
         sleep options[:wait_for_delay]
       end
 
-      _terminate_actors
-      exit
+      supervisor.finalize
     rescue => ex
       Kernel.warn "[Listen warning]: Change block raised an exception: #{$!}"
       Kernel.warn "Backtrace:\n\t#{ex.backtrace.join("\n\t")}"
@@ -153,12 +166,5 @@ module Listen
       end
       changes.each { |_, v| v.uniq! }
     end
-
-    def _terminate_actors
-      Celluloid::Actor[:listen_adapter].terminate
-      Celluloid::Actor[:listen_silencer].terminate
-      Celluloid::Actor[:listen_change_pool].terminate
-      Celluloid::Actor[:listen_record].terminate
-    end
   end
 end

data/lib/listen/record.rb

@@ -28,7 +28,7 @@ module Listen
     def build
       @paths = _init_paths
       listener.directories.each do |path|
-        Actor[:listen_change_pool].change(path, type: 'Dir', recursive: true, silence: true)
+        listener.registry[:change_pool].change(path, type: 'Dir', recursive: true, silence: true)
       end
     end
 

data/lib/listen/silencer.rb

@@ -8,28 +8,41 @@ module Listen
     # The default list of files that get ignored.
     DEFAULT_IGNORED_EXTENSIONS  = %w[.DS_Store .tmp]
 
-    attr_accessor :listener, :patterns
+    attr_accessor :listener, :only_patterns, :ignore_patterns
 
     def initialize(listener)
       @listener = listener
-      _init_patterns
+      _init_only_patterns
+      _init_ignore_patterns
     end
 
-    def silenced?(path)
-      patterns.any? { |pattern| _relative_path(path) =~ pattern }
+    def silenced?(path, type = 'Unknown')
+      silenced = false
+
+      if only_patterns && type == 'File'
+        silenced = !only_patterns.any? { |pattern| _relative_path(path) =~ pattern }
+      end
+
+      silenced ||= ignore_patterns.any? { |pattern| _relative_path(path) =~ pattern }
     end
 
     private
 
-    def _init_patterns
-      @patterns = []
-      @patterns << _default_patterns unless listener.options[:ignore!]
-      @patterns << listener.options[:ignore] << listener.options[:ignore!]
-      @patterns.compact!
-      @patterns.flatten!
+    def _init_only_patterns
+      if listener.options[:only]
+        @only_patterns = Array(listener.options[:only])
+      end
+    end
+
+    def _init_ignore_patterns
+      @ignore_patterns = []
+      @ignore_patterns << _default_ignore_patterns unless listener.options[:ignore!]
+      @ignore_patterns << listener.options[:ignore] << listener.options[:ignore!]
+      @ignore_patterns.compact!
+      @ignore_patterns.flatten!
     end
 
-    def _default_patterns
+    def _default_ignore_patterns
       [_default_ignored_directories_patterns, _default_ignored_extensions_patterns]
     end
 

data/lib/listen/version.rb

@@ -1,3 +1,3 @@
 module Listen
-  VERSION = '2.2.0'
+  VERSION = '2.3.1'
 end

data/spec/acceptance/listen_spec.rb

@@ -13,13 +13,7 @@ describe "Listen" do
     @listener = setup_listener(options, callback)
     @listener.start
   }
-  after {
-    begin
-      listener.stop
-    rescue SystemExit
-      # ignore the SystemExit error from the thread
-    end
-  }
+  after { listener.stop }
 
   context "with one listen dir" do
     let(:paths) { Pathname.new(Dir.pwd) }
@@ -158,6 +152,17 @@ describe "Listen" do
           end
         end
 
+        context "default ignored dir with file in listen dir" do
+          around { |example| mkdir_p '.bundle'; touch '.bundle/file.rb'; example.run }
+          let(:options) { { force_polling: polling, latency: 0.1 } }
+
+          it "doesn't listen to file touch" do
+            expect(listen {
+              touch '.bundle/file.rb'
+            }).to eq({ modified: [], added: [], removed: [] })
+          end
+        end
+
         context "ignored dir with file in listen dir" do
           around { |example| mkdir_p 'ignored_dir'; touch 'ignored_dir/file.rb'; example.run }
           let(:options) { { force_polling: polling, latency: 0.1, ignore: /ignored_dir/ } }
@@ -180,6 +185,29 @@ describe "Listen" do
           end
         end
 
+        context "with only option" do
+          let(:options) { { force_polling: polling, latency: 0.1, only: /\.rb$/ } }
+
+          it "listens only to file touch matching with only patterns" do
+            expect(listen {
+              touch 'file.rb'
+              touch 'file.txt'
+            }).to eq({ modified: [], added: ['file.rb'], removed: [] })
+          end
+        end
+
+        context "with ignore and only option" do
+          let(:options) { { force_polling: polling, latency: 0.1, ignore: /bar\.rb$/, only: /\.rb$/ } }
+
+          it "listens only to file touch matching with only patterns" do
+            expect(listen {
+              touch 'file.rb'
+              touch 'bar.rb'
+              touch 'file.txt'
+            }).to eq({ modified: [], added: ['file.rb'], removed: [] })
+          end
+        end
+
         describe "#ignore" do
           around { |example| touch 'file.rb'; example.run }
           let(:options) { { force_polling: polling, latency: 0.1, ignore: /\.rb$/ } }

data/spec/lib/listen/adapter/base_spec.rb

@@ -2,7 +2,8 @@ require 'spec_helper'
 
 describe Listen::Adapter::Base do
   let(:adapter) { described_class.new(listener) }
-  let(:listener) { double(Listen::Listener, options: {}) }
+  let(:registry) { double(Celluloid::Registry) }
+  let(:listener) { double(Listen::Listener, registry: registry, options: {}) }
 
   describe "#_latency" do
     it "returns default_latency with listener actor latency not present" do
@@ -20,7 +21,7 @@ describe Listen::Adapter::Base do
     let(:change_pool_async) { double('ChangePoolAsync') }
     before {
       change_pool.stub(:async) { change_pool_async }
-      Celluloid::Actor.stub(:[]).with(:listen_change_pool) { change_pool }
+      registry.stub(:[]).with(:change_pool) { change_pool }
     }
 
     context "listener listen" do

data/spec/lib/listen/adapter/polling_spec.rb

@@ -1,13 +1,14 @@
 require 'spec_helper'
 
 describe Listen::Adapter::Polling do
-  let(:listener) { double(Listen::Listener, options: {}, listen?: true) }
+  let(:registry) { double(Celluloid::Registry) }
+  let(:listener) { double(Listen::Listener, registry: registry, options: {}, listen?: true) }
   let(:adapter) { described_class.new(listener) }
   let(:change_pool) { double(Listen::Change, terminate: true) }
   let(:change_pool_async) { double('ChangePoolAsync') }
   before {
     change_pool.stub(:async) { change_pool_async }
-    Celluloid::Actor.stub(:[]).with(:listen_change_pool) { change_pool }
+    registry.stub(:[]).with(:change_pool) { change_pool }
   }
 
   describe ".usable?" do

data/spec/lib/listen/adapter_spec.rb

@@ -1,7 +1,6 @@
 require 'spec_helper'
 
 describe Listen::Adapter do
-  let(:adapter) { Listen::Adapter.new(listener) }
   let(:listener) { double(Listen::Listener, options: {}) }
   before {
     Listen::Adapter::BSD.stub(:usable?) { false }
@@ -10,58 +9,57 @@ describe Listen::Adapter do
     Listen::Adapter::Windows.stub(:usable?) { false }
   }
 
-  describe ".new" do
+  describe ".select" do
     it "returns Polling adapter if forced" do
-      listener.stub(:options) { { force_polling: true } }
-      expect(adapter).to be_kind_of Listen::Adapter::Polling
+      klass = Listen::Adapter.select(force_polling: true)
+      expect(klass).to eq Listen::Adapter::Polling
     end
 
     it "returns BSD adapter when usable" do
       Listen::Adapter::BSD.stub(:usable?) { true }
-      expect(Listen::Adapter::BSD).to receive(:new)
-      adapter
+      klass = Listen::Adapter.select
+      expect(klass).to eq Listen::Adapter::BSD
     end
 
     it "returns Darwin adapter when usable" do
       Listen::Adapter::Darwin.stub(:usable?) { true }
-      expect(Listen::Adapter::Darwin).to receive(:new)
-      adapter
+      klass = Listen::Adapter.select
+      expect(klass).to eq Listen::Adapter::Darwin
     end
 
     it "returns Linux adapter when usable" do
       Listen::Adapter::Linux.stub(:usable?) { true }
-      expect(Listen::Adapter::Linux).to receive(:new)
-      adapter
+      klass = Listen::Adapter.select
+      expect(klass).to eq Listen::Adapter::Linux
     end
 
     it "returns Windows adapter when usable" do
       Listen::Adapter::Windows.stub(:usable?) { true }
-      expect(Listen::Adapter::Windows).to receive(:new)
-      adapter
+      klass = Listen::Adapter.select
+      expect(klass).to eq Listen::Adapter::Windows
     end
 
     context "no usable adapters" do
       before { Kernel.stub(:warn) }
 
       it "returns Polling adapter" do
-        expect(adapter).to be_kind_of Listen::Adapter::Polling
+        klass = Listen::Adapter.select(force_polling: true)
+        expect(klass).to eq Listen::Adapter::Polling
       end
 
       it "warns polling fallback with default message" do
         expect(Kernel).to receive(:warn).with("[Listen warning]:\n  #{described_class::POLLING_FALLBACK_MESSAGE}")
-        adapter
+        Listen::Adapter.select
       end
 
       it "doesn't warn if polling_fallback_message is false" do
-        listener.stub(:options) { { polling_fallback_message: false } }
         expect(Kernel).to_not receive(:warn)
-        adapter
+        Listen::Adapter.select(polling_fallback_message: false)
       end
 
       it "warns polling fallback with custom message if set" do
-        listener.stub(:options) { { polling_fallback_message: 'custom fallback message' } }
         expect(Kernel).to receive(:warn).with("[Listen warning]:\n  custom fallback message")
-        adapter
+        Listen::Adapter.select(polling_fallback_message: 'custom fallback message')
       end
     end
 end

data/spec/lib/listen/change_spec.rb

@@ -2,15 +2,16 @@ require 'spec_helper'
 
 describe Listen::Change do
   let(:change) { Listen::Change.new(listener) }
-  let(:listener) { double(Listen::Listener, options: {}) }
+  let(:registry) { double(Celluloid::Registry) }
+  let(:listener) { double(Listen::Listener, registry: registry, options: {}) }
   let(:listener_changes) { double("listener_changes") }
   before {
     listener.stub(:changes) { listener_changes }
   }
 
   describe "#change" do
-    let(:silencer) { double(Listen::Silencer, silenced?: false) }
-    before { Celluloid::Actor.stub(:[]).with(:listen_silencer) { silencer } }
+    let(:silencer) { double('Listen::Silencer', silenced?: false) }
+    before { registry.stub(:[]).with(:silencer) { silencer } }
 
     context "file path" do
       context "with known change" do
@@ -20,25 +21,28 @@ describe Listen::Change do
         end
 
         it "doesn't notify to listener if path is silenced" do
-          expect(silencer).to receive(:silenced?).with('file_path') { true }
+          # expect(silencer).to receive(:silenced?).with('file_path', 'File').and_return(true)
+          expect(silencer).to receive(:silenced?).and_return(true)
           expect(listener_changes).to_not receive(:<<)
+
           change.change('file_path', type: 'File', change: :modified)
         end
       end
 
       context "with unknown change" do
-        let(:file) { double(Listen::File) }
+        let(:file) { double('Listen::File') }
         before { Listen::File.stub(:new) { file } }
 
         it "calls Listen::File#change" do
-          expect(Listen::File).to receive(:new).with('file_path') { file }
+          expect(Listen::File).to receive(:new).with(listener, 'file_path') { file }
           expect(file).to receive(:change)
           change.change('file_path', type: 'File')
         end
 
         it "doesn't call Listen::File#change if path is silenced" do
-          expect(silencer).to receive(:silenced?).with('file_path') { true }
+          expect(silencer).to receive(:silenced?).with('file_path', 'File').and_return(true)
           expect(Listen::File).to_not receive(:new)
+
           change.change('file_path', type: 'File')
         end
 
@@ -88,7 +92,7 @@ describe Listen::Change do
       before { Listen::Directory.stub(:new) { dir } }
 
       it "calls Listen::Directory#scan" do
-        expect(Listen::Directory).to receive(:new).with('dir_path', dir_options) { dir }
+        expect(Listen::Directory).to receive(:new).with(listener, 'dir_path', dir_options) { dir }
         expect(dir).to receive(:scan)
         change.change('dir_path', dir_options)
       end

data/spec/lib/listen/directory_spec.rb

@@ -1,6 +1,8 @@
 require 'spec_helper'
 
 describe Listen::Directory do
+  let(:registry) { double(Celluloid::Registry) }
+  let(:listener) { double(Listen::Listener, registry: registry, options: {}) }
   let(:record) { double(Listen::Record, async: double(set_path: true, unset_path: true)) }
   let(:change_pool) { double(Listen::Change) }
   let(:change_pool_async) { double('ChangePoolAsync') }
@@ -8,8 +10,8 @@ describe Listen::Directory do
   around { |example| fixtures { |path| example.run } }
   before {
     change_pool.stub(:async) { change_pool_async }
-    Celluloid::Actor.stub(:[]).with(:listen_record) { record }
-    Celluloid::Actor.stub(:[]).with(:listen_change_pool) { change_pool }
+    registry.stub(:[]).with(:record) { record }
+    registry.stub(:[]).with(:change_pool) { change_pool }
   }
 
   describe "#scan" do
@@ -18,7 +20,7 @@ describe Listen::Directory do
     let(:other_file_path) { dir_path.join('other_file.rb') }
     let(:inside_dir_path) { dir_path.join('inside_dir') }
     let(:other_inside_dir_path) { dir_path.join('other_inside_dir') }
-    let(:dir) { Listen::Directory.new(dir_path, options) }
+    let(:dir) { Listen::Directory.new(listener, dir_path, options) }
 
     context "with recursive off" do
       let(:options) { { recursive: false } }

data/spec/lib/listen/file_spec.rb

@@ -1,14 +1,16 @@
 require 'spec_helper'
 
 describe Listen::File do
+  let(:registry) { double(Celluloid::Registry) }
+  let(:listener) { double(Listen::Listener, registry: registry, options: {}) }
   let(:record) { double(Listen::Record, async: double(set_path: true, unset_path: true)) }
   let(:path) { Pathname.new(Dir.pwd) }
   around { |example| fixtures { |path| example.run } }
-  before { Celluloid::Actor.stub(:[]).with(:listen_record) { record } }
+  before { registry.stub(:[]).with(:record) { record } }
 
   describe "#change" do
     let(:file_path) { path.join('file.rb') }
-    let(:file) { Listen::File.new(file_path) }
+    let(:file) { Listen::File.new(listener, file_path) }
     let(:expected_data) {
       if darwin?
         { type: 'File', mtime: kind_of(Float), mode: kind_of(Integer), md5: kind_of(String) }

data/spec/lib/listen/listener_spec.rb

@@ -3,16 +3,21 @@ require 'spec_helper'
 describe Listen::Listener do
   let(:listener) { Listen::Listener.new(options) }
   let(:options) { {} }
+  let(:registry) { double(Celluloid::Registry, :[]= => true) }
+  let(:supervisor) { double(Celluloid::SupervisionGroup, add: true, pool: true) }
   let(:record) { double(Listen::Record, terminate: true, build: true) }
   let(:silencer) { double(Listen::Silencer, terminate: true) }
   let(:adapter) { double(Listen::Adapter::Base) }
   let(:change_pool) { double(Listen::Change, terminate: true) }
   let(:change_pool_async) { double('ChangePoolAsync') }
   before {
-    Celluloid::Actor.stub(:[]).with(:listen_silencer) { silencer }
-    Celluloid::Actor.stub(:[]).with(:listen_adapter) { adapter }
-    Celluloid::Actor.stub(:[]).with(:listen_record) { record }
-    Celluloid::Actor.stub(:[]).with(:listen_change_pool) { change_pool }
+    Celluloid::Registry.stub(:new) { registry }
+    Celluloid::SupervisionGroup.stub(:run!) { supervisor }
+    registry.stub(:[]).with(:silencer) { silencer }
+    registry.stub(:[]).with(:adapter) { adapter }
+    registry.stub(:[]).with(:record) { record }
+    registry.stub(:[]).with(:change_pool) { change_pool }
+
   }
 
   describe "initialize" do
@@ -55,12 +60,6 @@ describe Listen::Listener do
 
   describe "#start" do
     before {
-      Listen::Silencer.stub(:new)
-      Listen::Change.stub(:pool)
-      Listen::Adapter.stub(:new)
-      Listen::Record.stub(:new)
-      Celluloid::Actor.stub(:[]=)
-      Celluloid.stub(:cores) { 1 }
       adapter.stub_chain(:async, :start)
     }
 
@@ -70,26 +69,23 @@ describe Listen::Listener do
     end
 
     it "registers silencer" do
-      expect(Listen::Silencer).to receive(:new).with(listener) { silencer }
-      expect(Celluloid::Actor).to receive(:[]=).with(:listen_silencer, silencer)
+      expect(supervisor).to receive(:add).with(Listen::Silencer, as: :silencer, args: listener)
       listener.start
     end
 
-    it "registers change_pool" do
-      expect(Listen::Change).to receive(:pool).with(args: listener) { change_pool }
-      expect(Celluloid::Actor).to receive(:[]=).with(:listen_change_pool, change_pool)
+    it "supervises change_pool" do
+      expect(supervisor).to receive(:pool).with(Listen::Change, as: :change_pool, args: listener)
       listener.start
     end
 
-    it "registers adaper" do
-      expect(Listen::Adapter).to receive(:new).with(listener) { adapter }
-      expect(Celluloid::Actor).to receive(:[]=).with(:listen_adapter, adapter)
+    it "supervises adaper" do
+      Listen::Adapter.stub(:select) { Listen::Adapter::Polling }
+      expect(supervisor).to receive(:add).with(Listen::Adapter::Polling, as: :adapter, args: listener)
       listener.start
     end
 
-    it "registers record" do
-      expect(Listen::Record).to receive(:new).with(listener) { record }
-      expect(Celluloid::Actor).to receive(:[]=).with(:listen_record, record)
+    it "supervises record" do
+      expect(supervisor).to receive(:add).with(Listen::Record, as: :record, args: listener)
       listener.start
     end
 
@@ -191,9 +187,9 @@ describe Listen::Listener do
     let(:new_silencer) { double(Listen::Silencer) }
     before { Celluloid::Actor.stub(:[]=) }
 
-    it "resets silencer actor with new pattern" do
+    it "resets silencer actor" do
       expect(Listen::Silencer).to receive(:new).with(listener) { new_silencer }
-      expect(Celluloid::Actor).to receive(:[]=).with(:listen_silencer, new_silencer)
+      expect(registry).to receive(:[]=).with(:silencer, new_silencer)
       listener.ignore(/foo/)
     end
 
@@ -222,9 +218,9 @@ describe Listen::Listener do
     let(:new_silencer) { double(Listen::Silencer) }
     before { Celluloid::Actor.stub(:[]=) }
 
-    it "resets silencer actor with new pattern" do
+    it "resets silencer actor" do
       expect(Listen::Silencer).to receive(:new).with(listener) { new_silencer }
-      expect(Celluloid::Actor).to receive(:[]=).with(:listen_silencer, new_silencer)
+      expect(registry).to receive(:[]=).with(:silencer, new_silencer)
       listener.ignore!(/foo/)
       expect(listener.options).to include(ignore!: /foo/)
     end
@@ -250,4 +246,25 @@ describe Listen::Listener do
     end
   end
 
+  describe "#only" do
+    let(:new_silencer) { double(Listen::Silencer) }
+    before { Celluloid::Actor.stub(:[]=) }
+
+    it "resets silencer actor" do
+      expect(Listen::Silencer).to receive(:new).with(listener) { new_silencer }
+      expect(registry).to receive(:[]=).with(:silencer, new_silencer)
+      listener.only(/foo/)
+    end
+
+    context "with existing only options" do
+      let(:options) { { only: /bar/ } }
+
+      it "overwrites existing ignore options" do
+        expect(Listen::Silencer).to receive(:new).with(listener)
+        listener.only([/foo/])
+        expect(listener.options).to include(only: [/foo/])
+      end
+    end
+  end
+
 end

data/spec/lib/listen/record_spec.rb

@@ -1,7 +1,8 @@
 require 'spec_helper'
 
 describe Listen::Record do
-  let(:listener) { double(Listen::Listener, options: {}) }
+  let(:registry) { double(Celluloid::Registry) }
+  let(:listener) { double(Listen::Listener, registry: registry, options: {}) }
   let(:record) { Listen::Record.new(listener) }
   let(:path) { '/dir/path/file.rb' }
   let(:data) { { type: 'File' } }
@@ -74,7 +75,7 @@ describe Listen::Record do
     let(:change_pool) { double(Listen::Change, terminate: true) }
     before {
       change_pool.stub(:change)
-      Celluloid::Actor.stub(:[]).with(:listen_change_pool) { change_pool }
+      registry.stub(:[]).with(:change_pool) { change_pool }
       listener.stub(:directories) { directories }
     }
 

data/spec/lib/listen/silencer_spec.rb

@@ -49,26 +49,28 @@ describe Listen::Silencer do
       end
     end
 
-    context "with ignore options" do
-      let(:options) { { ignore: [%r{^foo/bar}, /\.pid$/] } }
+    context 'with ignore options (regexp)' do
+      let(:options) { { ignore: /\.pid$/ } }
 
-      it "silences custom ignored directory" do
-        path = pwd.join('foo', 'bar')
-        expect(silencer.silenced?(path)).to be_true
+      it "silences path matching custom ignore regex" do
+        expect(silencer.silenced?(pwd.join('foo.pid'))).to be_true
       end
+    end
+
+    context 'with ignore options (array)' do
+      let(:options) { { ignore: [%r{^foo/bar}, /\.pid$/] } }
 
-      it "silences custom ignored extension" do
-        path = pwd.join('foo.pid')
-        expect(silencer.silenced?(path)).to be_true
+      it "silences paths matching custom ignore regexes" do
+        expect(silencer.silenced?(pwd.join('foo/bar/baz'))).to be_true
+        expect(silencer.silenced?(pwd.join('foo.pid'))).to be_true
       end
     end
 
     context "with ignore! options" do
-      let(:options) { { ignore!: %r{foo/bar} } }
+      let(:options) { { ignore!: /\.pid$/ } }
 
       it "silences custom ignored directory" do
-        path = pwd.join('foo', 'bar')
-        expect(silencer.silenced?(path)).to be_true
+        expect(silencer.silenced?(pwd.join('foo.pid'))).to be_true
       end
 
       it "doesn't silence default ignored directory" do
@@ -77,6 +79,73 @@ describe Listen::Silencer do
       end
     end
 
+    context "with only options (regexp)" do
+      let(:options) { { only: %r{foo} } }
+
+      it "do not take only regex in account if type is Unknown" do
+        path = pwd.join('baz')
+        expect(silencer.silenced?(path)).to be_false
+      end
+
+      it "do not silence path matches only regex if type is File" do
+        path = pwd.join('foo')
+        expect(silencer.silenced?(path, 'File')).to be_false
+      end
+
+      it "silences other directory" do
+        path = pwd.join('bar')
+        expect(silencer.silenced?(path, 'File')).to be_true
+      end
+    end
+
+    context "with only options (array)" do
+      let(:options) { { only: [%r{^foo/}, %r{\.txt$}] } }
+
+      it "do not take only regex in account if type is Unknown" do
+        expect(silencer.silenced?(pwd.join('baz'))).to be_false
+      end
+
+      it "doesn't silence good directory" do
+        expect(silencer.silenced?(pwd.join('foo/bar.rb'), 'File')).to be_false
+      end
+
+      it "doesn't silence good file" do
+        expect(silencer.silenced?(pwd.join('bar.txt'), 'File')).to be_false
+      end
+
+      it "silences other directory" do
+        expect(silencer.silenced?(pwd.join('bar/baz.rb'), 'File')).to be_true
+      end
+
+      it "silences other file" do
+        expect(silencer.silenced?(pwd.join('bar.rb'), 'File')).to be_true
+      end
+    end
+
+    context 'with ignore and only options' do
+      let(:options) { { only: /\.pid$/, ignore: %r{^bar} } }
+
+      it "do not take only regex in account if type is Unknown" do
+        expect(silencer.silenced?(pwd.join('baz'))).to be_false
+      end
+
+      it "do not take only regex in account if type is Unknown but silences if ignore regex matches path" do
+        expect(silencer.silenced?(pwd.join('bar'))).to be_true
+      end
+
+      it 'silences path not matching custom only regex' do
+        expect(silencer.silenced?(pwd.join('foo.rb'), 'File')).to be_true
+      end
+
+      it 'silences path matching custom ignore regex' do
+        expect(silencer.silenced?(pwd.join('bar.pid', 'File'))).to be_true
+      end
+
+      it 'do not silence path matching custom only regex and not matching custom ignore regex' do
+        expect(silencer.silenced?(pwd.join('foo.pid', 'File'))).to be_false
+      end
+    end
+
     it "doesn't silence normal path" do
       path = pwd.join('some_dir', 'some_file.rb')
       expect(silencer.silenced?(path)).to be_false

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: listen
 version: !ruby/object:Gem::Version
-  version: 2.2.0
+  version: 2.3.1
 platform: ruby
 authors:
 - Thibaud Guillaume-Gentil
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-10-29 00:00:00.000000000 Z
+date: 2013-12-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: celluloid
@@ -181,7 +181,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.1.9
+rubygems_version: 2.0.14
 signing_key: 
 specification_version: 4
 summary: Listen to file modifications
@@ -205,3 +205,4 @@ test_files:
 - spec/support/acceptance_helper.rb
 - spec/support/fixtures_helper.rb
 - spec/support/platform_helper.rb
+has_rdoc: