listen 2.7.4 → 2.7.5

data/spec/lib/listen/record_spec.rb

@@ -7,86 +7,89 @@ describe Listen::Record do
   let(:path) { '/dir/path/file.rb' }
   let(:data) { { type: 'File' } }
 
-  describe "#set_path" do
-    it "sets path by spliting direname and basename" do
+  describe '#set_path' do
+    it 'sets path by spliting direname and basename' do
       record.set_path(path, data)
-      expect(record.paths).to eq({ '/dir/path' => { 'file.rb' => data } })
+      expect(record.paths).to eq('/dir/path' => { 'file.rb' => data })
     end
 
-    it "sets path and keeps old data not overwritten" do
+    it 'sets path and keeps old data not overwritten' do
       record.set_path(path, data.merge(foo: 1, bar: 2))
       record.set_path(path, data.merge(foo: 3))
-      expect(record.paths).to eq({ '/dir/path' => { 'file.rb' => data.merge(foo: 3, bar: 2) } })
+      expected = { '/dir/path' => { 'file.rb' => data.merge(foo: 3, bar: 2) } }
+      expect(record.paths).to eq(expected)
     end
   end
 
-  describe "#unset_path" do
-    context "path is present" do
+  describe '#unset_path' do
+    context 'path is present' do
       before { record.set_path(path, data) }
 
-      it "unsets path" do
+      it 'unsets path' do
         record.unset_path(path)
-        expect(record.paths).to eq({ '/dir/path' => {} })
+        expect(record.paths).to eq('/dir/path' => {})
       end
     end
 
-    context "path not present" do
-      it "unsets path" do
+    context 'path not present' do
+      it 'unsets path' do
         record.unset_path(path)
-        expect(record.paths).to eq({ '/dir/path' => {} })
+        expect(record.paths).to eq('/dir/path' => {})
       end
     end
   end
 
-  describe "#file_data" do
-    context "path is present" do
+  describe '#file_data' do
+    context 'path is present' do
       before { record.set_path(path, data) }
 
-      it "returns file data" do
+      it 'returns file data' do
         expect(record.file_data(path)).to eq data
       end
     end
 
-    context "path not present" do
-      it "return empty hash" do
+    context 'path not present' do
+      it 'return empty hash' do
         expect(record.file_data(path)).to be_empty
       end
     end
   end
 
-  describe "#dir_entries" do
-    context "path is present" do
+  describe '#dir_entries' do
+    context 'path is present' do
       before { record.set_path(path, data) }
 
-      it "returns file path" do
-        expect(record.dir_entries('/dir/path')).to eq({ 'file.rb' => data })
+      it 'returns file path' do
+        expect(record.dir_entries('/dir/path')).to eq('file.rb' => data)
       end
     end
 
-    context "path not present" do
-      it "unsets path" do
+    context 'path not present' do
+      it 'unsets path' do
         expect(record.dir_entries('/dir/path')).to eq({})
       end
     end
   end
 
-  describe "#build" do
+  describe '#build' do
     let(:directories) { ['dir_path'] }
     let(:change_pool) { double(Listen::Change, terminate: true) }
-    before {
+    before do
       change_pool.stub(:change)
       registry.stub(:[]).with(:change_pool) { change_pool }
       listener.stub(:directories) { directories }
-    }
+    end
 
-    it "re-inits paths" do
+    it 're-inits paths' do
       record.set_path(path, data)
       record.build
       expect(record.file_data(path)).to be_empty
     end
 
-    it "calls change asynchronously on all directories to build record"  do
-      expect(change_pool).to receive(:change).with('dir_path', type: 'Dir', recursive: true, silence: true)
+    it 'calls change asynchronously on all directories to build record'  do
+      expect(change_pool).to receive(:change).
+        with('dir_path', type: 'Dir', recursive: true, silence: true)
+
       record.build
     end
   end

data/spec/lib/listen/silencer_spec.rb

@@ -2,17 +2,23 @@ require 'spec_helper'
 
 describe Listen::Silencer do
   let(:options) { {} }
