listen 2.0.0 → 2.0.1

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

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe Listen::Adapter::BSD do
+
+  if bsd?
+    let(:listener) { double(Listen::Listener) }
+    let(:adapter) { described_class.new(listener) }
+
+    describe ".usable?" do
+      it "returns always true" do
+        expect(described_class).to be_usable
+      end
+
+      it 'requires rb-kqueue and find gem' do
+        described_class.usable?
+        expect(defined?(KQueue)).to be_true
+        expect(defined?(Find)).to be_true
+      end
+    end
+  end
+
+  if darwin?
+    it "isn't usable on Darwin" do
+      expect(described_class).to_not be_usable
+    end
+  end
+
+  if linux?
+    it "isn't usable on Linux" do
+      expect(described_class).to_not be_usable
+    end
+  end
+
+  if windows?
+    it "isn't usable on Windows" do
+      expect(described_class).to_not be_usable
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe Listen::Adapter::Darwin do
+  if darwin?
+    let(:listener) { double(Listen::Listener) }
+    let(:adapter) { described_class.new(listener) }
+
+    describe ".usable?" do
+      it "returns always true" do
+        expect(described_class).to be_usable
+      end
+    end
+
+    describe '#initialize' do
+      it 'requires rb-fsevent gem' do
+        described_class.new(listener)
+        expect(defined?(FSEvent)).to be_true
+      end
+    end
+  end
+
+  if windows?
+    it "isn't usable on Windows" do
+      expect(described_class).to_not be_usable
+    end
+  end
+
+  if linux?
+    it "isn't usable on Linux" do
+      expect(described_class).to_not be_usable
+    end
+  end
+
+  if bsd?
+    it "isn't usable on BSD" do
+      expect(described_class).to_not be_usable
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe Listen::Adapter::Linux do
+  if linux?
+    let(:listener) { double(Listen::Listener) }
+    let(:adapter) { described_class.new(listener) }
+
+    describe ".usable?" do
+      it "returns always true" do
+        expect(described_class).to be_usable
+      end
+    end
+
+    describe '#initialize' do
+      it 'requires rb-inotify gem' do
+        described_class.new(listener)
+        expect(defined?(INotify)).to be_true
+      end
+    end
+  end
+
+  if darwin?
+    it "isn't usable on Darwin" do
+      expect(described_class).to_not be_usable
+    end
+  end
+
+  if windows?
+    it "isn't usable on Windows" do
+      expect(described_class).to_not be_usable
+    end
+  end
+
+  if bsd?
+    it "isn't usable on BSD" do
+      expect(described_class).to_not be_usable
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe Listen::Adapter::Polling do
+  let(:listener) { double(Listen::Listener, options: {}) }
+  let(:adapter) { described_class.new(listener) }
+
+  describe ".usable?" do
+    it "returns always true" do
+      expect(described_class).to be_usable
+    end
+  end
+
+  describe "#start" do
+    let(:directories) { ['directory_path'] }
+    before {
+      listener.stub(:options) { {} }
+      listener.stub(:directories) { directories }
+    }
+
+    it "notifies change on every listener directories path" do
+      adapter.should_receive(:_notify_change).with('directory_path', type: 'Dir', recursive: true)
+      t = Thread.new { adapter.start }
+      sleep 0.01
+      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
+    end
+
+    it "returns latency from listener actor if present" do
+      listener.stub(:options) { { latency: 1234 } }
+      expect(adapter.send(:_latency)).to eq 1234
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe Listen::Adapter::Windows do
+  if windows?
+    let(:listener) { double(Listen::Listener) }
+    let(:adapter) { described_class.new(listener) }
+
+    describe ".usable?" do
+      it "returns always true" do
+        expect(described_class).to be_usable
+      end
+
+      it 'requires wdm gem' do
+        described_class.usable?
+        expect(defined?(WDM)).to be_true
+      end
+    end
+  end
+
+  if darwin?
+    it "isn't usable on Darwin" do
+      expect(described_class).to_not be_usable
+    end
+  end
+
+  if linux?
+    it "isn't usable on Linux" do
+      expect(described_class).to_not be_usable
+    end
+  end
+
+  if bsd?
+    it "isn't usable on BSD" do
+      expect(described_class).to_not be_usable
+    end
+  end
+end

