fluid_cli 0.1.5 → 0.1.6

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

@@ -1,284 +0,0 @@
-# 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

@@ -1,33 +0,0 @@
-# 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

@@ -1,118 +0,0 @@
-# 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

@@ -1,250 +0,0 @@
-# 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