-  let(:listener) { double(Listen::Listener,
-    directories: [Pathname.new(Dir.pwd), Pathname.new("/Users/Shared/")],
-    options: options
-  ) }
+
+  let(:listener) do
+    double(Listen::Listener,
+           directories: [Pathname.pwd, Pathname.new('/Users/Shared/')],
+           options: options
+          )
+  end
+
   let(:silencer) { Listen::Silencer.new(listener) }
 
-  describe "#silenced?" do
-    let(:pwd) { Pathname.new(Dir.pwd) }
+  describe '#silenced?' do
+    let(:pwd) { Pathname.pwd }
 
-    context "default ignore" do
-      Listen::Silencer::DEFAULT_IGNORED_DIRECTORIES.each do |dir|
+    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|
         describe do
           let(:path) { pwd.join(dir) }
 
@@ -20,7 +26,7 @@ describe Listen::Silencer do
             expect(silencer.silenced?(path)).to be_true
           end
 
-          context "with a directory beginning with the same name" do
+          context 'with a directory beginning with the same name' do
             let(:path) { pwd.join("#{dir}foo") }
 
             it "doesn't silences default ignored directory: #{dir}foo" do
@@ -28,7 +34,7 @@ describe Listen::Silencer do
             end
           end
 
-          context "with a directory ending with the same name" do
+          context 'with a directory ending with the same name' do
             let(:path) { pwd.join("foo#{dir}") }
 
             it "doesn't silences default ignored directory: foo#{dir}" do
@@ -38,10 +44,12 @@ describe Listen::Silencer do
         end
       end
 
-      %w(.DS_Store foo.tmp foo~ foo.rbo54321.new).each do |path|
+      gedit_files = %w(.goutputstream-S3FBGX)
+      kate_files = %w(foo.rbo54321.new foo.rbB22583.new foo.rb.kate-swp)
+      (%w(.DS_Store foo.tmp foo~) + kate_files + gedit_files).each do |path|
         describe do
           it "by default silences files like: #{path}" do
-            expect(silencer.silenced?(pwd.join(path))).to be_true
+            expect(silencer.silenced?(pwd + path)).to be_true
           end
         end
       end
@@ -49,7 +57,7 @@ describe Listen::Silencer do
       %w(foo.tmpl file.new file54321.new).each do |path|
         describe do
           it "by default does not silence files like: #{path}" do
-            expect(silencer.silenced?(pwd.join(path))).to be_false
+            expect(silencer.silenced?(pwd + path)).to be_false
           end
         end
       end
@@ -58,102 +66,116 @@ describe Listen::Silencer do
     context 'with ignore options (regexp)' do
       let(:options) { { ignore: /\.pid$/ } }
 
-      it "silences path matching custom ignore regex" do
-        expect(silencer.silenced?(pwd.join('foo.pid'))).to be_true
+      it 'silences path matching custom ignore regex' do
+        expect(silencer.silenced?(pwd + 'foo.pid')).to be_true
       end
     end
 
     context 'with ignore options (array)' do
       let(:options) { { ignore: [%r{^foo/bar}, /\.pid$/] } }
 
-      it "silences paths matching custom ignore regexes" do
-        expect(silencer.silenced?(pwd.join('foo/bar/baz'))).to be_true
-        expect(silencer.silenced?(pwd.join('foo.pid'))).to be_true
+      it 'silences paths matching custom ignore regexes' do
+        expect(silencer.silenced?(pwd + 'foo/bar/baz')).to be_true
+        expect(silencer.silenced?(pwd + 'foo.pid')).to be_true
       end
     end
 
-    context "with ignore! options" do
+    context 'with ignore! options' do
       let(:options) { { ignore!: /\.pid$/ } }
 
-      it "silences custom ignored directory" do
-        expect(silencer.silenced?(pwd.join('foo.pid'))).to be_true
+      it 'silences custom ignored directory' do
+        expect(silencer.silenced?(pwd + 'foo.pid')).to be_true
       end
 
       it "doesn't silence default ignored directory" do
