fluid_cli 0.1.4 → 0.1.6

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

@@ -1,199 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Listen::Adapter::Linux do
-  describe 'class methods' do
-    subject { described_class }
-
-    if linux?
-      it { should be_usable }
-    else
-      it { should_not be_usable }
-    end
-  end
-
-  if linux?
-    describe 'instance methods' do
-      before(:all) do
-        require 'rb-inotify'
-      end
-
-      let(:dir1) { Pathname.new("/foo/dir1") }
-
-      let(:queue) { instance_double(Queue, "queue", close: nil) }
-      let(:config) { instance_double(Listen::Adapter::Config, "config", queue: queue) }
-      let(:silencer) { instance_double(Listen::Silencer, "silencer") }
-      let(:snapshot) { instance_double(Listen::Change, "snapshot") }
-      let(:record) { instance_double(Listen::Record, "record") }
-
-      # TODO: fix other adapters too!
-      subject { described_class.new(config) }
-
-      after do
-        subject.stop
-      end
-
-      describe 'watch events' do
-        let(:directories) { [Pathname.pwd] }
-        let(:adapter_options) { {} }
-        let(:default_events) { [:recursive, :attrib, :create, :modify, :delete, :move, :close_write] }
-        let(:fake_worker) { double(:fake_worker_for_watch_events) }
-        let(:fake_notifier) { double(:fake_notifier, new: fake_worker) }
-
-        before do
-          stub_const('INotify::Notifier', fake_notifier)
-
-          allow(config).to receive(:directories).and_return(directories)
-          allow(config).to receive(:adapter_options).and_return(adapter_options)
-          allow(config).to receive(:silencer).and_return(silencer)
-          allow(fake_worker).to receive(:close)
-        end
-
-        after do
-          subject.stop
-        end
-
-        it 'starts by calling watch with default events' do
-          expect(fake_worker).to receive(:watch).with(*directories.map(&:to_s), *default_events)
-          subject.start
-        end
-      end
-
-      describe 'inotify max watches exceeded' do
-        let(:directories) { [Pathname.pwd] }
-        let(:adapter_options) { {} }
-
-        before do
-          fake_worker = double(:fake_worker_for_inotify_limit_message)
-          allow(fake_worker).to receive(:watch).and_raise(Errno::ENOSPC)
-          allow(fake_worker).to receive(:close)
-
-          fake_notifier = double(:fake_notifier, new: fake_worker)
-          stub_const('INotify::Notifier', fake_notifier)
-
-          allow(config).to receive(:directories).and_return(directories)
-          allow(config).to receive(:adapter_options).and_return(adapter_options)
-        end
-
-        it 'raises exception' do
-          expect { subject.start }.to raise_exception(Listen::Error::INotifyMaxWatchesExceeded, /inotify max watches exceeded/i)
-        end
-      end
-
-      # TODO: should probably be adapted to be more like adapter/base_spec.rb
-      describe '_callback' do
-        let(:directories) { [dir1] }
-        let(:adapter_options) { { events: [:recursive, :close_write] } }
-
-        before do
-          fake_worker = double(:fake_worker_for_callback)
-          events = [:recursive, :close_write]
-          allow(fake_worker).to receive(:watch).with('/foo/dir1', *events)
-          allow(fake_worker).to receive(:close)
-
-          fake_notifier = double(:fake_notifier, new: fake_worker)
-          stub_const('INotify::Notifier', fake_notifier)
-
-          allow(config).to receive(:directories).and_return(directories)
-          allow(config).to receive(:adapter_options).and_return(adapter_options)
-          allow(config).to receive(:silencer).and_return(silencer)
-
-          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)
-
-          allow(subject).to receive(:require).with('rb-inotify')
-          subject.configure
-        end
-
-        let(:expect_change) do
-          lambda do |change|
-            expect(snapshot).to receive(:invalidate).with(
-              :file,
-              'path/foo.txt',
-              {
-                cookie: 123,
-                change: change
-              }
-            )
-          end
-        end
-
-        let(:event_callback) do
-          lambda do |flags|
-            callbacks = subject.instance_variable_get(:'@callbacks')
-            callbacks.values.flatten.each do |callback|
-              callback.call double(
-                :inotify_event,
-                name: 'foo.txt',
-                watcher: double(:watcher, path: '/foo/dir1/path'),
-                flags: flags,
-                cookie: 123)
-            end
-          end
-        end
-
-        # TODO: get fsevent adapter working like INotify
-        unless /1|true/ =~ ENV['LISTEN_GEM_SIMULATE_FSEVENT']
-          it 'recognizes close_write as modify' do
-            expect_change.call(:modified)
-            event_callback.call([:close_write])
-          end
-
-          it 'recognizes moved_to as moved_to' do
-            expect_change.call(:moved_to)
-            event_callback.call([:moved_to])
-          end
-
-          it 'recognizes moved_from as moved_from' do
-            expect_change.call(:moved_from)
-            event_callback.call([:moved_from])
-          end
-        end
-      end
-
-      describe '#stop' do
-        let(:fake_worker) { double(:fake_worker_for_stop, close: true) }
-        let(:directories) { [dir1] }
-        let(:adapter_options) { { events: [:recursive, :close_write] } }
-
-        before do
-          allow(config).to receive(:directories).and_return(directories)
-          allow(config).to receive(:adapter_options).and_return(adapter_options)
-        end
-
-        context 'when configured' do
-          before do
-            events = [:recursive, :close_write]
-            allow(fake_worker).to receive(:watch).with('/foo/dir1', *events)
-
-            fake_notifier = double(:fake_notifier, new: fake_worker)
-            stub_const('INotify::Notifier', fake_notifier)
-
-            allow(config).to receive(:silencer).and_return(silencer)
-
-            allow(subject).to receive(:require).with('rb-inotify')
-            subject.configure
-          end
-
-          it 'stops the worker' do
-            subject.stop
-          end
-        end
-
-        context 'when not even initialized' do
-          before do
-            allow(queue).to receive(:close)
-          end
-
-          it 'does not crash' do
-            expect do
-              subject.stop
-            end.to_not raise_error
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,83 +0,0 @@
-# frozen_string_literal: true
-
-include Listen
-
-RSpec.describe Adapter::Polling do
-  describe 'class' do
-    subject { described_class }
-    it { should be_usable }
-  end
-
-  subject do
-    described_class.new(config)
-  end
-
-  let(:dir1) do
-    instance_double(Pathname, 'dir1', to_s: '/foo/dir1', cleanpath: real_dir1)
-  end
-
-  # just so cleanpath works in above double
-  let(:real_dir1) { instance_double(Pathname, 'dir1', to_s: '/foo/dir1') }
-
-  let(:config) { instance_double(Listen::Adapter::Config, "config") }
-  let(:directories) { [dir1] }
-  let(:options) { {} }
-  let(:queue) { instance_double(Queue, "queue") }
-  let(:silencer) { instance_double(Listen::Silencer, "silencer") }
-  let(:snapshot) { instance_double(Listen::Change, "snapshot") }
-
-  let(:record) { instance_double(Listen::Record) }
-
-  context 'with a valid configuration' do
-    before do
-      allow(config).to receive(:directories).and_return(directories)
-      allow(config).to receive(:adapter_options).and_return(options)
-      allow(config).to receive(:queue).and_return(queue)
-      allow(config).to receive(:silencer).and_return(silencer)
-
-      allow(Listen::Record).to receive(:new).with(dir1, silencer).and_return(record)
-
-      allow(Listen::Change).to receive(:new).with(config, record).
-        and_return(snapshot)
-      allow(Listen::Change::Config).to receive(:new).with(queue, silencer).
-        and_return(config)
-    end
-
-    describe '#start' do
-      before do
-        allow(snapshot).to receive(:record).and_return(record)
-        allow(record).to receive(:build)
-      end
-
-      after do
-        allow(queue).to receive(:close)
-        subject.stop
-      end
-
-      it 'notifies change on every listener directories path' do
-        expect(snapshot).to receive(:invalidate).
-          with(:dir, '.', { recursive: true })
-
-        t = Thread.new { subject.start }
-        sleep 0.25
-        t.kill
-      end
-    end
-
-    describe '#_latency' do
-      subject do
-        adapter = described_class.new(config)
-        adapter.options.latency
-      end
-
-      context 'with no overriding option' do
-        it { should eq 1.0 }
-      end
-
-      context 'with custom latency overriding' do
-        let(:options) { { latency: 1234 } }
-        it { should eq 1234 }
-      end
-    end
-  end
-end

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

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

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

