fluid_cli 0.1.2

data/vendor/deps/listen/lib/listen/adapter/base.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require 'listen/options'
+require 'listen/record'
+require 'listen/change'
+require 'listen/thread'
+
+module Listen
+  module Adapter
+    class Base
+      attr_reader :options, :config
+
+      # TODO: only used by tests
+      DEFAULTS = {}.freeze
+
+      def initialize(config)
+        @started = false
+        @config = config
+
+        @configured = nil
+
+        fail 'No directories to watch!' if config.directories.empty?
+
+        defaults = self.class.const_get('DEFAULTS')
+        @options = Listen::Options.new(config.adapter_options, defaults)
+      rescue
+        _log_exception 'adapter config failed: %s:%s called from: %s', caller
+        raise
+      end
+
+      # TODO: it's a separate method as a temporary workaround for tests
+      # rubocop:disable Metrics/MethodLength
+      def configure
+        if @configured
+          Listen.logger.warn('Adapter already configured!')
+          return
+        end
+
+        @configured = true
+
+        @callbacks ||= {}
+        config.directories.each do |dir|
+          callback = @callbacks[dir] || lambda do |event|
+            _process_event(dir, event)
+          end
+          @callbacks[dir] = callback
+          _configure(dir, &callback)
+        end
+
+        @snapshots ||= {}
+        # TODO: separate config per directory (some day maybe)
+        change_config = Change::Config.new(config.queue, config.silencer)
+        config.directories.each do |dir|
+          record = Record.new(dir, config.silencer)
+          snapshot = Change.new(change_config, record)
+          @snapshots[dir] = snapshot
+        end
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      def started?
+        @started
+      end
+
+      def start
+        configure
+
+        if started?
+          Listen.logger.warn('Adapter already started!')
+          return
+        end
+
+        @started = true
+
+        @run_thread = Listen::Thread.new("run_thread") do
+          @snapshots.each_value do |snapshot|
+            _timed('Record.build()') { snapshot.record.build }
+          end
+          _run
+        end
+      end
+
+      def stop
+        _stop
+        config.queue.close # this causes queue.pop to return `nil` to the front-end
+      end
+
+      private
+
+      def _stop
+        @run_thread&.kill
+        @run_thread = nil
+      end
+
+      def _timed(title)
+        start = MonotonicTime.now
+        yield
+        diff = MonotonicTime.now - start
+        Listen.logger.info format('%s: %.05f seconds', title, diff)
+      rescue
+        Listen.logger.warn "#{title} crashed: #{$ERROR_INFO.inspect}"
+        raise
+      end
+
+      # TODO: allow backend adapters to pass specific invalidation objects
+      # e.g. Darwin -> DirRescan, INotify -> MoveScan, etc.
+      def _queue_change(type, dir, rel_path, options)
+        @snapshots[dir].invalidate(type, rel_path, options)
+      end
+
+      def _log_exception(msg, caller_stack)
+        formatted = format(
+          msg,
+          $ERROR_INFO,
+          $ERROR_POSITION * "\n",
+          caller_stack * "\n"
+        )
+
+        Listen.logger.error(formatted)
+      end
+
+      class << self
+        def usable?
+          const_get('OS_REGEXP') =~ RbConfig::CONFIG['target_os']
+        end
+      end
+    end
+  end
+end