-        path = pwd.join(Listen::Silencer::DEFAULT_IGNORED_DIRECTORIES.first)
-        expect(silencer.silenced?(path)).to be_false
+        expect(silencer.silenced?(pwd + '.git')).to be_false
       end
     end
 
-    context "with only options (regexp)" do
+    context 'with only options (regexp)' do
       let(:options) { { only: %r{foo} } }
 
-      it "do not take only regex in account if type is Unknown" do
-        path = pwd.join('baz')
-        expect(silencer.silenced?(path)).to be_false
+      it 'do not take only regex in account if type is Unknown' do
+        expect(silencer.silenced?(pwd + 'baz')).to be_false
       end
 
-      it "do not silence path matches only regex if type is File" do
-        path = pwd.join('foo')
-        expect(silencer.silenced?(path, 'File')).to be_false
+      it 'do not silence path matches only regex if type is File' do
+        expect(silencer.silenced?(pwd + 'foo', 'File')).to be_false
       end
 
-      it "silences other directory" do
-        path = pwd.join('bar')
-        expect(silencer.silenced?(path, 'File')).to be_true
+      it 'silences other directory' do
+        expect(silencer.silenced?(pwd + 'bar', 'File')).to be_true
       end
     end
 
-    context "with only options (array)" do
+    context 'with only options (array)' do
       let(:options) { { only: [%r{^foo/}, %r{\.txt$}] } }
 
-      it "do not take only regex in account if type is Unknown" do
-        expect(silencer.silenced?(pwd.join('baz'))).to be_false
+      it 'do not take only regex in account if type is Unknown' do
+        expect(silencer.silenced?(pwd + 'baz')).to be_false
       end
 
       it "doesn't silence good directory" do
-        expect(silencer.silenced?(pwd.join('foo/bar.rb'), 'File')).to be_false
+        expect(silencer.silenced?(pwd + 'foo/bar.rb', 'File')).to be_false
       end
 
       it "doesn't silence good file" do
-        expect(silencer.silenced?(pwd.join('bar.txt'), 'File')).to be_false
+        expect(silencer.silenced?(pwd + 'bar.txt', 'File')).to be_false
       end
 
-      it "silences other directory" do
-        expect(silencer.silenced?(pwd.join('bar/baz.rb'), 'File')).to be_true
+      it 'silences other directory' do
+        expect(silencer.silenced?(pwd + 'bar/baz.rb', 'File')).to be_true
       end
 
-      it "silences other file" do
-        expect(silencer.silenced?(pwd.join('bar.rb'), 'File')).to be_true
+      it 'silences other file' do
+        expect(silencer.silenced?(pwd + 'bar.rb', 'File')).to be_true
       end
     end
 
     context 'with ignore and only options' do
       let(:options) { { only: /\.pid$/, ignore: %r{^bar} } }
 
-      it "do not take only regex in account if type is Unknown" do
-        expect(silencer.silenced?(pwd.join('baz'))).to be_false
-      end
+      context 'with Unknown type' do
+        context 'when not matching :only' do
+          context 'when not matching :ignore' do
+            it 'does not silence' do
+              expect(silencer.silenced?(pwd + 'baz')).to be_false
+            end
+          end
 
-      it "do not take only regex in account if type is Unknown but silences if ignore regex matches path" do
-        expect(silencer.silenced?(pwd.join('bar'))).to be_true
+          context 'when matching :ignore' do
+            it 'silences' do
+              expect(silencer.silenced?(pwd + 'bar')).to be_true
+            end
+          end
+        end
       end
 
-      it 'silences path not matching custom only regex' do
-        expect(silencer.silenced?(pwd.join('foo.rb'), 'File')).to be_true
-      end
+      context 'with File type' do
+        context 'when not matching :only' do
+          it 'silences' do
+            expect(silencer.silenced?(pwd + 'foo.rb', 'File')).to be_true
+          end
+        end
 
-      it 'silences path matching custom ignore regex' do
-        expect(silencer.silenced?(pwd.join('bar.pid', 'File'))).to be_true
-      end
+        context 'when matching :only' do
+          context 'when matching :ignore' do
+            it 'silences' do
+              expect(silencer.silenced?(pwd + 'bar.pid', 'File')).to be_true
+            end
+          end
 