@@ -1,69 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Listen::Adapter do
-  let(:listener) { instance_double(Listen::Listener, options: {}) }
-  before do
-    allow(Listen::Adapter::BSD).to receive(:usable?) { false }
-    allow(Listen::Adapter::Darwin).to receive(:usable?) { false }
-    allow(Listen::Adapter::Linux).to receive(:usable?) { false }
-    allow(Listen::Adapter::Windows).to receive(:usable?) { false }
-  end
-
-  describe '.select' do
-    it 'returns Polling adapter if forced' do
-      klass = Listen::Adapter.select(force_polling: true)
-      expect(klass).to eq Listen::Adapter::Polling
-    end
-
-    it 'returns BSD adapter when usable' do
-      allow(Listen::Adapter::BSD).to receive(:usable?) { true }
-      klass = Listen::Adapter.select
-      expect(klass).to eq Listen::Adapter::BSD
-    end
-
-    it 'returns Darwin adapter when usable' do
-      allow(Listen::Adapter::Darwin).to receive(:usable?) { true }
-      klass = Listen::Adapter.select
-      expect(klass).to eq Listen::Adapter::Darwin
-    end
-
-    it 'returns Linux adapter when usable' do
-      allow(Listen::Adapter::Linux).to receive(:usable?) { true }
-      klass = Listen::Adapter.select
-      expect(klass).to eq Listen::Adapter::Linux
-    end
-
-    it 'returns Windows adapter when usable' do
-      allow(Listen::Adapter::Windows).to receive(:usable?) { true }
-      klass = Listen::Adapter.select
-      expect(klass).to eq Listen::Adapter::Windows
-    end
-
-    context 'no usable adapters' do
-      before { allow(Kernel).to receive(:warn) }
-
-      it 'returns Polling adapter' do
-        klass = Listen::Adapter.select(force_polling: true)
-        expect(klass).to eq Listen::Adapter::Polling
-      end
-
-      it 'warns polling fallback with default message' do
-        msg = described_class::POLLING_FALLBACK_MESSAGE
-        expect(Listen).to receive(:adapter_warn).with("[Listen warning]:\n  #{msg}")
-        Listen::Adapter.select
-      end
-
-      it "doesn't warn if polling_fallback_message is false" do
-        expect(Kernel).to_not receive(:warn)
-        Listen::Adapter.select(polling_fallback_message: false)
-      end
-
-      it 'warns polling fallback with custom message if set' do
-        expected_msg = "[Listen warning]:\n  custom fallback message"
-        expect(Listen).to receive(:adapter_warn).with(expected_msg)
-        msg = 'custom fallback message'
-        Listen::Adapter.select(polling_fallback_message: msg)
-      end
-    end
-  end
-end

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