data/vendor/deps/listen/lib/listen/adapter/bsd.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+# Listener implementation for BSD's `kqueue`.
+# @see http://www.freebsd.org/cgi/man.cgi?query=kqueue
+# @see https://github.com/mat813/rb-kqueue/blob/master/lib/rb-kqueue/queue.rb
+#
+module Listen
+  module Adapter
+    class BSD < Base
+      OS_REGEXP = /bsd|dragonfly/i
+
+      DEFAULTS = {
+        events: [
+          :delete,
+          :write,
+          :extend,
+          :attrib,
+          :rename
+          # :link, :revoke
+        ]
+      }.freeze
+
+      BUNDLER_DECLARE_GEM = <<-EOS.gsub(/^ {6}/, '')
+        Please add the following to your Gemfile to avoid polling for changes:
+          gem 'rb-kqueue', '>= 0.2'
+      EOS
+
+      def self.usable?
+        return false unless super
+        require 'rb-kqueue'
+        require 'find'
+        true
+      rescue LoadError
+        Listen.adapter_warn(BUNDLER_DECLARE_GEM)
+        false
+      end
+
+      private
+
+      def _configure(directory, &callback)
+        @worker ||= KQueue::Queue.new
+        @callback = callback
+        # use Record to make a snapshot of dir, so we
+        # can detect new files
+        _find(directory.to_s) { |path| _watch_file(path, @worker) }
+      end
+
+      def _run
+        @worker.run
+      end
+
+      def _process_event(dir, event)
+        full_path = _event_path(event)
+        if full_path.directory?
+          # Force dir content tracking to kick in, or we won't have
+          # names of added files
+          _queue_change(:dir, dir, '.', recursive: true)
+        elsif full_path.exist?
+          path = full_path.relative_path_from(dir)
+          _queue_change(:file, dir, path.to_s, change: _change(event.flags))
+        end
+
+        # If it is a directory, and it has a write flag, it means a
+        # file has been added so find out which and deal with it.
+        # No need to check for removed files, kqueue will forget them
+        # when the vfs does.
+        _watch_for_new_file(event) if full_path.directory?
+      end
+
+      def _change(event_flags)
+        { modified: [:attrib, :extend],
+          added:    [:write],
+          removed:  [:rename, :delete] }.each do |change, flags|
+          return change unless (flags & event_flags).empty?
+        end
+        nil
+      end
+
+      def _event_path(event)
+        Pathname.new(event.watcher.path)
+      end
+
+      def _watch_for_new_file(event)
+        queue = event.watcher.queue
+        _find(_event_path(event).to_s) do |file_path|
+          unless queue.watchers.find { |_, v| v.path == file_path.to_s }
+            _watch_file(file_path, queue)
+          end
+        end
+      end
+
+      def _watch_file(path, queue)
+        queue.watch_file(path, *options.events, &@callback)
+      rescue Errno::ENOENT => e
+        Listen.logger.warn "kqueue: watch file failed: #{e.message}"
+      end
+
+      # Quick rubocop workaround
+      def _find(*paths, &block)
+        Find.send(:find, *paths, &block)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'pathname'
+
+module Listen
+  module Adapter
+    class Config
+      attr_reader :directories, :silencer, :queue, :adapter_options
+
+      def initialize(directories, queue, silencer, adapter_options)
+        # Default to current directory if no directories are supplied
+        directories = [Dir.pwd] if directories.to_a.empty?
+
+        # TODO: fix (flatten, array, compact?)
+        @directories = directories.map do |directory|
+          Pathname.new(directory.to_s).realpath
+        end
+
+        @directories.each do |pathname|
+          unless pathname.directory?
+            fail ArgumentError, "must be a directory: #{pathname}"
+          end
+        end
+
+        @silencer = silencer
+        @queue = queue
+        @adapter_options = adapter_options
+      end
+    end
+  end
+end

