fluid_cli 0.1.4 → 0.1.6

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

@@ -1,118 +0,0 @@
-# frozen_string_literal: true
-
-require 'listen/event/queue'
-
-# TODO: not part of listener really
-RSpec.describe Listen::Event::Queue do
-  let(:queue) { instance_double(Thread::Queue, 'my queue') }
-
-  let(:config) { instance_double(Listen::Event::Queue::Config) }
-
-  let(:relative) { false }
-
-  subject { described_class.new(config) }
-
-  before do
-    allow(config).to receive(:relative?).and_return(relative)
-    allow(Thread::Queue).to receive(:new).and_return(queue)
-  end
-
-  describe '#empty?' do
-    before do
-      allow(queue).to receive(:empty?).and_return(empty)
-    end
-
-    context 'when empty' do
-      let(:empty) { true }
-      it { is_expected.to be_empty }
-    end
-
-    context 'when not empty' do
-      let(:empty) { false }
-      let(:watched_dir) { fake_path('watched_dir') }
-      before do
-        allow(queue).to receive(:empty?).and_return(false)
-      end
-      it { is_expected.to_not be_empty }
-    end
-  end
-
-  describe '#pop' do
-    before do
-      allow(queue).to receive(:pop).and_return('foo')
-    end
-
-    context 'when empty' do
-      let(:value) { 'foo' }
-      it 'forward the call to the queue' do
-        expect(subject.pop).to eq('foo')
-      end
-    end
-  end
-
-  describe '#<<' do
-    let(:watched_dir) { fake_path('watched_dir') }
-    before do
-      allow(queue).to receive(:<<)
-    end
-
-    context 'when relative option is true' do
-      let(:relative) { true }
-
-      context 'when watched dir is the current dir' do
-        let(:options) { { relative: true, directories: Pathname.pwd } }
-
-        let(:dir_rel_path) { fake_path('.') }
-        let(:foo_rel_path) { fake_path('foo', exist?: true) }
-
-        it 'registers relative paths' do
-          allow(dir_rel_path).to receive(:+).with('foo') { foo_rel_path }
-
-          allow(watched_dir).to receive(:relative_path_from).
-            with(Pathname.pwd).
-            and_return(dir_rel_path)
-
-          expect(queue).to receive(:<<).
-            with([:file, :modified, dir_rel_path, 'foo', {}])
-
-          subject.<<([:file, :modified, watched_dir, 'foo', {}])
-        end
-      end
-
-      context 'when watched dir is not the current dir' do
-        let(:options) { { relative: true } }
-        let(:dir_rel_path) { fake_path('..') }
-        let(:foo_rel_path) { fake_path('../foo', exist?: true) }
-
-        it 'registers relative path' do
-          allow(watched_dir).to receive(:relative_path_from).
-            with(Pathname.pwd).
-            and_return(dir_rel_path)
-
-          expect(queue).to receive(:<<).
-            with([:file, :modified, dir_rel_path, 'foo', {}])
-
-          subject.<<([:file, :modified, watched_dir, 'foo', {}])
-        end
-      end
-
-      context 'when watched dir is on another drive' do
-        let(:watched_dir) { fake_path('watched_dir', realpath: 'd:/foo') }
-        let(:foo_rel_path) { fake_path('d:/foo', exist?: true) }
-
-        it 'registers full path' do
-          allow(watched_dir).to receive(:relative_path_from).
-            with(Pathname.pwd).
-            and_raise(ArgumentError)
-
-          allow(watched_dir).to receive(:+).with('foo') { foo_rel_path }
-
-          expect(queue).to receive(:<<).
-            with([:file, :modified, watched_dir, 'foo', {}])
-
-          subject.<<([:file, :modified, watched_dir, 'foo', {}])
-        end
-      end
-    end
-  end
-end

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

