listen 2.0.0 → 2.0.1

data/spec/lib/listen/file_spec.rb

@@ -0,0 +1,112 @@
+require 'spec_helper'
+
+describe Listen::File do
+  let(:record) { double(Listen::Record, async: double(set_path: true, unset_path: true)) }
+  let(:path) { Pathname.new(Dir.pwd) }
+  around { |example| fixtures { |path| example.run } }
+  before { Celluloid::Actor.stub(:[]).with(:listen_record) { record } }
+
+  describe "#change" do
+    let(:file_path) { path.join('file.rb') }
+    let(:file) { Listen::File.new(file_path) }
+    let(:expected_data) {
+      if darwin?
+        { type: 'File', mtime: kind_of(Float), mode: kind_of(Integer), md5: kind_of(String) }
+      else
+        { 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
+          expect(file.change).to eq :removed
+        end
+        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 "old record path mtime" do
+          let(:record_mtime) { (Time.now - 1).to_f }
+
+          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)
+            file.change
+          end
+        end
+
+        context "same record path mtime" do
+          let(:record_mtime) { ::File.lstat(file_path).mtime.to_f }
+          let(:record_mode)  { ::File.lstat(file_path).mode }
+          let(:record_md5)   { Digest::MD5.file(file_path).digest }
+
+          context "same record path mode" do
+            it "returns nil" do
+              expect(file.change).to be_nil
+            end
+          end
+
+          context "diferent record path mode" do
+            let(:record_mode) { 'foo' }
+
+            it "returns modified" do
+              expect(file.change).to eq :modified
+            end
+          end
+
+          context "same record path md5" do
+            it "returns nil" do
+              expect(file.change).to be_nil
+            end
+          end
+
+          context "different record path md5" do
+            let(:record_md5) { 'foo' }
+
+            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)
+              file.change
+            end
+          end
+
+        end
+      end
+    end
+
+    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 }
+
+        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)
+          file.change
+        end
+      end
+    end
+  end
+
+end

data/spec/lib/listen/listener_spec.rb

