fluid_cli 0.1.4 → 0.1.6

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

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

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

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

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

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