fluid_cli 0.1.2

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

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+
+RSpec.describe Listen::Adapter::Linux do
+  describe 'class methods' do
+    subject { described_class }
+
+    if linux?
+      it { should be_usable }
+    else
+      it { should_not be_usable }
+    end
+  end
+
+  if linux?
+    describe 'instance methods' do
+      before(:all) do
+        require 'rb-inotify'
+      end
+
+      let(:dir1) { Pathname.new("/foo/dir1") }
+
+      let(:queue) { instance_double(Queue, "queue", close: nil) }
+      let(:config) { instance_double(Listen::Adapter::Config, "config", queue: queue) }
+      let(:silencer) { instance_double(Listen::Silencer, "silencer") }
+      let(:snapshot) { instance_double(Listen::Change, "snapshot") }
+      let(:record) { instance_double(Listen::Record, "record") }
+
+      # TODO: fix other adapters too!
+      subject { described_class.new(config) }
+
+      after do
+        subject.stop
+      end
+
+      describe 'watch events' do
+        let(:directories) { [Pathname.pwd] }
+        let(:adapter_options) { {} }
+        let(:default_events) { [:recursive, :attrib, :create, :modify, :delete, :move, :close_write] }
+        let(:fake_worker) { double(:fake_worker_for_watch_events) }
+        let(:fake_notifier) { double(:fake_notifier, new: fake_worker) }
+
+        before do
+          stub_const('INotify::Notifier', fake_notifier)
+
+          allow(config).to receive(:directories).and_return(directories)
+          allow(config).to receive(:adapter_options).and_return(adapter_options)
+          allow(config).to receive(:silencer).and_return(silencer)
+          allow(fake_worker).to receive(:close)
+        end
+
+        after do
+          subject.stop
+        end
+
+        it 'starts by calling watch with default events' do
+          expect(fake_worker).to receive(:watch).with(*directories.map(&:to_s), *default_events)
+          subject.start
+        end
+      end
+
+      describe 'inotify max watches exceeded' do
+        let(:directories) { [Pathname.pwd] }
+        let(:adapter_options) { {} }
+
+        before do
+          fake_worker = double(:fake_worker_for_inotify_limit_message)
+          allow(fake_worker).to receive(:watch).and_raise(Errno::ENOSPC)
+          allow(fake_worker).to receive(:close)
+
+          fake_notifier = double(:fake_notifier, new: fake_worker)
+          stub_const('INotify::Notifier', fake_notifier)
+
+          allow(config).to receive(:directories).and_return(directories)
+          allow(config).to receive(:adapter_options).and_return(adapter_options)
+        end
+
+        it 'raises exception' do
+          expect { subject.start }.to raise_exception(Listen::Error::INotifyMaxWatchesExceeded, /inotify max watches exceeded/i)
+        end
+      end
+
+      # TODO: should probably be adapted to be more like adapter/base_spec.rb
+      describe '_callback' do
+        let(:directories) { [dir1] }
+        let(:adapter_options) { { events: [:recursive, :close_write] } }
+
+        before do
+          fake_worker = double(:fake_worker_for_callback)
+          events = [:recursive, :close_write]
+          allow(fake_worker).to receive(:watch).with('/foo/dir1', *events)
+          allow(fake_worker).to receive(:close)
+
+          fake_notifier = double(:fake_notifier, new: fake_worker)
+          stub_const('INotify::Notifier', fake_notifier)
+
+          allow(config).to receive(:directories).and_return(directories)
+          allow(config).to receive(:adapter_options).and_return(adapter_options)
+          allow(config).to receive(:silencer).and_return(silencer)
+
+          allow(Listen::Record).to receive(:new).with(dir1, silencer).and_return(record)
+          allow(Listen::Change::Config).to receive(:new).with(queue, silencer).
+            and_return(config)
+          allow(Listen::Change).to receive(:new).with(config, record).
+            and_return(snapshot)
+
+          allow(subject).to receive(:require).with('rb-inotify')
+          subject.configure
+        end
+
+        let(:expect_change) do
+          lambda do |change|
+            expect(snapshot).to receive(:invalidate).with(
+              :file,
+              'path/foo.txt',
+              {
+                cookie: 123,
+                change: change
+              }
+            )
+          end
+        end
+
+        let(:event_callback) do
+          lambda do |flags|
+            callbacks = subject.instance_variable_get(:'@callbacks')
+            callbacks.values.flatten.each do |callback|
+              callback.call double(
+                :inotify_event,
+                name: 'foo.txt',
+                watcher: double(:watcher, path: '/foo/dir1/path'),
+                flags: flags,
+                cookie: 123)
+            end
+          end
+        end
+
+        # TODO: get fsevent adapter working like INotify
+        unless /1|true/ =~ ENV['LISTEN_GEM_SIMULATE_FSEVENT']
+          it 'recognizes close_write as modify' do
+            expect_change.call(:modified)
+            event_callback.call([:close_write])
+          end
+
+          it 'recognizes moved_to as moved_to' do
+            expect_change.call(:moved_to)
+            event_callback.call([:moved_to])
+          end
+
+          it 'recognizes moved_from as moved_from' do
+            expect_change.call(:moved_from)
+            event_callback.call([:moved_from])
+          end
+        end
+      end
+
+      describe '#stop' do
+        let(:fake_worker) { double(:fake_worker_for_stop, close: true) }
+        let(:directories) { [dir1] }
+        let(:adapter_options) { { events: [:recursive, :close_write] } }
+
+        before do
+          allow(config).to receive(:directories).and_return(directories)
+          allow(config).to receive(:adapter_options).and_return(adapter_options)
+        end
+
+        context 'when configured' do
+          before do
+            events = [:recursive, :close_write]
+            allow(fake_worker).to receive(:watch).with('/foo/dir1', *events)
+
+            fake_notifier = double(:fake_notifier, new: fake_worker)
+            stub_const('INotify::Notifier', fake_notifier)
+
+            allow(config).to receive(:silencer).and_return(silencer)
+
+            allow(subject).to receive(:require).with('rb-inotify')
+            subject.configure
+          end
+
+          it 'stops the worker' do
+            subject.stop
+          end
+        end
+
+        context 'when not even initialized' do
+          before do
+            allow(queue).to receive(:close)
+          end
+
+          it 'does not crash' do
+            expect do
+              subject.stop
+            end.to_not raise_error
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+include Listen
+
+RSpec.describe Adapter::Polling do
+  describe 'class' do
+    subject { described_class }
+    it { should be_usable }
+  end
+
+  subject do
+    described_class.new(config)
+  end
+
+  let(:dir1) do
+    instance_double(Pathname, 'dir1', to_s: '/foo/dir1', cleanpath: real_dir1)
+  end
+
+  # just so cleanpath works in above double
+  let(:real_dir1) { instance_double(Pathname, 'dir1', to_s: '/foo/dir1') }
+
+  let(:config) { instance_double(Listen::Adapter::Config, "config") }
+  let(:directories) { [dir1] }
+  let(:options) { {} }
+  let(:queue) { instance_double(Queue, "queue") }
+  let(:silencer) { instance_double(Listen::Silencer, "silencer") }
+  let(:snapshot) { instance_double(Listen::Change, "snapshot") }
+
+  let(:record) { instance_double(Listen::Record) }
+
+  context 'with a valid configuration' do
+    before do
+      allow(config).to receive(:directories).and_return(directories)
+      allow(config).to receive(:adapter_options).and_return(options)
+      allow(config).to receive(:queue).and_return(queue)
+      allow(config).to receive(:silencer).and_return(silencer)
+
+      allow(Listen::Record).to receive(:new).with(dir1, silencer).and_return(record)
+
+      allow(Listen::Change).to receive(:new).with(config, record).
+        and_return(snapshot)
+      allow(Listen::Change::Config).to receive(:new).with(queue, silencer).
+        and_return(config)
+    end
+
+    describe '#start' do
+      before do
+        allow(snapshot).to receive(:record).and_return(record)
+        allow(record).to receive(:build)
+      end
+
+      after do
+        allow(queue).to receive(:close)
+        subject.stop
+      end
+
+      it 'notifies change on every listener directories path' do
+        expect(snapshot).to receive(:invalidate).
+          with(:dir, '.', { recursive: true })
+
+        t = Thread.new { subject.start }
+        sleep 0.25
+        t.kill
+      end
+    end
+
+    describe '#_latency' do
+      subject do
+        adapter = described_class.new(config)
+        adapter.options.latency
+      end
+
+      context 'with no overriding option' do
+        it { should eq 1.0 }
+      end
+
+      context 'with custom latency overriding' do
+        let(:options) { { latency: 1234 } }
+        it { should eq 1234 }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+RSpec.describe Listen::Adapter::Windows do
+  describe 'class' do
+    subject { described_class }
+
+    if windows?
+      it { should be_usable }
+    else
+      it { should_not be_usable }
+    end
+  end
+end

