listen 2.7.4 → 2.7.5

data/spec/lib/listen/file_spec.rb

@@ -3,83 +3,111 @@ 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(:record) do
+    double(Listen::Record, async: double(set_path: true, unset_path: true))
+  end
+
   let(:path) { Pathname.new(Dir.pwd) }
-  around { |example| fixtures { |path| example.run } }
+  around { |example| fixtures { example.run } }
   before { registry.stub(:[]).with(:record) { record } }
 
-  describe "#change" do
+  describe '#change' do
     let(:file_path) { path.join('file.rb') }
     let(:file) { Listen::File.new(listener, file_path) }
-    let(:expected_data) { { type: 'File', mtime: kind_of(Float), mode: kind_of(Integer) } }
 
-    context "path present in record" do
+    let(:expected_data) do
+      { type: 'File', mtime: kind_of(Float), mode: kind_of(Integer) }
+    end
+
+    context 'path present in record' do
       let(:record_mtime) { nil }
       let(:record_md5) { nil }
       let(:record_mode) { nil }
-      let(:record_data) { { type: 'File', mtime: record_mtime, md5: record_md5, mode: record_mode } }
-      before { record.stub_chain(:future, :file_data) { double(value: record_data) } }
 
-      context "non-existing path" do
-        it "returns added" do
+      let(:record_data) do
+        { type: 'File',
+          mtime: record_mtime,
+          md5: record_md5,
+          mode: record_mode }
+      end
+
+      before do
+        record.stub_chain(:future, :file_data) { double(value: record_data) }
+      end
+
+      context 'non-existing path' do
+        it 'returns added' do
           expect(file.change).to eq :removed
         end
-        it "sets path in record" do
+        it 'sets path in record' do
           expect(record.async).to receive(:unset_path).with(file_path)
           file.change
         end
       end
 
-      context "existing path" do
-        around { |example| touch file_path; example.run }
+      context 'existing path' do
+        around do |example|
+          touch file_path
+          example.run
+        end
 
-        context "old record path mtime" do
+        context 'old record path mtime' do
           let(:record_mtime) { (Time.now - 1).to_f }
 
-          it "returns modified" do
+          it 'returns modified' do
             expect(file.change).to eq :modified
           end
 
-          it "sets path in record with expected data" do
-            expect(record.async).to receive(:set_path).with(file_path, expected_data)
+          it 'sets path in record with expected data' do
+            expect(record.async).to receive(:set_path).
+              with(file_path, expected_data)
+
             file.change
           end
         end
 
-        context "same record path mtime" do
+        context 'same record path mtime' do
           let(:record_mtime) { ::File.lstat(file_path).mtime.to_f }
           let(:record_mode)  { ::File.lstat(file_path).mode }
 
-          context "same record path mode" do
-            it "returns nil" do
+          context 'same record path mode' do
+            it 'returns nil' do
               expect(file.change).to be_nil
             end
           end
 
-          context "diferent record path mode" do
+          context 'diferent record path mode' do
             let(:record_mode) { 'foo' }
 
-            it "returns modified" do
+            it 'returns modified' do
               expect(file.change).to eq :modified
             end
           end
 
-          context "same record path md5" do
-            it "returns nil" do
+          context 'same record path md5' do
+            it 'returns nil' do
               expect(file.change).to be_nil
             end
           end
 
           if darwin?
-            context "different record path md5" do
+            context 'different record path md5' do
               let(:record_md5) { 'foo' }
-              let(:expected_data) { { type: 'File', mtime: kind_of(Float), mode: kind_of(Integer), md5: kind_of(String) } }
+              let(:expected_data) do
+                { type: 'File',
+                  mtime: kind_of(Float),
+                  mode: kind_of(Integer),
+                  md5: kind_of(String) }
+              end
 
-              it "returns modified" do
+              it 'returns modified' do
                 expect(file.change).to eq :modified
               end
-              it "sets path in record with expected data" do
-                expect(record.async).to receive(:set_path).with(file_path, expected_data)
+              it 'sets path in record with expected data' do
+                expect(record.async).to receive(:set_path).
+                  with(file_path, expected_data)
+
                 file.change
               end
             end
