fluid_cli 0.1.5 → 0.1.6

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

@@ -1,321 +0,0 @@
-# frozen_string_literal: true
-
-include Listen
-
-RSpec.describe Listener do
-  let(:realdir1) { fake_path('/foo/dir1', children: []) }
-  let(:realdir2) { fake_path('/foo/dir2', children: []) }
-
-  let(:dir1) { fake_path('dir1', realpath: realdir1) }
-  let(:dir2) { fake_path('dir2', realpath: realdir2) }
-
-  let(:dirs) { ['dir1'] }
-
-  let(:block) { instance_double(Proc) }
-
-  subject do
-    described_class.new(*(dirs + [options]).compact) do |*changes|
-      block.call(*changes)
-    end
-  end
-
-  let(:options) { {} }
-
-  let(:record) { instance_double(Record, build: true, root: 'dir2') }
-  let(:silencer) { instance_double(Silencer, configure: nil) }
-
-  let(:backend_class) { class_double('Listen::Backend') }
-
-  let(:backend) { instance_double(Backend) }
-
-  let(:optimizer_config) { instance_double(QueueOptimizer::Config) }
-  let(:optimizer) { instance_double(QueueOptimizer) }
-
-  let(:processor_config) { instance_double(Event::Config) }
-  let(:processor) { instance_double(Event::Loop) }
-
-  let(:event_queue) { instance_double(Event::Queue) }
-
-  let(:default_latency) { 0.1 }
-  let(:backend_wait_for_delay) { 0.123 }
-
-  let(:processing_thread) { instance_double(Thread) }
-
-  before do
-    allow(Silencer).to receive(:new) { silencer }
-
-    allow(Backend).to receive(:new).
-      with(anything, event_queue, silencer, anything).
-      and_return(backend)
-
-    allow(backend).to receive(:min_delay_between_events).
-      and_return(backend_wait_for_delay)
-
-    # TODO: use a configuration object to clean this up
-
-    allow(QueueOptimizer::Config).to receive(:new).with(backend, silencer).
-      and_return(optimizer_config)
-
-    allow(QueueOptimizer).to receive(:new).with(optimizer_config).
-      and_return(optimizer)
-
-    allow(Event::Queue).to receive(:new).and_return(event_queue)
-
-    allow(Event::Config).to receive(:new).
-      with(anything, event_queue, optimizer, backend_wait_for_delay).
-      and_return(processor_config)
-
-    allow(Event::Loop).to receive(:new).with(processor_config).
-      and_return(processor)
-
-    allow(Record).to receive(:new).and_return(record)
-
-    allow(Pathname).to receive(:new).with('dir1').and_return(dir1)
-    allow(Pathname).to receive(:new).with('dir2').and_return(dir2)
-
-    allow(Thread).to receive(:new).and_return(processing_thread)
-    allow(processing_thread).to receive(:alive?).and_return(true)
-    allow(processing_thread).to receive(:wakeup)
-    allow(processing_thread).to receive(:join)
-
-    allow(block).to receive(:call)
-  end
-
-  describe 'initialize' do
-    it { should_not be_paused }
-
-    context 'with a block' do
-      let(:myblock) { instance_double(Proc) }
-      let(:block) { proc { myblock.call } }
-      subject do
-        described_class.new('dir1') do |*args|
-          myblock.call(*args)
-        end
-      end
-
-      it 'passes the block to the event processor' do
-        allow(Event::Config).to receive(:new) do |*_args, &some_block|
-          expect(some_block).to be
-          some_block.call
-          processor_config
-        end
-        expect(myblock).to receive(:call)
-        subject
-      end
-    end
-
-    context 'with directories' do
-      subject { described_class.new('dir1', 'dir2') }
-
-      it 'passes directories to backend' do
-        allow(Backend).to receive(:new).
-          with(%w[dir1 dir2], anything, anything, anything).
-          and_return(backend)
-        subject
-      end
-    end
-  end
-
-  describe '#start' do
-    before do
-      allow(backend).to receive(:start)
-      allow(silencer).to receive(:silenced?) { false }
-    end
-
-    it 'sets paused to false' do
-      allow(processor).to receive(:start)
-      subject.start
-      expect(subject).to_not be_paused
-    end
-
-    it 'starts adapter' do
-      expect(backend).to receive(:start)
-      allow(processor).to receive(:start)
-      subject.start
-    end
-  end
-
-  describe '#stop' do
-    before do
-      allow(backend).to receive(:start)
-      allow(processor).to receive(:start)
-    end
-
-    context 'when fully started' do
-      before do
-        subject.start
-      end
-
-      it 'terminates' do
-        allow(backend).to receive(:stop)
-        allow(processor).to receive(:stop)
-        subject.stop
-      end
-    end
-
-    context 'when only initialized' do
-      before do
-        subject
-      end
-
-      it 'terminates' do
-        allow(backend).to receive(:stop)
-        allow(processor).to receive(:stop)
-        subject.stop
-      end
-    end
-  end
-
-  describe '#pause' do
-    before do
-      allow(backend).to receive(:start)
-      allow(processor).to receive(:start)
-      subject.start
-    end
-    it 'sets paused to true' do
-      allow(processor).to receive(:pause)
-      subject.pause
-      expect(subject).to be_paused
-    end
-  end
-
-  describe 'unpause with start' do
-    before do
-      allow(backend).to receive(:start)
-      allow(processor).to receive(:start)
-      subject.start
-      allow(processor).to receive(:pause)
-      subject.pause
-    end
-
-    it 'sets paused to false' do
-      subject.start
-      expect(subject).to_not be_paused
-    end
-  end
-
-  describe '#paused?' do
-    before do
-      allow(backend).to receive(:start)
-      allow(processor).to receive(:start)
-      subject.start
-    end
-
-    it 'returns true when paused' do
-      allow(processor).to receive(:pause)
-      subject.pause
-      expect(subject).to be_paused
-    end
-
-    it 'returns false when not paused' do
-      expect(subject).not_to be_paused
-    end
-  end
-
-  describe '#listen?' do
-    context 'when processing' do
-      before do
-        allow(backend).to receive(:start)
-        allow(processor).to receive(:start)
-        subject.start
-      end
-      it { should be_processing }
-    end
-
-    context 'when stopped' do
-      it { should_not be_processing }
-    end
-
-    context 'when paused' do
-      before do
-        allow(backend).to receive(:start)
-        allow(processor).to receive(:start)
-        subject.start
-        allow(processor).to receive(:pause)
-        subject.pause
-      end
-
-      it { should_not be_processing }
-    end
-  end
-
-  # TODO: move these to silencer_controller?
-  describe '#ignore' do
-    context 'with existing ignore options' do
-      let(:options) { { ignore: /bar/ } }
-
-      it 'adds up to existing ignore options' do
-        expect(silencer).to receive(:configure).once.with({ ignore: [/bar/] })
-
-        subject
-
-        expect(silencer).to receive(:configure).once.
-          with({ ignore: [/bar/, /foo/] })
-
-        subject.ignore(/foo/)
-      end
-    end
-
-    context 'with existing ignore options (array)' do
-      let(:options) { { ignore: [/bar/] } }
-
-      it 'adds up to existing ignore options' do
-        expect(silencer).to receive(:configure).once.with({ ignore: [/bar/] })
-
-        subject
-
-        expect(silencer).to receive(:configure).once.
-          with({ ignore: [/bar/, /foo/] })
-
-        subject.ignore(/foo/)
-      end
-    end
-  end
-
-  # TODO: move these to silencer_controller?
-  describe '#ignore!' do
-    context 'with no existing options' do
-      let(:options) { {} }
-
-      it 'sets options' do
-        expect(silencer).to receive(:configure).with(options)
-        subject
-      end
-    end
-
-    context 'with existing ignore! options' do
-      let(:options) { { ignore!: /bar/ } }
-
-      it 'overwrites existing ignore options' do
-        expect(silencer).to receive(:configure).once.with({ ignore!: [/bar/] })
-        subject
-        expect(silencer).to receive(:configure).once.with({ ignore!: [/foo/] })
-        subject.ignore!([/foo/])
-      end
-    end
-
-    context 'with existing ignore options' do
-      let(:options) { { ignore: /bar/ } }
-
-      it 'deletes ignore options' do
-        expect(silencer).to receive(:configure).once.with({ ignore: [/bar/] })
-        subject
-        expect(silencer).to receive(:configure).once.with({ ignore!: [/foo/] })
-        subject.ignore!([/foo/])
-      end
-    end
-  end
-
-  describe '#only' do
-    context 'with existing only options' do
-      let(:options) { { only: /bar/ } }
-
-      it 'overwrites existing ignore options' do
-        expect(silencer).to receive(:configure).once.with({ only: [/bar/] })
-        subject
-        expect(silencer).to receive(:configure).once.with({ only: [/foo/] })
-        subject.only([/foo/])
-      end
-    end
-  end
-end

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