data/vendor/deps/listen/spec/lib/listen/adapter_spec.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+RSpec.describe Listen::Adapter do
+  let(:listener) { instance_double(Listen::Listener, options: {}) }
+  before do
+    allow(Listen::Adapter::BSD).to receive(:usable?) { false }
+    allow(Listen::Adapter::Darwin).to receive(:usable?) { false }
+    allow(Listen::Adapter::Linux).to receive(:usable?) { false }
+    allow(Listen::Adapter::Windows).to receive(:usable?) { false }
+  end
+
+  describe '.select' do
+    it 'returns Polling adapter if forced' do
+      klass = Listen::Adapter.select(force_polling: true)
+      expect(klass).to eq Listen::Adapter::Polling
+    end
+
+    it 'returns BSD adapter when usable' do
+      allow(Listen::Adapter::BSD).to receive(:usable?) { true }
+      klass = Listen::Adapter.select
+      expect(klass).to eq Listen::Adapter::BSD
+    end
+
+    it 'returns Darwin adapter when usable' do
+      allow(Listen::Adapter::Darwin).to receive(:usable?) { true }
+      klass = Listen::Adapter.select
+      expect(klass).to eq Listen::Adapter::Darwin
+    end
+
+    it 'returns Linux adapter when usable' do
+      allow(Listen::Adapter::Linux).to receive(:usable?) { true }
+      klass = Listen::Adapter.select
+      expect(klass).to eq Listen::Adapter::Linux
+    end
+
+    it 'returns Windows adapter when usable' do
+      allow(Listen::Adapter::Windows).to receive(:usable?) { true }
+      klass = Listen::Adapter.select
+      expect(klass).to eq Listen::Adapter::Windows
+    end
+
+    context 'no usable adapters' do
+      before { allow(Kernel).to receive(:warn) }
+
+      it 'returns Polling adapter' do
+        klass = Listen::Adapter.select(force_polling: true)
+        expect(klass).to eq Listen::Adapter::Polling
+      end
+
+      it 'warns polling fallback with default message' do
+        msg = described_class::POLLING_FALLBACK_MESSAGE
+        expect(Listen).to receive(:adapter_warn).with("[Listen warning]:\n  #{msg}")
+        Listen::Adapter.select
+      end
+
+      it "doesn't warn if polling_fallback_message is false" do
+        expect(Kernel).to_not receive(:warn)
+        Listen::Adapter.select(polling_fallback_message: false)
+      end
+
+      it 'warns polling fallback with custom message if set' do
+        expected_msg = "[Listen warning]:\n  custom fallback message"
+        expect(Listen).to receive(:adapter_warn).with(expected_msg)
+        msg = 'custom fallback message'
+        Listen::Adapter.select(polling_fallback_message: msg)
+      end
+    end
+  end
+end

