listen 2.7.5 → 2.7.6

data/spec/lib/listen/record_spec.rb

@@ -1,29 +1,32 @@
 require 'spec_helper'
 
 describe Listen::Record do
-  let(:registry) { double(Celluloid::Registry) }
-  let(:listener) { double(Listen::Listener, registry: registry, options: {}) }
+  let(:registry) { instance_double(Celluloid::Registry) }
+
+  let(:listener) do
+    instance_double(Listen::Listener, registry: registry, options: {})
+  end
+
   let(:record) { Listen::Record.new(listener) }
   let(:path) { '/dir/path/file.rb' }
-  let(:data) { { type: 'File' } }
 
   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 })
+    it 'sets path by spliting dirname and basename' do
+      record.set_path(:file, path)
+      expect(record.paths['/dir/path']).to eq('file.rb' => { type: :file })
     end
 
     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))
-      expected = { '/dir/path' => { 'file.rb' => data.merge(foo: 3, bar: 2) } }
-      expect(record.paths).to eq(expected)
+      record.set_path(:file, path, foo: 1, bar: 2)
+      record.set_path(:file, path, foo: 3)
+      file_data = record.paths['/dir/path']['file.rb']
+      expect(file_data).to eq(foo: 3, bar: 2, type: :file)
     end
   end
 
   describe '#unset_path' do
     context 'path is present' do
-      before { record.set_path(path, data) }
+      before { record.set_path(:file, path) }
 
       it 'unsets path' do
         record.unset_path(path)
@@ -41,10 +44,10 @@ describe Listen::Record do
 
   describe '#file_data' do
     context 'path is present' do
-      before { record.set_path(path, data) }
+      before { record.set_path(:file, path) }
 
       it 'returns file data' do
-        expect(record.file_data(path)).to eq data
+        expect(record.file_data(path)).to eq(type: :file)
       end
     end
 
@@ -57,10 +60,11 @@ describe Listen::Record do
 
   describe '#dir_entries' do
     context 'path is present' do
-      before { record.set_path(path, data) }
+      before { record.set_path(:file, path) }
 
       it 'returns file path' do
-        expect(record.dir_entries('/dir/path')).to eq('file.rb' => data)
+        entries = record.dir_entries('/dir/path')
+        expect(entries).to eq('file.rb' => { type: :file })
       end
     end
 
@@ -73,24 +77,58 @@ describe Listen::Record do
 
   describe '#build' do
     let(:directories) { ['dir_path'] }
-    let(:change_pool) { double(Listen::Change, terminate: true) }
+
+    let(:actor) do
+      instance_double(Listen::Change, change: nil, terminate: true)
+    end
+
     before do
-      change_pool.stub(:change)
-      registry.stub(:[]).with(:change_pool) { change_pool }
-      listener.stub(:directories) { directories }
+      allow(listener).to receive(:directories) { directories }
+      allow(listener).to receive(:sync).with(:change_pool) { actor }
     end
 
     it 're-inits paths' do
-      record.set_path(path, data)
+      record.set_path(:file, path)
       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)
+      expect(actor).to receive(:change).
+        with(:dir, 'dir_path', recursive: true, silence: true, build: true)
+      record.build
+    end
+  end
+
+  describe '#still_building!' do
+    let(:directories) { ['dir_path'] }
 
+    let(:actor) do
+      instance_double(Listen::Change, change: nil, terminate: true)
+    end
+
+    before do
+      allow(listener).to receive(:directories) { directories }
+      allow(listener).to receive(:sync).with(:change_pool) { actor }
+    end
+
+    it 'keeps the build blocking longer' do
+      record # To avoid initializing record in thread
+
+      th = Thread.new do
+        10.times do
+          sleep 0.05
+          record.still_building!
+        end
+      end
+
+      started = Time.now
       record.build
+      ended  = Time.now
+
+      th.join
+
+      expect(ended - started).to be > 0.5
     end
   end
 end

data/spec/lib/listen/silencer_spec.rb

@@ -4,10 +4,11 @@ describe Listen::Silencer do
   let(:options) { {} }
 
   let(:listener) do