@@ -1,82 +0,0 @@
-# frozen_string_literal: true
-
-require 'listen/backend'
-
-RSpec.describe Listen::Backend do
-  let(:dir1) { instance_double(Pathname, 'dir1', to_s: '/foo/dir1') }
-
-  let(:silencer) { instance_double(Listen::Silencer) }
-  let(:queue) { instance_double(Queue) }
-
-  let(:select_options) do
-    { force_polling: false, polling_fallback_message: 'foo' }
-  end
-
-  let(:adapter_options) { { latency: 1234 } }
-  let(:options) { select_options.merge(adapter_options) }
-
-  let(:adapter_config_class) { class_double('Listen::Adapter::Config') }
-  let(:adapter_config) { instance_double('Listen::Adapter::Config') }
-
-  let(:config) { instance_double(Listen::Listener::Config) }
-
-  subject { described_class.new([dir1], queue, silencer, config) }
-
-  # Use Polling since it has a valid :latency option
-  let(:adapter_defaults) { { latency: 5.4321 } }
-  let(:adapter_class) { Listen::Adapter::Polling }
-  let(:adapter) { instance_double('Listen::Adapter::Polling') }
-
-  let(:config_min_delay_between_events) { 0.1234 }
-
-  before do
-    stub_const('Listen::Adapter::Config', adapter_config_class)
-
-    allow(adapter_config_class).to receive(:new).
-      with([dir1], queue, silencer, adapter_options).
-      and_return(adapter_config)
-
-    allow(Listen::Adapter).to receive(:select).
-      with(select_options).and_return(adapter_class)
-
-    allow(adapter_class).to receive(:new).
-      with(adapter_config).and_return(adapter)
-
-    allow(Listen::Adapter::Polling).to receive(:new).with(adapter_config).
-      and_return(adapter)
-
-    allow(config).to receive(:adapter_select_options).
-      and_return(select_options)
-
-    allow(config).to receive(:adapter_instance_options).
-      and_return(adapter_options)
-
-    allow(config).to receive(:min_delay_between_events).
-      and_return(config_min_delay_between_events)
-  end
-
-  describe '#initialize' do
-    context 'with config' do
-      it 'sets up an adapter class' do
-        expect(adapter_class).to receive(:new).
-          with(adapter_config).and_return(adapter)
-
-        subject
-      end
-    end
-  end
-
-  describe '#start' do
-    it 'starts the adapter' do
-      expect(adapter).to receive(:start)
-      subject.start
-    end
-  end
-
-  describe '#stop' do
-    it 'stops the adapter' do
-      expect(adapter).to receive(:stop)
-      subject.stop
-    end
-  end
-end

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