data/vendor/deps/listen/spec/lib/listen/backend_spec.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require 'listen/backend'
+
+RSpec.describe Listen::Backend do
+  let(:dir1) { instance_double(Pathname, 'dir1', to_s: '/foo/dir1') }
+
+  let(:silencer) { instance_double(Listen::Silencer) }
+  let(:queue) { instance_double(Queue) }
+
+  let(:select_options) do
+    { force_polling: false, polling_fallback_message: 'foo' }
+  end
+
+  let(:adapter_options) { { latency: 1234 } }
+  let(:options) { select_options.merge(adapter_options) }
+
+  let(:adapter_config_class) { class_double('Listen::Adapter::Config') }
+  let(:adapter_config) { instance_double('Listen::Adapter::Config') }
+
+  let(:config) { instance_double(Listen::Listener::Config) }
+
+  subject { described_class.new([dir1], queue, silencer, config) }
+
+  # Use Polling since it has a valid :latency option
+  let(:adapter_defaults) { { latency: 5.4321 } }
+  let(:adapter_class) { Listen::Adapter::Polling }
+  let(:adapter) { instance_double('Listen::Adapter::Polling') }
+
+  let(:config_min_delay_between_events) { 0.1234 }
+
+  before do
+    stub_const('Listen::Adapter::Config', adapter_config_class)
+
+    allow(adapter_config_class).to receive(:new).
+      with([dir1], queue, silencer, adapter_options).
+      and_return(adapter_config)
+
+    allow(Listen::Adapter).to receive(:select).
+      with(select_options).and_return(adapter_class)
+
+    allow(adapter_class).to receive(:new).
+      with(adapter_config).and_return(adapter)
+
+    allow(Listen::Adapter::Polling).to receive(:new).with(adapter_config).
+      and_return(adapter)
+
+    allow(config).to receive(:adapter_select_options).
+      and_return(select_options)
+
+    allow(config).to receive(:adapter_instance_options).
+      and_return(adapter_options)
+
+    allow(config).to receive(:min_delay_between_events).
+      and_return(config_min_delay_between_events)
+  end
+
+  describe '#initialize' do
+    context 'with config' do
+      it 'sets up an adapter class' do
+        expect(adapter_class).to receive(:new).
+          with(adapter_config).and_return(adapter)
+
+        subject
+      end
+    end
+  end
+
+  describe '#start' do
+    it 'starts the adapter' do
+      expect(adapter).to receive(:start)
+      subject.start
+    end
+  end
+
+  describe '#stop' do
+    it 'stops the adapter' do
+      expect(adapter).to receive(:stop)
+      subject.stop
+    end
+  end
+end