@@ -1,212 +0,0 @@
-# frozen_string_literal: true
-
-require 'listen/logger'
-
-RSpec.describe 'logger.rb' do
-  around do |spec|
-    orig_logger = Listen.instance_variable_get(:@logger)
-
-    spec.run
-
-    Listen.logger = orig_logger
-  end
-
-  describe 'Listen.logger' do
-    ENV_VARIABLE_NAME = 'LISTEN_GEM_DEBUGGING'
-
-    let(:logger) { instance_double(::Logger, "logger") }
-
-    around do |spec|
-      orig_debugging_env_variable = ENV.fetch(ENV_VARIABLE_NAME, :not_set)
-
-      spec.run
-
-      if orig_debugging_env_variable == :not_set
-        ENV.delete(ENV_VARIABLE_NAME)
-      else
-        ENV[ENV_VARIABLE_NAME] = orig_debugging_env_variable
-      end
-    end
-
-    describe 'logger=' do
-      it 'allows the logger to be set' do
-        Listen.logger = logger
-        expect(Listen.logger).to be(logger)
-      end
-
-      it 'allows nil to be set (implying default logger)' do
-        Listen.logger = nil
-        expect(Listen.logger).to be_kind_of(::Logger)
-      end
-    end
-
-    describe 'logger' do
-      before do
-        Listen.instance_variable_set(:@logger, nil)
-      end
-
-      it 'returns default logger if none set' do
-        expect(Listen.logger).to be_kind_of(::Logger)
-      end
-
-      ['debug', 'DEBUG', '2', 'level2', '2 '].each do |env_value|
-        it "infers DEBUG level from #{ENV_VARIABLE_NAME}=#{env_value.inspect}" do
-          ENV[ENV_VARIABLE_NAME] = env_value
-          expect(Listen.logger.level).to eq(::Logger::DEBUG)
-        end
-      end
-
-      ['info', 'INFO', 'true', ' true', 'TRUE', 'TRUE ', 'yes', 'YES', ' yesss!', '1', 'level1'].each do |env_value|
-        it "infers INFO level from #{ENV_VARIABLE_NAME}=#{env_value.inspect}" do
-          ENV[ENV_VARIABLE_NAME] = env_value
-          expect(Listen.logger.level).to eq(::Logger::INFO)
-        end
-      end
-
-      ['warn', 'WARN', ' warn', 'warning'].each do |env_value|
-        it "infers WARN level from #{ENV_VARIABLE_NAME}=#{env_value.inspect}" do
-          ENV[ENV_VARIABLE_NAME] = env_value
-          expect(Listen.logger.level).to eq(::Logger::WARN)
-        end
-      end
-
-      ['error', 'ERROR', 'OTHER'].each do |env_value|
-        it "infers ERROR level from #{ENV_VARIABLE_NAME}=#{env_value.inspect}" do
-          ENV[ENV_VARIABLE_NAME] = env_value
-          expect(Listen.logger.level).to eq(::Logger::ERROR)
-        end
-      end
-
-      ['fatal', 'FATAL', ' fatal'].each do |env_value|
-        it "infers FATAL level from #{ENV_VARIABLE_NAME}=#{env_value.inspect}" do
-          ENV[ENV_VARIABLE_NAME] = env_value
-          expect(Listen.logger.level).to eq(::Logger::FATAL)
-        end
-      end
-    end
-  end
-
-  describe 'Listen.adapter_warn_behavior' do
-    subject { Listen.adapter_warn(message) }
-
-    after do
-      Listen.adapter_warn_behavior = :warn
-    end
-    let(:message) { "warning message" }
-
-    it 'defaults to :warn' do
-      expect(Listen.adapter_warn_behavior).to eq(:warn)
-
-      expect(Listen).to receive(:warn).with(message)
-
-      subject
-    end
-
-    it 'allows the adapter_warn_behavior to be set to :log' do
-      Listen.adapter_warn_behavior = :log
-
-      expect(Listen.logger).to receive(:warn).with(message)
-
-      subject
-    end
-
-    [:silent, nil, false].each do |behavior|
-      it "allows the adapter_warn_behavior to be set to #{behavior} to silence the warnings" do
-        Listen.adapter_warn_behavior = behavior
-
-        expect(Listen.logger).not_to receive(:warn)
-        expect(Listen).not_to receive(:warn)
-
-        subject
-      end
-    end
-
-    context "when LISTEN_GEM_ADAPTER_WARN_BEHAVIOR is set to 'log'" do
-      around do |spec|
-        orig_debugging_env_variable = ENV.fetch('LISTEN_GEM_ADAPTER_WARN_BEHAVIOR', :not_set)
-
-        ENV['LISTEN_GEM_ADAPTER_WARN_BEHAVIOR'] = 'log'
-
-        spec.run
-
-        if orig_debugging_env_variable == :not_set
-          ENV.delete('LISTEN_GEM_ADAPTER_WARN_BEHAVIOR')
-        else
-          ENV['ENV_VARIABLE_NAME'] = orig_debugging_env_variable
-        end
-      end
-
-      [:silent, nil, false, :warn].each do |behavior|
-        it "respects the environment variable over #{behavior.inspect}" do
-          Listen.adapter_warn_behavior = behavior
-
-          expect(Listen.logger).to receive(:warn).with(message)
-
-          subject
-        end
-      end
-
-      it "respects the environment variable over a callable config" do
-        Listen.adapter_warn_behavior = ->(_message) { :warn }
-
-        expect(Listen.logger).to receive(:warn).with(message)
-
-        subject
-      end
-    end
-
-    context 'when adapter_warn_behavior is set to a callable object like a proc' do
-      before do
-        Listen.adapter_warn_behavior = ->(message) do
-          case message
-          when /USE warn/
-            :warn
-          when /USE log/
-            :log
-          when /USE silent/
-            :silent
-          when /USE false/
-            false
-          when /USE nil/
-            nil
-          else
-            true
-          end
-        end
-      end
-
-      [true, :warn].each do |behavior|
-        context "when the message matches a #{behavior.inspect} pattern" do
-          let(:message) { "USE #{behavior.inspect}" }
-          it 'respects :warn' do
-            expect(Listen).to receive(:warn).with(message)
-
-            subject
-          end
-        end
-      end
-
-      context 'when the message matches a :silent pattern' do
-        let(:message) { "USE silent" }
-        it 'respects :silent' do
-          expect(Listen).not_to receive(:warn).with(message)
-          expect(Listen).not_to receive(:warn)
-
-          subject
-        end
-      end
-
-      [false, nil].each do |behavior|
-        context "when the message matches a #{behavior} pattern" do
-          let(:message) { "USE #{behavior.inspect}" }
-          it 'respects :silent' do
-            expect(Listen).not_to receive(:warn).with(message)
-            expect(Listen).not_to receive(:warn)
-
-            subject
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-require 'listen/monotonic_time'
-
-RSpec.describe Listen::MonotonicTime do
-  after(:all) do
-    # load once more with constants unstubbed/unhidden
-    load './lib/listen/monotonic_time.rb'
-  end
-
-  context 'module methods' do
-    describe '.now' do
-      subject { described_class.now }
-      let(:tick_count) { 0.123 }
-
-      context 'when CLOCK_MONOTONIC defined' do
-        before do
-          stub_const('Process::CLOCK_MONOTONIC', 10)
-          load './lib/listen/monotonic_time.rb'
-        end
-
-        it 'returns the CLOCK_MONOTONIC tick count' do
-          expect(Process).to receive(:clock_gettime).with(Process::CLOCK_MONOTONIC).and_return(tick_count)
-          expect(subject).to eq(tick_count)
-        end
-      end
-
-      context 'when CLOCK_MONOTONIC not defined but CLOCK_MONOTONIC_RAW defined' do
-        before do
-          hide_const('Process::CLOCK_MONOTONIC')
-          stub_const('Process::CLOCK_MONOTONIC_RAW', 11)
-          load './lib/listen/monotonic_time.rb'
-        end
-
-        it 'returns the floating point Time.now' do
-          expect(Process).to receive(:clock_gettime).with(Process::CLOCK_MONOTONIC_RAW).and_return(tick_count)
-          expect(subject).to eq(tick_count)
-        end
-      end
-
-      context 'when neither CLOCK_MONOTONIC nor CLOCK_MONOTONIC_RAW defined' do
-        let(:now) { instance_double(Time, "time") }
-
-        before do
-          hide_const('Process::CLOCK_MONOTONIC')
-          hide_const('Process::CLOCK_MONOTONIC_RAW')
-          load './lib/listen/monotonic_time.rb'
-        end
-
-        it 'returns the floating point Time.now' do
-          expect(Time).to receive(:now).and_return(now)
-          expect(now).to receive(:to_f).and_return(tick_count)
-          expect(subject).to eq(tick_count)
-        end
-      end
-    end
-  end
-end

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