data/vendor/deps/listen/lib/listen/adapter/darwin.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require 'listen/thread'
+
+module Listen
+  module Adapter
+    # Adapter implementation for Mac OS X `FSEvents`.
+    #
+    class Darwin < Base
+      OS_REGEXP = /darwin(?<major_version>(1|2)\d+)/i
+
+      # The default delay between checking for changes.
+      DEFAULTS = { latency: 0.1 }.freeze
+
+      INCOMPATIBLE_GEM_VERSION = <<-EOS.gsub(/^ {8}/, '')
+        rb-fsevent > 0.9.4 no longer supports OS X 10.6 through 10.8.
+
+        Please add the following to your Gemfile to avoid polling for changes:
+          require 'rbconfig'
+          if RbConfig::CONFIG['target_os'] =~ /darwin(1[0-3])/i
+            gem 'rb-fsevent', '<= 0.9.4'
+          end
+      EOS
+
+      def self.usable?
+        version = RbConfig::CONFIG['target_os'][OS_REGEXP, :major_version]
+        return false unless version
+        return true if version.to_i >= 13 # darwin13 is OS X 10.9
+
+        require 'rb-fsevent'
+        fsevent_version = Gem::Version.new(FSEvent::VERSION)
+        return true if fsevent_version <= Gem::Version.new('0.9.4')
+        Listen.adapter_warn(INCOMPATIBLE_GEM_VERSION)
+        false
+      end
+
+      private
+
+      def _configure(dir, &callback)
+        @callbacks[dir] = callback
+      end
+
+      def _run
+        require 'rb-fsevent'
+        worker = FSEvent.new
+        dirs_to_watch = @callbacks.keys.map(&:to_s)
+        Listen.logger.info { "fsevent: watching: #{dirs_to_watch.inspect}" }
+        worker.watch(dirs_to_watch, { latency: options.latency }, &method(:_process_changes))
+        @worker_thread = Listen::Thread.new("worker_thread") { worker.run }
+      end
+
+      def _process_changes(dirs)
+        dirs.each do |dir|
+          dir = Pathname.new(dir.sub(%r{/$}, ''))
+
+          @callbacks.each do |watched_dir, callback|
+            if watched_dir.eql?(dir) || Listen::Directory.ascendant_of?(watched_dir, dir)
+              callback.call(dir)
+            end
+          end
+        end
+      end
+
+      def _process_event(dir, path)
+        Listen.logger.debug { "fsevent: processing path: #{path.inspect}" }
+        # TODO: does this preserve symlinks?
+        rel_path = path.relative_path_from(dir).to_s
+        _queue_change(:dir, dir, rel_path, recursive: true)
+      end
+
+      def _stop
+        @worker_thread&.kill
+        super
+      end
+    end
+  end
+end

data/vendor/deps/listen/lib/listen/adapter/linux.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module Listen
+  module Adapter
+    # @see https://github.com/nex3/rb-inotify
+    class Linux < Base
+      OS_REGEXP = /linux/i
+
+      DEFAULTS = {
+        events: [
+          :recursive,
+          :attrib,
+          :create,
+          :modify,
+          :delete,
+          :move,
+          :close_write
+        ],
+        wait_for_delay: 0.1
+      }.freeze
+
+      private
+
+      README_URL = 'https://github.com/guard/listen'\
+        '/blob/master/README.md#increasing-the-amount-of-inotify-watchers'
+
+      def _configure(directory, &callback)
+        require 'rb-inotify'
+        @worker ||= ::INotify::Notifier.new
+        @worker.watch(directory.to_s, *options.events, &callback)
+      rescue Errno::ENOSPC
+        raise ::Listen::Error::INotifyMaxWatchesExceeded, <<~EOS
+          Unable to monitor directories for changes because iNotify max watches exceeded. See #{README_URL} .
+        EOS
+      end
+
+      def _run
+        @worker.run
+      end
+
+      # rubocop:disable Metrics/MethodLength
+      def _process_event(dir, event)
+        # NOTE: avoid using event.absolute_name since new API
+        # will need to have a custom recursion implemented
+        # to properly match events to configured directories
+        path = Pathname.new(event.watcher.path) + event.name
+        rel_path = path.relative_path_from(dir).to_s
+
+        Listen.logger.debug { "inotify: #{rel_path} (#{event.flags.inspect})" }
+
+        if /1|true/ =~ ENV['LISTEN_GEM_SIMULATE_FSEVENT']
+          if (event.flags & [:moved_to, :moved_from]) || _dir_event?(event)
+            rel_path = path.dirname.relative_path_from(dir).to_s
+          end
+          _queue_change(:dir, dir, rel_path, {})
+          return
+        end
+
+        return if _skip_event?(event)
+
+        cookie_params = event.cookie.zero? ? {} : { cookie: event.cookie }
+
+        # NOTE: don't pass options to force rescanning the directory, so we can
+        # detect moving/deleting a whole tree
+        if _dir_event?(event)
+          _queue_change(:dir, dir, rel_path, cookie_params)
+          return
+        end
+
+        params = cookie_params.merge(change: _change(event.flags))
+
+        _queue_change(:file, dir, rel_path, params)
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      def _skip_event?(event)
+        # Event on root directory
+        return true if event.name == ''
+        # INotify reports changes to files inside directories as events
+        # on the directories themselves too.
+        #
+        # @see http://linux.die.net/man/7/inotify
+        _dir_event?(event) && (event.flags & [:close, :modify]).any?
+      end
+
+      def _change(event_flags)
+        { modified:   [:attrib, :close_write],
+          moved_to:   [:moved_to],
+          moved_from: [:moved_from],
+          added:      [:create],
+          removed:    [:delete] }.each do |change, flags|
+          return change unless (flags & event_flags).empty?
+        end
+        nil
+      end
+
+      def _dir_event?(event)
+        event.flags.include?(:isdir)
+      end
+
+      def _stop
+        @worker&.close
+
+        super
+      end
+    end
+  end
+end

