listen 2.7.6 → 2.7.7

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

@@ -1,28 +1,27 @@
 require 'spec_helper'
 
-describe Listen::Adapter::Polling do
+include Listen
+
+describe Adapter::Polling do
   describe 'class' do
     subject { described_class }
     it { should be_local_fs }
     it { should be_usable }
   end
 
-  subject { described_class.new(listener) }
+  subject do
+    described_class.new(options.merge(mq: mq, directories: directories))
+  end
 
   let(:options) { {} }
-  let(:listener) { instance_double(Listen::Listener, options: options) }
-  let(:worker) { instance_double(Listen::Change) }
-
-  before { allow(listener).to receive(:async).with(:change_pool) { worker } }
+  let(:mq) { instance_double(Listener, options: options) }
 
   describe '#start' do
-    before { allow(listener).to receive(:directories) { ['directory_path'] } }
+    let(:directories) { [Pathname.pwd] }
 
     it 'notifies change on every listener directories path' do
-      expect(worker).to receive(:change).with(
-        :dir,
-        'directory_path',
-        recursive: true)
+      expect(mq).to receive(:_queue_raw_change).
+        with(:dir, Pathname.pwd, '.', recursive: true)
 
       t = Thread.new { subject.start }
       sleep 0.25
@@ -31,10 +30,13 @@ describe Listen::Adapter::Polling do
   end
 
   describe '#_latency' do
-    subject { described_class.new(listener).send(:_latency) }
+    subject do
+      adapter = described_class.new(options.merge(mq: mq, directories: []))
+      adapter.options.latency
+    end
 
     context 'with no overriding option' do
-      it { should eq described_class.const_get('DEFAULT_POLLING_LATENCY') }
+      it { should eq 1.0 }
     end
 
     context 'with custom latency overriding' do

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

@@ -5,7 +5,9 @@ describe Listen::Adapter::TCP do
   let(:host) { '10.0.0.2' }
   let(:port) { 4000 }
 
-  subject { described_class.new(listener) }
+  let(:options) { { host: host, port: port } }
+
+  subject { described_class.new(options.merge(mq: listener)) }
   let(:registry) { instance_double(Celluloid::Registry) }
 
   let(:listener) do
@@ -111,11 +113,12 @@ describe Listen::Adapter::TCP do
   end
 
   describe '#handle_message' do
+    let(:dir) { Pathname.pwd }
     it 'notifies listener of path changes' do
-      message = Listen::TCP::Message.new('file', 'modified', '/foo', {})
+      message = Listen::TCP::Message.new('file', 'modified', dir, 'foo', {})
 
       expect(subject.wrapped_object).
-        to receive(:_notify_change).with :file, '/foo', change: :modified
+        to receive(:_queue_change).with :file, dir, 'foo', change: :modified
 
       subject.handle_message message
     end

data/spec/lib/listen/change_spec.rb

@@ -4,11 +4,15 @@ describe Listen::Change do
   let(:subject) { Listen::Change.new(listener) }
   let(:listener) { instance_double(Listen::Listener, options: {}) }
   let(:record) { instance_double(Listen::Record) }
-  let(:file_path) { Pathname.new('file_path') }
+  let(:full_file_path) { instance_double(Pathname, to_s: '/dir/file.rb') }
+  let(:full_dir_path) { instance_double(Pathname, to_s: '/dir') }
+  let(:dir) { instance_double(Pathname) }
 
   before do
     allow(listener).to receive(:sync).with(:record) { record }
     allow(listener).to receive(:async).with(:change_pool) { subject }
+    allow(dir).to receive(:+).with('file.rb') { full_file_path }
+    allow(dir).to receive(:+).with('dir1') { full_dir_path }
   end
 
   describe '#change' do
@@ -16,48 +20,43 @@ describe Listen::Change do
     before { allow(listener).to receive(:silencer) { silencer } }
 
     context 'with build options' do
-      let(:async_record) do
-        instance_double(Listen::Record, still_building!: nil)
-      end
-
-      it 'calls update_last_build_time on record' do
+      it 'calls still_building! on record' do
         allow(listener).to receive(:queue)
         allow(record).to receive(:async) { async_record }
-        expect(async_record).to receive(:unset_path)
-        subject.change(:file, file_path, build: true)
+        allow(Listen::File).to receive(:change)
+        subject.change(:file, dir, 'file.rb', build: true)
       end
     end
 
     context 'file' do
       context 'with known change' do
-        let(:file_path) { Pathname('file_path') }
         it 'notifies change directly to listener' do
           expect(listener).to receive(:queue).
-            with(:file, :modified, file_path, {})
+            with(:file, :modified, dir, 'file.rb', {})
 