@@ -0,0 +1,269 @@
+require 'spec_helper'
+
+describe Listen::Listener do
+  let(:listener) { Listen::Listener.new(options) }
+  let(:options) { {} }
+  let(:record) { double(Listen::Record, terminate: true, build: true) }
+  let(:silencer) { double(Listen::Silencer, terminate: true) }
+  let(:adapter) { double(Listen::Adapter::Base) }
+  let(:change_pool) { double(Listen::Change, terminate: true) }
+  let(:change_pool_async) { double('ChangePoolAsync') }
+  before {
+    Celluloid::Actor.stub(:[]).with(:listen_silencer) { silencer }
+    Celluloid::Actor.stub(:[]).with(:listen_adapter) { adapter }
+    Celluloid::Actor.stub(:[]).with(:listen_record) { record }
+    Celluloid::Actor.stub(:[]).with(:listen_change_pool) { change_pool }
+  }
+
+  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| }
+      listener = Listen::Listener.new('lib', &block)
+      expect(listener.block).not_to be_nil
+    end
+
+    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")]
+    end
+  end
+
+  describe "options" do
+    it "sets default options" do
+      expect(listener.options).to eq({
+        debug: false,
+        latency: nil,
+        force_polling: false,
+        polling_fallback_message: nil })
+    end
+
+    it "sets new options on initialize" do
+      listener = Listen::Listener.new('lib', latency: 1.234)
+      expect(listener.options).to eq({
+        debug: false,
+        latency: 1.234,
+        force_polling: false,
+        polling_fallback_message: nil })
+    end
+  end
+
+  describe "#start" do
+    before {
+      Listen::Silencer.stub(:new)
+      Listen::Change.stub(:pool)
+      Listen::Adapter.stub(:new)
+      Listen::Record.stub(:new)
+      Celluloid::Actor.stub(:[]=)
+      Celluloid.stub(:cores) { 1 }
+      adapter.stub_chain(:async, :start)
+    }
+
+    it "traps INT signal" do
+      expect(Signal).to receive(:trap).with('INT')
+      listener.start
+    end
+
+    it "registers silencer" do
+      expect(Listen::Silencer).to receive(:new).with(listener.options) { silencer }
+      expect(Celluloid::Actor).to receive(:[]=).with(:listen_silencer, silencer)
+      listener.start
+    end
+
+    it "registers change_pool" do
+      expect(Listen::Change).to receive(:pool).with(args: listener) { change_pool }
+      expect(Celluloid::Actor).to receive(:[]=).with(:listen_change_pool, change_pool)
+      listener.start
+    end
+
+    it "registers adaper" do
+      expect(Listen::Adapter).to receive(:new).with(listener) { adapter }
+      expect(Celluloid::Actor).to receive(:[]=).with(:listen_adapter, adapter)
+      listener.start
+    end
+
+    it "registers record" do
+      expect(Listen::Record).to receive(:new).with(listener) { record }
+      expect(Celluloid::Actor).to receive(:[]=).with(:listen_record, record)
+      listener.start
+    end
+
+    it "builds record" do
+      expect(record).to receive(:build)
+      listener.start
+    end
+
+    it "sets paused to false" do
+      listener.start
+      expect(listener.paused).to be_false
+    end
+
+    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
+      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
+      listener.changes = [{ modified: 'foo' }]
+      block_stub = double('block')
+      listener.block = block_stub
+      expect(block_stub).to receive(:call).with(['foo'], [], [])
+      listener.start
+      sleep 0.01
+    end
+  end
+
+  describe "#stop" do
+    let(:thread) { double(kill: true) }
+    before {
+      Celluloid::Actor.stub(:kill)
+      listener.stub(:thread) { thread }
+    }
+
+    it "kills thread" do
+      expect(thread).to receive(:kill)
+      listener.stop
+    end
+
+    it "terminates silencer" do
+      expect(silencer).to receive(:terminate)
+      listener.stop
+    end
+
+    it "kills adapter" do
+      expect(Celluloid::Actor).to receive(:kill).with(adapter)
+      listener.stop
+    end
+
+    it "terminates change_pool" do
+      expect(change_pool).to receive(:terminate)
+      listener.stop
+    end
+
+    it "terminates record" do
+      expect(record).to receive(:terminate)
+      listener.stop
+    end
+  end
+
+  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
+      expect(record).to receive(:build)
+      listener.unpause
+    end
+
+    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
+      listener.paused = true
+      expect(listener).to be_paused
+    end
+    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
+      listener.paused = false
+      expect(listener).not_to be_paused
+    end
+  end
+
+  describe "#paused?" do
+    it "returns true when not paused (false)" do
+      listener.paused = false
+      expect(listener.listen?).to be_true
+    end
+    it "returns false when not paused (nil)" do
+      listener.paused = nil
+      expect(listener.listen?).to be_false
+    end
+    it "returns false when paused" do
+      listener.paused = true
+      expect(listener.listen?).to be_false
+    end
+  end
+
+  describe "#ignore" do
+    let(:new_silencer) { double(Listen::Silencer) }
+    before { Celluloid::Actor.stub(:[]=) }
+
+    it "resets silencer actor with new pattern" do
+      expect(Listen::Silencer).to receive(:new).with(hash_including(ignore: [nil, /foo/])) { new_silencer }
+      expect(Celluloid::Actor).to receive(:[]=).with(:listen_silencer, new_silencer)
+      listener.ignore(/foo/)
+    end
+
+    context "with existing ignore options" do
+      let(:options) { { ignore: /bar/ } }
+
+      it "adds up to existing ignore options" do
+        expect(Listen::Silencer).to receive(:new).with(hash_including(ignore: [/bar/, /foo/]))
+        listener.ignore(/foo/)
+      end
+    end
+
+    context "with existing ignore options (array)" do
+      let(:options) { { ignore: [/bar/] } }
+
+      it "adds up to existing ignore options" do
+        expect(Listen::Silencer).to receive(:new).with(hash_including(ignore: [[/bar/], /foo/]))
+        listener.ignore(/foo/)
+      end
+    end
+  end
+
+  describe "#ignore!" do
+    let(:new_silencer) { double(Listen::Silencer) }
+    before { Celluloid::Actor.stub(:[]=) }
+
+    it "resets silencer actor with new pattern" do
+      expect(Listen::Silencer).to receive(:new).with(hash_including(ignore!: /foo/)) { new_silencer }
+      expect(Celluloid::Actor).to receive(:[]=).with(:listen_silencer, new_silencer)
+      listener.ignore!(/foo/)
+    end
+
+    context "with existing ignore! options" do
+      let(:options) { { ignore!: /bar/ } }
+
+      it "overwrites existing ignore options" do
+        expect(Listen::Silencer).to receive(:new).with(hash_including(ignore!: [/foo/]))
+        listener.ignore!([/foo/])
+      end
+    end
+
+    context "with existing ignore options" do
+      let(:options) { { ignore: /bar/ } }
+
+      it "deletes ignore options" do
+        expect(Listen::Silencer).to receive(:new).with(hash_not_including(ignore: /bar/))
+        listener.ignore!([/foo/])
+      end
+    end
+  end
+
+end

data/spec/lib/listen/record_spec.rb

@@ -0,0 +1,92 @@
+require 'spec_helper'
+
+describe Listen::Record do
+  let(:listener) { double(Listen::Listener, options: {}) }
+  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 } })
+    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))
+      expect(record.paths).to eq({ '/dir/path' => { 'file.rb' => data.merge(foo: 3, bar: 2) } })
+    end
+  end
+
+  describe "#unset_path" do
+    context "path is present" do
+      before { record.set_path(path, data) }
+
+      it "unsets path" do
+        record.unset_path(path)
+        expect(record.paths).to eq({ '/dir/path' => {} })
+      end
+    end
+
+    context "path not present" do
+      it "unsets path" do
+        record.unset_path(path)
+        expect(record.paths).to eq({ '/dir/path' => {} })
+      end
+    end
+  end
+
+  describe "#file_data" do
+    context "path is present" do
+      before { record.set_path(path, data) }
+
+      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
+        expect(record.file_data(path)).to be_empty
+      end
+    end
+  end
+
+  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 })
+      end
+    end
+
+    context "path not present" do
+      it "unsets path" do
+        expect(record.dir_entries('/dir/path')).to eq({})
+      end
+    end
+  end
+
+  describe "#build" do
+    let(:directories) { ['dir_path'] }
+    let(:change_pool) { double(Listen::Change, terminate: true) }
+    before {
+      change_pool.stub(:change)
+      Celluloid::Actor.stub(:[]).with(:listen_change_pool) { change_pool }
+      listener.stub(:directories) { directories }
+    }
+
+    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)
+      record.build
+    end
+  end
+end