-      it 'do not silence path matching custom only regex and not matching custom ignore regex' do
-        expect(silencer.silenced?(pwd.join('foo.pid', 'File'))).to be_false
+          context 'when not matching :ignore' do
+            it 'does not silence' do
+              expect(silencer.silenced?(pwd + 'foo.pid', 'File')).to be_false
+            end
+          end
+        end
       end
     end
 
     it "doesn't silence normal path" do
-      path = pwd.join('some_dir', 'some_file.rb')
+      path = pwd + 'some_dir' + 'some_file.rb'
       expect(silencer.silenced?(path)).to be_false
     end
   end

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

@@ -6,12 +6,13 @@ describe Listen::TCP::Broadcaster do
   let(:port) { 4000 }
 
   subject { described_class.new(host, port) }
-  let(:server)  { double(described_class::TCPServer, close: true, accept: nil) }
+  let(:server) { double(described_class::TCPServer, close: true, accept: nil) }
   let(:socket)  { double(described_class::TCPSocket, write: true) }
   let(:payload) { Listen::TCP::Message.new.payload }
 
   before do
-    expect(described_class::TCPServer).to receive(:new).with(host, port).and_return server
+    expect(described_class::TCPServer).to receive(:new).
+      with(host, port).and_return server
   end
 
   after do

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

@@ -8,14 +8,18 @@ describe Listen::TCP::Listener do
   subject { described_class.new("#{host}:#{port}", :recipient, 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(:broadcaster) { double(Listen::TCP::Broadcaster) }
   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 }
@@ -23,7 +27,7 @@ describe Listen::TCP::Listener do
     registry.stub(:[]).with(:record) { record }
     registry.stub(:[]).with(:change_pool) { change_pool }
     registry.stub(:[]).with(:broadcaster) { broadcaster }
-  }
+  end
 
   describe '#initialize' do
     its(:mode) { should be :recipient }
@@ -64,7 +68,8 @@ describe Listen::TCP::Listener do
       end
 
       it 'registers broadcaster' do
-        expect(supervisor).to receive(:add).with(Listen::TCP::Broadcaster, as: :broadcaster, args: [nil, port])
+        expect(supervisor).to receive(:add).
+          with(Listen::TCP::Broadcaster, as: :broadcaster, args: [nil, port])
         subject.start
       end
 
@@ -77,11 +82,9 @@ describe Listen::TCP::Listener do
     describe '#block' do
       let(:async) { double('TCP broadcaster async', broadcast: true) }
       let(:callback) { double(call: true) }
-      let(:changes) { {
-        modified: ['/foo'],
-        added: [],
-        removed: []
-      }}
+      let(:changes) do
+        { modified: ['/foo'], added: [], removed: [] }
+      end
 
       before do
         broadcaster.stub(:async).and_return async
@@ -101,7 +104,10 @@ describe Listen::TCP::Listener do
 
       context 'when stopped' do
         it 'honours stopped state and does nothing' do
-          allow(subject).to receive(:supervisor) { double('SupervisionGroup', terminate: true) }
+          allow(subject).to receive(:supervisor) do
+            double('SupervisionGroup', terminate: true)
+          end
+
           subject.stop
           expect(broadcaster).not_to receive(:async)
           expect(callback).not_to receive(:call)
@@ -115,7 +121,7 @@ describe Listen::TCP::Listener do
 
       it 'invokes original callback block' do
         subject.block = callback
-        expect(callback).to receive(:call).with *changes.values
+        expect(callback).to receive(:call).with(*changes.values)
       end
     end
   end

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

@@ -4,7 +4,7 @@ require 'spec_helper'
 
 describe Listen::TCP::Message do
 
-  let(:object)  { [1, 2, {'foo' => 'bar'}] }
+  let(:object)  { [1, 2, { 'foo' => 'bar' }] }
   let(:body)    { '[1,2,{"foo":"bar"}]' }
   let(:size)    { 19 }
   let(:payload) { "\x00\x00\x00\x13[1,2,{\"foo\":\"bar\"}]" }