-          subject.change(:file, file_path, change: :modified)
+          subject.change(:file, dir, 'file.rb', change: :modified)
         end
 
         it "doesn't notify to listener if path is silenced" do
           expect(silencer).to receive(:silenced?).and_return(true)
           expect(listener).to_not receive(:queue)
-          subject.change(:file, file_path, change: :modified)
+          subject.change(:file, dir, 'file.rb', change: :modified)
         end
       end
 
       context 'with unknown change' do
 
         it 'calls Listen::File#change' do
-          expect(Listen::File).to receive(:change).with(record, file_path)
-          subject.change(:file, file_path)
+          expect(Listen::File).to receive(:change).with(record, dir, 'file.rb')
+          subject.change(:file, dir, 'file.rb')
         end
 
         it "doesn't call Listen::File#change if path is silenced" do
           expect(silencer).to receive(:silenced?).
-            with(file_path, :file).and_return(true)
+            with(Pathname('file.rb'), :file).and_return(true)
 
           expect(Listen::File).to_not receive(:change)
-          subject.change(:file, file_path)
+          subject.change(:file, dir, 'file.rb')
         end
 
         context 'that returns a change' do
@@ -65,20 +64,16 @@ describe Listen::Change do
 
           context 'listener listen' do
             it 'notifies change to listener' do
-              file_path = instance_double(Pathname,
-                                          to_s: 'file_path',
-                                          exist?: true)
-
               expect(listener).to receive(:queue).
-                with(:file, :modified, file_path)
+                with(:file, :modified, dir, 'file.rb')
 
-              subject.change(:file, file_path)
+              subject.change(:file, dir, 'file.rb')
             end
 
             context 'silence option' do
               it 'notifies change to listener' do
                 expect(listener).to_not receive(:queue)
-                subject.change(:file, file_path, silence: true)
+                subject.change(:file, dir, 'file.rb', silence: true)
               end
             end
           end
@@ -89,7 +84,7 @@ describe Listen::Change do
 
           it "doesn't notifies no change" do
             expect(listener).to_not receive(:queue)
-            subject.change(:file, file_path)
+            subject.change(:file, dir, 'file.rb')
           end
         end
       end
@@ -97,13 +92,12 @@ describe Listen::Change do
 
     context 'directory' do
       let(:dir_options) { { recursive: true } }
-      let(:dir_path) { Pathname.new('dir_path') }
 
       it 'calls Listen::Directory#new' do
         expect(Listen::Directory).to receive(:scan).
-          with(subject, record, dir_path, dir_options)
+          with(subject, record, dir, 'dir1', dir_options)
 
-        subject.change(:dir, dir_path, dir_options)
+        subject.change(:dir, dir, 'dir1', dir_options)
       end
     end
   end

data/spec/lib/listen/directory_spec.rb

@@ -3,60 +3,68 @@ require 'spec_helper'
 include Listen
 
 describe Directory do
-  let(:path) { Pathname.pwd }
-  let(:dir) { path + 'dir' }
-  let(:file) { dir + 'file.rb' }
-  let(:file2) { dir + 'file2.rb' }
-  let(:subdir) { dir + 'subdir' }
-  let(:subdir2) { instance_double(Pathname, directory?: true) }
+  let(:dir) { double(:dir) }
+  let(:file) { double(:file, directory?: false) }
+  let(:file2) { double(:file2, directory?: false) }
+  let(:subdir) { double(:subdir, directory?: true) }
 
   let(:queue) { instance_double(Change, change: nil) }
 
   let(:async_record) do
-    instance_double(Record, set_path: true, unset_path: true)
+    instance_double(Record, add_dir: true, unset_path: true)
   end
 
   let(:record) do
     instance_double(Record, async: async_record, dir_entries: record_entries)
   end
 
+  before do
+    allow(dir).to receive(:+).with('.') { dir }
+    allow(dir).to receive(:+).with('file.rb') { file }
+    allow(dir).to receive(:+).with('subdir') { subdir }
+
+    allow(file).to receive(:relative_path_from).with(dir) { 'file.rb' }
+    allow(file2).to receive(:relative_path_from).with(dir) { 'file2.rb' }
+    allow(subdir).to receive(:relative_path_from).with(dir) { 'subdir' }
+  end
+
   context '#scan with recursive off' do
     let(:options) { { recursive: false } }
 
     context 'with file & subdir in record' do
       let(:record_entries) do
-        { 'file.rb' => { type: :file }, 'subdir' => { type: :dir } }
+        { 'file.rb' => { mtime: 1.1 }, 'subdir' => {} }
       end
 
       context 'with empty dir' do
         before { allow(dir).to receive(:children) { [] } }
 
         it 'sets record dir path' do