data/vendor/deps/listen/lib/listen/adapter/polling.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Listen
+  module Adapter
+    # Polling Adapter that works cross-platform and
+    # has no dependencies. This is the adapter that
+    # uses the most CPU processing power and has higher
+    # file IO than the other implementations.
+    #
+    class Polling < Base
+      OS_REGEXP = // # match every OS
+
+      DEFAULTS = { latency: 1.0, wait_for_delay: 0.05 }.freeze
+
+      private
+
+      def _configure(_, &callback)
+        @polling_callbacks ||= []
+        @polling_callbacks << callback
+      end
+
+      def _run
+        loop do
+          start = MonotonicTime.now
+          @polling_callbacks.each do |callback|
+            callback.call(nil)
+            if (nap_time = options.latency - (MonotonicTime.now - start)) > 0
+              # TODO: warn if nap_time is negative (polling too slow)
+              sleep(nap_time)
+            end
+          end
+        end
+      end
+
+      def _process_event(dir, _)
+        _queue_change(:dir, dir, '.', recursive: true)
+      end
+    end
+  end
+end

data/vendor/deps/listen/lib/listen/adapter/windows.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Listen
+  module Adapter
+    # Adapter implementation for Windows `wdm`.
+    #
+    class Windows < Base
+      OS_REGEXP = /mswin|mingw|cygwin/i
+
+      BUNDLER_DECLARE_GEM = <<-EOS.gsub(/^ {6}/, '')
+        Please add the following to your Gemfile to avoid polling for changes:
+          gem 'wdm', '>= 0.1.0'
+      EOS
+
+      def self.usable?
+        return false unless super
+        require 'wdm'
+        true
+      rescue LoadError
+        Listen.logger.debug format('wdm - load failed: %s:%s', $ERROR_INFO,
+                                   $ERROR_POSITION * "\n")
+
+        Listen.adapter_warn(BUNDLER_DECLARE_GEM)
+        false
+      end
+
+      private
+
+      def _configure(dir)
+        require 'wdm'
+        Listen.logger.debug 'wdm - starting...'
+        @worker ||= WDM::Monitor.new
+        @worker.watch_recursively(dir.to_s, :files) do |change|
+          yield([:file, change])
+        end
+
+        @worker.watch_recursively(dir.to_s, :directories) do |change|
+          yield([:dir, change])
+        end
+
+        @worker.watch_recursively(dir.to_s, :attributes, :last_write) do |change|
+          yield([:attr, change])
+        end
+      end
+
+      def _run
+        @worker.run!
+      end
+
+      # rubocop:disable Metrics/MethodLength
+      def _process_event(dir, event)
+        Listen.logger.debug "wdm - callback: #{event.inspect}"
+
+        type, change = event
+
+        full_path = Pathname(change.path)
+
+        rel_path = full_path.relative_path_from(dir).to_s
+
+        options = { change: _change(change.type) }
+
+        case type
+        when :file
+          _queue_change(:file, dir, rel_path, options)
+        when :attr
+          unless full_path.directory?
+            _queue_change(:file, dir, rel_path, options)
+          end
+        when :dir
+          case change.type
+          when :removed
+            # TODO: check if watched dir?
+            _queue_change(:dir, dir, Pathname(rel_path).dirname.to_s, {})
+          when :added
+            _queue_change(:dir, dir, rel_path, {})
+            # do nothing - changed directory means either:
+            #   - removed subdirs (handled above)
+            #   - added subdirs (handled above)
+            #   - removed files (handled by _file_callback)
+            #   - added files (handled by _file_callback)
+            # so what's left?
+          end
+        end
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      def _change(type)
+        { modified: [:modified, :attrib], # TODO: is attrib really passed?
+          added:    [:added, :renamed_new_file],
+          removed:  [:removed, :renamed_old_file] }.find do |change, types|
+          types.include?(type) and break change
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'listen/adapter/base'
+require 'listen/adapter/bsd'
+require 'listen/adapter/darwin'
+require 'listen/adapter/linux'
+require 'listen/adapter/polling'
+require 'listen/adapter/windows'
+
+module Listen
+  module Adapter
+    OPTIMIZED_ADAPTERS = [Darwin, Linux, BSD, Windows].freeze
+    POLLING_FALLBACK_MESSAGE = 'Listen will be polling for changes.'\
+      'Learn more at https://github.com/guard/listen#listen-adapters.'
+
+    class << self
+      def select(options = {})
+        Listen.logger.debug 'Adapter: considering polling ...'
+        return Polling if options[:force_polling]
+        Listen.logger.debug 'Adapter: considering optimized backend...'
+        return _usable_adapter_class if _usable_adapter_class
+        Listen.logger.debug 'Adapter: falling back to polling...'
+        _warn_polling_fallback(options)
+        Polling
+      rescue
+        Listen.logger.warn format('Adapter: failed: %s:%s', $ERROR_POSITION.inspect,
+                                  $ERROR_POSITION * "\n")
+        raise
+      end
+
+      private
+
+      def _usable_adapter_class
+        OPTIMIZED_ADAPTERS.find(&:usable?)
+      end
+
+      def _warn_polling_fallback(options)
+        msg = options.fetch(:polling_fallback_message, POLLING_FALLBACK_MESSAGE)
+        Listen.adapter_warn("[Listen warning]:\n  #{msg}") if msg
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'listen/adapter'
+require 'listen/adapter/base'
+require 'listen/adapter/config'
+
+require 'forwardable'
+
+# This class just aggregates configuration object to avoid Listener specs
+# from exploding with huge test setup blocks
+module Listen
+  class Backend
+    extend Forwardable
+
+    def initialize(directories, queue, silencer, config)
+      adapter_select_opts = config.adapter_select_options
+
+      adapter_class = Adapter.select(adapter_select_opts)
+
+      # Use default from adapter if possible
+      @min_delay_between_events = config.min_delay_between_events
+      @min_delay_between_events ||= adapter_class::DEFAULTS[:wait_for_delay]
+      @min_delay_between_events ||= 0.1
+
+      adapter_opts = config.adapter_instance_options(adapter_class)
+
+      aconfig = Adapter::Config.new(directories, queue, silencer, adapter_opts)
+      @adapter = adapter_class.new(aconfig)
+    end
+
+    delegate start: :adapter
+    delegate stop: :adapter
+
+    attr_reader :min_delay_between_events
+
+    private
+
+    attr_reader :adapter
+  end
+end