@@ -89,18 +117,23 @@ describe Listen::File do
       end
     end
 
-    context "path not present in record" do
+    context 'path not present in record' do
       before { record.stub_chain(:future, :file_data) { double(value: {}) } }
 
-      context "existing path" do
-        around { |example| touch file_path; example.run }
+      context 'existing path' do
+        around do |example|
+          touch file_path
+          example.run
+        end
 
-        it "returns added" do
+        it 'returns added' do
           expect(file.change).to eq :added
         end
 
-        it "sets path in record with expected data" do
-          expect(record.async).to receive(:set_path).with(file_path, expected_data)
+        it 'sets path in record with expected data' do
+          expect(record.async).to receive(:set_path).
+            with(file_path, expected_data)
+
           file.change
         end
       end

data/spec/lib/listen/listener_spec.rb

@@ -4,13 +4,20 @@ 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(:supervisor) do
+    double(Celluloid::SupervisionGroup,
+           add: true,
+           pool: true)
+  end
+
   let(:record) { double(Listen::Record, terminate: true, build: true) }
   let(:silencer) { double(Listen::Silencer, terminate: true) }
-  let(:adapter) { double(Listen::Adapter::Base) }
+  let(:adapter_class) { double(:adapter_class, local_fs?: true) }
+  let(:adapter) { double(Listen::Adapter::Base, class: adapter_class) }
   let(:change_pool) { double(Listen::Change, terminate: true) }
   let(:change_pool_async) { double('ChangePoolAsync') }
-  before {
+  before do
     Celluloid::Registry.stub(:new) { registry }
     Celluloid::SupervisionGroup.stub(:run!) { supervisor }
     registry.stub(:[]).with(:silencer) { silencer }
@@ -18,98 +25,110 @@ describe Listen::Listener do
     registry.stub(:[]).with(:record) { record }
     registry.stub(:[]).with(:change_pool) { change_pool }
 
-  }
+  end
 
-  describe "initialize" do
-    it "sets paused to false" do
+  describe 'initialize' do
+    it 'sets paused to false' do
       expect(listener).not_to be_paused
     end
 
-    it "sets block" do
-      block = Proc.new { |modified, added, removed| }
+    it 'sets block' do
+      block = proc {}
       listener = Listen::Listener.new('lib', &block)
       expect(listener.block).not_to be_nil
     end
 
-    it "sets directories with realpath" do
+    it 'sets directories with realpath' do
       listener = Listen::Listener.new('lib', 'spec')
-      expect(listener.directories).to eq [Pathname.new("#{Dir.pwd}/lib"), Pathname.new("#{Dir.pwd}/spec")]
+      expected = %w(lib spec).map { |dir| Pathname.pwd.join(dir) }
+      expect(listener.directories).to eq expected
     end
   end
 
-  describe "options" do
-    it "sets default options" do
-      expect(listener.options).to eq({
-        debug: false,
-        latency: nil,
-        wait_for_delay: 0.1,
-        force_polling: false,
-        polling_fallback_message: nil })
-    end
-
-    it "sets new options on initialize" do
-      listener = Listen::Listener.new('lib', latency: 1.234, wait_for_delay: 0.85)
-      expect(listener.options).to eq({
-        debug: false,
-        latency: 1.234,
-        wait_for_delay: 0.85,
-        force_polling: false,
-        polling_fallback_message: nil })
+  describe 'options' do
+    it 'sets default options' do
+      expect(listener.options).to eq(
+                                       debug: false,
+                                       latency: nil,
+                                       wait_for_delay: 0.1,
+                                       force_polling: false,
+                                       polling_fallback_message: nil)
+    end
+
+    it 'sets new options on initialize' do
+      listener = Listen::Listener.new('lib',
+                                      latency: 1.234,
+                                      wait_for_delay: 0.85)
+
+      expect(listener.options).to eq(
+                                       debug: false,
+                                       latency: 1.234,
+                                       wait_for_delay: 0.85,
+                                       force_polling: false,
+                                       polling_fallback_message: nil)
     end
   end
 