@@ -1,102 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Listen::Change do
-  let(:config) { instance_double(Listen::Change::Config) }
-  let(:dir) { instance_double(Pathname) }
-  let(:record) { instance_double(Listen::Record, root: '/dir') }
-  subject { Listen::Change.new(config, record) }
-
-  let(:full_file_path) { instance_double(Pathname, to_s: '/dir/file.rb') }
-  let(:full_dir_path) { instance_double(Pathname, to_s: '/dir') }
-
-  before do
-    allow(dir).to receive(:+).with('file.rb') { full_file_path }
-    allow(dir).to receive(:+).with('dir1') { full_dir_path }
-  end
-
-  describe '#change' do
-    before do
-      allow(config).to receive(:silenced?).and_return(false)
-    end
-
-    context 'with build options' do
-      it 'calls still_building! on record' do
-        allow(config).to receive(:queue)
-        allow(Listen::File).to receive(:change)
-        subject.invalidate(:file, 'file.rb', build: true)
-      end
-    end
-
-    context 'file' do
-      context 'with known change' do
-        it 'notifies change directly to listener' do
-          expect(config).to receive(:queue).
-            with(:file, :modified, Pathname.new('/dir'), 'file.rb', {})
-
-          subject.invalidate(:file, 'file.rb', change: :modified)
-        end
-
-        it "doesn't notify to listener if path is silenced" do
-          expect(config).to receive(:silenced?).and_return(true)
-          expect(config).to_not receive(:queue)
-          subject.invalidate(:file, 'file.rb', change: :modified)
-        end
-      end
-
-      context 'with unknown change' do
-        it 'calls Listen::File#change' do
-          expect(Listen::File).to receive(:change).with(record, 'file.rb')
-          subject.invalidate(:file, 'file.rb', {})
-        end
-
-        it "doesn't call Listen::File#change if path is silenced" do
-          expect(config).to receive(:silenced?).
-            with('file.rb', :file).and_return(true)
-
-          expect(Listen::File).to_not receive(:change)
-          subject.invalidate(:file, 'file.rb', {})
-        end
-
-        context 'that returns a change' do
-          before { allow(Listen::File).to receive(:change) { :modified } }
-
-          context 'listener listen' do
-            it 'notifies change to listener' do
-              expect(config).to receive(:queue).
-                with(:file, :modified, Pathname.new('/dir'), 'file.rb')
-
-              subject.invalidate(:file, 'file.rb', {})
-            end
-
-            context 'silence option' do
-              it 'notifies change to listener' do
-                expect(config).to_not receive(:queue)
-                subject.invalidate(:file, 'file.rb', silence: true)
-              end
-            end
-          end
-        end
-
-        context 'that returns no change' do
-          before { allow(Listen::File).to receive(:change) { nil } }
-
-          it "doesn't notifies no change" do
-            expect(config).to_not receive(:queue)
-            subject.invalidate(:file, 'file.rb', {})
-          end
-        end
-      end
-    end
-
-    context 'directory' do
-      let(:dir_options) { { recursive: true } }
-
-      it 'calls Listen::Directory#new' do
-        expect(Listen::Directory).to receive(:scan).
-          with(subject, 'dir1', dir_options)
-
-        subject.invalidate(:dir, 'dir1', dir_options)
-      end
-    end
-  end
-end

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