-          expect(async_record).to receive(:set_path).with(:dir, dir)
-          described_class.scan(queue, record, dir, options)
+          expect(async_record).to receive(:add_dir).with(dir, '.')
+          described_class.scan(queue, record, dir, '.', options)
         end
 
         it "queues changes for file path and dir that doesn't exist" do
-          expect(queue).to receive(:change).with(:file, file)
+          expect(queue).to receive(:change).with(:file, dir, 'file.rb')
 
           expect(queue).to receive(:change).
-            with(:dir, subdir, recursive: false)
+            with(:dir, dir, 'subdir', recursive: false)
 
-          described_class.scan(queue, record, dir, options)
+          described_class.scan(queue, record, dir, '.', options)
         end
       end
 
-      context 'with file2.rb in dir' do
+      context 'with only file2.rb in dir' do
         before { allow(dir).to receive(:children) { [file2] } }
 
         it 'notices file & file2 and no longer existing dir' do
-          expect(queue).to receive(:change).with(:file, file)
-          expect(queue).to receive(:change).with(:file, file2)
+          expect(queue).to receive(:change).with(:file, dir, 'file.rb')
+          expect(queue).to receive(:change).with(:file, dir, 'file2.rb')
 
           expect(queue).to receive(:change).
-            with(:dir, subdir, recursive: false)
+            with(:dir, dir, 'subdir', recursive: false)
 
-          described_class.scan(queue, record, dir, options)
+          described_class.scan(queue, record, dir, '.', options)
         end
       end
     end
@@ -69,12 +77,12 @@ describe Directory do
 
         it 'reports no changes' do
           expect(queue).to_not receive(:change)
-          described_class.scan(queue, record, dir, options)
+          described_class.scan(queue, record, dir, '.', options)
         end
 
         it 'unsets record dir path' do
-          expect(async_record).to receive(:unset_path).with(dir)
-          described_class.scan(queue, record, dir, options)
+          expect(async_record).to receive(:unset_path).with(dir, '.')
+          described_class.scan(queue, record, dir, '.', options)
         end
       end
 
@@ -82,13 +90,13 @@ describe Directory do
         before { allow(dir).to receive(:children) { [file] } }
 
         it 'queues changes for file & file2 paths' do
-          expect(queue).to receive(:change).with(:file, file)
-          expect(queue).to_not receive(:change).with(:file, file2)
+          expect(queue).to receive(:change).with(:file, dir, 'file.rb')
+          expect(queue).to_not receive(:change).with(:file, dir, 'file2.rb')
 
           expect(queue).to_not receive(:change).
-            with(:dir, subdir, recursive: false)
+            with(:dir, dir, 'subdir', recursive: false)
 
-          described_class.scan(queue, record, dir, options)
+          described_class.scan(queue, record, dir, '.', options)
         end
       end
     end
@@ -99,38 +107,42 @@ describe Directory do
 
     context 'with file.rb & subdir in record' do
       let(:record_entries) do
-        { 'file.rb' => { type: :file }, 'subdir' => { type: :dir } }
+        { 'file.rb' => { mtime: 1.1 }, 'subdir' => {} }
       end
 
       context 'with empty dir' do
-        before { allow(dir).to receive(:children) { [] } }
+        before do
+          allow(dir).to receive(:children) { [] }
+        end
 
         it 'queues changes for file & subdir path' do
-          expect(queue).to receive(:change).with(:file, file)
+          expect(queue).to receive(:change).with(:file, dir, 'file.rb')
 
           expect(queue).to receive(:change).
-            with(:dir, subdir, recursive: true)
+            with(:dir, dir, 'subdir', recursive: true)
 
-          described_class.scan(queue, record, dir, options)
+          described_class.scan(queue, record, dir, '.', options)
         end
       end
 
       context 'with subdir2 path present in dir' do
+        let(:subdir2) { double(:subdir2, directory?: true, children: []) }
+
         before do
-          allow(path).to receive(:children) { [dir] }
           allow(dir).to receive(:children) { [subdir2] }
+          allow(subdir2).to receive(:relative_path_from).with(dir) { 'subdir2' }
         end
 
         it 'queues changes for file, file2 & subdir paths' do
-          expect(queue).to receive(:change).with(:file, file)
+          expect(queue).to receive(:change).with(:file, dir, 'file.rb')
 
           expect(queue).to receive(:change).
-            with(:dir, subdir, recursive: true)
+            with(:dir, dir, 'subdir', recursive: true)
 
           expect(queue).to receive(:change).
-            with(:dir, subdir2, recursive: true)
+            with(:dir, dir, 'subdir2', recursive: true)
 
