fluid_cli 0.1.2

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

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

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

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

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