fluid_cli 0.1.2

data/vendor/deps/listen/lib/listen/change.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require 'listen/file'
+require 'listen/directory'
+
+module Listen
+  # TODO: rename to Snapshot
+  class Change
+    # TODO: test this class for coverage
+    class Config
+      def initialize(queue, silencer)
+        @queue = queue
+        @silencer = silencer
+      end
+
+      def silenced?(path, type)
+        @silencer.silenced?(Pathname(path), type)
+      end
+
+      def queue(*args)
+        @queue << args
+      end
+    end
+
+    attr_reader :record
+
+    def initialize(config, record)
+      @config = config
+      @record = record
+    end
+
+    # Invalidate some part of the snapshot/record (dir, file, subtree, etc.)
+    # rubocop:disable Metrics/MethodLength
+    # rubocop:disable Metrics/CyclomaticComplexity
+    # rubocop:disable Metrics/PerceivedComplexity
+    def invalidate(type, rel_path, options)
+      watched_dir = Pathname.new(record.root)
+
+      change = options[:change]
+      cookie = options[:cookie]
+
+      if !cookie && @config.silenced?(rel_path, type)
+        Listen.logger.debug { "(silenced): #{rel_path.inspect}" }
+        return
+      end
+
+      path = watched_dir + rel_path
+
+      Listen.logger.debug do
+        log_details = options[:silence] && 'recording' || change || 'unknown'
+        "#{log_details}: #{type}:#{path} (#{options.inspect})"
+      end
+
+      if change
+        options = cookie ? { cookie: cookie } : {}
+        @config.queue(type, change, watched_dir, rel_path, options)
+      elsif type == :dir
+        # NOTE: POSSIBLE RECURSION
+        # TODO: fix - use a queue instead
+        Directory.scan(self, rel_path, options)
+      elsif (change = File.change(record, rel_path)) && !options[:silence]
+        @config.queue(:file, change, watched_dir, rel_path)
+      end
+    end
+    # rubocop:enable Metrics/MethodLength
+    # rubocop:enable Metrics/CyclomaticComplexity
+    # rubocop:enable Metrics/PerceivedComplexity
+  end
+end

data/vendor/deps/listen/lib/listen/cli.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'thor'
+require 'listen'
+require 'logger'
+
+module Listen
+  class CLI < Thor
+    default_task :start
+
+    desc 'start', 'Starts Listen'
+
+    class_option :verbose,
+                 type:    :boolean,
+                 default: false,
+                 aliases: '-v',
+                 banner:  'Verbose'
+
+    class_option :directory,
+                 type:    :array,
+                 default: ['.'],
+                 aliases: '-d',
+                 banner:  'One or more directories to listen to'
+
+    class_option :relative,
+                 type:    :boolean,
+                 default: false,
+                 aliases: '-r',
+                 banner:  'Convert paths relative to current directory'
+
+    def start
+      Listen::Forwarder.new(options).start
+    end
+  end
+
+  class Forwarder
+    attr_reader :logger
+
+    def initialize(options)
+      @options = options
+      @logger = ::Logger.new(STDOUT, level: ::Logger::INFO)
+      @logger.formatter = proc { |_, _, _, msg| "#{msg}\n" }
+    end
+
+    def start
+      logger.info 'Starting listen...'
+
+      directory = @options[:directory]
+      relative = @options[:relative]
+      callback = proc do |modified, added, removed|
+        if @options[:verbose]
+          logger.info "+ #{added}" unless added.empty?
+          logger.info "- #{removed}" unless removed.empty?
+          logger.info "> #{modified}" unless modified.empty?
+        end
+      end
+
+      listener = Listen.to(*directory, relative: relative, &callback)
+
+      listener.start
+
+      sleep 0.5 while listener.processing?
+    end
+  end
+end