-          described_class.scan(queue, record, dir, options)
+          described_class.scan(queue, record, dir, '.', options)
         end
       end
     end
@@ -139,22 +151,28 @@ describe Directory do
       let(:record_entries) { {} }
 
       context 'with non-existing dir' do
-        before { allow(dir).to receive(:children) { fail Errno::ENOENT } }
+        before do
+          allow(dir).to receive(:children) { fail Errno::ENOENT }
+        end
 
         it 'reports no changes' do
           expect(queue).to_not receive(:change)
-          described_class.scan(queue, record, dir, options)
+          described_class.scan(queue, record, dir, '.', options)
         end
       end
 
-      context 'with subdir2 present in dir' do
-        before { allow(dir).to receive(:children) { [subdir2] } }
+      context 'with subdir present in dir' do
 
-        it 'queues changes for file & file2 paths' do
+        before do
+          allow(dir).to receive(:children) { [subdir] }
+          allow(subdir).to receive(:children) { [] }
+        end
+
+        it 'queues changes for subdir' do
           expect(queue).to receive(:change).
-            with(:dir, subdir2, recursive: true)
+            with(:dir, dir, 'subdir', recursive: true)
 
-          described_class.scan(queue, record, dir, options)
+          described_class.scan(queue, record, dir, '.', options)
         end
       end
     end

data/spec/lib/listen/file_spec.rb

@@ -4,7 +4,8 @@ describe Listen::File do
   let(:async_record) do
     instance_double(
       Listen::Record,
-      set_path: true,
+      add_dir: true,
+      update_file: true,
       unset_path: true,
     )
   end
@@ -18,8 +19,7 @@ describe Listen::File do
   end
 
   let(:path) { Pathname.pwd }
-  let(:file_path) { path + 'file.rb' }
-  let(:subject) { described_class.change(record, file_path) }
+  let(:subject) { described_class.change(record, path, 'file.rb') }
 
   around { |example| fixtures { example.run } }
 
@@ -30,16 +30,13 @@ describe Listen::File do
       { mtime: kind_of(Float), mode: kind_of(Integer) }
     end
 
-    context 'with file in record' do
+    context 'with file record' do
       let(:record_mtime) { nil }
       let(:record_md5) { nil }
       let(:record_mode) { nil }
 
       let(:record_data) do
-        { type: :file,
-          mtime: record_mtime,
-          md5: record_md5,
-          mode: record_mode }
+        { mtime: record_mtime, md5: record_md5, mode: record_mode }
       end
 
       context 'with non-existing file' do
@@ -48,7 +45,7 @@ describe Listen::File do
         it { should be :removed }
 
         it 'sets path in record' do
-          expect(async_record).to receive(:unset_path).with(file_path)
+          expect(async_record).to receive(:unset_path).with(path, 'file.rb')
           subject
         end
       end
@@ -81,8 +78,8 @@ describe Listen::File do
           it { should be :modified }
 
           it 'sets path in record with expected data' do
-            expect(async_record).to receive(:set_path).
-              with(:file, file_path, expected_data)
+            expect(async_record).to receive(:update_file).
+              with(path, 'file.rb', expected_data)
             subject
           end
         end
@@ -97,8 +94,8 @@ describe Listen::File do
             it { should be :modified }
 
             it 'sets path in record with expected data' do
-              expect(async_record).to receive(:set_path).
-                with(:file, file_path, expected_data)
+              expect(async_record).to receive(:update_file).
+                with(path, 'file.rb', expected_data)
               subject
             end
           end
@@ -109,8 +106,8 @@ describe Listen::File do
             it { should be :modified }
 
             it 'sets path in record with expected data' do
-              expect(async_record).to receive(:set_path).
-                with(:file, file_path, expected_data)
+              expect(async_record).to receive(:update_file).
+                with(path, 'file.rb', expected_data)
               subject
             end
           end
@@ -182,8 +179,8 @@ describe Listen::File do
                     it { should be :modified }
 
                     it 'sets path in record with expected data' do
-                      expect(async_record).to receive(:set_path).
-                        with(:file, file_path, expected_data. merge(md5: md5))
+                      expect(async_record).to receive(:update_file).
+                        with(path, 'file.rb', expected_data. merge(md5: md5))
                       subject
                     end
                   end
@@ -216,9 +213,8 @@ describe Listen::File do
         end
 
         it 'sets path in record with expected data' do
-          expect(async_record).to receive(:set_path).
-            with(:file, file_path, expected_data)
-
+          expect(async_record).to receive(:update_file).
+            with(path, 'file.rb', expected_data)
           subject
         end
       end