fluid_cli 0.1.2

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

@@ -0,0 +1,284 @@
+# frozen_string_literal: true
+
+include Listen
+
+RSpec.describe Directory do
+  def fake_file_stat(name, options = {})
+    defaults = { directory?: false }
+    instance_double(::File::Stat, name, defaults.merge(options))
+  end
+
+  def fake_dir_stat(name, options = {})
+    defaults = { directory?: true }
+    instance_double(::File::Stat, name, defaults.merge(options))
+  end
+
+  def fake_children(exception, dir, *args, &block)
+    if block_given?
+      exception.send(:allow, dir).to receive(:children, &block)
+    else
+      exception.send(:allow, dir).to receive(:children).and_return(*args)
+    end
+    exception.send(:allow, dir).to receive(:exist?).and_return(true)
+    exception.send(:allow, dir).to receive(:directory?).and_return(true)
+  end
+
+  let(:dir) { double(:dir) }
+  let(:file) { fake_path('file.rb') }
+  let(:file2) { fake_path('file2.rb') }
+  let(:subdir) { fake_path('subdir') }
+
+  let(:record) do
+    instance_double(
+      Record,
+      root: 'some_dir',
+      dir_entries: record_entries,
+      add_dir: true,
+      unset_path: true)
+  end
+
+  let(:snapshot) { instance_double(Change, record: record, invalidate: nil) }
+
+  before do
+    allow(dir).to receive(:+).with('.') { dir }
+    allow(dir).to receive(:+).with('file.rb') { file }
+    allow(dir).to receive(:+).with('subdir') { subdir }
+
+    allow(file).to receive(:relative_path_from).with(dir) { 'file.rb' }
+    allow(file2).to receive(:relative_path_from).with(dir) { 'file2.rb' }
+    allow(subdir).to receive(:relative_path_from).with(dir) { 'subdir' }
+
+    allow(Pathname).to receive(:new).with('some_dir').and_return(dir)
+    allow(Pathname).to receive(:new).with('.').and_return(dir)
+
+    allow(::File).to receive(:lstat) do |*args|
+      fail "Not stubbed: File.lstat(#{args.map(&:inspect) * ','})"
+    end
+  end
+
+  context '#scan with recursive off' do
+    let(:options) { { recursive: false } }
+
+    context 'with file & subdir in record' do
+      let(:record_entries) do
+        { 'file.rb' => { mtime: 1.1 }, 'subdir' => {} }.freeze
+      end
+
+      context 'with empty dir' do
+        before { fake_children(self, dir, []) }
+
+        it 'sets record dir path' do
+          expect(record).to receive(:add_dir).with('.')
+          described_class.scan(snapshot, '.', options)
+        end
+
+        it "snapshots changes for file path and dir that doesn't exist" do
+          expect(snapshot).to receive(:invalidate).with(:file, 'file.rb', {})
+
+          expect(snapshot).to receive(:invalidate).
+            with(:dir, 'subdir', { recursive: false })
+
+          described_class.scan(snapshot, '.', options)
+        end
+      end
+
+      context 'when subdir is removed' do
+        before do
+          fake_children(self, dir, [file])
+          allow(::File).to receive(:lstat).with('file.rb').
+            and_return(fake_file_stat('file.rb'))
+        end
+
+        it 'notices subdir does not exist' do
+          expect(snapshot).to receive(:invalidate).
+            with(:dir, 'subdir', { recursive: false })
+
+          described_class.scan(snapshot, '.', options)
+        end
+      end
+
+      context 'when file.rb removed' do
+        before do
+          fake_children(self, dir, [subdir])
+
+          allow(::File).to receive(:lstat).with('subdir').
+            and_return(fake_dir_stat('subdir'))
+        end
+
+        it 'notices file was removed' do
+          expect(snapshot).to receive(:invalidate).with(:file, 'file.rb', {})
+          described_class.scan(snapshot, '.', options)
+        end
+      end
+
+      context 'when file.rb no longer exists after scan' do
+        before do
+          fake_children(self, dir, [file], [file2])
+
+          allow(::File).to receive(:lstat).with('file.rb').
+            and_raise(Errno::ENOENT)
+
+          allow(::File).to receive(:lstat).with('file2.rb').
+            and_return(fake_file_stat('file2.rb'))
+        end
+
+        it 'rescans' do
+          expect(snapshot).to receive(:invalidate).with(:file, 'file2.rb', {})
+          described_class.scan(snapshot, '.', options)
+        end
+      end
+
+      context 'when file2.rb is added' do
+        before do
+          fake_children(self, dir, [file, file2, subdir])
+
+          allow(::File).to receive(:lstat).with('file.rb').
+            and_return(fake_file_stat('file.rb'))
+
+          allow(::File).to receive(:lstat).with('file2.rb').
+            and_return(fake_file_stat('file2.rb'))
+
+          allow(::File).to receive(:lstat).with('subdir').
+            and_return(fake_dir_stat('subdir'))
+        end
+
+        it 'notices file removed and file2 changed' do
+          expect(snapshot).to receive(:invalidate).with(:file, 'file2.rb', {})
+          described_class.scan(snapshot, '.', options)
+        end
+      end
+    end
+
+    context 'with empty record' do
+      let(:record_entries) { {} }
+
+      context 'with non-existing dir path' do
+        before { fake_children(self, dir) { fail Errno::ENOENT } }
+
+        it 'reports no changes' do
+          expect(snapshot).to_not receive(:invalidate)
+          described_class.scan(snapshot, '.', options)
+        end
+
+        it 'unsets record dir path' do
+          expect(record).to receive(:unset_path).with('.')
+          described_class.scan(snapshot, '.', options)
+        end
+      end
+
+      context 'when network share is disconnected' do
+        before { fake_children(self, dir) { fail Errno::EHOSTDOWN } }
+
+        it 'reports no changes' do
+          expect(snapshot).to_not receive(:invalidate)
+          described_class.scan(snapshot, '.', options)
+        end
+
+        it 'unsets record dir path' do
+          expect(record).to receive(:unset_path).with('.')
+          described_class.scan(snapshot, '.', options)
+        end
+      end
+
+      context 'with file.rb in dir' do
+        before do
+          fake_children(self, dir, [file])
+
+          allow(::File).to receive(:lstat).with('file.rb').
+            and_return(fake_file_stat('file.rb'))
+        end
+
+        it 'snapshots changes for file & file2 paths' do
+          expect(snapshot).to receive(:invalidate).
+            with(:file, 'file.rb', {})
+
+          expect(snapshot).to_not receive(:invalidate).
+            with(:file, 'file2.rb', {})
+
+          expect(snapshot).to_not receive(:invalidate).
+            with(:dir, 'subdir', recursive: false)
+
+          described_class.scan(snapshot, '.', options)
+        end
+      end
+    end
+  end
+
+  context '#scan with recursive on' do
+    let(:options) { { recursive: true } }
+
+    context 'with file.rb & subdir in record' do
+      let(:record_entries) do
+        { 'file.rb' => { mtime: 1.1 }, 'subdir' => {} }
+      end
+
+      context 'with empty dir' do
+        before { fake_children(self, dir, []) }
+
+        it 'snapshots changes for file & subdir path' do
+          expect(snapshot).to receive(:invalidate).with(:file, 'file.rb', {})
+
+          expect(snapshot).to receive(:invalidate).
+            with(:dir, 'subdir', { recursive: true })
+
+          described_class.scan(snapshot, '.', options)
+        end
+      end
+
+      context 'with subdir2 path present' do
+        let(:subdir2) { fake_path('subdir2', children: []) }
+
+        before do
+          fake_children(self, dir, [subdir2])
+          allow(subdir2).to receive(:relative_path_from).with(dir) { 'subdir2' }
+
+          allow(::File).to receive(:lstat).with('subdir2').
+            and_return(fake_dir_stat('subdir2'))
+        end
+
+        it 'snapshots changes for file, file2 & subdir paths' do
+          expect(snapshot).to receive(:invalidate).with(:file, 'file.rb', {})
+
+          expect(snapshot).to receive(:invalidate).
+            with(:dir, 'subdir', { recursive: true })
+
+          expect(snapshot).to receive(:invalidate).
+            with(:dir, 'subdir2', { recursive: true })
+
+          described_class.scan(snapshot, '.', options)
+        end
+      end
+    end
+
+    context 'with empty record' do
+      let(:record_entries) { {} }
+
+      context 'with non-existing dir' do
+        before do
+          fake_children(self, dir) { fail Errno::ENOENT }
+        end
+
+        it 'reports no changes' do
+          expect(snapshot).to_not receive(:invalidate)
+          described_class.scan(snapshot, '.', options)
+        end
+      end
+
+      context 'with subdir present in dir' do
+        before do
+          fake_children(self, dir, [subdir])
+          fake_children(self, subdir, [])
+          allow(::File).to receive(:lstat).with('subdir').
+            and_return(fake_dir_stat('subdir'))
+        end
+
+        it 'snapshots changes for subdir' do
+          expect(snapshot).to receive(:invalidate).
+            with(:dir, 'subdir', { recursive: true })
+
+          described_class.scan(snapshot, '.', options)
+        end
+      end
+    end
+  end
+end

