listen 2.7.4 → 2.7.5

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

@@ -5,8 +5,8 @@ describe Listen::Adapter::Windows do
     let(:listener) { double(Listen::Listener) }
     let(:adapter) { described_class.new(listener) }
 
-    describe ".usable?" do
-      it "returns always true" do
+    describe '.usable?' do
+      it 'returns always true' do
         expect(described_class).to be_usable
       end
 
@@ -34,4 +34,7 @@ describe Listen::Adapter::Windows do
       expect(described_class).to_not be_usable
     end
   end
+
+  specify { expect(described_class).to be_local_fs }
+
 end

data/spec/lib/listen/adapter_spec.rb

@@ -1,59 +1,61 @@
 require 'spec_helper'
 
 describe Listen::Adapter do
+
   let(:listener) { double(Listen::Listener, options: {}) }
-  before {
+  before do
     Listen::Adapter::BSD.stub(:usable?) { false }
     Listen::Adapter::Darwin.stub(:usable?) { false }
     Listen::Adapter::Linux.stub(:usable?) { false }
     Listen::Adapter::Windows.stub(:usable?) { false }
-  }
+  end
 
-  describe ".select" do
+  describe '.select' do
     it 'returns TCP adapter when requested' do
       klass = Listen::Adapter.select(force_tcp: true)
       expect(klass).to eq Listen::Adapter::TCP
     end
 
-    it "returns Polling adapter if forced" do
+    it 'returns Polling adapter if forced' do
       klass = Listen::Adapter.select(force_polling: true)
       expect(klass).to eq Listen::Adapter::Polling
     end
 
-    it "returns BSD adapter when usable" do
+    it 'returns BSD adapter when usable' do
       Listen::Adapter::BSD.stub(:usable?) { true }
       klass = Listen::Adapter.select
       expect(klass).to eq Listen::Adapter::BSD
     end
 
-    it "returns Darwin adapter when usable" do
+    it 'returns Darwin adapter when usable' do
       Listen::Adapter::Darwin.stub(:usable?) { true }
       klass = Listen::Adapter.select
       expect(klass).to eq Listen::Adapter::Darwin
     end
 
-    it "returns Linux adapter when usable" do
+    it 'returns Linux adapter when usable' do
       Listen::Adapter::Linux.stub(:usable?) { true }
       klass = Listen::Adapter.select
       expect(klass).to eq Listen::Adapter::Linux
     end
 
-    it "returns Windows adapter when usable" do
+    it 'returns Windows adapter when usable' do
       Listen::Adapter::Windows.stub(:usable?) { true }
       klass = Listen::Adapter.select
       expect(klass).to eq Listen::Adapter::Windows
     end
 
-    context "no usable adapters" do
+    context 'no usable adapters' do
       before { Kernel.stub(:warn) }
 
-      it "returns Polling adapter" do
+      it 'returns Polling adapter' do
         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}")
+      it 'warns polling fallback with default message' do
+        msg = described_class::POLLING_FALLBACK_MESSAGE
+        expect(Kernel).to receive(:warn).with("[Listen warning]:\n  #{msg}")
         Listen::Adapter.select
       end
 
@@ -62,11 +64,12 @@ describe Listen::Adapter do
         Listen::Adapter.select(polling_fallback_message: false)
       end
 
-      it "warns polling fallback with custom message if set" do
-        expect(Kernel).to receive(:warn).with("[Listen warning]:\n  custom fallback message")
-        Listen::Adapter.select(polling_fallback_message: 'custom fallback message')
+      it 'warns polling fallback with custom message if set' do
+        expected_msg = "[Listen warning]:\n  custom fallback message"
+        expect(Kernel).to receive(:warn).with(expected_msg)
+        msg = 'custom fallback message'
+        Listen::Adapter.select(polling_fallback_message: msg)
       end
     end
-end
-
+  end
 end

data/spec/lib/listen/change_spec.rb

@@ -4,64 +4,72 @@ describe Listen::Change do
   let(:change) { Listen::Change.new(listener) }
   let(:registry) { double(Celluloid::Registry) }
   let(:listener) { double(Listen::Listener, registry: registry, options: {}) }
-  let(:listener_changes) { double("listener_changes") }
-  before {
+  let(:listener_changes) { double('listener_changes') }
+  before do
     listener.stub(:changes) { listener_changes }
-  }
+  end
 
-  describe "#change" do
+  describe '#change' do
     let(:silencer) { double('Listen::Silencer', silenced?: false) }
     before { registry.stub(:[]).with(:silencer) { silencer } }
 
