fluid_cli 0.1.2

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

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

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

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

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