-  describe "#start" do
-    before {
+  describe '#start' do
+    before do
       adapter.stub_chain(:async, :start)
       silencer.stub(:silenced?) { false }
-    }
+    end
+
+    it 'registers silencer' do
+      expect(supervisor).to receive(:add).
+        with(Listen::Silencer, as: :silencer, args: listener)
 
-    it "registers silencer" do
-      expect(supervisor).to receive(:add).with(Listen::Silencer, as: :silencer, args: listener)
       listener.start
     end
 
-    it "supervises change_pool" do
-      expect(supervisor).to receive(:pool).with(Listen::Change, as: :change_pool, args: listener)
+    it 'supervises change_pool' do
+      expect(supervisor).to receive(:pool).
+        with(Listen::Change, as: :change_pool, args: listener)
+
       listener.start
     end
 
-    it "supervises adaper" do
+    it 'supervises adaper' do
       Listen::Adapter.stub(:select) { Listen::Adapter::Polling }
-      expect(supervisor).to receive(:add).with(Listen::Adapter::Polling, as: :adapter, args: listener)
+      expect(supervisor).to receive(:add).
+        with(Listen::Adapter::Polling, as: :adapter, args: listener)
+
       listener.start
     end
 
-    it "supervises record" do
-      expect(supervisor).to receive(:add).with(Listen::Record, as: :record, args: listener)
+    it 'supervises record' do
+      expect(supervisor).to receive(:add).
+        with(Listen::Record, as: :record, args: listener)
+
       listener.start
     end
 
-    it "builds record" do
+    it 'builds record' do
       expect(record).to receive(:build)
       listener.start
     end
 
-    it "sets paused to false" do
+    it 'sets paused to false' do
       listener.start
       expect(listener.paused).to be_false
     end
 
-    it "starts adapter asynchronously" do
+    it 'starts adapter asynchronously' do
       async_stub = double
       expect(adapter).to receive(:async) { async_stub }
       expect(async_stub).to receive(:start)
       listener.start
     end
 
-    it "starts adapter asynchronously" do
+    it 'starts adapter asynchronously' do
       async_stub = double
       expect(adapter).to receive(:async) { async_stub }
       expect(async_stub).to receive(:start)
       listener.start
     end
 
-    it "calls block on changes" do
+    it 'calls block on changes' do
       foo = double(Pathname, to_s: 'foo', exist?: true, directory?: false)
       listener.changes = [{ modified: foo }]
       block_stub = double('block')
@@ -120,96 +139,96 @@ describe Listen::Listener do
     end
   end
 
-  describe "#stop" do
-    it "terminates supervisor" do
+  describe '#stop' do
+    it 'terminates supervisor' do
       listener.supervisor = supervisor
       expect(supervisor).to receive(:terminate)
       listener.stop
     end
   end
 
-  describe "#pause" do
-    it "sets paused to true" do
+  describe '#pause' do
+    it 'sets paused to true' do
       listener.pause
       expect(listener.paused).to be_true
     end
   end
 
-  describe "#unpause" do
-    it "builds record" do
+  describe '#unpause' do
+    it 'builds record' do
       expect(record).to receive(:build)
       listener.unpause
     end
 
-    it "sets paused to false" do
+    it 'sets paused to false' do
       record.stub(:build)
       listener.unpause
       expect(listener.paused).to be_false
     end
   end
 
-  describe "#paused?" do
-    it "returns true when paused" do
+  describe '#paused?' do
+    it 'returns true when paused' do
       listener.paused = true
       expect(listener).to be_paused
     end
-    it "returns false when not paused (nil)" do
+    it 'returns false when not paused (nil)' do
       listener.paused = nil
       expect(listener).not_to be_paused
     end
-    it "returns false when not paused (false)" do
+    it 'returns false when not paused (false)' do
       listener.paused = false
       expect(listener).not_to be_paused
     end
   end
 
-  describe "#listen?" do
-    it "returns true when not paused (false)" do
+  describe '#listen?' do
+    it 'returns true when not paused (false)' do
       listener.paused = false
       listener.stopping = false
       expect(listener.listen?).to be_true
     end
-    it "returns false when not paused (nil)" do
+    it 'returns false when not paused (nil)' do
       listener.paused = nil
       listener.stopping = false
       expect(listener.listen?).to be_false
     end