-    double(Listen::Listener,
-           directories: [Pathname.pwd, Pathname.new('/Users/Shared/')],
-           options: options
-          )
+    instance_double(
+      Listen::Listener,
+      directories: [Pathname.pwd, Pathname.new('/Users/Shared/')],
+      options: options
+    )
   end
 
   let(:silencer) { Listen::Silencer.new(listener) }
@@ -19,46 +20,42 @@ describe Listen::Silencer 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) }
+        it "silences #{dir}" do
+          expect(silencer.silenced?(pwd + dir, :dir)).to be_truthy
+        end
 
-          it "silences default ignored directory: #{dir}" do
-            expect(silencer.silenced?(path)).to be_true
-          end
+        it "doesn't silence #{dir}foo" do
+          expect(silencer.silenced?(pwd + "#{dir}foo", :dir)).to be_falsey
+        end
 
-          context 'with a directory beginning with the same name' do
-            let(:path) { pwd.join("#{dir}foo") }
+        it "doesn't silence foo#{dir}" do
+          expect(silencer.silenced?(pwd + "foo#{dir}", :dir)).to be_falsey
+        end
+      end
 
-            it "doesn't silences default ignored directory: #{dir}foo" do
-              expect(silencer.silenced?(path)).to be_false
-            end
-          end
+      all_files = %w(.DS_Store foo.tmp foo~)
 
-          context 'with a directory ending with the same name' do
-            let(:path) { pwd.join("foo#{dir}") }
+      # Gedit swap files
+      all_files += %w(.goutputstream-S3FBGX)
 
-            it "doesn't silences default ignored directory: foo#{dir}" do
-              expect(silencer.silenced?(path)).to be_false
-            end
-          end
-        end
-      end
+      # Kate editor swap files
+      all_files += %w(foo.rbo54321.new foo.rbB22583.new foo.rb.kate-swp)
 
-      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 + path)).to be_true
-          end
+      # Intellij swap files
+      all_files += %w(foo.rb___jb_bak___ foo.rb___jb_old___)
+
+      # Vim swap files
+      all_files += %w(foo.swp foo.swx foo.swpx 4913)
+
+      all_files.each do |path|
+        it "silences #{path}" do
+          expect(silencer.silenced?(pwd + path, :file)).to be_truthy
         end
       end
 
-      %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 + path)).to be_false
-          end
+      %w(foo.tmpl file.new file54321.new a.swf 14913 49131).each do |path|
+        it "does not silence #{path}" do
+          expect(silencer.silenced?(pwd + path, :file)).to be_falsey
         end
       end
     end
@@ -67,7 +64,7 @@ describe Listen::Silencer do
       let(:options) { { ignore: /\.pid$/ } }
 
       it 'silences path matching custom ignore regex' do
-        expect(silencer.silenced?(pwd + 'foo.pid')).to be_true
+        expect(silencer.silenced?(pwd + 'foo.pid', :file)).to be_truthy
       end
     end
 
@@ -75,8 +72,8 @@ describe Listen::Silencer do
       let(:options) { { ignore: [%r{^foo/bar}, /\.pid$/] } }
 
       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
+        expect(silencer.silenced?(pwd + 'foo/bar/baz', :file)).to be_truthy
+        expect(silencer.silenced?(pwd + 'foo.pid', :file)).to be_truthy
       end
     end
 
@@ -84,90 +81,66 @@ describe Listen::Silencer do
       let(:options) { { ignore!: /\.pid$/ } }
 
       it 'silences custom ignored directory' do
-        expect(silencer.silenced?(pwd + 'foo.pid')).to be_true
+        expect(silencer.silenced?(pwd + 'foo.pid', :file)).to be_truthy
       end
 
       it "doesn't silence default ignored directory" do
-        expect(silencer.silenced?(pwd + '.git')).to be_false
+        expect(silencer.silenced?(pwd + '.git', :file)).to be_falsey
       end
     end
 
     context 'with only options (regexp)' do
       let(:options) { { only: %r{foo} } }
 
-      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
-        expect(silencer.silenced?(pwd + 'foo', 'File')).to be_false
+        expect(silencer.silenced?(pwd + 'foo', :file)).to be_falsey
       end
 
       it 'silences other directory' do