@@ -1,254 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Listen::File do
-  let(:record) do
-    instance_double(
-      Listen::Record,
-      root: '/foo/bar',
-      file_data: record_data,
-      add_dir: true,
-      update_file: true,
-      unset_path: true
-    )
-  end
-
-  let(:path) { Pathname.pwd }
-  let(:subject) { described_class.change(record, 'file.rb') }
-
-  around { |example| fixtures { example.run } }
-
-  before { allow(::File).to receive(:lstat) { fail 'Not stubbed!' } }
-
-  describe '#change' do
-    let(:expected_data) do
-      { mtime: kind_of(Float), mode: kind_of(Integer), size: kind_of(Integer) }
-    end
-
-    context 'with file record' do
-      let(:record_mtime) { nil }
-      let(:record_sha) { nil }
-      let(:record_mode) { nil }
-      let(:record_size) { nil }
-
-      let(:record_data) do
-        { mtime: record_mtime, sha: record_sha, mode: record_mode, size: record_size }
-      end
-
-      context 'with non-existing file' do
-        before { allow(::File).to receive(:lstat) { fail Errno::ENOENT } }
-
-        it { is_expected.to eq(:removed) }
-
-        it 'sets path in record' do
-          expect(record).to receive(:unset_path).with('file.rb')
-          subject
-        end
-      end
-
-      context 'with existing file' do
-        let(:stat_mtime) { Time.now.to_f - 1234.567 }
-        let(:stat_ctime) { Time.now.to_f - 1234.567 }
-        let(:stat_atime) { Time.now.to_f - 1234.567 }
-        let(:stat_mode) { 0640 }
-
-        let(:record_size) { 42 }
-        let(:stat_size) { record_size }
-
-        let(:sha) { fail 'stub me (sha)' }
-
-        let(:stat) do
-          instance_double(
-            File::Stat,
-            mtime: stat_mtime,
-            atime: stat_atime,
-            ctime: stat_ctime,
-            mode: stat_mode,
-            size: stat_size
-          )
-        end
-
-        before do
-          allow(::File).to receive(:lstat) { stat }
-          allow(Digest::SHA256).to receive(:file) { double(:sha, digest: sha) }
-        end
-
-        context 'with different mode in record' do
-          let(:record_mode) { 0722 }
-
-          it { should be :modified }
-
-          it 'sets path in record with expected data' do
-            expect(record).to receive(:update_file).
-              with('file.rb', expected_data)
-            subject
-          end
-        end
-
-        context 'with same mode in record' do
-          let(:record_mode) { stat_mode }
-
-          # e.g. file was overwritten by earlier copy
-          context 'with earlier mtime than in record' do
-            let(:record_mtime) { stat_mtime.to_f - 123.45 }
-
-            it { should be :modified }
-
-            it 'sets path in record with expected data' do
-              expect(record).to receive(:update_file).
-                with('file.rb', expected_data)
-              subject
-            end
-          end
-
-          context 'with later mtime than in record' do
-            let(:record_mtime) { stat_mtime.to_f + 123.45 }
-
-            it { should be :modified }
-
-            it 'sets path in record with expected data' do
-              expect(record).to receive(:update_file).
-                with('file.rb', expected_data)
-              subject
-            end
-          end
-
-          context 'with identical mtime in record' do
-            let(:record_mtime) { stat_mtime.to_f }
-
-            context 'with accurate stat times' do
-              let(:stat_mtime) { Time.at(1_401_235_714.123).utc }
-              let(:stat_atime) { Time.at(1_401_235_714.123).utc }
-              let(:stat_ctime) { Time.at(1_401_235_714.123).utc }
-              let(:record_mtime) { stat_mtime.to_f }
-              it { should be_nil }
-            end
-
-            context 'with inaccurate stat times' do
-              let(:stat_mtime) { Time.at(1_401_235_714.0).utc }
-              let(:stat_atime) { Time.at(1_401_235_714.0).utc }
-              let(:stat_ctime) { Time.at(1_401_235_714.0).utc }
-
-              let(:record_mtime) { stat_mtime.to_f }
-
-              context 'with real mtime barely not within last second' do
-                before { allow(Time).to receive(:now) { now } }
-
-                # NOTE: if real mtime is ???14.99, the
-                # saved mtime is ???14.0
-                let(:now) { Time.at(1_401_235_716.00).utc }
-                it { should be_nil }
-              end
-
-              context 'with real mtime barely within last second' do
-                # NOTE: real mtime is in range (???14.0 .. ???14.999),
-                # so saved mtime at ???14.0 means it could be
-                # ???14.999, so ???15.999 could still be within 1 second
-                # range
-                let(:now) { Time.at(1_401_235_715.999999).utc }
-
-                before { allow(Time).to receive(:now) { now } }
-
-                context 'without available sha' do
-                  let(:sha) { fail Errno::ENOENT }
-
-                  # Treat it as a removed file, because chances are ...
-                  # whatever is listening for changes won't be able to deal
-                  # with the file either (e.g. because of permissions)
-                  it { should be :removed }
-
-                  it 'should not unset record' do
-                    expect(record).to_not receive(:unset_path)
-                  end
-                end
-
-                context 'with available sha' do
-                  let(:sha) { 'd41d8cd98f00b204e9800998ecf8427e' }
-
-                  context 'with same sha in record' do
-                    let(:record_sha) { sha }
-                    it { should be_nil }
-                  end
-
-                  context 'with no sha in record' do
-                    let(:record_sha) { nil }
-                    it { should be_nil }
-                  end
-
-                  context 'with different sha in record' do
-                    let(:record_sha) { 'foo' }
-                    it { should be :modified }
-
-                    it 'sets path in record with expected data' do
-                      expected = expected_data.merge(sha: sha)
-                      expect(record).to receive(:update_file).
-                        with('file.rb', expected)
-                      subject
-                    end
-                  end
-                end
-              end
-            end
-          end
-        end
-      end
-    end
-
-    context 'with empty record' do
-      let(:record_data) { {} }
-
-      context 'with existing path' do
-        let(:stat) do
-          instance_double(
-            File::Stat,
-            mtime: 1234,
-            mode: 0645,
-            size: 0
-          )
-        end
-
-        before do
-          allow(::File).to receive(:lstat) { stat }
-        end
-
-        it 'returns added' do
-          expect(subject).to eq :added
-        end
-
-        it 'sets path in record with expected data' do
-          expect(record).to receive(:update_file).
-            with('file.rb', expected_data)
-          subject
-        end
-      end
-    end
-  end
-
-  describe '#inaccurate_mac_time?' do
-    let(:stat) do
-      instance_double(File::Stat, mtime: mtime, atime: atime, ctime: ctime, size: 0)
-    end
-
-    subject { Listen::File.inaccurate_mac_time?(stat) }
-
-    context 'with no accurate times' do
-      let(:mtime) { Time.at(1_234_567.0).utc }
-      let(:atime) { Time.at(1_234_567.0).utc }
-      let(:ctime) { Time.at(1_234_567.0).utc }
-      it { should be_truthy }
-    end
-
-    context 'with all accurate times' do
-      let(:mtime) { Time.at(1_234_567.89).utc }
-      let(:atime) { Time.at(1_234_567.89).utc }
-      let(:ctime) { Time.at(1_234_567.89).utc }
-      it { should be_falsey }
-    end
-
-    context 'with one accurate time' do
-      let(:mtime) { Time.at(1_234_567.0).utc }
-      let(:atime) { Time.at(1_234_567.89).utc }
-      let(:ctime) { Time.at(1_234_567.0).utc }
-      it { should be_falsey }
-    end
-  end
-end

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