-    it "returns false when paused" do
+    it 'returns false when paused' do
       listener.paused = true
       listener.stopping = false
       expect(listener.listen?).to be_false
     end
-    it "returns false when stopped" do
+    it 'returns false when stopped' do
       listener.paused = false
       listener.stopping = true
       expect(listener.listen?).to be_false
     end
   end
 
-  describe "#ignore" do
+  describe '#ignore' do
     let(:new_silencer) { double(Listen::Silencer) }
     before { Celluloid::Actor.stub(:[]=) }
 
-    it "resets silencer actor" do
+    it 'resets silencer actor' do
       expect(Listen::Silencer).to receive(:new).with(listener) { new_silencer }
       expect(registry).to receive(:[]=).with(:silencer, new_silencer)
       listener.ignore(/foo/)
     end
 
-    context "with existing ignore options" do
+    context 'with existing ignore options' do
       let(:options) { { ignore: /bar/ } }
 
-      it "adds up to existing ignore options" do
+      it 'adds up to existing ignore options' do
         expect(Listen::Silencer).to receive(:new).with(listener)
         listener.ignore(/foo/)
         expect(listener.options).to include(ignore: [/bar/, /foo/])
       end
     end
 
-    context "with existing ignore options (array)" do
+    context 'with existing ignore options (array)' do
       let(:options) { { ignore: [/bar/] } }
 
-      it "adds up to existing ignore options" do
+      it 'adds up to existing ignore options' do
         expect(Listen::Silencer).to receive(:new).with(listener)
         listener.ignore(/foo/)
         expect(listener.options).to include(ignore: [[/bar/], /foo/])
@@ -217,31 +236,31 @@ describe Listen::Listener do
     end
   end
 
-  describe "#ignore!" do
+  describe '#ignore!' do
     let(:new_silencer) { double(Listen::Silencer) }
     before { Celluloid::Actor.stub(:[]=) }
 
-    it "resets silencer actor" do
+    it 'resets silencer actor' do
       expect(Listen::Silencer).to receive(:new).with(listener) { new_silencer }
       expect(registry).to receive(:[]=).with(:silencer, new_silencer)
       listener.ignore!(/foo/)
       expect(listener.options).to include(ignore!: /foo/)
     end
 
-    context "with existing ignore! options" do
+    context 'with existing ignore! options' do
       let(:options) { { ignore!: /bar/ } }
 
-      it "overwrites existing ignore options" do
+      it 'overwrites existing ignore options' do
         expect(Listen::Silencer).to receive(:new).with(listener)
         listener.ignore!([/foo/])
         expect(listener.options).to include(ignore!: [/foo/])
       end
     end
 
-    context "with existing ignore options" do
+    context 'with existing ignore options' do
       let(:options) { { ignore: /bar/ } }
 
-      it "deletes ignore options" do
+      it 'deletes ignore options' do
         expect(Listen::Silencer).to receive(:new).with(listener)
         listener.ignore!([/foo/])
         expect(listener.options).to_not include(ignore: /bar/)
@@ -249,20 +268,20 @@ describe Listen::Listener do
     end
   end
 
-  describe "#only" do
+  describe '#only' do
     let(:new_silencer) { double(Listen::Silencer) }
     before { Celluloid::Actor.stub(:[]=) }
 
-    it "resets silencer actor" do
+    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
+    context 'with existing only options' do
       let(:options) { { only: /bar/ } }
 
-      it "overwrites existing ignore options" do
+      it 'overwrites existing ignore options' do
         expect(Listen::Silencer).to receive(:new).with(listener)
         listener.only([/foo/])
         expect(listener.options).to include(only: [/foo/])
@@ -275,28 +294,31 @@ describe Listen::Listener do
       silencer.stub(:silenced?) { false }
 
       fake_time = 0
-      listener.stub(:sleep) { |sec| fake_time += sec; listener.stopping = true if fake_time > 1 }
+      listener.stub(:sleep) do |sec|
+        fake_time += sec
+        listener.stopping = true if fake_time > 1
+      end
 