-        expect(silencer.silenced?(pwd + 'bar', 'File')).to be_true
+        expect(silencer.silenced?(pwd + 'bar', :file)).to be_truthy
       end
     end
 
     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 + 'baz')).to be_false
-      end
-
       it "doesn't silence good directory" do
-        expect(silencer.silenced?(pwd + 'foo/bar.rb', 'File')).to be_false
+        expect(silencer.silenced?(pwd + 'foo/bar.rb', :file)).to be_falsey
       end
 
       it "doesn't silence good file" do
-        expect(silencer.silenced?(pwd + 'bar.txt', 'File')).to be_false
+        expect(silencer.silenced?(pwd + 'bar.txt', :file)).to be_falsey
       end
 
       it 'silences other directory' do
-        expect(silencer.silenced?(pwd + 'bar/baz.rb', 'File')).to be_true
+        expect(silencer.silenced?(pwd + 'bar/baz.rb', :file)).to be_truthy
       end
 
       it 'silences other file' do
-        expect(silencer.silenced?(pwd + 'bar.rb', 'File')).to be_true
+        expect(silencer.silenced?(pwd + 'bar.rb', :file)).to be_truthy
       end
     end
 
     context 'with ignore and only options' do
       let(:options) { { only: /\.pid$/, ignore: %r{^bar} } }
 
-      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
-
-          context 'when matching :ignore' do
-            it 'silences' do
-              expect(silencer.silenced?(pwd + 'bar')).to be_true
-            end
-          end
-        end
-      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
+            expect(silencer.silenced?(pwd + 'foo.rb', :file)).to be_truthy
           end
         end
 
         context 'when matching :only' do
           context 'when matching :ignore' do
             it 'silences' do
-              expect(silencer.silenced?(pwd + 'bar.pid', 'File')).to be_true
+              expect(silencer.silenced?(pwd + 'bar.pid', :file)).to be_truthy
             end
           end
 
           context 'when not matching :ignore' do
             it 'does not silence' do
-              expect(silencer.silenced?(pwd + 'foo.pid', 'File')).to be_false
+              expect(silencer.silenced?(pwd + 'foo.pid', :file)).to be_falsey
             end
           end
         end
@@ -175,8 +148,8 @@ describe Listen::Silencer do
     end
 
     it "doesn't silence normal path" do
-      path = pwd + 'some_dir' + 'some_file.rb'
-      expect(silencer.silenced?(path)).to be_false
+      path = (pwd + 'some_dir') + 'some_file.rb'
+      expect(silencer.silenced?(path, :file)).to be_falsey
     end
   end
 

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

@@ -1,115 +1,124 @@
 require 'spec_helper'
 
+require 'listen/tcp/broadcaster'
+
 describe Listen::TCP::Broadcaster do
 
   let(:host) { '10.0.0.2' }
   let(:port) { 4000 }
 
   subject { described_class.new(host, port) }
-  let(:server) { double(described_class::TCPServer, close: true, accept: nil) }
-  let(:socket)  { double(described_class::TCPSocket, write: true) }
+
+  let(:server) do
+    instance_double(described_class::TCPServer, close: true, accept: nil)
+  end
+
+  let(:socket) do
+    instance_double(described_class::TCPSocket, close: true, write: true)
+  end
+
+  let(:socket2) do
+    instance_double(described_class::TCPSocket, close: true, write: true)
+  end
+
   let(:payload) { Listen::TCP::Message.new.payload }
 
   before do
     expect(described_class::TCPServer).to receive(:new).
       with(host, port).and_return server
+    allow(server).to receive(:accept).and_raise('stub called')
   end
 
   after do
     subject.terminate
   end
 
-  describe '#initialize' do
-    it 'initializes and exposes a server' do
-      expect(subject.server).to be server
-    end
-
-    it 'initializes and exposes a list of sockets' do
-      expect(subject.sockets).to eq []
-    end
-  end
-
   describe '#start' do
-    let(:async) { double('TCP-listener async') }
-
     it 'invokes run loop asynchronously' do
-      subject.stub(:async).and_return async
-      expect(async).to receive(:run)
+      expect_any_instance_of(described_class).to receive(:run)
       subject.start
     end
   end
 
   describe '#finalize' do