data/spec/lib/listen/adapter_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+
+describe Listen::Adapter do
+  let(:adapter) { Listen::Adapter.new(listener) }
+  let(:listener) { double(Listen::Listener, options: {}) }
+  before {
+    Listen::Adapter::BSD.stub(:usable?) { false }
+    Listen::Adapter::Darwin.stub(:usable?) { false }
+    Listen::Adapter::Linux.stub(:usable?) { false }
+    Listen::Adapter::Windows.stub(:usable?) { false }
+  }
+
+  describe ".new" do
+    it "returns Polling adapter if forced" do
+      listener.stub(:options) { { force_polling: true } }
+      expect(adapter).to be_kind_of Listen::Adapter::Polling
+    end
+
+    it "returns Polling adapter if not on MRI" do
+      stub_const("RUBY_ENGINE", 'foo')
+      Listen::Adapter::Linux.stub(:usable?) { true }
+      expect(adapter).to be_kind_of Listen::Adapter::Polling
+    end
+
+    if RUBY_ENGINE == 'ruby'
+      it "returns BSD adapter when usable" do
+        Listen::Adapter::BSD.stub(:usable?) { true }
+        expect(Listen::Adapter::BSD).to receive(:new)
+        adapter
+      end
+
+      it "returns Darwin adapter when usable" do
+        Listen::Adapter::Darwin.stub(:usable?) { true }
+        expect(Listen::Adapter::Darwin).to receive(:new)
+        adapter
+      end
+
+      it "returns Linux adapter when usable" do
+        Listen::Adapter::Linux.stub(:usable?) { true }
+        expect(Listen::Adapter::Linux).to receive(:new)
+        adapter
+      end
+
+      it "returns Windows adapter when usable" do
+        Listen::Adapter::Windows.stub(:usable?) { true }
+        expect(Listen::Adapter::Windows).to receive(:new)
+        adapter
+      end
+
+      context "no usable adapters" do
+        before { Kernel.stub(:warn) }
+
+        it "returns Polling adapter" do
+          expect(adapter).to be_kind_of Listen::Adapter::Polling
+        end
+
+        it "warns polling fallback with default message" do
+          expect(Kernel).to receive(:warn).with("[Listen warning]:\n  #{described_class::POLLING_FALLBACK_MESSAGE}")
+          adapter
+        end
+
+        it "doesn't warn if polling_fallback_message is false" do
+          listener.stub(:options) { { polling_fallback_message: false } }
+          expect(Kernel).to_not receive(:warn)
+          adapter
+        end
+
+        it "warns polling fallback with custom message if set" do
+          listener.stub(:options) { { polling_fallback_message: 'custom fallback message' } }
+          expect(Kernel).to receive(:warn).with("[Listen warning]:\n  custom fallback message")
+          adapter
+        end
+      end
+    end
+  end
+
+end

data/spec/lib/listen/change_spec.rb