-      listener.block = proc { |modified, added, removed|
+      listener.block = proc do |modified, added, _|
         expect(modified).to eql(['foo.txt'])
         expect(added).to eql(['bar.txt'])
-      }
+      end
 
       foo = double(Pathname, to_s: 'foo.txt', exist?: true, directory?: false)
       bar = double(Pathname, to_s: 'bar.txt', exist?: true, directory?: false)
 
       i = 0
       listener.stub(:_pop_changes) do
-        i+=1
+        i += 1
         case i
-          when 1
-            []
-          when 2
-            [{modified: foo}]
-          when 3
-            [{added: bar}]
-          else
-            []
+        when 1
+          []
+        when 2
+          [{ modified: foo }]
+        when 3
+          [{ added: bar }]
+        else
+          []
         end
       end
 
@@ -343,14 +365,12 @@ describe Listen::Listener do
       expect(smooshed).to eq(modified: ['foo'], added: [], removed: [])
     end
 
-    context "with cookie" do
+    context 'with cookie' do
 
       it 'recognizes single moved_to as add' do
         foo = double(Pathname, to_s: 'foo', exist?: true, directory?: false)
-        changes = [
-          { moved_to: foo , cookie: 4321 },
-        ]
-        expect(silencer).to receive(:silenced?).with(foo, 'File').and_return(false)
+        changes = [{ moved_to: foo , cookie: 4321 }]
+        expect(silencer).to receive(:silenced?).with(foo, 'File') { false }
         smooshed = listener.send :_smoosh_changes, changes
         expect(smooshed).to eq(modified: [], added: ['foo'], removed: [])
       end
@@ -360,35 +380,45 @@ describe Listen::Listener do
         bar = double(:bar, to_s: 'bar', exist?: true, directory?: false)
         changes = [
           { moved_from: foo , cookie: 4321 },
-          { moved_to: bar, cookie: 4321 },
+          { moved_to: bar, cookie: 4321 }
         ]
-        expect(silencer).to receive(:silenced?).twice.with(foo, 'File').and_return(false)
-        expect(silencer).to receive(:silenced?).with(bar, 'File').and_return(false)
+
+        expect(silencer).to receive(:silenced?).
+          twice.with(foo, 'File') { false }
+
+        expect(silencer).to receive(:silenced?).with(bar, 'File') { false }
         smooshed = listener.send :_smoosh_changes, changes
         expect(smooshed).to eq(modified: [], added: ['bar'], removed: [])
       end
 
       # Scenario with workaround for editors using rename()
       it 'recognizes related moved_to with ignored moved_from as modify' do
-        ignored = double(Pathname, to_s: 'foo', exist?: true, directory?: false)
+
+        ignored = double(Pathname,
+                         to_s: 'foo',
+                         exist?: true,
+                         directory?: false)
+
         foo = double(Pathname, to_s: 'foo', exist?: true, directory?: false)
         changes = [
           { moved_from: ignored, cookie: 4321 },
-          { moved_to: foo , cookie: 4321 },
+          { moved_to: foo , cookie: 4321 }
         ]
-        expect(silencer).to receive(:silenced?).with(ignored, 'File').and_return(true)
-        expect(silencer).to receive(:silenced?).with(foo, 'File').and_return(false)
+        expect(silencer).to receive(:silenced?).with(ignored, 'File') { true }
+        expect(silencer).to receive(:silenced?).with(foo, 'File') { false }
         smooshed = listener.send :_smoosh_changes, changes
         expect(smooshed).to eq(modified: ['foo'], added: [], removed: [])
       end
     end
 
-    context "with no cookie" do
+    context 'with no cookie' do
       it 'recognizes properly ignores files' do
-        ignored = double(Pathname, to_s: 'foo', exist?: true, directory?: false)
-        changes = [
-          { modified: ignored },
-        ]
+        ignored = double(Pathname,
+                         to_s: 'foo',
+                         exist?: true,
+                         directory?: false)
+
+        changes = [{ modified: ignored }]
         expect(silencer).to receive(:silenced?).with(ignored, 'File') { true }
         smooshed = listener.send :_smoosh_changes, changes
         expect(smooshed).to eq(modified: [], added: [], removed: [])