data/vendor/deps/listen/spec/lib/listen/change_spec.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+RSpec.describe Listen::Change do
+  let(:config) { instance_double(Listen::Change::Config) }
+  let(:dir) { instance_double(Pathname) }
+  let(:record) { instance_double(Listen::Record, root: '/dir') }
+  subject { Listen::Change.new(config, record) }
+
+  let(:full_file_path) { instance_double(Pathname, to_s: '/dir/file.rb') }
+  let(:full_dir_path) { instance_double(Pathname, to_s: '/dir') }
+
+  before do
+    allow(dir).to receive(:+).with('file.rb') { full_file_path }
+    allow(dir).to receive(:+).with('dir1') { full_dir_path }
+  end
+
+  describe '#change' do
+    before do
+      allow(config).to receive(:silenced?).and_return(false)
+    end
+
+    context 'with build options' do
+      it 'calls still_building! on record' do
+        allow(config).to receive(:queue)
+        allow(Listen::File).to receive(:change)
+        subject.invalidate(:file, 'file.rb', build: true)
+      end
+    end
+
+    context 'file' do
+      context 'with known change' do
+        it 'notifies change directly to listener' do
+          expect(config).to receive(:queue).
+            with(:file, :modified, Pathname.new('/dir'), 'file.rb', {})
+
+          subject.invalidate(:file, 'file.rb', change: :modified)
+        end
+
+        it "doesn't notify to listener if path is silenced" do
+          expect(config).to receive(:silenced?).and_return(true)
+          expect(config).to_not receive(:queue)
+          subject.invalidate(:file, 'file.rb', change: :modified)
+        end
+      end
+
+      context 'with unknown change' do
+        it 'calls Listen::File#change' do
+          expect(Listen::File).to receive(:change).with(record, 'file.rb')
+          subject.invalidate(:file, 'file.rb', {})
+        end
+
+        it "doesn't call Listen::File#change if path is silenced" do
+          expect(config).to receive(:silenced?).
+            with('file.rb', :file).and_return(true)
+
+          expect(Listen::File).to_not receive(:change)
+          subject.invalidate(:file, 'file.rb', {})
+        end
+
+        context 'that returns a change' do
+          before { allow(Listen::File).to receive(:change) { :modified } }
+
+          context 'listener listen' do
+            it 'notifies change to listener' do
+              expect(config).to receive(:queue).
+                with(:file, :modified, Pathname.new('/dir'), 'file.rb')
+
+              subject.invalidate(:file, 'file.rb', {})
+            end
+
+            context 'silence option' do
+              it 'notifies change to listener' do
+                expect(config).to_not receive(:queue)
+                subject.invalidate(:file, 'file.rb', silence: true)
+              end
+            end
+          end
+        end
+
+        context 'that returns no change' do
+          before { allow(Listen::File).to receive(:change) { nil } }
+
+          it "doesn't notifies no change" do
+            expect(config).to_not receive(:queue)
+            subject.invalidate(:file, 'file.rb', {})
+          end
+        end
+      end
+    end
+
+    context 'directory' do
+      let(:dir_options) { { recursive: true } }
+
+      it 'calls Listen::Directory#new' do
+        expect(Listen::Directory).to receive(:scan).
+          with(subject, 'dir1', dir_options)
+
+        subject.invalidate(:dir, 'dir1', dir_options)
+      end
+    end
+  end
+end

