fluid_cli 0.1.2

data/vendor/deps/listen/spec/acceptance/listen_spec.rb

@@ -0,0 +1,320 @@
+# frozen_string_literal: true
+
+RSpec.describe 'Listen', acceptance: true do
+  let(:base_options) { { latency: 0.1 } }
+  let(:polling_options) { {} }
+  let(:options) { {} }
+  let(:all_options) { base_options.merge(polling_options).merge(options) }
+
+  let(:wrapper) { setup_listener(all_options, :track_changes) }
+
+  context 'with normal start/stop' do
+    before { wrapper.listener.start }
+    after { wrapper.listener.stop }
+
+    subject { wrapper }
+
+    context 'with one listen dir' do
+      let(:paths) { Pathname.new(Dir.pwd) }
+      around { |example| fixtures { example.run } }
+
+      modes =
+        case ENV['TEST_LISTEN_ADAPTER_MODES']
+        when 'polling'
+          [true]
+        when 'native'
+          [false]
+        else
+          [false, true]
+        end
+
+      # TODO: make it configurable
+      # TODO: restore
+      modes.each do |polling|
+        context "force_polling option to #{polling}" do
+          let(:polling_options) { { force_polling: polling } }
+
+          if polling
+            context 'when polling' do
+              context 'with a large latency' do
+                let(:options) { { latency: 10 } }
+                it 'passes the latency option correctly' do
+                  expect(subject).to_not process_addition_of('file.rb')
+                end
+              end
+            end
+          else
+            unless darwin?
+              context 'when driver does not support option' do
+                let(:options) { { latency: 10 } }
+                it 'does not pass the latency option' do
+                  expect(subject).to process_addition_of('file.rb')
+                end
+              end
+            end
+          end
+
+          context 'with default ignore options' do
+            context 'with nothing in listen dir' do
+              it { is_expected.to process_addition_of('file.rb') }
+              it { is_expected.to process_addition_of('.hidden') }
+
+              it 'listens to multiple files addition' do
+                result = wrapper.listen do
+                  change_fs(:added, 'file1.rb')
+                  change_fs(:added, 'file2.rb')
+                end
+
+                expect(result).to eq(modified: [],
+                                     added: %w[file1.rb file2.rb],
+                                     removed: [])
+              end
+
+              it 'listens to file moved inside' do
+                touch '../file.rb'
+                expect(wrapper.listen do
+                  mv '../file.rb', 'file.rb'
+                end).to eq(modified: [], added: ['file.rb'], removed: [])
+              end
+            end
+
+            context 'existing file.rb in listen dir' do
+              around do |example|
+                change_fs(:added, 'file.rb')
+                example.run
+              end
+
+              it { is_expected.to process_modification_of('file.rb') }
+              it { is_expected.to process_removal_of('file.rb') }
+
+              it 'listens to file.rb moved out' do
+                expect(wrapper.listen do
+                  mv 'file.rb', '../file.rb'
+                end).to eq(modified: [], added: [], removed: ['file.rb'])
+              end
+
+              it 'listens to file mode change' do
+                prev_mode = File.stat('file.rb').mode
+
+                result = wrapper.listen do
+                  windows? ? `attrib +r file.rb` : chmod(0444, 'file.rb')
+                end
+
+                new_mode = File.stat('file.rb').mode
+                no_event = result[:modified].empty? && prev_mode == new_mode
+
+                # Check if chmod actually works or an attrib event happens,
+                # or expect nothing otherwise
+                #
+                # (e.g. fails for polling+vfat on Linux, but works with
+                # INotify+vfat because you get an event regardless if mode
+                # actually changes)
+                #
+                files = no_event ? [] : ['file.rb']
+
+                expect(result).to eq(modified: files, added: [], removed: [])
+              end
+            end
+
+            context 'hidden file in listen dir' do
+              around do |example|
+                change_fs(:added, '.hidden')
+                example.run
+              end
+
+              it { is_expected.to process_modification_of('.hidden') }
+            end
+
+            context 'dir in listen dir' do
+              around do |example|
+                mkdir_p 'dir'
+                example.run
+              end
+
+              it { is_expected.to process_addition_of('dir/file.rb') }
+            end
+
+            context 'dir with file in listen dir' do
+              around do |example|
+                mkdir_p 'dir'
+                touch 'dir/file.rb'
+                example.run
+              end
+
+              it 'listens to file move' do
+                expected = { modified: [],
+                             added: %w[file.rb],
+                             removed: %w[dir/file.rb] }
+
+                expect(wrapper.listen do
+                  mv 'dir/file.rb', 'file.rb'
+                end).to eq expected
+              end
+            end
+
+            context 'two dirs with files in listen dir' do
+              around do |example|
+                mkdir_p 'dir1'
+                touch 'dir1/file1.rb'
+                mkdir_p 'dir2'
+                touch 'dir2/file2.rb'
+                example.run
+              end
+
+              it 'listens to multiple file moves' do
+                expected = {
+                  modified: [],
+                  added: ['dir1/file2.rb', 'dir2/file1.rb'],
+                  removed: ['dir1/file1.rb', 'dir2/file2.rb']
+                }
+
+                expect(wrapper.listen do
+                  mv 'dir1/file1.rb', 'dir2/file1.rb'
+                  mv 'dir2/file2.rb', 'dir1/file2.rb'
+                end).to eq expected
+              end
+
+              it 'listens to dir move' do
+                expected = { modified: [],
+                             added: ['dir2/dir1/file1.rb'],
+                             removed: ['dir1/file1.rb'] }
+
+                expect(wrapper.listen do
+                  mv 'dir1', 'dir2/'
+                end).to eq expected
+              end
+            end
+
+            context 'listens to subdirectory removed' do
+              around do |example|
+                mkdir_p 'dir1'
+                mkdir_p 'dir1/subdir1'
+                mkdir_p 'dir1/subdir1/subdir2'
+                touch 'dir1/subdir1/file.rb'
+                touch 'dir1/subdir1/subdir2/file.rb'
+                example.run
+              end
+
+              it 'listen to the files of a removed directory' do
+                expected = {
+                  modified: [],
+                  added:    [],
+                  removed:  %w[dir1/subdir1/file.rb dir1/subdir1/subdir2/file.rb]
+                }
+
+                expect(wrapper.listen do
+                  rm_rf 'dir1'
+                end).to eq expected
+              end
+            end
+
+            context 'listens to sub-subdirectory removed' do
+              around do |example|
+                mkdir_p 'dir1'
+                mkdir_p 'dir1/subdir1'
+                mkdir_p 'dir1/subdir1/subdir2'
+                touch 'dir1/subdir1/file.rb'
+                touch 'dir1/subdir1/subdir2/file.rb'
+                example.run
+              end
+
+              it 'listen to the files of a removed directory' do
+                expected = {
+                  modified: [],
+                  added:    [],
+                  removed:  %w[dir1/subdir1/file.rb dir1/subdir1/subdir2/file.rb]
+                }
+
+                expect(wrapper.listen do
+                  rm_rf 'dir1/subdir1'
+                end).to eq expected
+              end
+            end
+
+            context 'with .bundle dir ignored by default' do
+              around do |example|
+                mkdir_p '.bundle'
+                example.run
+              end
+
+              it { is_expected.not_to process_addition_of('.bundle/file.rb') }
+            end
+          end
+
+          context 'when :ignore is *ignored_dir*' do
+            context 'ignored dir with file in listen dir' do
+              let(:options) { { ignore: /ignored_dir/ } }
+
+              around do |example|
+                mkdir_p 'ignored_dir'
+                example.run
+              end
+
+              it { is_expected.not_to process_addition_of('ignored_dir/file.rb') }
+            end
+
+            context 'when :only is *.rb' do
+              let(:options) { { only: /\.rb$/ } }
+
+              it { is_expected.to process_addition_of('file.rb') }
+              it { is_expected.not_to process_addition_of('file.txt') }
+            end
+
+            context 'when :ignore is bar.rb' do
+              context 'when :only is *.rb' do
+                let(:options) { { ignore: /bar\.rb$/, only: /\.rb$/ } }
+
+                it { is_expected.to process_addition_of('file.rb') }
+                it { is_expected.not_to process_addition_of('file.txt') }
+                it { is_expected.not_to process_addition_of('bar.rb') }
+              end
+            end
+
+            context 'when default ignore is *.rb' do
+              let(:options) { { ignore: /\.rb$/ } }
+
+              it { is_expected.not_to process_addition_of('file.rb') }
+
+              context 'with #ignore on *.txt mask' do
+                before { wrapper.listener.ignore(/\.txt/) }
+
+                it { is_expected.not_to process_addition_of('file.rb') }
+                it { is_expected.not_to process_addition_of('file.txt') }
+              end
+
+              context 'with #ignore! on *.txt mask' do
+                before { wrapper.listener.ignore!(/\.txt/) }
+
+                it { is_expected.to process_addition_of('file.rb') }
+                it { is_expected.not_to process_addition_of('file.txt') }
+              end
+            end
+          end
+        end
+      end
+    end
+
+    context 'with paths set' do
+      let(:paths) { Pathname.new(Dir.pwd) }
+
+      it 'allows extra calls to stop' do
+        wrapper.listener.stop
+        wrapper.listener.stop
+      end
+    end
+  end
+
+  context 'when never started' do
+    let(:paths) { Pathname.new(Dir.pwd) }
+
+    it 'allows stop' do
+      wrapper.listener.stop
+    end
+
+    it 'extra calls to stop' do
+      wrapper.listener.stop
+      wrapper.listener.stop
+      wrapper.listener.stop
+    end
+  end
+end

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

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+RSpec.describe Listen::Adapter::Base do
+  class FakeAdapter < described_class
+    def initialize(config)
+      @my_callbacks = {}
+      super
+    end
+
+    def _run
+      fail NotImplementedError
+    end
+
+    def _configure(dir, &callback)
+      @my_callbacks[dir.to_s] = callback
+    end
+
+    def fake_event(event)
+      dir = event[:dir]
+      @my_callbacks[dir].call(event)
+    end
+
+    def _process_event(dir, event)
+      _queue_change(:file, dir, event[:file], cookie: event[:cookie])
+    end
+  end
+
+  let(:thread) { instance_double(Thread, "thread") }
+  let(:dir1) { instance_double(Pathname, 'dir1', to_s: '/foo/dir1') }
+
+  let(:config) { instance_double(Listen::Adapter::Config) }
+  let(:queue) { instance_double(Queue) }
+  let(:silencer) { instance_double(Listen::Silencer) }
+  let(:adapter_options) { {} }
+
+  let(:snapshot) { instance_double(Listen::Change) }
+  let(:record) { instance_double(Listen::Record) }
+
+  subject { FakeAdapter.new(config) }
+
+  before do
+    allow(config).to receive(:directories).and_return([dir1])
+    allow(config).to receive(:queue).and_return(queue)
+    allow(config).to receive(:silencer).and_return(silencer)
+    allow(config).to receive(:adapter_options).and_return(adapter_options)
+
+    allow(Thread).to receive(:new) do |&block|
+      block.call
+      allow(thread).to receive(:name=)
+      thread
+    end
+
+    # Stuff that happens in configure()
+    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)
+  end
+
+  describe '#start' do
+    before do
+      allow(subject).to receive(:_run)
+
+      allow(snapshot).to receive(:record).and_return(record)
+      allow(record).to receive(:build)
+    end
+
+    it 'builds record' do
+      expect(record).to receive(:build)
+      subject.start
+    end
+
+    it 'runs the adapter' do
+      expect(subject).to receive(:_run)
+      subject.start
+    end
+  end
+
+  describe 'handling events' do
+    before do
+      allow(subject).to receive(:_run)
+
+      allow(snapshot).to receive(:record).and_return(record)
+      allow(record).to receive(:build)
+    end
+
+    context 'when an event occurs' do
+      it 'passes invalidates the snapshot based on the event' do
+        subject.start
+
+        expect(snapshot).to receive(:invalidate).with(:file, 'bar', { cookie: 3 })
+
+        event = { dir: '/foo/dir1', file: 'bar', type: :moved, cookie: 3 }
+        subject.fake_event(event)
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require 'listen/adapter/config'
+
+RSpec.describe Listen::Adapter::Config do
+  let(:directories) { [path1, path2] }
+  let(:queue) { instance_double(Queue) }
+  let(:silencer) { instance_double(Listen::Silencer) }
+
+  # NOTE: defaults are handled later in Listen::Options
+  let(:adapter_options) { { latency: 1.234 } }
+
+  subject do
+    described_class.new(directories, queue, silencer, adapter_options)
+  end
+
+  # Here's what may be  passed to initializer
+  let(:path1) { fake_path('/real/path1', realpath: real_path1) }
+  let(:path2) { fake_path('/real/path2', realpath: real_path2) }
+  let(:path3) { fake_path('/real/path3', realpath: real_path3) }
+
+  let(:current_path) do
+    fake_path('/real/current_path', realpath: real_current_path)
+  end
+
+  let(:symlinked_dir1) { fake_path('symlinked_dir1', realpath: real_path1) }
+  let(:symlinked_dir2) { fake_path('symlinked_dir1', realpath: real_path2) }
+
+  # Here's what expected to be returned (just so that realpath() calls return
+  # something useful)
+  let(:real_path1) { fake_path('/real/path1') }
+  let(:real_path2) { fake_path('/real/path2') }
+  let(:real_path3) { fake_path('/real/path3', directory?: false) }
+  let(:real_current_path) { fake_path('/real/current_path') }
+
+  before do
+    allow(Pathname).to receive(:new) do |*args|
+      fail "unstubbed Pathname.new(#{args.map(&:inspect) * ','})"
+    end
+
+    allow(Pathname).to receive(:new).with('/real/path1').and_return(path1)
+    allow(Pathname).to receive(:new).with('/real/path2').and_return(path2)
+    allow(Pathname).to receive(:new).with('/real/path3').and_return(path3)
+
+    allow(Pathname).to receive(:new).with(path1).and_return(path1)
+    allow(Pathname).to receive(:new).with(path2).and_return(path2)
+
+    allow(Pathname).to receive(:new).with('symlinked_dir1').
+      and_return(symlinked_dir1)
+
+    allow(Pathname).to receive(:new).with('symlinked_dir2').
+      and_return(symlinked_dir2)
+
+    allow(Dir).to receive(:pwd).and_return('/real/current_path')
+
+    allow(Pathname).to receive(:new).
+      with('/real/current_path').and_return(current_path)
+  end
+
+  describe '#initialize' do
+    context 'with directories as array' do
+      context 'with strings for directories' do
+        context 'when already resolved' do
+          let(:directories) { ['/real/path1', '/real/path2'] }
+          it 'returns array of pathnames' do
+            expect(subject.directories).to eq([real_path1, real_path2])
+          end
+        end
+
+        context 'when not resolved' do
+          let(:directories) { %w[symlinked_dir1 symlinked_dir2] }
+          it 'returns array of resolved pathnames' do
+            expect(subject.directories).to eq([real_path1, real_path2])
+          end
+        end
+      end
+
+      context 'with Pathnames for directories' do
+        let(:directories) { [path1, path2] }
+        it 'returns array of pathnames' do
+          expect(subject.directories).to eq([real_path1, real_path2])
+        end
+      end
+    end
+
+    context 'with directories as messy array' do
+      pending 'implement me'
+    end
+
+    context 'with no directories' do
+      let(:directories) { }
+      it 'returns the current path in array' do
+        expect(subject.directories).to eq([real_current_path])
+      end
+    end
+
+    context 'with file path' do
+      let(:directories) { ['/real/path3'] }
+      it 'raises argument error requesting a directory' do
+        expect { subject }.to raise_error(ArgumentError, /must be a directory/)
+      end
+    end
+  end
+
+  describe '#adapter_options' do
+    it 'provides a set of adapter_specific options' do
+      expect(subject.adapter_options).to eq(latency: 1.234)
+    end
+  end
+
+  describe '#queue' do
+    it 'provides a direct queue for filesystem events' do
+      expect(subject.queue).to eq(queue)
+    end
+  end
+
+  describe '#silencer' do
+    it 'provides a silencer object' do
+      expect(subject.silencer).to eq(silencer)
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+# This is just so stubs work
+require 'rb-fsevent'
+
+require 'listen/adapter/darwin'
+
+include Listen
+
+RSpec.describe Adapter::Darwin do
+  describe 'class' do
+    subject { described_class }
+
+    context 'on darwin 13.0 (OS X Mavericks)' do
+      before do
+        allow(RbConfig::CONFIG).to receive(:[]).and_return('darwin13.0')
+      end
+
+      it { should be_usable }
+    end
+
+    context 'on darwin20 (macOS Big Sur)' do
+      before do
+        allow(RbConfig::CONFIG).to receive(:[]).and_return('darwin20')
+      end
+
+      it { should be_usable }
+    end
+
+    context 'on darwin10.0 (OS X Snow Leopard)' do
+      before do
+        allow(RbConfig::CONFIG).to receive(:[]).and_return('darwin10.0')
+      end
+
+      context 'with rb-fsevent > 0.9.4' do
+        before { stub_const('FSEvent::VERSION', '0.9.6') }
+        it 'shows a warning and should not be usable' do
+          expect(Listen).to receive(:adapter_warn)
+          expect(subject).to_not be_usable
+        end
+      end
+
+      context 'with rb-fsevent <= 0.9.4' do
+        before { stub_const('FSEvent::VERSION', '0.9.4') }
+        it { should be_usable }
+      end
+    end
+
+    context 'on another platform (linux)' do
+      before { allow(RbConfig::CONFIG).to receive(:[]).and_return('linux') }
+      it { should_not be_usable }
+    end
+  end
+
+  let(:options) { {} }
+  let(:config) { instance_double(Listen::Adapter::Config) }
+  let(:queue) { instance_double(::Queue) }
+  let(:silencer) { instance_double(Listen::Silencer) }
+
+  let(:dir1) { fake_path('/foo/dir1', cleanpath: fake_path('/foo/dir1')) }
+  let(:directories) { [dir1] }
+
+  subject { described_class.new(config) }
+
+  before do
+    allow(config).to receive(:directories).and_return(directories)
+    allow(config).to receive(:adapter_options).and_return(options)
+  end
+
+  describe '#_latency' do
+    subject { described_class.new(config).options.latency }
+
+    context 'with no overriding option' do
+      it { should eq 0.1 }
+    end
+
+    context 'with custom latency overriding' do
+      let(:options) { { latency: 1234 } }
+      it { should eq 1234 }
+    end
+  end
+end