-    context "file path" do
-      context "with known change" do
-        it "notifies change directly to listener" do
-          expect(listener_changes).to receive(:<<).with(modified: Pathname.new('file_path'))
-          change.change(Pathname.new('file_path'), type: 'File', change: :modified)
+    context 'file path' do
+      context 'with known change' do
+        it 'notifies change directly to listener' do
+          expect(listener_changes).to receive(:<<).
+            with(modified: Pathname.new('file_path'))
+
+          options = { type: 'File', change: :modified }
+          change.change(Pathname.new('file_path'), options)
         end
 
         it "doesn't notify to listener if path is silenced" do
-          # 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(Pathname.new('file_path'), type: 'File', change: :modified)
+          options = { type: 'File', change: :modified }
+          change.change(Pathname.new('file_path'), options)
         end
       end
 
-      context "with unknown change" do
+      context 'with unknown change' do
         let(:file) { double('Listen::File') }
         before { Listen::File.stub(:new) { file } }
 
-        it "calls Listen::File#change" do
-          expect(Listen::File).to receive(:new).with(listener, Pathname.new('file_path')) { file }
+        it 'calls Listen::File#change' do
+          expect(Listen::File).to receive(:new).
+            with(listener, Pathname.new('file_path')) { file }
+
           expect(file).to receive(:change)
           change.change(Pathname.new('file_path'), type: 'File')
         end
 
         it "doesn't call Listen::File#change if path is silenced" do
-          expect(silencer).to receive(:silenced?).with(Pathname.new('file_path'), 'File').and_return(true)
+          expect(silencer).to receive(:silenced?).
+            with(Pathname.new('file_path'), 'File').and_return(true)
+
           expect(Listen::File).to_not receive(:new)
 
           change.change(Pathname.new('file_path'), type: 'File')
         end
 
-        context "that returns a change" do
+        context 'that returns a change' do
           before { file.stub(:change) { :modified } }
 
-          context "listener listen" do
+          context 'listener listen' do
             before { listener.stub(:listen?) { true } }
 
-            it "notifies change to listener" do
+            it 'notifies change to listener' do
               file_path = double(Pathname, to_s: 'file_path', exist?: true)
               expect(listener_changes).to receive(:<<).with(modified: file_path)
               change.change(file_path, type: 'File')
             end
 
-            context "silence option" do
-              it "notifies change to listener" do
+            context 'silence option' do
+              it 'notifies change to listener' do
                 expect(listener_changes).to_not receive(:<<)
-                change.change(Pathname.new('file_path'), type: 'File', silence: true)
+                options = { type: 'File', silence: true }
+                change.change(Pathname.new('file_path'), options)
               end
             end
           end
@@ -69,14 +77,14 @@ describe Listen::Change do
           context "listener doesn't listen" do
             before { listener.stub(:listen?) { false } }
 
-            it "notifies change to listener" do
+            it 'notifies change to listener' do
               expect(listener_changes).to_not receive(:<<)
               change.change(Pathname.new('file_path'), type: 'File')
             end
           end
         end
 
-        context "that returns no change" do
+        context 'that returns no change' do
           before { file.stub(:change) { nil } }
 
           it "doesn't notifies no change" do
@@ -87,13 +95,15 @@ describe Listen::Change do
       end
     end
 
-    context "directory path" do
+    context 'directory path' do
       let(:dir) { double(Listen::Directory) }
       let(:dir_options) { { type: 'Dir', recursive: true } }
       before { Listen::Directory.stub(:new) { dir } }
 
-      it "calls Listen::Directory#scan" do
-        expect(Listen::Directory).to receive(:new).with(listener, Pathname.new('dir_path'), dir_options) { dir }
+      it 'calls Listen::Directory#scan' do
+        expect(Listen::Directory).to receive(:new).
+          with(listener, Pathname.new('dir_path'), dir_options) { dir }
+
         expect(dir).to receive(:scan)
         change.change(Pathname.new('dir_path'), dir_options)
       end

data/spec/lib/listen/directory_spec.rb

@@ -3,18 +3,22 @@ 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(:record) do
+    double(Listen::Record, async: double(set_path: true, unset_path: true))
+  end
+
   let(:change_pool) { double(Listen::Change) }
   let(:change_pool_async) { double('ChangePoolAsync') }
   let(:path) { Pathname.new(Dir.pwd) }