data/vendor/deps/listen/lib/listen/directory.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module Listen
+  # TODO: refactor (turn it into a normal object, cache the stat, etc)
+  class Directory
+    # rubocop:disable Metrics/MethodLength
+    def self.scan(snapshot, rel_path, options)
+      record = snapshot.record
+      dir = Pathname.new(record.root)
+      previous = record.dir_entries(rel_path)
+
+      record.add_dir(rel_path)
+
+      # TODO: use children(with_directory: false)
+      path = dir + rel_path
+      current = Set.new(_children(path))
+
+      Listen.logger.debug do
+        format('%s: %s(%s): %s -> %s',
+               (options[:silence] ? 'Recording' : 'Scanning'),
+               rel_path, options.inspect, previous.inspect, current.inspect)
+      end
+
+      begin
+        current.each do |full_path|
+          type = ::File.lstat(full_path.to_s).directory? ? :dir : :file
+          item_rel_path = full_path.relative_path_from(dir).to_s
+          _change(snapshot, type, item_rel_path, options)
+        end
+      rescue Errno::ENOENT
+        # The directory changed meanwhile, so rescan it
+        current = Set.new(_children(path))
+        retry
+      end
+
+      # TODO: this is not tested properly
+      previous = previous.reject { |entry, _| current.include?(path + entry) }
+
+      _async_changes(snapshot, Pathname.new(rel_path), previous, options)
+    rescue Errno::ENOENT, Errno::EHOSTDOWN
+      record.unset_path(rel_path)
+      _async_changes(snapshot, Pathname.new(rel_path), previous, options)
+    rescue Errno::ENOTDIR
+      # TODO: path not tested
+      record.unset_path(rel_path)
+      _async_changes(snapshot, path, previous, options)
+      _change(snapshot, :file, rel_path, options)
+    rescue
+      Listen.logger.warn { format('scan DIED: %s:%s', $ERROR_INFO, $ERROR_POSITION * "\n") }
+      raise
+    end
+    # rubocop:enable Metrics/MethodLength
+
+    def self.ascendant_of?(base, other)
+      other.ascend do |ascendant|
+        break true if base == ascendant
+      end
+    end
+
+    def self._async_changes(snapshot, path, previous, options)
+      fail "Not a Pathname: #{path.inspect}" unless path.respond_to?(:children)
+      previous.each do |entry, data|
+        # TODO: this is a hack with insufficient testing
+        type = data.key?(:mtime) ? :file : :dir
+        rel_path_s = (path + entry).to_s
+        _change(snapshot, type, rel_path_s, options)
+      end
+    end
+
+    def self._change(snapshot, type, path, options)
+      return snapshot.invalidate(type, path, options) if type == :dir
+
+      # Minor param cleanup for tests
+      # TODO: use a dedicated Event class
+      opts = options.dup
+      opts.delete(:recursive)
+      snapshot.invalidate(type, path, opts)
+    end
+
+    def self._children(path)
+      return path.children unless RUBY_ENGINE == 'jruby'
+
+      # JRuby inconsistency workaround, see:
+      # https://github.com/jruby/jruby/issues/3840
+      exists = path.exist?
+      directory = path.directory?
+      exists && !directory and raise Errno::ENOTDIR, path.to_s
+      path.children
+    end
+  end
+end

data/vendor/deps/listen/lib/listen/error.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+# Besides programming error exceptions like ArgumentError,
+# all public interface exceptions should be declared here and inherit from Listen::Error.
+module Listen
+  class Error < RuntimeError
+    class NotStarted < Error; end
+    class SymlinkLoop < Error; end
+    class INotifyMaxWatchesExceeded < Error; end
+  end
+end

data/vendor/deps/listen/lib/listen/event/config.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Listen
+  module Event
+    class Config
+      attr_reader :listener, :event_queue, :min_delay_between_events
+
+      def initialize(
+        listener,
+        event_queue,
+        queue_optimizer,
+        wait_for_delay,
+        &block
+      )
+        @listener = listener
+        @event_queue = event_queue
+        @queue_optimizer = queue_optimizer
+        @min_delay_between_events = wait_for_delay
+        @block = block
+      end
+
+      def sleep(seconds)
+        Kernel.sleep(seconds)
+      end
+
+      def call(*args)
+        @block&.call(*args)
+      end
+
+      def callable?
+        @block
+      end
+
+      def optimize_changes(changes)
+        @queue_optimizer.smoosh_changes(changes)
+      end
+    end
+  end
+end