@@ -1,111 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Listen::QueueOptimizer do
-  let(:config) { instance_double(Listen::QueueOptimizer::Config) }
-  subject { described_class.new(config) }
-
-  # watched dir
-  let(:dir) { fake_path('dir') }
-
-  # files
-  let(:foo) { fake_path('foo') }
-  let(:bar) { fake_path('bar') }
-  let(:ignored) { fake_path('ignored') }
-
-  before do
-    allow(config).to receive(:debug)
-
-    allow(dir).to receive(:+).with('foo') { foo }
-    allow(dir).to receive(:+).with('bar') { bar }
-    allow(dir).to receive(:+).with('ignored') { ignored }
-
-    allow(config).to receive(:silenced?).
-      with(Pathname('ignored'), :file) { true }
-
-    allow(config).to receive(:silenced?).
-      with(Pathname('foo'), :file) { false }
-
-    allow(config).to receive(:silenced?).
-      with(Pathname('bar'), :file) { false }
-
-    allow(config).to receive(:exist?).with(foo).and_return(true)
-    allow(config).to receive(:exist?).with(bar).and_return(true)
-    allow(config).to receive(:exist?).with(ignored).and_return(true)
-  end
-
-  describe 'smoosh_changes' do
-    subject { described_class.new(config).smoosh_changes(changes) }
-
-    context 'with rename from temp file' do
-      let(:changes) do
-        [
-          [:file, :modified, dir, 'foo'],
-          [:file, :removed, dir, 'foo'],
-          [:file, :added, dir, 'foo'],
-          [:file, :modified, dir, 'foo']
-        ]
-      end
-      it { is_expected.to eq(modified: ['foo'], added: [], removed: []) }
-    end
-
-    context 'with a detected temp file' do
-      before { allow(config).to receive(:exist?).with(foo).and_return(false) }
-
-      let(:changes) do
-        [
-          [:file, :added, dir, 'foo'],
-          [:file, :modified, dir, 'foo'],
-          [:file, :removed, dir, 'foo'],
-          [:file, :modified, dir, 'foo']
-        ]
-      end
-      it { is_expected.to eq(modified: [], added: [], removed: []) }
-    end
-
-    # e.g. "mv foo x && mv x foo" is like "touch foo"
-    context 'when double move' do
-      let(:changes) do
-        [
-          [:file, :removed, dir, 'foo'],
-          [:file, :added, dir, 'foo']
-        ]
-      end
-      it { is_expected.to eq(modified: ['foo'], added: [], removed: []) }
-    end
-
-    context 'with cookie' do
-      context 'when single moved' do
-        let(:changes) { [[:file, :moved_to, dir, 'foo', { cookie: 4321 }]] }
-        it { is_expected.to eq(modified: [], added: ['foo'], removed: []) }
-      end
-
-      context 'when related moved_to' do
-        let(:changes) do
-          [
-            [:file, :moved_from, dir, 'foo', { cookie: 4321 }],
-            [:file, :moved_to, dir, 'bar', { cookie: 4321 }]
-          ]
-        end
-        it { is_expected.to eq(modified: [], added: ['bar'], removed: []) }
-      end
-
-      # Scenario with workaround for editors using rename()
-      context 'when related moved_to with ignored moved_from' do
-        let(:changes) do
-          [
-            [:file, :moved_from, dir, 'ignored', { cookie: 4321 }],
-            [:file, :moved_to, dir, 'foo', { cookie: 4321 }]
-          ]
-        end
-        it { is_expected.to eq(modified: ['foo'], added: [], removed: []) }
-      end
-    end
-
-    context 'with no cookie' do
-      context 'with ignored file' do
-        let(:changes) { [[:file, :modified, dir, 'ignored']] }
-        it { is_expected.to eq(modified: [], added: [], removed: []) }
-      end
-    end
-  end
-end