-  around { |example| fixtures { |path| example.run } }
-  before {
+  around { |example| fixtures { example.run } }
+  before do
     change_pool.stub(:async) { change_pool_async }
     registry.stub(:[]).with(:record) { record }
     registry.stub(:[]).with(:change_pool) { change_pool }
-  }
+  end
 
-  describe "#scan" do
+  describe '#scan' do
     let(:dir_path) { path.join('dir') }
     let(:file_path) { dir_path.join('file.rb') }
     let(:other_file_path) { dir_path.join('other_file.rb') }
@@ -22,129 +26,182 @@ describe Listen::Directory do
     let(:other_inside_dir_path) { dir_path.join('other_inside_dir') }
     let(:dir) { Listen::Directory.new(listener, dir_path, options) }
 
-    context "with recursive off" do
+    context 'with recursive off' do
       let(:options) { { recursive: false } }
 
-      context "file & inside_dir paths present in record" do
-        let(:record_dir_entries) { {
-          'file.rb' => { type: 'File' },
-          'inside_dir' => { type: 'Dir' } } }
-        before {
-          record.stub_chain(:future, :dir_entries) { double(value: record_dir_entries) }
+      context 'file & inside_dir paths present in record' do
+        let(:record_dir_entries) do
+          {
+            'file.rb' => { type: 'File' },
+            'inside_dir' => { type: 'Dir' }
+          }
+        end
+
+        before do
+          record.stub_chain(:future, :dir_entries) do
+            double(value: record_dir_entries)
+          end
+
           change_pool_async.stub(:change)
-        }
+        end
 
-        context "empty dir" do
-          around { |example| mkdir dir_path; example.run }
+        context 'empty dir' do
+          around do |example|
+            mkdir dir_path
+            example.run
+          end
 
-          it "sets record dir path" do
-            expect(record.async).to receive(:set_path).with(dir_path, type: 'Dir')
+          it 'sets record dir path' do
+            expect(record.async).to receive(:set_path).
+              with(dir_path, type: 'Dir')
             dir.scan
           end
 
           it "calls change for file path and dir that doesn't exist" do
-            expect(change_pool_async).to receive(:change).with(file_path, type: 'File', recursive: false)
-            expect(change_pool_async).to receive(:change).with(inside_dir_path, type: 'Dir', recursive: false)
+            expect(change_pool_async).to receive(:change).
+              with(file_path, type: 'File', recursive: false)
+
+            expect(change_pool_async).to receive(:change).
+              with(inside_dir_path, type: 'Dir', recursive: false)
+
             dir.scan
           end
         end
 
-        context "other file path present in dir" do
-          around { |example|
-            mkdir dir_path;
-            touch other_file_path;
-            example.run }
+        context 'other file path present in dir' do
+          around do |example|
+            mkdir dir_path
+            touch other_file_path
+            example.run
+          end
+
+          it 'notices file & other_file and no longer existing dir' do
+            expect(change_pool_async).to receive(:change).
+              with(file_path, type: 'File', recursive: false)
+
+            expect(change_pool_async).to receive(:change).
+              with(other_file_path, type: 'File', recursive: false)
+
+            expect(change_pool_async).to receive(:change).
+              with(inside_dir_path, type: 'Dir', recursive: false)
 
-          it "calls change for file & other_file paths and dir that doesn't exist" do
-            expect(change_pool_async).to receive(:change).with(file_path, type: 'File', recursive: false)
-            expect(change_pool_async).to receive(:change).with(other_file_path, type: 'File', recursive: false)
-            expect(change_pool_async).to receive(:change).with(inside_dir_path, type: 'Dir', recursive: false)
             dir.scan
           end
         end
       end
 
-      context "dir paths not present in record" do
-        before { record.stub_chain(:future, :dir_entries) { double(value: {}) } }
+      context 'dir paths not present in record' do
+        before do
+          record.stub_chain(:future, :dir_entries) { double(value: {}) }
+        end
 
-        context "non-existing dir path" do
-          it "calls change only for file path" do
+        context 'non-existing dir path' do
+          it 'calls change only for file path' do
             expect(change_pool_async).to_not receive(:change)
             dir.scan
           end
 
-          it "unsets record dir path" do
+          it 'unsets record dir path' do
             expect(record.async).to receive(:unset_path).with(dir_path)
             dir.scan
           end
         end
 