data/vendor/deps/listen/spec/lib/listen/cli_spec.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require 'listen/cli'
+
+RSpec.describe Listen::CLI do
+  let(:options) { {} }
+  let(:forwarder) { instance_double(Listen::Forwarder) }
+
+  before do
+    allow(forwarder).to receive(:start)
+  end
+
+  describe 'directories option' do
+    context 'not specified' do
+      let(:options) { %w[] }
+      it 'is set to local directory' do
+        expect(Listen::Forwarder).to receive(:new) do |options|
+          expect(options[:directory]).to eq(['.'])
+          forwarder
+        end
+        described_class.start(options)
+      end
+    end
+
+    context 'with a single directory' do
+      let(:options) { %w[-d app] }
+      it 'is set to app' do
+        expect(Listen::Forwarder).to receive(:new) do |options|
+          expect(options[:directory]).to eq(['app'])
+          forwarder
+        end
+        described_class.start(options)
+      end
+    end
+
+    context 'with a multiple directories' do
+      let(:options) { %w[-d app spec] }
+      it 'is set to an array of the directories' do
+        expect(Listen::Forwarder).to receive(:new) do |options|
+          expect(options[:directory]).to eq(%w[app spec])
+          forwarder
+        end
+        described_class.start(options)
+      end
+    end
+  end
+
+  describe 'relative option' do
+    context 'without relative option' do
+      let(:options) { %w[] }
+      it 'is set to false' do
+        expect(Listen::Forwarder).to receive(:new) do |options|
+          expect(options[:relative]).to be(false)
+          forwarder
+        end
+        described_class.start(options)
+      end
+    end
+
+    context 'when -r' do
+      let(:options) { %w[-r] }
+
+      it 'is set to true' do
+        expect(Listen::Forwarder).to receive(:new) do |options|
+          expect(options[:relative]).to be(true)
+          forwarder
+        end
+        described_class.start(options)
+      end
+    end
+
+    context 'when --relative' do
+      let(:options) { %w[--relative] }
+
+      it 'supports -r option' do
+        expect(Listen::Forwarder).to receive(:new) do |options|
+          expect(options[:relative]).to be(true)
+          forwarder
+        end
+        described_class.start(options)
+      end
+
+      it 'supports --relative option' do
+        expect(Listen::Forwarder).to receive(:new) do |options|
+          expect(options[:relative]).to be(true)
+          forwarder
+        end
+        described_class.start(options)
+      end
+    end
+  end
+end
+
+RSpec.describe Listen::Forwarder do
+  let(:logger) { instance_double(Logger) }
+  let(:listener) { instance_double(Listen::Listener) }
+
+  before do
+    allow(Logger).to receive(:new).and_return(logger)
+    allow(logger).to receive(:level=)
+    allow(logger).to receive(:formatter=)
+    allow(logger).to receive(:info)
+
+    allow(listener).to receive(:start)
+    allow(listener).to receive(:processing?).and_return false
+  end
+
+  it 'passes relative option to Listen' do
+    value = double('value')
+    expect(Listen).to receive(:to).
+      with(hash_including(relative: value)).
+      and_return(listener)
+
+    described_class.new(relative: value).start
+  end
+end