data/vendor/deps/listen/lib/listen/event/loop.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require 'timeout'
+require 'listen/event/processor'
+require 'listen/thread'
+require 'listen/error'
+
+module Listen
+  module Event
+    class Loop
+      include Listen::FSM
+
+      Error = ::Listen::Error
+      NotStarted = ::Listen::Error::NotStarted # for backward compatibility
+
+      start_state :pre_start
+      state :pre_start
+      state :starting
+      state :started
+      state :stopped
+
+      def initialize(config)
+        @config = config
+        @wait_thread = nil
+        @reasons = ::Queue.new
+        initialize_fsm
+      end
+
+      def wakeup_on_event
+        if started? && @wait_thread&.alive?
+          _wakeup(:event)
+        end
+      end
+
+      def started?
+        state == :started
+      end
+
+      MAX_STARTUP_SECONDS = 5.0
+
+      # @raises Error::NotStarted if background thread hasn't started in MAX_STARTUP_SECONDS
+      def start
+        # TODO: use a Fiber instead?
+        return unless state == :pre_start
+
+        transition! :starting
+
+        @wait_thread = Listen::Thread.new("wait_thread") do
+          _process_changes
+        end
+
+        Listen.logger.debug("Waiting for processing to start...")
+
+        wait_for_state(:started, timeout: MAX_STARTUP_SECONDS) or
+          raise Error::NotStarted, "thread didn't start in #{MAX_STARTUP_SECONDS} seconds (in state: #{state.inspect})"
+
+        Listen.logger.debug('Processing started.')
+      end
+
+      def pause
+        # TODO: works?
+        # fail NotImplementedError
+      end
+
+      def stop
+        transition! :stopped
+
+        @wait_thread&.join
+        @wait_thread = nil
+      end
+
+      def stopped?
+        state == :stopped
+      end
+
+      private
+
+      def _process_changes
+        processor = Event::Processor.new(@config, @reasons)
+
+        transition! :started
+
+        processor.loop_for(@config.min_delay_between_events)
+      end
+
+      def _wakeup(reason)
+        @reasons << reason
+        @wait_thread.wakeup
+      end
+    end
+  end
+end

data/vendor/deps/listen/lib/listen/event/processor.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require 'listen/monotonic_time'
+
+module Listen
+  module Event
+    class Processor
+      def initialize(config, reasons)
+        @config = config
+        @listener = config.listener
+        @reasons = reasons
+        _reset_no_unprocessed_events
+      end
+
+      # TODO: implement this properly instead of checking the state at arbitrary
+      # points in time
+      def loop_for(latency)
+        @latency = latency
+
+        loop do
+          event = _wait_until_events
+          _check_stopped
+          _wait_until_events_calm_down
+          _wait_until_no_longer_paused
+          _process_changes(event)
+        end
+      rescue Stopped
+        Listen.logger.debug('Processing stopped')
+      end
+
+      private
+
+      class Stopped < RuntimeError
+      end
+
+      def _wait_until_events_calm_down
+        loop do
+          now = MonotonicTime.now
+
+          # Assure there's at least latency between callbacks to allow
+          # for accumulating changes
+          diff = _deadline - now
+          break if diff <= 0
+
+          # give events a bit of time to accumulate so they can be
+          # compressed/optimized
+          _sleep(diff)
+        end
+      end
+
+      def _wait_until_no_longer_paused
+        @listener.wait_for_state(*(Listener.states.keys - [:paused]))
+      end
+
+      def _check_stopped
+        if @listener.stopped?
+          _flush_wakeup_reasons
+          raise Stopped
+        end
+      end
+
+      def _sleep(seconds)
+        _check_stopped
+        config.sleep(seconds)
+        _check_stopped
+
+        _flush_wakeup_reasons do |reason|
+          if reason == :event && !@listener.paused?
+            _remember_time_of_first_unprocessed_event
+          end
+        end
+      end
+
+      def _remember_time_of_first_unprocessed_event
+        @_remember_time_of_first_unprocessed_event ||= MonotonicTime.now
+      end
+
+      def _reset_no_unprocessed_events
+        @_remember_time_of_first_unprocessed_event = nil
+      end
+
+      def _deadline
+        @_remember_time_of_first_unprocessed_event + @latency
+      end
+
+      # blocks until event is popped
+      # returns the event or `nil` when the event_queue is closed
+      # rubocop:disable Naming/MemoizedInstanceVariableName
+      def _wait_until_events
+        config.event_queue.pop.tap do |_event|
+          @_remember_time_of_first_unprocessed_event ||= MonotonicTime.now
+        end
+      end
+      # rubocop:enable Naming/MemoizedInstanceVariableName
+
+      def _flush_wakeup_reasons
+        until @reasons.empty?
+          reason = @reasons.pop
+          yield reason if block_given?
+        end
+      end
+
+      # for easier testing without sleep loop
+      def _process_changes(event)
+        _reset_no_unprocessed_events
+
+        changes = [event]
+        changes << config.event_queue.pop until config.event_queue.empty?
+
+        return unless config.callable?
+
+        hash = config.optimize_changes(changes)
+        result = [hash[:modified], hash[:added], hash[:removed]]
+        return if result.all?(&:empty?)
+
+        block_start = MonotonicTime.now
+        exception_note = " (exception)"
+        ::Listen::Thread.rescue_and_log('_process_changes') do
+          config.call(*result)
+          exception_note = nil
+        end
+        Listen.logger.debug "Callback#{exception_note} took #{MonotonicTime.now - block_start} sec"
+      end
+
+      attr_reader :config
+    end
+  end
+end

