listen 2.7.6 → 2.7.7

data/spec/lib/listen/silencer_spec.rb

@@ -1,156 +1,86 @@
 require 'spec_helper'
 
+RSpec::Matchers.define :accept do |type, path|
+  match { |actual| !actual.silenced?(Pathname(path), type) }
+end
+
 describe Listen::Silencer do
   let(:options) { {} }
-
-  let(:listener) do
-    instance_double(
-      Listen::Listener,
-      directories: [Pathname.pwd, Pathname.new('/Users/Shared/')],
-      options: options
-    )
-  end
-
-  let(:silencer) { Listen::Silencer.new(listener) }
+  before { subject.configure(options) }
 
   describe '#silenced?' do
-    let(:pwd) { Pathname.pwd }
-
-    context 'default ignore' do
-      hidden_dirs = %w(.git .svn .hg .rbx .bundle)
-      other_dirs = %w(bundle vendor/bundle log tmp vendor/ruby)
-      (hidden_dirs + other_dirs).each do |dir|
-        it "silences #{dir}" do
-          expect(silencer.silenced?(pwd + dir, :dir)).to be_truthy
-        end
-
-        it "doesn't silence #{dir}foo" do
-          expect(silencer.silenced?(pwd + "#{dir}foo", :dir)).to be_falsey
-        end
-
-        it "doesn't silence foo#{dir}" do
-          expect(silencer.silenced?(pwd + "foo#{dir}", :dir)).to be_falsey
-        end
+    it { should accept(:file, Pathname('some_dir') + 'some_file.rb') }
+
+    context 'with default ignore' do
+      hidden_ignored = %w(.git .svn .hg .rbx .bundle)
+      other_ignored = %w(bundle vendor/bundle log tmp vendor/ruby)
+      (hidden_ignored + other_ignored).each do |dir|
+        it { should_not accept(:dir, dir) }
+        it { should accept(:dir, "#{dir}foo") }
+        it { should accept(:dir, "foo#{dir}") }
       end
 
-      all_files = %w(.DS_Store foo.tmp foo~)
+      ignored = %w(.DS_Store foo.tmp foo~)
 
       # Gedit swap files
-      all_files += %w(.goutputstream-S3FBGX)
+      ignored += %w(.goutputstream-S3FBGX)
 
       # Kate editor swap files
-      all_files += %w(foo.rbo54321.new foo.rbB22583.new foo.rb.kate-swp)
+      ignored += %w(foo.rbo54321.new foo.rbB22583.new foo.rb.kate-swp)
 
       # Intellij swap files
-      all_files += %w(foo.rb___jb_bak___ foo.rb___jb_old___)
+      ignored += %w(foo.rb___jb_bak___ foo.rb___jb_old___)
 
       # Vim swap files
-      all_files += %w(foo.swp foo.swx foo.swpx 4913)
+      ignored += %w(foo.swp foo.swx foo.swpx 4913)
 
-      all_files.each do |path|
-        it "silences #{path}" do
-          expect(silencer.silenced?(pwd + path, :file)).to be_truthy
-        end
+      ignored.each do |path|
+        it { should_not accept(:file, path) }
       end
 
       %w(foo.tmpl file.new file54321.new a.swf 14913 49131).each do |path|
-        it "does not silence #{path}" do
-          expect(silencer.silenced?(pwd + path, :file)).to be_falsey
-        end
+        it { should accept(:file, path) }
       end
     end
 
-    context 'with ignore options (regexp)' do
+    context 'when ignoring *.pid' do
       let(:options) { { ignore: /\.pid$/ } }
-
-      it 'silences path matching custom ignore regex' do
-        expect(silencer.silenced?(pwd + 'foo.pid', :file)).to be_truthy
-      end
+      it { should_not accept(:file, 'foo.pid') }
     end
 
-    context 'with ignore options (array)' do
+    context 'when ignoring foo/bar* and *.pid' do
       let(:options) { { ignore: [%r{^foo/bar}, /\.pid$/] } }
-
-      it 'silences paths matching custom ignore regexes' do
-        expect(silencer.silenced?(pwd + 'foo/bar/baz', :file)).to be_truthy
-        expect(silencer.silenced?(pwd + 'foo.pid', :file)).to be_truthy
-      end
+      it { should_not accept(:file, 'foo/bar/baz') }
+      it { should_not accept(:file, 'foo.pid') }
     end
 
-    context 'with ignore! options' do
+    context 'when ignoring only *.pid' do
       let(:options) { { ignore!: /\.pid$/ } }
-
-      it 'silences custom ignored directory' do
-        expect(silencer.silenced?(pwd + 'foo.pid', :file)).to be_truthy
-      end
-
-      it "doesn't silence default ignored directory" do
-        expect(silencer.silenced?(pwd + '.git', :file)).to be_falsey
-      end
+      it { should_not accept(:file, 'foo.pid') }
+      it { should accept(:file, '.git') }
     end
 
-    context 'with only options (regexp)' do
+    context 'when accepting only *foo*' do
       let(:options) { { only: %r{foo} } }
-
-      it 'do not silence path matches only regex if type is File' do
-        expect(silencer.silenced?(pwd + 'foo', :file)).to be_falsey
-      end
-
-      it 'silences other directory' do
-        expect(silencer.silenced?(pwd + 'bar', :file)).to be_truthy
-      end
+      it { should accept(:file, 'foo') }
+      it { should_not accept(:file, 'bar') }
     end
 
-    context 'with only options (array)' do
+    context 'when accepting only foo/* and *.txt' do
       let(:options) { { only: [%r{^foo/}, %r{\.txt$}] } }