@@ -1,116 +0,0 @@
-# frozen_string_literal: true
-
-require 'listen/cli'
-
-RSpec.describe Listen::CLI do
-  let(:options) { {} }
-  let(:forwarder) { instance_double(Listen::Forwarder) }
-
-  before do
-    allow(forwarder).to receive(:start)
-  end
-
-  describe 'directories option' do
-    context 'not specified' do
-      let(:options) { %w[] }
-      it 'is set to local directory' do
-        expect(Listen::Forwarder).to receive(:new) do |options|
-          expect(options[:directory]).to eq(['.'])
-          forwarder
-        end
-        described_class.start(options)
-      end
-    end
-
-    context 'with a single directory' do
-      let(:options) { %w[-d app] }
-      it 'is set to app' do
-        expect(Listen::Forwarder).to receive(:new) do |options|
-          expect(options[:directory]).to eq(['app'])
-          forwarder
-        end
-        described_class.start(options)
-      end
-    end
-
-    context 'with a multiple directories' do
-      let(:options) { %w[-d app spec] }
-      it 'is set to an array of the directories' do
-        expect(Listen::Forwarder).to receive(:new) do |options|
-          expect(options[:directory]).to eq(%w[app spec])
-          forwarder
-        end
-        described_class.start(options)
-      end
-    end
-  end
-
-  describe 'relative option' do
-    context 'without relative option' do
-      let(:options) { %w[] }
-      it 'is set to false' do
-        expect(Listen::Forwarder).to receive(:new) do |options|
-          expect(options[:relative]).to be(false)
-          forwarder
-        end
-        described_class.start(options)
-      end
-    end
-
-    context 'when -r' do
-      let(:options) { %w[-r] }
-
-      it 'is set to true' do
-        expect(Listen::Forwarder).to receive(:new) do |options|
-          expect(options[:relative]).to be(true)
-          forwarder
-        end
-        described_class.start(options)
-      end
-    end
-
-    context 'when --relative' do
-      let(:options) { %w[--relative] }
-
-      it 'supports -r option' do
-        expect(Listen::Forwarder).to receive(:new) do |options|
-          expect(options[:relative]).to be(true)
-          forwarder
-        end
-        described_class.start(options)
-      end
-
-      it 'supports --relative option' do
-        expect(Listen::Forwarder).to receive(:new) do |options|
-          expect(options[:relative]).to be(true)
-          forwarder
-        end
-        described_class.start(options)
-      end
-    end
-  end
-end
-
-RSpec.describe Listen::Forwarder do
-  let(:logger) { instance_double(Logger) }
-  let(:listener) { instance_double(Listen::Listener) }
-
-  before do
-    allow(Logger).to receive(:new).and_return(logger)
-    allow(logger).to receive(:level=)
-    allow(logger).to receive(:formatter=)
-    allow(logger).to receive(:info)
-
-    allow(listener).to receive(:start)
-    allow(listener).to receive(:processing?).and_return false
-  end
-
-  it 'passes relative option to Listen' do
-    value = double('value')
-    expect(Listen).to receive(:to).
-      with(hash_including(relative: value)).
-      and_return(listener)
-
-    described_class.new(relative: value).start
-  end
-end