data/vendor/deps/listen/lib/listen/event/queue.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+module Listen
+  module Event
+    class Queue
+      extend Forwardable
+
+      class Config
+        def initialize(relative)
+          @relative = relative
+        end
+
+        def relative?
+          @relative
+        end
+      end
+
+      def initialize(config)
+        @event_queue = ::Queue.new
+        @config = config
+      end
+
+      def <<(args)
+        type, change, dir, path, options = *args
+        fail "Invalid type: #{type.inspect}" unless [:dir, :file].include? type
+        fail "Invalid change: #{change.inspect}" unless change.is_a?(Symbol)
+        fail "Invalid path: #{path.inspect}" unless path.is_a?(String)
+
+        dir = if @config.relative?
+          _safe_relative_from_cwd(dir)
+        else
+          dir
+        end
+        @event_queue << [type, change, dir, path, options]
+      end
+
+      delegate empty?: :@event_queue
+      delegate pop: :@event_queue
+      delegate close: :@event_queue
+
+      private
+
+      def _safe_relative_from_cwd(dir)
+        dir.relative_path_from(Pathname.pwd)
+      rescue ArgumentError
+        dir
+      end
+    end
+  end
+end

data/vendor/deps/listen/lib/listen/file.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require 'digest'
+
+module Listen
+  class File
+    # rubocop:disable Metrics/MethodLength
+    # rubocop:disable Metrics/CyclomaticComplexity
+    # rubocop:disable Metrics/PerceivedComplexity
+    def self.change(record, rel_path)
+      path = Pathname.new(record.root) + rel_path
+      lstat = path.lstat
+
+      data = { mtime: lstat.mtime.to_f, mode: lstat.mode, size: lstat.size }
+
+      record_data = record.file_data(rel_path)
+
+      if record_data.empty?
+        record.update_file(rel_path, data)
+        return :added
+      end
+
+      if data[:mode] != record_data[:mode]
+        record.update_file(rel_path, data)
+        return :modified
+      end
+
+      if data[:mtime] != record_data[:mtime]
+        record.update_file(rel_path, data)
+        return :modified
+      end
+
+      if data[:size] != record_data[:size]
+        record.update_file(rel_path, data)
+        return :modified
+      end
+
+      return if /1|true/ =~ ENV['LISTEN_GEM_DISABLE_HASHING']
+      return unless inaccurate_mac_time?(lstat)
+
+      # Check if change happened within 1 second (maybe it's even
+      # too much, e.g. 0.3-0.5 could be sufficient).
+      #
+      # With rb-fsevent, there's a (configurable) latency between
+      # when file was changed and when the event was triggered.
+      #
+      # If a file is saved at ???14.998, by the time the event is
+      # actually received by Listen, the time could already be e.g.
+      # ???15.7.
+      #
+      # And since Darwin adapter uses directory scanning, the file
+      # mtime may be the same (e.g. file was changed at ???14.001,
+      # then at ???14.998, but the fstat time would be ???14.0 in
+      # both cases).
+      #
+      # If change happened at ???14.999997, the mtime is 14.0, so for
+      # an mtime=???14.0 we assume it could even be almost ???15.0
+      #
+      # So if Time.now.to_f is ???15.999998 and stat reports mtime
+      # at ???14.0, then event was due to that file'd change when:
+      #
+      # ???15.999997 - ???14.999998 < 1.0s
+      #
+      # So the "2" is "1 + 1" (1s to cover rb-fsevent latency +
+      # 1s maximum difference between real mtime and that recorded
+      # in the file system)
+      #
+      return if data[:mtime].to_i + 2 <= Time.now.to_f
+
+      sha = Digest::SHA256.file(path).digest
+      record.update_file(rel_path, data.merge(sha: sha))
+      if record_data[:sha] && sha != record_data[:sha]
+        :modified
+      end
+    rescue SystemCallError
+      record.unset_path(rel_path)
+      :removed
+    rescue
+      Listen.logger.debug "lstat failed for: #{rel_path} (#{$ERROR_INFO})"
+      raise
+    end
+    # rubocop:enable Metrics/MethodLength
+    # rubocop:enable Metrics/CyclomaticComplexity
+    # rubocop:enable Metrics/PerceivedComplexity
+
+    def self.inaccurate_mac_time?(stat)
+      # 'mac' means Modified/Accessed/Created
+
+      # Since precision depends on mounted FS (e.g. you can have a FAT partiion
+      # mounted on Linux), check for fields with a remainder to detect this
+
+      [stat.mtime, stat.ctime, stat.atime].map(&:usec).all?(&:zero?)
+    end
+  end
+end