-
-      it "doesn't silence good directory" do
-        expect(silencer.silenced?(pwd + 'foo/bar.rb', :file)).to be_falsey
-      end
-
-      it "doesn't silence good file" do
-        expect(silencer.silenced?(pwd + 'bar.txt', :file)).to be_falsey
-      end
-
-      it 'silences other directory' do
-        expect(silencer.silenced?(pwd + 'bar/baz.rb', :file)).to be_truthy
-      end
-
-      it 'silences other file' do
-        expect(silencer.silenced?(pwd + 'bar.rb', :file)).to be_truthy
-      end
+      it { should accept(:file, 'foo/bar.rb') }
+      it { should accept(:file, 'bar.txt') }
+      it { should_not accept(:file, 'bar/baz.rb') }
+      it { should_not accept(:file, 'bar.rb') }
     end
 
-    context 'with ignore and only options' do
-      let(:options) { { only: /\.pid$/, ignore: %r{^bar} } }
-
-      context 'with File type' do
-        context 'when not matching :only' do
-          it 'silences' do
-            expect(silencer.silenced?(pwd + 'foo.rb', :file)).to be_truthy
-          end
-        end
-
-        context 'when matching :only' do
-          context 'when matching :ignore' do
-            it 'silences' do
-              expect(silencer.silenced?(pwd + 'bar.pid', :file)).to be_truthy
-            end
-          end
-
-          context 'when not matching :ignore' do
-            it 'does not silence' do
-              expect(silencer.silenced?(pwd + 'foo.pid', :file)).to be_falsey
-            end
-          end
-        end
+    context 'when accepting only *.pid' do
+      context 'when ignoring bar*' do
+        let(:options) { { only: /\.pid$/, ignore: %r{^bar} } }
+        it { should_not accept(:file, 'foo.rb') }
+        it { should_not accept(:file, 'bar.pid') }
+        it { should accept(:file, 'foo.pid') }
       end
     end
-
-    it "doesn't silence normal path" do
-      path = (pwd + 'some_dir') + 'some_file.rb'
-      expect(silencer.silenced?(path, :file)).to be_falsey
-    end
   end
-
 end

data/spec/lib/listen/tcp/listener_spec.rb

@@ -17,7 +17,7 @@ describe Listen::Listener do
   end
 
   let(:record) { instance_double(Listen::Record, terminate: true, build: true) }
-  let(:silencer) { instance_double(Listen::Silencer, terminate: true) }
+  let(:silencer) { instance_double(Listen::Silencer, configure: nil) }
   let(:adapter) { instance_double(Listen::Adapter::Base) }
   let(:async) { instance_double(Listen::TCP::Broadcaster, broadcast: true) }
   let(:broadcaster) { instance_double(Listen::TCP::Broadcaster, async: async) }
@@ -26,11 +26,12 @@ describe Listen::Listener do
   before do
     allow(Celluloid::Registry).to receive(:new) { registry }
     allow(Celluloid::SupervisionGroup).to receive(:run!) { supervisor }
-    allow(registry).to receive(:[]).with(:silencer) { silencer }
     allow(registry).to receive(:[]).with(:adapter) { adapter }
     allow(registry).to receive(:[]).with(:record) { record }
     allow(registry).to receive(:[]).with(:change_pool) { change_pool }
     allow(registry).to receive(:[]).with(:broadcaster) { broadcaster }
+
+    allow(Listen::Silencer).to receive(:new) { silencer }
   end
 
   describe '#initialize' do
@@ -78,15 +79,17 @@ describe Listen::Listener do
           end
 
           subject.stop
-          subject.queue(:file, :modified, 'foo')
+          subject.queue(:file, :modified, Pathname.pwd, 'foo')
           expect(broadcaster).not_to receive(:async)
         end
       end
 
+      let(:dir) { Pathname.pwd }
+
       it 'broadcasts changes asynchronously' do
-        message = Listen::TCP::Message.new(:file, :modified, 'foo', {})
+        message = Listen::TCP::Message.new(:file, :modified, dir, 'foo', {})
         expect(async).to receive(:broadcast).with message.payload
-        subject.queue(:file, :modified, 'foo')
+        subject.queue(:file, :modified, Pathname.pwd, 'foo')
       end
     end
   end

data/spec/support/acceptance_helper.rb

@@ -185,14 +185,25 @@ class ListenerWrapper
   end
 
   def listen(reset_queue = true)
-    @timed_changes.allow_changes(reset_queue) do
+    # Give previous events time to be received, queued and processed
+    # so they complete and don't interfere
+    sleep lag
 
-      # give events time to be received, queued and processed
-      sleep lag
+    @timed_changes.allow_changes(reset_queue) do
 
       yield
 
-      sleep lag # wait for changes
+      # Polling sleep (default: 1s)
+      adapter = @listener.sync(:adapter)
+      if adapter.is_a?(Listen::Adapter::Polling)
+        sleep adapter.options.latency
+      end
+
+      # Lag should include:
+      #  0.1s - 0.2s if the test needs Listener queue to be processed
+      #  0.1s in case the system is busy
+      #  0.1s - for celluloid overhead and scheduling
+      sleep lag
     end
 
     # Keep this to detect a lag too small (changes during this sleep

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: listen
 version: !ruby/object:Gem::Version
-  version: 2.7.6
+  version: 2.7.7
 platform: ruby
 authors:
 - Thibaud Guillaume-Gentil
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-02 00:00:00.000000000 Z
+date: 2014-06-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: celluloid
@@ -157,6 +157,7 @@ files:
 - lib/listen/directory.rb
 - lib/listen/file.rb
 - lib/listen/listener.rb
+- lib/listen/options.rb
 - lib/listen/queue_optimizer.rb
 - lib/listen/record.rb
 - lib/listen/silencer.rb