data/vendor/deps/listen/spec/lib/listen/event/config_spec.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'listen/event/config'
+
+RSpec.describe Listen::Event::Config do
+  let(:listener) { instance_double(Listen::Listener) }
+  let(:event_queue) { instance_double(Listen::Event::Queue) }
+  let(:queue_optimizer) { instance_double(Listen::QueueOptimizer) }
+  let(:wait_for_delay) { 1.234 }
+
+  context 'with a given block' do
+    let(:myblock) { instance_double(Proc) }
+
+    subject do
+      described_class.new(
+        listener,
+        event_queue,
+        queue_optimizer,
+        wait_for_delay) do |*args|
+          myblock.call(*args)
+        end
+    end
+
+    it 'calls the block' do
+      expect(myblock).to receive(:call).with(:foo, :bar)
+      subject.call(:foo, :bar)
+    end
+
+    it 'is callable' do
+      expect(subject).to be_callable
+    end
+  end
+end

data/vendor/deps/listen/spec/lib/listen/event/loop_spec.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require 'thread'
+require 'listen/event/config'
+require 'listen/event/loop'
+
+RSpec.describe Listen::Event::Loop do
+  let(:config) { instance_double(Listen::Event::Config, 'config') }
+  let(:processor) { instance_double(Listen::Event::Processor, 'processor') }
+  let(:thread) { instance_double(Thread, 'thread') }
+
+  let(:reasons) { instance_double(::Queue, 'reasons') }
+  let(:ready) { instance_double(::Queue, 'ready') }
+
+  let(:blocks) do
+    {
+      thread_block: proc { fail 'thread block stub called' },
+    }
+  end
+
+  subject { described_class.new(config) }
+
+  # TODO: this is hideous
+  before do
+    allow(::Queue).to receive(:new).and_return(reasons, ready)
+    allow(Listen::Event::Processor).to receive(:new).with(config, reasons).
+      and_return(processor)
+
+    allow(Thread).to receive(:new) do |*args, &block|
+      fail 'Unstubbed call:'\
+        " Thread.new(#{args.map(&:inspect) * ','},&#{block.inspect})"
+    end
+
+    allow(config).to receive(:min_delay_between_events).and_return(1.234)
+
+    allow(thread).to receive(:name=)
+    allow(Thread).to receive(:new) do |*_, &block|
+      blocks[:thread_block] = block
+      thread
+    end
+
+    allow(Kernel).to receive(:sleep) do |*args|
+      fail "stub called: sleep(#{args.map(&:inspect) * ','})"
+    end
+  end
+
+  describe '#start' do
+    it 'is started' do
+      expect(processor).to receive(:loop_for).with(1.234)
+      expect(Thread).to receive(:new) do |&block|
+        block.call
+        thread
+      end
+      subject.start
+      expect(subject).to be_started
+    end
+
+    context 'when start is called again' do
+      it 'returns silently' do
+        expect(processor).to receive(:loop_for).with(1.234)
+        expect(Thread).to receive(:new) do |&block|
+          block.call
+          thread
+        end
+        subject.start
+        expect { subject.start }.to_not raise_exception
+      end
+    end
+
+    context 'when state change to :started takes longer than 5 seconds' do
+      before do
+        expect(Thread).to receive(:new) { thread }
+        expect_any_instance_of(::ConditionVariable).to receive(:wait) { } # return immediately
+      end
+
+      it 'raises Error::NotStarted' do
+        expect do
+          subject.start
+        end.to raise_exception(::Listen::Error::NotStarted, "thread didn't start in 5.0 seconds (in state: :starting)")
+      end
+    end
+  end
+
+  context 'when set up / started' do
+    before do
+      allow(thread).to receive(:alive?).and_return(true)
+      allow(config).to receive(:min_delay_between_events).and_return(1.234)
+
+      allow(processor).to receive(:loop_for).with(1.234)
+
+      expect(Thread).to receive(:new) do |&block|
+        block.call
+        thread
+      end
+
+      subject.start
+    end
+
+    describe '#stop' do
+      before do
+        allow(thread).to receive(:join)
+      end
+
+      it 'frees the thread' do
+        subject.stop
+      end
+
+      it 'waits for the thread to finish' do
+        expect(thread).to receive(:join)
+        subject.stop
+      end
+
+      it 'sets the reason for waking up' do
+        subject.stop
+      end
+    end
+  end
+end