@@ -0,0 +1,97 @@
+require 'spec_helper'
+
+describe Listen::Change do
+  let(:change) { Listen::Change.new(listener) }
+  let(:listener) { double(Listen::Listener, options: {}) }
+  let(:listener_changes) { double("listener_changes") }
+  before {
+    listener.stub(:changes) { listener_changes }
+  }
+
+  describe "#change" do
+    let(:silencer) { double(Listen::Silencer, silenced?: false) }
+    before { Celluloid::Actor.stub(:[]).with(:listen_silencer) { silencer } }
+
+    context "file path" do
+      context "with known change" do
+        it "notifies change directly to listener" do
+          expect(listener_changes).to receive(:<<).with(modified: 'file_path')
+          change.change('file_path', type: 'File', change: :modified)
+        end
+
+        it "doesn't notify to listener if path is silenced" do
+          expect(silencer).to receive(:silenced?).with('file_path') { true }
+          expect(listener_changes).to_not receive(:<<)
+          change.change('file_path', type: 'File', change: :modified)
+        end
+      end
+
+      context "with unknown change" do
+        let(:file) { double(Listen::File) }
+        before { Listen::File.stub(:new) { file } }
+
+        it "calls Listen::File#change" do
+          expect(Listen::File).to receive(:new).with('file_path') { file }
+          expect(file).to receive(:change)
+          change.change('file_path', type: 'File')
+        end
+
+        it "doesn't call Listen::File#change if path is silenced" do
+          expect(silencer).to receive(:silenced?).with('file_path') { true }
+          expect(Listen::File).to_not receive(:new)
+          change.change('file_path', type: 'File')
+        end
+
+        context "that returns a change" do
+          before { file.stub(:change) { :modified } }
+
+          context "listener listen" do
+            before { listener.stub(:listen?) { true } }
+
+            it "notifies change to listener" do
+              expect(listener_changes).to receive(:<<).with(modified: 'file_path')
+              change.change('file_path', type: 'File')
+            end
+
+            context "silence option" do
+              it "notifies change to listener" do
+                expect(listener_changes).to_not receive(:<<)
+                change.change('file_path', type: 'File', silence: true)
+              end
+            end
+          end
+
+          context "listener doesn't listen" do
+            before { listener.stub(:listen?) { false } }
+
+            it "notifies change to listener" do
+              expect(listener_changes).to_not receive(:<<)
+              change.change('file_path', type: 'File')
+            end
+          end
+        end
+
+        context "that returns no change" do
+          before { file.stub(:change) { nil } }
+
+          it "doesn't notifies no change" do
+            expect(listener_changes).to_not receive(:<<)
+            change.change('file_path', type: 'File')
+          end
+        end
+      end
+    end
+
+    context "directory path" do
+      let(:dir) { double(Listen::Directory) }
+      let(:dir_options) { { type: 'Dir', recursive: true } }
+      before { Listen::Directory.stub(:new) { dir } }
+
+      it "calls Listen::Directory#scan" do
+        expect(Listen::Directory).to receive(:new).with('dir_path', dir_options) { dir }
+        expect(dir).to receive(:scan)
+        change.change('dir_path', dir_options)
+      end
+    end
+  end
+end

data/spec/lib/listen/directory_spec.rb

