listen 2.7.4 → 2.7.5

data/spec/acceptance/tcp_spec.rb

@@ -6,14 +6,16 @@ describe Listen::TCP do
 
   let(:broadcaster) { Listen.to(Dir.pwd, forward_to: port) }
   let(:recipient)  { Listen.on(port) }
-  let(:callback) { ->(modified, added, removed) {
-    add_changes(:modified, modified)
-    add_changes(:added, added)
-    add_changes(:removed, removed)
-  } }
+  let(:callback) do
+    lambda do |modified, added, removed|
+      add_changes(:modified, modified)
+      add_changes(:added, added)
+      add_changes(:removed, removed)
+    end
+  end
   let(:paths) { Pathname.new(Dir.pwd) }
 
-  around { |example| fixtures { |path| example.run } }
+  around { |example| fixtures { example.run } }
 
   before do
     broadcaster.start
@@ -25,9 +27,9 @@ describe Listen::TCP do
     end
 
     it 'still handles local changes' do
-      expect(listen {
+      expect(listen do
         touch 'file.rb'
-      }).to eq(
+      end).to eq(
         modified: [],
         added:    ['file.rb'],
         removed:  []
@@ -37,9 +39,9 @@ describe Listen::TCP do
     it 'may be paused and unpaused' do
       broadcaster.pause
 
-      expect(listen {
+      expect(listen do
         touch 'file.rb'
-      }).to eq(
+      end).to eq(
         modified: [],
         added:    [],
         removed:  []
@@ -47,9 +49,9 @@ describe Listen::TCP do
 
       broadcaster.unpause
 
-      expect(listen {
+      expect(listen do
         touch 'file.rb'
-      }).to eq(
+      end).to eq(
         modified: ['file.rb'],
         added:    [],
         removed:  []
@@ -59,9 +61,9 @@ describe Listen::TCP do
     it 'may be stopped and restarted' do
       broadcaster.stop
 
-      expect(listen {
+      expect(listen do
         touch 'file.rb'
-      }).to eq(
+      end).to eq(
         modified: [],
         added:    [],
         removed:  []
@@ -69,9 +71,9 @@ describe Listen::TCP do
 
       broadcaster.start
 
-      expect(listen {
+      expect(listen do
         touch 'file.rb'
-      }).to eq(
+      end).to eq(
         modified: ['file.rb'],
         added:    [],
         removed:  []
@@ -86,9 +88,9 @@ describe Listen::TCP do
     end
 
     it 'receives changes over TCP' do
-      expect(listen(1) {
+      expect(listen(1) do
         touch 'file.rb'
-      }).to eq(
+      end).to eq(
         modified: [],
         added:    ['file.rb'],
         removed:  []
@@ -98,9 +100,9 @@ describe Listen::TCP do
     it 'may be paused and unpaused' do
       recipient.pause
 
-      expect(listen(1) {
+      expect(listen(1) do
         touch 'file.rb'
-      }).to eq(
+      end).to eq(
         modified: [],
         added:    [],
         removed:  []
@@ -108,9 +110,9 @@ describe Listen::TCP do
 
       recipient.unpause
 
-      expect(listen(1) {
+      expect(listen(1) do
         touch 'file.rb'
-      }).to eq(
+      end).to eq(
         modified: ['file.rb'],
         added:    [],
         removed:  []
@@ -120,9 +122,9 @@ describe Listen::TCP do
     it 'may be stopped and restarted' do
       recipient.stop
 
-      expect(listen(1) {
+      expect(listen(1) do
         touch 'file.rb'
-      }).to eq(
+      end).to eq(
         modified: [],
         added:    [],
         removed:  []
@@ -130,9 +132,9 @@ describe Listen::TCP do
 
       recipient.start
 
-      expect(listen(1) {
+      expect(listen(1) do
         touch 'file.rb'
-      }).to eq(
+      end).to eq(
         modified: ['file.rb'],
         added:    [],
         removed:  []

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

@@ -5,30 +5,32 @@ describe Listen::Adapter::Base do
   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
-      expect(adapter.send(:_latency)).to eq Listen::Adapter::Base::DEFAULT_LATENCY
+  describe '#_latency' do
+    it 'returns default_latency with listener actor latency not present' do
+      latency = Listen::Adapter::Base::DEFAULT_LATENCY
+      expect(adapter.send(:_latency)).to eq latency
     end
 
-    it "returns latency from listener actor if present" do
+    it 'returns latency from listener actor if present' do
       listener.stub(:options) { { latency: 1234 } }
       expect(adapter.send(:_latency)).to eq 1234
     end
   end
 
-  describe "#_notify_change" do
+  describe '#_notify_change' do
     let(:change_pool) { double(Listen::Change) }
     let(:change_pool_async) { double('ChangePoolAsync') }
-    before {
+    before do
       change_pool.stub(:async) { change_pool_async }
       registry.stub(:[]).with(:change_pool) { change_pool }
-    }
+    end
 
-    context "listener listen" do
-      before { listener.stub(:listen?) { true} }
+    context 'listener listen' do
+      before { listener.stub(:listen?) { true } }
 
-      it "calls change on change_pool asynchronously" do
-        expect(change_pool_async).to receive(:change).with('path', type: 'Dir', recurcise: true)
+      it 'calls change on change_pool asynchronously' do
+        expect(change_pool_async).to receive(:change).
+          with('path', type: 'Dir', recurcise: true)
         adapter.send(:_notify_change, 'path', type: 'Dir', recurcise: true)
       end
     end
@@ -36,7 +38,7 @@ describe Listen::Adapter::Base do
     context "listener doesn't listen" do
       before { listener.stub(:listen?) { false } }
 
-      it "calls change on change_pool asynchronously" do
+      it 'calls change on change_pool asynchronously' do
         expect(change_pool_async).to_not receive(:change)
         adapter.send(:_notify_change, 'path', type: 'Dir', recurcise: true)
       end

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

@@ -6,8 +6,8 @@ describe Listen::Adapter::BSD 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
 
@@ -36,4 +36,7 @@ describe Listen::Adapter::BSD do
       expect(described_class).to_not be_usable
     end
   end
+
+  specify { expect(described_class).to be_local_fs }
+
 end

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

@@ -5,8 +5,8 @@ describe Listen::Adapter::Darwin 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
     end
@@ -36,4 +36,7 @@ describe Listen::Adapter::Darwin do
       expect(described_class).to_not be_usable
     end
   end
+
+  specify { expect(described_class).to be_local_fs }
+
 end

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

@@ -5,8 +5,8 @@ describe Listen::Adapter::Linux 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
     end
@@ -14,60 +14,72 @@ describe Listen::Adapter::Linux do
     describe '#initialize' do
       it 'requires rb-inotify gem' do
         described_class.new(listener)
-        expect(defined?(INotify)).to be_true
+        expect(defined?(INotify)).to be
       end
     end
 
     # workaround: Celluloid ignores SystemExit exception messages
-    describe "inotify limit message" do
+    describe 'inotify limit message' do
       let!(:adapter) { described_class.new(listener) }
-      let(:expected_message) { described_class.const_get('INOTIFY_LIMIT_MESSAGE') }
 
       before do
-        allow_any_instance_of(INotify::Notifier).to receive(:watch).and_raise(Errno::ENOSPC)
-        allow(listener).to receive(:directories) { [ 'foo/dir' ] }
+        allow_any_instance_of(INotify::Notifier).to receive(:watch).
+          and_raise(Errno::ENOSPC)
+
+        allow(listener).to receive(:directories) { ['foo/dir'] }
       end
 
-      it "should be show before calling abort" do
+      it 'should be show before calling abort' do
+        expected_message = described_class.const_get('INOTIFY_LIMIT_MESSAGE')
         expect(STDERR).to receive(:puts).with(expected_message)
 
         # Expect RuntimeError here, for the sake of unit testing (actual
         # handling depends on Celluloid supervisor setup, which is beyond the
         # scope of adapter tests)
-        expect{adapter.start}.to raise_error RuntimeError, expected_message
+        expect { adapter.start }.to raise_error RuntimeError, expected_message
       end
     end
 
     describe '_worker_callback' do
 
-      let(:expect_change) {
-        ->(change) {
-          allow_any_instance_of(Listen::Adapter::Base).to receive(:_notify_change).with(Pathname.new('path/foo.txt'), type: 'File', change: change, cookie: 123)
-        }
-      }
+      let(:expect_change) do
+        lambda do |change|
+          allow_any_instance_of(Listen::Adapter::Base).
+            to receive(:_notify_change).
+            with(
+              Pathname.new('path/foo.txt'),
+              type: 'File',
+              change: change,
+              cookie: 123)
+        end
+      end
 
-      let(:event_callback) {
-        ->(flags) {
+      let(:event_callback) do
+        lambda do |flags|
           callback = adapter.send(:_worker_callback)
-          callback.call double(:event, name: 'foo.txt', flags: flags, absolute_name: 'path/foo.txt', cookie: 123)
-        }
-      }
+          callback.call double(:event,
+                               name: 'foo.txt',
+                               flags: flags,
+                               absolute_name: 'path/foo.txt',
+                               cookie: 123)
+        end
+      end
 
       # use case: close_write is the only way to detect changes
       # on ecryptfs
       it 'recognizes close_write as modify' do
-        expect_change.(:modified)
-        event_callback.([:close_write])
+        expect_change.call(:modified)
+        event_callback.call([:close_write])
       end
 
       it 'recognizes moved_to as moved_to' do
-        expect_change.(:moved_to)
-        event_callback.([:moved_to])
+        expect_change.call(:moved_to)
+        event_callback.call([:moved_to])
       end
 
       it 'recognizes moved_from as moved_from' do
-        expect_change.(:moved_from)
-        event_callback.([:moved_from])
+        expect_change.call(:moved_from)
+        event_callback.call([:moved_from])
       end
     end
 
@@ -90,4 +102,7 @@ describe Listen::Adapter::Linux do
       expect(described_class).to_not be_usable
     end
   end
+
+  specify { expect(described_class).to be_local_fs }
+
 end

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

@@ -2,44 +2,59 @@ require 'spec_helper'
 
 describe Listen::Adapter::Polling do
   let(:registry) { double(Celluloid::Registry) }
-  let(:listener) { double(Listen::Listener, registry: registry, options: {}, listen?: true) }
+  let(:listener) do
+    double(Listen::Listener,
+           registry: registry,
+           options: {},
+           listen?: true)
+  end
+
   let(:adapter) { described_class.new(listener) }
   let(:change_pool) { double(Listen::Change, terminate: true) }
   let(:change_pool_async) { double('ChangePoolAsync') }
-  before {
+
+  before do
     change_pool.stub(:async) { change_pool_async }
     registry.stub(:[]).with(:change_pool) { change_pool }
-  }
+  end
 
-  describe ".usable?" do
-    it "returns always true" do
+  describe '.usable?' do
+    it 'returns always true' do
       expect(described_class).to be_usable
     end
   end
 
-  describe "#start" do
+  describe '#start' do
     let(:directories) { ['directory_path'] }
-    before {
+    before do
       listener.stub(:options) { {} }
       listener.stub(:directories) { directories }
-    }
+    end
+
+    it 'notifies change on every listener directories path' do
+      expect(change_pool_async).to receive(:change).with(
+        'directory_path',
+        type: 'Dir',
+        recursive: true)
 
-    it "notifies change on every listener directories path" do
-      expect(change_pool_async).to receive(:change).with('directory_path', type: 'Dir', recursive: true)
       t = Thread.new { adapter.start }
       sleep 0.25
       t.kill
     end
   end
 
-  describe "#_latency" do
-    it "returns default_latency with listener actor latency not present" do
-      expect(adapter.send(:_latency)).to eq Listen::Adapter::Polling::DEFAULT_POLLING_LATENCY
+  describe '#_latency' do
+    it 'returns default_latency with listener actor latency not present' do
+      expected_latency =  Listen::Adapter::Polling::DEFAULT_POLLING_LATENCY
+      expect(adapter.send(:_latency)).to eq expected_latency
     end
 
-    it "returns latency from listener actor if present" do
+    it 'returns latency from listener actor if present' do
       listener.stub(:options) { { latency: 1234 } }
       expect(adapter.send(:_latency)).to eq 1234
     end
   end
+
+  specify { expect(described_class).to be_local_fs }
+
 end

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

@@ -7,8 +7,16 @@ describe Listen::Adapter::TCP do
 
   subject { described_class.new(listener) }
   let(:registry) { double(Celluloid::Registry) }
-  let(:listener) { double(Listen::TCP::Listener, registry: registry, options: {}, host: host, port: port) }
-  let(:socket)   { double(described_class::TCPSocket, close: true, recv: nil) }
+
+  let(:listener) do
+    double(Listen::TCP::Listener,
+           registry: registry,
+           options: {},
+           host: host,
+           port: port)
+  end
+
+  let(:socket) { double(described_class::TCPSocket, close: true, recv: nil) }
 
   before do
     described_class::TCPSocket.stub(:new).and_return socket
@@ -26,7 +34,10 @@ describe Listen::Adapter::TCP do
 
   describe '#start' do
     it 'initializes and exposes a socket with listener host and port' do
-      expect(described_class::TCPSocket).to receive(:new).with listener.host, listener.port
+      expect(described_class::TCPSocket).
+        to receive(:new).
+        with listener.host, listener.port
+
       subject.start
       expect(subject.socket).to be socket
     end
@@ -99,12 +110,19 @@ describe Listen::Adapter::TCP do
         'removed'  => []
       )
 
-      expect(subject.wrapped_object).to receive(:_notify_change).with '/foo', change: :modified
-      expect(subject.wrapped_object).to receive(:_notify_change).with '/bar', change: :modified
-      expect(subject.wrapped_object).to receive(:_notify_change).with '/baz', change: :added
+      expect(subject.wrapped_object).
+        to receive(:_notify_change).with '/foo', change: :modified
+
+      expect(subject.wrapped_object).
+        to receive(:_notify_change).with '/bar', change: :modified
+
+      expect(subject.wrapped_object).
+        to receive(:_notify_change).with '/baz', change: :added
 
       subject.handle_message message
     end
   end
 
+  specify { expect(described_class).to_not be_local_fs }
+
 end