data/vendor/deps/listen/spec/lib/listen/event/processor_spec.rb

@@ -0,0 +1,250 @@
+# frozen_string_literal: true
+
+require 'listen/event/processor'
+require 'listen/event/config'
+
+RSpec.describe Listen::Event::Processor do
+  let(:event_queue) { instance_double(::Queue, 'event_queue') }
+  let(:event) { instance_double(::Array, 'event') }
+  let(:listener) { instance_double(Listen::Listener, 'listener') }
+  let(:config) { instance_double(Listen::Event::Config, 'config', listener: listener) }
+  let(:reasons) { instance_double(::Queue, 'reasons') }
+
+  subject { described_class.new(config, reasons) }
+
+  # This is to simulate events over various points in time
+  let(:sequence) do
+    {}
+  end
+
+  let(:state) do
+    { monotonic_time: 0.0 }
+  end
+
+  def status_for_time(time)
+    # find the status of the listener for a given point in time
+    previous_state_timestamps = sequence.keys.reject { |k| k > time }
+    last_state_before_given_time = previous_state_timestamps.max
+    sequence[last_state_before_given_time]
+  end
+
+  before do
+    allow(config).to receive(:event_queue).and_return(event_queue)
+
+    allow(listener).to receive(:stopped?) do
+      status_for_time(state[:monotonic_time]) == :stopped
+    end
+
+    allow(listener).to receive(:paused?) do
+      status_for_time(state[:monotonic_time]) == :paused
+    end
+
+    allow(Listen::MonotonicTime).to receive(:now) do
+      state[:monotonic_time]
+    end
+  end
+
+  describe '#loop_for' do
+    before do
+      allow(reasons).to receive(:empty?).and_return(true)
+    end
+
+    context 'when stopped' do
+      before do
+        sequence[0.0] = :stopped
+      end
+
+      context 'with pending changes' do
+        before do
+          allow(event_queue).to receive(:empty?).and_return(false)
+        end
+
+        it 'does not change the event queue' do
+          expect(event_queue).to receive(:pop).and_return(event)
+          subject.loop_for(1)
+        end
+
+        it 'does not sleep' do
+          expect(config).to_not receive(:sleep)
+          expect(event_queue).to receive(:pop).and_return(event)
+          t = Listen::MonotonicTime.now
+          subject.loop_for(1)
+          diff = Listen::MonotonicTime.now - t
+          expect(diff).to be < 0.02
+        end
+      end
+    end
+
+    context 'when not stopped' do
+      before do
+        allow(event_queue).to receive(:empty?).and_return(true)
+      end
+
+      context 'when initially paused' do
+        before do
+          sequence[0.0] = :paused
+        end
+
+        context 'when stopped after sleeping' do
+          before do
+            sequence[0.2] = :stopped
+          end
+
+          it 'sleeps, waiting to be woken up' do
+            expect(config).to receive(:sleep).once { state[:monotonic_time] = 0.6 }
+            expect(event_queue).to receive(:pop).and_return(event)
+            subject.loop_for(1)
+          end
+
+          it 'breaks' do
+            expect(event_queue).to receive(:pop).and_return(event)
+            allow(config).to receive(:sleep).once { state[:monotonic_time] = 0.6 }
+            expect(config).to_not receive(:call)
+            subject.loop_for(1)
+          end
+        end
+
+        context 'when still paused after sleeping' do
+          context 'when there were no events before' do
+            before do
+              sequence[1.0] = :stopped
+            end
+
+            it 'sleeps for latency to possibly later optimize some events' do
+              # pretend we were woken up at 0.6 seconds since start
+              allow(config).to receive(:sleep).
+                with(anything) { |*_args| state[:monotonic_time] += 0.6 }
+
+              # pretend we slept for latency (now: 1.6 seconds since start)
+              allow(config).to receive(:sleep).
+                with(1.0) { |*_args| state[:monotonic_time] += 1.0 }
+
+              expect(event_queue).to receive(:pop).and_return(event)
+              subject.loop_for(1)
+            end
+          end
+
+          context 'when there were no events for ages' do
+            before do
+              sequence[3.5] = :stopped # in the future to break from the loop
+            end
+
+            it 'still does not process events because it is paused' do
+              # pretend we were woken up at 0.6 seconds since start
+              allow(config).to receive(:sleep).
+                with(anything) { |*_args| state[:monotonic_time] += 2.0 }
+
+              # second loop starts here (no sleep, coz recent events, but no
+              # processing coz paused
+
+              # pretend we were woken up at 3.6 seconds since start
+              allow(listener).to receive(:wait_for_state).
+                with(:initializing, :backend_started, :processing_events, :stopped) do |*_args|
+                state[:monotonic_time] += 3.0
+                raise ScriptError, 'done'
+              end
+
+              expect(event_queue).to receive(:pop).and_return(event)
+              expect { subject.loop_for(1) }.to raise_exception(ScriptError, 'done')
+            end
+          end
+        end
+      end
+
+      context 'when initially processing' do
+        before do
+          sequence[0.0] = :processing
+        end
+
+        context 'when event queue is empty' do
+          before do
+            allow(event_queue).to receive(:empty?).and_return(true)
+          end
+
+          context 'when stopped after sleeping' do
+            before do
+              sequence[0.2] = :stopped
+            end
+
+            it 'sleeps, waiting to be woken up' do
+              expect(event_queue).to receive(:pop).and_return(event)
+              expect(config).to receive(:sleep).
+                once { |*_args| state[:monotonic_time] = 0.6 }
+
+              subject.loop_for(1)
+            end
+
+            it 'breaks' do
+              allow(config).to receive(:sleep).
+                once { |*_args| state[:monotonic_time] = 0.6 }
+
+              expect(config).to_not receive(:call)
+              expect(event_queue).to receive(:pop).and_return(event)
+              subject.loop_for(1)
+            end
+          end
+        end
+
+        context 'when event queue has events' do
+          context 'when there were events ages ago' do
+            before do
+              sequence[3.5] = :stopped # in the future to break from the loop
+            end
+
+            it 'processes events' do
+              allow(event_queue).to receive(:empty?).
+                and_return(false, false, true)
+
+              # resets latency check
+              expect(config).to receive(:callable?).and_return(true)
+
+              change = [:file, :modified, 'foo', 'bar']
+              resulting_changes = { modified: ['foo'], added: [], removed: [] }
+              allow(event_queue).to receive(:pop).and_return(change).exactly(4)
+
+              allow(config).to receive(:optimize_changes).with([change, change, change]).
+                and_return(resulting_changes)
+
+              final_changes = [['foo'], [], []]
+              allow(config).to receive(:call) do |*changes|
+                state[:monotonic_time] = 4.0 # stopped
+                expect(changes).to eq(final_changes)
+              end
+
+              allow(listener).to receive(:wait_for_state).
+                with(:initializing, :backend_started, :processing_events, :stopped)
+
+              subject.instance_variable_set(:@_remember_time_of_first_unprocessed_event, -3)
+              subject.loop_for(1)
+            end
+          end
+        end
+      end
+    end
+  end
+
+  describe '_process_changes' do
+    context 'when it raises an exception derived from StandardError' do
+      before do
+        allow(event_queue).to receive(:empty?).and_return(true)
+        allow(config).to receive(:callable?).and_return(true)
+        resulting_changes = { modified: ['foo'], added: [], removed: [] }
+        allow(config).to receive(:optimize_changes).with(anything).and_return(resulting_changes)
+        expect(config).to receive(:call).and_raise(ArgumentError, "bang!")
+        expect(config).to receive(:call).and_return(nil)
+        expect(config).to receive(:call).and_raise("error!")
+      end
+
+      it 'rescues and logs exception and continues' do
+        expect(Listen.logger).to receive(:error).with(/Exception rescued in _process_changes:\nArgumentError: bang!/)
+        expect(Listen.logger).to receive(:error).with(/Exception rescued in _process_changes:\nRuntimeError: error!/)
+        expect(Listen.logger).to receive(:debug).with(/Callback \(exception\) took/)
+        expect(Listen.logger).to receive(:debug).with(/Callback took/)
+        expect(Listen.logger).to receive(:debug).with(/Callback \(exception\) took/)
+        subject.send(:_process_changes, event)
+        subject.send(:_process_changes, event)
+        subject.send(:_process_changes, event)
+      end
+    end
+  end
+end