fluid_cli 0.1.2

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

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require 'listen/thread'
+
+RSpec.describe Listen::Thread do
+  let(:raise_nested_exception_block) do
+    -> do
+      begin
+        begin
+          raise ArgumentError, 'boom!'
+        rescue
+          raise 'nested inner'
+        end
+      rescue
+        raise 'nested outer'
+      end
+    end
+  end
+
+  let(:raise_script_error_block) do
+    -> do
+      raise ScriptError, "ruby typo!"
+    end
+  end
+
+  describe '.new' do
+    let(:name) { "worker_thread" }
+    let(:block) { -> { } }
+    subject { described_class.new(name, &block) }
+
+    it "calls Thread.new" do
+      expect(Thread).to receive(:new) do
+        thread = instance_double(Thread, "thread")
+        expect(thread).to receive(:name=).with("listen-#{name}")
+        thread
+      end
+      subject
+    end
+
+    context "when exception raised" do
+      let(:block) do
+        -> { raise ArgumentError, 'boom!' }
+      end
+
+      it "rescues and logs exceptions" do
+        pattern = <<~EOS.strip
+          Exception rescued in listen-worker_thread:
+          ArgumentError: boom!
+          .*\\/listen\\/thread_spec\\.rb
+        EOS
+        expect(Listen.logger).to receive(:error).with(/#{pattern}/)
+        subject.join
+      end
+
+      it "rescues and logs backtrace + exception backtrace" do
+        pattern = <<~EOS.strip
+          Exception rescued in listen-worker_thread:
+          ArgumentError: boom!
+          .*\\/listen\\/thread\\.rb.*--- Thread.new ---.*\\/listen\\/thread_spec\\.rb
+        EOS
+        expect(Listen.logger).to receive(:error).with(/#{pattern}/m)
+        subject.join
+      end
+    end
+
+    class TestExceptionDerivedFromException < Exception; end # rubocop:disable Lint/InheritException
+
+    context "when exception raised that is not derived from StandardError" do
+      [SystemExit, SystemStackError, NoMemoryError, SecurityError, TestExceptionDerivedFromException].each do |exception|
+        context exception.name do
+          let(:block) do
+            -> { raise exception, 'boom!' }
+          end
+
+          it "does not rescue" do
+            expect(Thread).to receive(:new) do |&block|
+              expect do
+                block.call
+              end.to raise_exception(exception, 'boom!')
+
+              thread = instance_double(Thread, "thread")
+              allow(thread).to receive(:name=).with(any_args)
+              thread
+            end
+
+            subject
+          end
+        end
+      end
+    end
+
+    context "when nested exceptions raised" do
+      let(:block) { raise_nested_exception_block }
+
+      it "details exception causes" do
+        pattern = <<~EOS
+          RuntimeError: nested outer
+          --- Caused by: ---
+          RuntimeError: nested inner
+          --- Caused by: ---
+          ArgumentError: boom!
+        EOS
+        expect(Listen.logger).to receive(:error).with(/#{pattern}/)
+        subject.join
+      end
+    end
+  end
+
+  describe '.rescue_and_log' do
+    it 'rescues and logs nested exceptions' do
+      pattern = <<~EOS
+        Exception rescued in method:
+        RuntimeError: nested outer
+        --- Caused by: ---
+        RuntimeError: nested inner
+        --- Caused by: ---
+        ArgumentError: boom!
+      EOS
+      expect(Listen.logger).to receive(:error).with(/#{pattern}/)
+      described_class.rescue_and_log("method", &raise_nested_exception_block)
+    end
+
+    context 'when exception raised that is not derived from StandardError' do
+      let(:block) { raise_script_error_block }
+
+      it "raises out" do
+        expect do
+          described_class.rescue_and_log("method", &raise_script_error_block)
+        end.to raise_exception(ScriptError, "ruby typo!")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+RSpec.describe Listen do
+  let(:listener) { instance_double(Listen::Listener, stop: nil) }
+
+  after do
+    Listen.stop
+  end
+
+  describe '.to' do
+    it 'initalizes listener' do
+      expect(Listen::Listener).to receive(:new).with('/path') { listener }
+      described_class.to('/path')
+    end
+  end
+
+  describe '.stop' do
+    it 'stops all listeners' do
+      allow(Listen::Listener).to receive(:new).with('/path') { listener }
+      expect(listener).to receive(:stop)
+      described_class.to('/path')
+      Listen.stop
+    end
+  end
+end

data/vendor/deps/listen/spec/spec_helper.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+# TODO: reduce requires everwhere and be more strict about it
+require 'listen'
+
+Listen.logger.level = Logger::WARN unless ENV['LISTEN_GEM_DEBUGGING']
+
+def ci?
+  ENV['CI']
+end
+
+if ci?
+  require 'coveralls'
+  Coveralls.wear!
+end
+
+Dir["#{__dir__}/support/**/*.rb"].sort.each { |f| require f }
+
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  config.order = :random
+  config.filter_run focus: true
+  config.run_all_when_everything_filtered = true
+  # config.fail_fast = !ci?
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+
+  RSpec::Support::ObjectFormatter.default_instance.max_formatted_output_length = 2_000
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_doubled_constant_names = true
+    mocks.verify_partial_doubles = true
+  end
+
+  config.disable_monkey_patching!
+end
+
+module SpecHelpers
+  def fake_path(str, options = {})
+    instance_double(Pathname, str, { to_s: str, directory?: true }.merge(options))
+  end
+end
+
+RSpec.configure do |config|
+  config.include SpecHelpers
+end
+
+Thread.abort_on_exception = true

data/vendor/deps/listen/spec/support/acceptance_helper.rb

@@ -0,0 +1,260 @@
+# frozen_string_literal: true
+
+{
+  modification: :modified,
+  addition: :added,
+  removal: :removed,
+  queued_modification: :modified,
+  queued_addition: :added
+}.each do |description, type|
+  RSpec::Matchers.define "process_#{description}_of".to_sym do |expected|
+    match do |actual|
+      # Use cases:
+      # 1. reset the changes so they don't have leftovers
+      # 2. keep the queue if we're testing for existing accumulated changes
+
+      # if were testing the queue (e.g. after unpause), don't reset
+      reset_queue = /queued_/ !~ description
+
+      actual.listen(reset_queue: reset_queue) do
+        change_fs(type, expected) if reset_queue
+      end
+      actual.changes[type].include? expected
+    end
+
+    failure_message do |actual|
+      "expected #{actual.changes.inspect} to include #{description} of #{expected}"
+    end
+
+    failure_message_when_negated do |actual|
+      "expected #{actual.changes.inspect} to not include #{description} of #{expected}"
+    end
+  end
+end
+
+# rubocop:disable Metrics/MethodLength
+def change_fs(type, path)
+  case type
+  when :modified
+    File.exist?(path) or fail "Bad test: cannot modify #{path.inspect} (it doesn't exist)"
+
+    # wait until full second, because this might be followed by a modification
+    # event (which otherwise may not be detected every time)
+    _sleep_until_next_second(Pathname.pwd)
+
+    File.open(path, 'a') { |f| f.write('foo') }
+
+    # separate it from upcoming modifications"
+    _sleep_to_separate_events
+  when :added
+    File.exist?(path) and fail "Bad test: cannot add #{path.inspect} (it already exists)"
+
+    # wait until full second, because this might be followed by a modification
+    # event (which otherwise may not be detected every time)
+    _sleep_until_next_second(Pathname.pwd)
+
+    File.write(path, 'foo')
+
+    # separate it from upcoming modifications"
+    _sleep_to_separate_events
+  when :removed
+    File.exist?(path) or fail "Bad test: cannot remove #{path.inspect} (it doesn't exist)"
+    File.unlink(path)
+  else
+    fail "bad test: unknown type: #{type.inspect}"
+  end
+end
+# rubocop:enable Metrics/MethodLength
+
+# Used by change_fs() above so that the FS change (e.g. file created) happens
+# as close to the start of a new second (time) as possible.
+#
+# E.g. if file is created at 1234567.999 (unix time), it's mtime on some
+# filesystems is rounded, so it becomes 1234567.0, but if the change
+# notification happens a little while later, e.g. at 1234568.111, now the file
+# mtime and the current time in seconds are different (1234567 vs 1234568), and
+# so the MD5 test won't kick in (see file.rb) - the file will not be considered
+# for content checking (sha), so File.change will consider the file unmodified.
+#
+# This means, that if a file is added at 1234567.888 (and updated in Record),
+# and then its content is modified at 1234567.999, and checking for changes
+# happens at 1234568.111, the modification won't be detected.
+# (because Record mtime is 1234567.0, current FS mtime from stat() is the
+# same, and the checking happens in another second - 1234568).
+#
+# So basically, adding a file and detecting its later modification should all
+# happen within 1 second (which makes testing and debugging difficult).
+#
+def _sleep_until_next_second(path)
+  Listen::File.inaccurate_mac_time?(path)
+
+  t = Time.now.utc
+  diff = t.to_f - t.to_i
+
+  sleep(1.05 - diff)
+end
+
+# Special class to only allow changes within a specific time window
+
+class TimedChanges
+  attr_reader :changes
+
+  def initialize
+    # Set to non-nil, because changes can immediately come after unpausing
+    # listener in an Rspec 'before()' block
+    @changes = { modified: [], added: [], removed: [] }
+  end
+
+  def change_offset
+    Time.now.to_f - @yield_time
+  end
+
+  def freeze_offset
+    result = @freeze_time - @yield_time
+    # Make an "almost zero" value more readable
+    result < 1e-4 ? 1e-4 : result
+  end
+
+  # Allow changes only during specific time wine
+  def allow_changes(reset_queue: true)
+    @freeze_time = nil
+    if reset_queue
+      # Clear to prepare for collecting new FS events
+      @changes = { modified: [], added: [], removed: [] }
+    else
+      # Since we're testing the queue and the listener callback is adding
+      # changes to the same hash (e.g. after a pause), copy the existing data
+      # to a new, unfrozen hash
+      @changes = @changes.dup if @changes.frozen?
+      @changes ||= { modified: [], added: [], removed: [] }
+    end
+
+    @yield_time = Time.now.to_f
+    yield
+    # Prevent recording changes after timeout
+    @changes.freeze
+    @freeze_time = Time.now.to_f
+  end
+end
+
+# Conveniently wrap a Listener instance for testing
+class ListenerWrapper
+  attr_reader :listener
+  attr_accessor :lag
+
+  def initialize(callback, paths, *args)
+    # Lag depends mostly on wait_for_delay On Linux desktop, it's 0.06 - 0.11
+    #
+    # On Travis it used to be > 0.5, but that was before broadcaster sent
+    # changes immediately, so 0.2-0.4 might be enough for Travis, but we set it
+    # to 0.8 (because 0.75 wasn't enough recently)
+    #
+    # The value should be 2-3 x wait_for_delay + time between fs operation and
+    # notification, which for polling and FSEvent means the configured latency
+    @lag = Float(ENV['LISTEN_TESTS_DEFAULT_LAG'] || 1.0)
+
+    @paths = paths
+
+    # Isolate collected changes between tests/listener instances
+    @timed_changes = TimedChanges.new
+
+    @listener = if callback
+      Listen.send(*args) do |modified, added, removed|
+        # Add changes to trigger frozen Hash error, making sure lag is enough
+        _add_changes(:modified, modified, changes)
+        _add_changes(:added, added, changes)
+        _add_changes(:removed, removed, changes)
+
+        callback.call(modified, added, removed) unless callback == :track_changes
+      end
+    else
+      Listen.send(*args)
+    end
+  end
+
+  def changes
+    @timed_changes.changes
+  end
+
+  def listen(reset_queue: true)
+    # Give previous events time to be received, queued and processed
+    # so they complete and don't interfere
+    sleep(lag)
+
+    @timed_changes.allow_changes(reset_queue: reset_queue) do
+      yield
+
+      # Polling sleep (default: 1s)
+      backend = @listener.instance_variable_get(:@backend)
+      adapter = backend.instance_variable_get(:@adapter)
+      sleep(1.0) if adapter.is_a?(Listen::Adapter::Polling)
+
+      # Lag should include:
+      #  0.1s - 0.2s if the test needs Listener queue to be processed
+      #  0.1s in case the system is busy
+      sleep(lag)
+    end
+
+    # Keep this to detect a lag too small (changes during this sleep
+    # will trigger "frozen hash" error caught below (and displaying timeout
+    # details)
+    sleep(1)
+
+    changes
+  end
+
+  private
+
+  def _add_changes(type, changes, dst)
+    dst[type] += _relative_path(changes)
+    dst[type].uniq!
+    dst[type].sort!
+  rescue RuntimeError => e
+    raise unless e.message == "can't modify frozen Hash"
+
+    # Show how by much the changes missed the timeout
+    change_offset = @timed_changes.change_offset
+    freeze_offset = @timed_changes.freeze_offset
+
+    raise "Changes took #{change_offset}s (allowed lag: #{freeze_offset})s"
+  end
+
+  def _relative_path(changes)
+    changes.map do |change|
+      unfrozen_copy = change.dup
+      [@paths].flatten.each do |path|
+        sub = path.sub(%r{/$}, '').to_s
+        unfrozen_copy.gsub!(%r{^#{sub}/}, '')
+      end
+      unfrozen_copy
+    end
+  end
+end
+
+def setup_listener(options, callback = nil)
+  ListenerWrapper.new(callback, paths, :to, paths, options)
+end
+
+def setup_recipient(port, callback = nil)
+  ListenerWrapper.new(callback, paths, :on, port)
+end
+
+def _sleep_to_separate_events
+  # separate the events or Darwin and Polling
+  # will detect only the :added event
+  #
+  # (This is because both use directory scanning which may not kick in time
+  # before the next filesystem change)
+  #
+  # The minimum for this is the time it takes between a syscall
+  # changing the filesystem ... and ... an async
+  # Listen::File.scan to finish comparing the file with the
+  # Record
+  #
+  # This necessary for:
+  # - Darwin Adapter
+  # - Polling Adapter
+  # - Linux Adapter in FSEvent emulation mode
+  # - maybe Windows adapter (probably not)
+  sleep(0.4)
+end

data/vendor/deps/listen/spec/support/fixtures_helper.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'tmpdir'
+
+include FileUtils
+
+# Prepares temporary fixture-directories and
+# cleans them afterwards.
+#
+# @param [Fixnum] number_of_directories the number of fixture-directories to
+# make
+#
+# @yield [path1, path2, ...] the empty fixture-directories
+# @yieldparam [String] path the path to a fixture directory
+#
+def fixtures(number_of_directories = 1)
+  current_pwd = Dir.pwd
+  paths = 1.upto(number_of_directories).map { mk_fixture_tmp_dir }
+
+  FileUtils.cd(paths.first) if number_of_directories == 1
+
+  yield(*paths)
+ensure
+  FileUtils.cd current_pwd
+  paths.map { |p| FileUtils.rm_rf(p) if File.exist?(p) }
+end
+
+def mk_fixture_tmp_dir
+  timestamp = Time.now.to_f.to_s.sub('.', '') + rand(9999).to_s
+  path = Pathname.pwd.join('spec', '.fixtures', timestamp).expand_path
+  path.tap(&:mkpath)
+end

data/vendor/deps/listen/spec/support/platform_helper.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+def darwin?
+  RbConfig::CONFIG['target_os'] =~ /darwin/i
+end
+
+def linux?
+  RbConfig::CONFIG['target_os'] =~ /linux/i
+end
+
+def bsd?
+  RbConfig::CONFIG['target_os'] =~ /bsd|dragonfly/i
+end
+
+def windows?
+  RbConfig::CONFIG['target_os'] =~ /mswin|mingw|cygwin/i
+end

data/vendor/deps/observer/.github/dependabot.yml

@@ -0,0 +1,6 @@
+version: 2
+updates:
+  - package-ecosystem: 'github-actions'
+    directory: '/'
+    schedule:
+      interval: 'weekly'

data/vendor/deps/observer/.github/workflows/test.yml

@@ -0,0 +1,33 @@
+name: test
+
+on: [push, pull_request]
+
+jobs:
+  ruby-versions:
+    uses: ruby/actions/.github/workflows/ruby_versions.yml@master
+    with:
+      engine: cruby
+      min_version: 2.4
+
+  test:
+    needs: ruby-versions
+    name: build (${{ matrix.ruby }} / ${{ matrix.os }})
+    strategy:
+      matrix:
+        ruby: ${{ fromJson(needs.ruby-versions.outputs.versions) }}
+        os: [ ubuntu-latest, macos-latest ]
+        exclude:
+          - ruby: 2.4
+            os: macos-latest
+          - ruby: 2.5
+            os: macos-latest
+    runs-on: ${{ matrix.os }}
+    steps:
+    - uses: actions/checkout@v5
+    - name: Set up Ruby
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby }}
+        bundler-cache: true # Run "bundle install", and cache the result automatically.
+    - name: Run test
+      run: bundle exec rake test

data/vendor/deps/observer/.gitignore

@@ -0,0 +1,8 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/vendor/deps/observer/BSDL

@@ -0,0 +1,22 @@
+Copyright (C) 1993-2013 Yukihiro Matsumoto. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+1. Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGE.

data/vendor/deps/observer/COPYING

@@ -0,0 +1,56 @@
+Ruby is copyrighted free software by Yukihiro Matsumoto <matz@netlab.jp>.
+You can redistribute it and/or modify it under either the terms of the
+2-clause BSDL (see the file BSDL), or the conditions below:
+
+1. You may make and give away verbatim copies of the source form of the
+   software without restriction, provided that you duplicate all of the
+   original copyright notices and associated disclaimers.
+
+2. You may modify your copy of the software in any way, provided that
+   you do at least ONE of the following:
+
+   a. place your modifications in the Public Domain or otherwise
+      make them Freely Available, such as by posting said
+      modifications to Usenet or an equivalent medium, or by allowing
+      the author to include your modifications in the software.
+
+   b. use the modified software only within your corporation or
+      organization.
+
+   c. give non-standard binaries non-standard names, with
+      instructions on where to get the original software distribution.
+
+   d. make other distribution arrangements with the author.
+
+3. You may distribute the software in object code or binary form,
+   provided that you do at least ONE of the following:
+
+   a. distribute the binaries and library files of the software,
+      together with instructions (in the manual page or equivalent)
+      on where to get the original distribution.
+
+   b. accompany the distribution with the machine-readable source of
+      the software.
+
+   c. give non-standard binaries non-standard names, with
+      instructions on where to get the original software distribution.
+
+   d. make other distribution arrangements with the author.
+
+4. You may modify and include the part of the software into any other
+   software (possibly commercial).  But some files in the distribution
+   are not written by the author, so that they are not under these terms.
+
+   For the list of those files and their copying conditions, see the
+   file LEGAL.
+
+5. The scripts and library files supplied as input to or produced as
+   output from the software do not automatically fall under the
+   copyright of the software, but belong to whomever generated them,
+   and may be sold commercially, and may be aggregated with this
+   software.
+
+6. THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR
+   IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+   WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+   PURPOSE.

data/vendor/deps/observer/Gemfile

@@ -0,0 +1,9 @@
+source "https://rubygems.org"
+
+gemspec
+
+group :development do
+  gem "bundler"
+  gem "rake"
+  gem "test-unit"
+end