@@ -0,0 +1,153 @@
+require 'spec_helper'
+
+describe Listen::Directory do
+  let(:record) { double(Listen::Record, async: double(set_path: true, unset_path: true)) }
+  let(:change_pool) { double(Listen::Change) }
+  let(:change_pool_async) { double('ChangePoolAsync') }
+  let(:path) { Pathname.new(Dir.pwd) }
+  around { |example| fixtures { |path| example.run } }
+  before {
+    change_pool.stub(:async) { change_pool_async }
+    Celluloid::Actor.stub(:[]).with(:listen_record) { record }
+    Celluloid::Actor.stub(:[]).with(:listen_change_pool) { change_pool }
+  }
+
+  describe "#scan" do
+    let(:dir_path) { path.join('dir') }
+    let(:file_path) { dir_path.join('file.rb') }
+    let(:other_file_path) { dir_path.join('other_file.rb') }
+    let(:inside_dir_path) { dir_path.join('inside_dir') }
+    let(:other_inside_dir_path) { dir_path.join('other_inside_dir') }
+    let(:dir) { Listen::Directory.new(dir_path, options) }
+
+    context "with recursive off" do
+      let(:options) { { recursive: false } }
+
+      context "file & inside_dir paths present in record" do
+        let(:record_dir_entries) { {
+          'file.rb' => { type: 'File' },
+          'inside_dir' => { type: 'Dir' } } }
+        before {
+          record.stub_chain(:future, :dir_entries) { double(value: record_dir_entries) }
+          change_pool_async.stub(:change)
+        }
+
+        context "empty dir" do
+          around { |example| mkdir dir_path; example.run }
+
+          it "sets record dir path" do
+            expect(record.async).to receive(:set_path).with(dir_path, type: 'Dir')
+            dir.scan
+          end
+
+          it "calls change for file path and dir that doesn't exist" do
+            expect(change_pool_async).to receive(:change).with(file_path, type: 'File', recursive: false)
+            expect(change_pool_async).to receive(:change).with(inside_dir_path, type: 'Dir', recursive: false)
+            dir.scan
+          end
+        end
+
+        context "other file path present in dir" do
+          around { |example|
+            mkdir dir_path;
+            touch other_file_path;
+            example.run }
+
+          it "calls change for file & other_file paths and dir that doesn't exist" do
+            expect(change_pool_async).to receive(:change).with(file_path, type: 'File', recursive: false)
+            expect(change_pool_async).to receive(:change).with(other_file_path, type: 'File', recursive: false)
+            expect(change_pool_async).to receive(:change).with(inside_dir_path, type: 'Dir', recursive: false)
+            dir.scan
+          end
+        end
+      end
+
+      context "dir paths not present in record" do
+        before { record.stub_chain(:future, :dir_entries) { double(value: {}) } }
+
+        context "non-existing dir path" do
+          it "calls change only for file path" do
+            expect(change_pool_async).to_not receive(:change)
+            dir.scan
+          end
+
+          it "unsets record dir path" do
+            expect(record.async).to receive(:unset_path).with(dir_path)
+            dir.scan
+          end
+        end
+
+        context "other file path present in dir" do
+          around { |example|
+            mkdir dir_path;
+            touch file_path;
+            example.run }
+
+          it "calls change for file & other_file paths" do
+            expect(change_pool_async).to receive(:change).with(file_path, type: 'File', recursive: false)
+            expect(change_pool_async).to_not receive(:change).with(other_file_path, type: 'File', recursive: false)
+            expect(change_pool_async).to_not receive(:change).with(inside_dir_path, type: 'Dir', recursive: false)
+            dir.scan
+          end
+        end
+      end
+    end
+
+    context "with recursive on" do
+      let(:options) { { recursive: true } }
+
+      context "file & inside_dir paths present in record" do
+        let(:record_dir_entries) { {
+          'file.rb' => { type: 'File' },
+          'inside_dir' => { type: 'Dir' } } }
+        before { record.stub_chain(:future, :dir_entries) { double(value: record_dir_entries) } }
+
+        context "empty dir" do
+          it "calls change for file & inside_dir path" do
+            expect(change_pool_async).to receive(:change).with(file_path, type: 'File', recursive: true)
+            expect(change_pool_async).to receive(:change).with(inside_dir_path, type: 'Dir', recursive: true)
+            dir.scan
+          end
+        end
+
+        context "other inside_dir path present in dir" do
+          around { |example|
+            mkdir dir_path;
+            mkdir other_inside_dir_path;
+            example.run }
+
+          it "calls change for file, other_file & inside_dir paths" do
+            expect(change_pool_async).to receive(:change).with(file_path, type: 'File', recursive: true)
+            expect(change_pool_async).to receive(:change).with(inside_dir_path, type: 'Dir', recursive: true)
+            expect(change_pool_async).to receive(:change).with(other_inside_dir_path, type: 'Dir', recursive: true)
+            dir.scan
+          end
+        end
+      end
+
+      context "dir paths not present in record" do
+        before { record.stub_chain(:future, :dir_entries) { double(value: {}) } }
+
+        context "non-existing dir path" do
+          it "calls change only for file path" do
+            expect(change_pool_async).to_not receive(:change)
+            dir.scan
+          end
+        end
+
+        context "other file path present in dir" do
+          around { |example|
+            mkdir dir_path;
+            mkdir other_inside_dir_path;
+            example.run }
+
+          it "calls change for file & other_file paths" do
+            expect(change_pool_async).to receive(:change).with(other_inside_dir_path, type: 'Dir', recursive: true)
+            dir.scan
+          end
+        end
+      end
+    end
+  end
+
+end