-    it 'clears sockets' do
-      expect(subject.sockets).to receive(:clear)
-      subject.finalize
-    end
+    before { allow(server).to receive(:accept).and_return nil }
 
     it 'closes server' do
-      expect(subject.server).to receive(:close)
+      expect(server).to receive(:close)
       subject.finalize
-      expect(subject.server).to be_nil
     end
   end
 
   describe '#broadcast' do
-    it 'unicasts to connected sockets' do
-      subject.handle_connection socket
-      expect(subject.wrapped_object).to receive(:unicast).with socket, payload
-      subject.broadcast payload
-    end
-  end
-
-  describe '#unicast' do
-    before do
-      subject.handle_connection socket
-    end
+    context 'with active socket' do
+      before { allow(server).to receive(:accept).and_return socket, nil }
 
-    context 'when succesful' do
-      it 'returns true and leaves socket untouched' do
-        expect(subject.unicast(socket, payload)).to be_true
-        expect(subject.sockets).to include socket
+      it 'should broadcast payload' do
+        expect(socket).to receive(:write).with(payload)
+        subject.run
+        subject.broadcast payload
       end
-    end
 
-    context 'on IO errors' do
-      it 'returns false and removes socket from list' do
-        socket.stub(:write).and_raise IOError
-        expect(subject.unicast(socket, payload)).to be_false
-        expect(subject.sockets).not_to include socket
+      it 'should keep socket' do
+        expect(socket).to receive(:write).twice.with(payload)
+        subject.run
+        2.times { subject.broadcast payload }
       end
-    end
 
-    context 'on connection reset by peer' do
-      it 'returns false and removes socket from list' do
-        socket.stub(:write).and_raise Errno::ECONNRESET
-        expect(subject.unicast(socket, payload)).to be_false
-        expect(subject.sockets).not_to include socket
+      context 'with IOError' do
+        it 'should remove socket from list' do
+          allow(socket).to receive(:write).once.and_raise IOError
+          subject.run
+          2.times { subject.broadcast payload }
+        end
       end
-    end
 
-    context 'on broken pipe' do
-      it 'returns false and removes socket from list' do
-        socket.stub(:write).and_raise Errno::EPIPE
-        expect(subject.unicast(socket, payload)).to be_false
-        expect(subject.sockets).not_to include socket
+      context 'when reset by peer' do
+        it 'should remove socket from list' do
+          allow(socket).to receive(:write).once.and_raise Errno::ECONNRESET
+          subject.run
+          2.times { subject.broadcast payload }
+        end
       end
-    end
-  end
 
-  describe '#run' do
-    it 'handles incoming connections' do
-      server.stub(:accept).and_return socket, nil
-      expect(subject.wrapped_object).to receive(:handle_connection).with socket
-      subject.run
-    end
-  end
+      context 'when broken pipe' do
+        it 'should remove socket from list' do
+          allow(socket).to receive(:write).once.and_raise Errno::EPIPE
+          subject.run
+          2.times { subject.broadcast payload }
+        end
+      end
 
-  describe '#handle_connection' do
-    it 'adds socket to list' do
-      subject.handle_connection socket
-      expect(subject.sockets).to include socket
+      context 'with another active socket' do
+        before do
+          allow(server).to receive(:accept).and_return socket, socket2, nil
+        end
+
+        it 'should broadcast payload to both' do
+          expect(socket).to receive(:write).with(payload)
+          expect(socket2).to receive(:write).with(payload)
+          subject.run
+          subject.broadcast payload
+        end
+
+        context 'with a failure in first socket' do
+          before do
+            allow(socket).to receive(:write).once.and_raise Errno::EPIPE
+          end
+
+          it 'should still broadcast to remaining socket' do
+            expect(socket2).to receive(:write).with(payload)
+            subject.run
+            subject.broadcast payload
+          end
+
+          it 'should broadcast to only remaining socket' do
+            expect(socket2).to receive(:write).twice.with(payload)
+            subject.run
+            2.times { subject.broadcast payload }
+          end
+        end
+      end
     end
   end
-
 end