@@ -1,147 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Listen::FSM do
-  context 'simple FSM' do
-    class SpecSimpleFsm
-      include Listen::FSM
-
-      attr_reader :entered_started
-
-      start_state :initial
-
-      state :started, to: :stopped do
-        @entered_started = true
-      end
-
-      state :failed, to: :stopped
-
-      state :stopped
-
-      def start
-        transition(:started)
-      end
-
-      def stop
-        transition(:stopped)
-      end
-
-      def fail
-        transition(:failed)
-      end
-
-      def initialize
-        initialize_fsm
-      end
-    end
-
-    subject(:fsm) { SpecSimpleFsm.new }
-
-    it 'starts in start_state' do
-      expect(subject.state).to eq(:initial)
-    end
-
-    it 'allows transitions' do
-      subject.start
-      expect(subject.state).to eq(:started)
-      expect(subject.entered_started).to eq(true)
-    end
-
-    it 'raises on disallowed transitions' do
-      subject.fail
-      expect do
-        subject.start
-      end.to raise_exception(ArgumentError,
-                             "SpecSimpleFsm can't change state from 'failed' to 'started', only to: stopped")
-      expect(subject.state).to eq(:failed)
-      expect(subject.entered_started).to eq(nil)
-    end
-
-    it 'declares transition and transition! private' do
-      expect { subject.transition(:started) }.to raise_exception(NoMethodError, /private.*transition/)
-      expect { subject.transition!(:started) }.to raise_exception(NoMethodError, /private.*transition!/)
-    end
-
-    describe '#wait_for_state' do
-      it 'returns truthy immediately if already in the desired state' do
-        expect(subject.instance_variable_get(:@state_changed)).to_not receive(:wait)
-        result = subject.wait_for_state(:initial)
-        expect(result).to be_truthy
-      end
-
-      it 'waits for the next state change and returns truthy if then in the desired state' do
-        expect(subject.instance_variable_get(:@state_changed)).to receive(:wait).with(anything, anything) do
-          subject.instance_variable_set(:@state, :started)
-        end
-        result = subject.wait_for_state(:started)
-        expect(result).to be_truthy
-      end
-
-      it 'waits for the next state change and returns falsey if then not the desired state' do
-        expect(subject.instance_variable_get(:@state_changed)).to receive(:wait).with(anything, anything)
-        result = subject.wait_for_state(:started)
-        expect(result).to be_falsey
-      end
-
-      it 'passes the timeout: down to wait, if given' do
-        expect(subject.instance_variable_get(:@state_changed)).to receive(:wait).with(anything, 5.0)
-        subject.wait_for_state(:started, timeout: 5.0)
-      end
-
-      it 'passes nil (infinite) timeout: down to wait, if none given' do
-        expect(subject.instance_variable_get(:@state_changed)).to receive(:wait).with(anything, nil)
-        subject.wait_for_state(:started)
-      end
-
-      it 'enforces precondition that states must be symbols' do
-        expect do
-          subject.wait_for_state(:started, 'stopped')
-        end.to raise_exception(ArgumentError, /states must be symbols .*got "stopped"/)
-      end
-    end
-  end
-
-  context 'FSM with no start state' do
-    class SpecFsmWithNoStartState
-      include Listen::FSM
-
-      state :started, to: :stopped
-
-      state :failed, to: :stopped
-
-      state :stopped
-
-      def initialize
-        initialize_fsm
-      end
-    end
-
-    subject(:fsm) { SpecFsmWithNoStartState.new }
-
-    it 'raises ArgumentError on new' do
-      expect { subject }.to raise_exception(ArgumentError,
-                                            /`start_state :<state>` must be declared before `new`/)
-    end
-  end
-
-  context 'FSM with string state name' do
-    subject(:fsm) do
-      instance_exec do
-        class SpecFsmWithStringState
-          include Listen::FSM
-
-          state 'started', to: 'stopped'
-
-          state 'stopped'
-
-          def initialize
-            initialize_fsm
-          end
-        end
-      end
-    end
-
-    it 'raises ArgumentError on new' do
-      expect { subject }.to raise_exception(ArgumentError, /state name must be a Symbol/)
-    end
-  end
-end

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

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-require 'listen/listener/config'
-RSpec.describe Listen::Listener::Config do
-  describe 'options' do
-    context 'custom options' do
-      subject do
-        described_class.new(
-          latency: 1.234,
-          wait_for_delay: 0.85,
-          force_polling: true,
-          relative: true)
-      end
-
-      it 'extracts adapter options' do
-        klass = Class.new do
-          DEFAULTS = { latency: 5.4321 }.freeze
-        end
-        expected = { latency: 1.234 }
-        expect(subject.adapter_instance_options(klass)).to eq(expected)
-      end
-
-      it 'extract adapter selecting options' do
-        expected = { force_polling: true, polling_fallback_message: nil }
-        expect(subject.adapter_select_options).to eq(expected)
-      end
-    end
-  end
-end