-        context "other file path present in dir" do
-          around { |example|
-            mkdir dir_path;
-            touch file_path;
-            example.run }
+        context 'other file path present in dir' do
+          around do |example|
+            mkdir dir_path
+            touch file_path
+            example.run
+          end
+
+          it 'calls change for file & other_file paths' do
+            expect(change_pool_async).to receive(:change).
+              with(file_path, type: 'File', recursive: false)
+
+            expect(change_pool_async).to_not receive(:change).
+              with(other_file_path, type: 'File', recursive: false)
+
+            expect(change_pool_async).to_not receive(:change).
+              with(inside_dir_path, type: 'Dir', recursive: false)
 
-          it "calls change for file & other_file paths" do
-            expect(change_pool_async).to receive(:change).with(file_path, type: 'File', recursive: false)
-            expect(change_pool_async).to_not receive(:change).with(other_file_path, type: 'File', recursive: false)
-            expect(change_pool_async).to_not receive(:change).with(inside_dir_path, type: 'Dir', recursive: false)
             dir.scan
           end
         end
       end
     end
 
-    context "with recursive on" do
+    context 'with recursive on' do
       let(:options) { { recursive: true } }
 
-      context "file & inside_dir paths present in record" do
-        let(:record_dir_entries) { {
+      context 'file & inside_dir paths present in record' do
+        let(:record_dir_entries) do {
           'file.rb' => { type: 'File' },
-          'inside_dir' => { type: 'Dir' } } }
-        before { record.stub_chain(:future, :dir_entries) { double(value: record_dir_entries) } }
+          'inside_dir' => { type: 'Dir' } }
+        end
+
+        before do
+          record.stub_chain(:future, :dir_entries) do
+            double(value: record_dir_entries)
+          end
+        end
+
+        context 'empty dir' do
+          it 'calls change for file & inside_dir path' do
+            expect(change_pool_async).to receive(:change).
+              with(file_path, type: 'File', recursive: true)
+
+            expect(change_pool_async).to receive(:change).
+              with(inside_dir_path, type: 'Dir', recursive: true)
 
-        context "empty dir" do
-          it "calls change for file & inside_dir path" do
-            expect(change_pool_async).to receive(:change).with(file_path, type: 'File', recursive: true)
-            expect(change_pool_async).to receive(:change).with(inside_dir_path, type: 'Dir', recursive: true)
             dir.scan
           end
         end
 
-        context "other inside_dir path present in dir" do
-          around { |example|
-            mkdir dir_path;
-            mkdir other_inside_dir_path;
-            example.run }
+        context 'other inside_dir path present in dir' do
+          around do |example|
+            mkdir dir_path
+            mkdir other_inside_dir_path
+            example.run
+          end
+
+          it 'calls change for file, other_file & inside_dir paths' do
+            expect(change_pool_async).to receive(:change).
+              with(file_path, type: 'File', recursive: true)
+
+            expect(change_pool_async).to receive(:change).
+              with(inside_dir_path, type: 'Dir', recursive: true)
+
+            expect(change_pool_async).to receive(:change).
+              with(other_inside_dir_path, type: 'Dir', recursive: true)
 
-          it "calls change for file, other_file & inside_dir paths" do
-            expect(change_pool_async).to receive(:change).with(file_path, type: 'File', recursive: true)
-            expect(change_pool_async).to receive(:change).with(inside_dir_path, type: 'Dir', recursive: true)
-            expect(change_pool_async).to receive(:change).with(other_inside_dir_path, type: 'Dir', recursive: true)
             dir.scan
           end
         end
       end
 
-      context "dir paths not present in record" do
-        before { record.stub_chain(:future, :dir_entries) { double(value: {}) } }
+      context 'dir paths not present in record' do
+        before do
+          record.stub_chain(:future, :dir_entries) { double(value: {}) }
+        end
 
-        context "non-existing dir path" do
-          it "calls change only for file path" do
+        context 'non-existing dir path' do
+          it 'calls change only for file path' do
             expect(change_pool_async).to_not receive(:change)
             dir.scan
           end
         end
 
-        context "other file path present in dir" do
-          around { |example|
-            mkdir dir_path;
-            mkdir other_inside_dir_path;
-            example.run }
+        context 'other file path present in dir' do
+          around do |example|
+            mkdir dir_path
+            mkdir other_inside_dir_path
+            example.run
+          end
+
+          it 'calls change for file & other_file paths' do
+            expect(change_pool_async).to receive(:change).
+              with(other_inside_dir_path, type: 'Dir', recursive: true)
 
-          it "calls change for file & other_file paths" do
-            expect(change_pool_async).to receive(:change).with(other_inside_dir_path, type: 'Dir', recursive: true)
             dir.scan
           end
         end