fluid_cli 0.1.2

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

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require 'listen/record/entry'
+require 'listen/record/symlink_detector'
+
+module Listen
+  class Record
+    # TODO: one Record object per watched directory?
+    # TODO: deprecate
+
+    attr_reader :root
+
+    def initialize(directory, silencer)
+      reset_tree
+      @root = directory.to_s
+      @silencer = silencer
+    end
+
+    def add_dir(rel_path)
+      if !empty_dirname?(rel_path.to_s)
+        @tree[rel_path.to_s]
+      end
+    end
+
+    def update_file(rel_path, data)
+      dirname, basename = Pathname(rel_path).split.map(&:to_s)
+      _fast_update_file(dirname, basename, data)
+    end
+
+    def unset_path(rel_path)
+      dirname, basename = Pathname(rel_path).split.map(&:to_s)
+      _fast_unset_path(dirname, basename)
+    end
+
+    def file_data(rel_path)
+      dirname, basename = Pathname(rel_path).split.map(&:to_s)
+      if empty_dirname?(dirname)
+        @tree[basename].dup
+      else
+        @tree[dirname][basename] ||= {}
+        @tree[dirname][basename].dup
+      end
+    end
+
+    def dir_entries(rel_path)
+      rel_path_s = rel_path.to_s
+      subtree = if empty_dirname?(rel_path_s)
+        @tree
+      else
+        @tree[rel_path_s]
+      end
+
+      subtree.each_with_object({}) do |(key, values), result|
+        # only return data for file entries inside the dir (which will each be sub-hashes)
+        if values.is_a?(Hash)
+          result[key] = values.has_key?(:mtime) ? values : {}
+        end
+      end
+    end
+
+    def build
+      reset_tree
+      # TODO: test with a file name given
+      # TODO: test other permissions
+      # TODO: test with mixed encoding
+      symlink_detector = SymlinkDetector.new
+      remaining = ::Queue.new
+      remaining << Entry.new(root, nil, nil)
+      _fast_build_dir(remaining, symlink_detector) until remaining.empty?
+    end
+
+    private
+
+    def empty_dirname?(dirname)
+      ['.', ''].include?(dirname)
+    end
+
+    def reset_tree
+      @tree = Hash.new { |h, k| h[k] = {} }
+    end
+
+    def _fast_update_file(dirname, basename, data)
+      if empty_dirname?(dirname.to_s)
+        @tree[basename] = @tree[basename].merge(data)
+      else
+        @tree[dirname][basename] = (@tree[dirname][basename] || {}).merge(data)
+      end
+    end
+
+    def _fast_unset_path(dirname, basename)
+      # this may need to be reworked to properly remove
+      # entries from a tree, without adding non-existing dirs to the record
+      if empty_dirname?(dirname.to_s)
+        if @tree.key?(basename)
+          @tree.delete(basename)
+        end
+      elsif @tree.key?(dirname)
+        @tree[dirname].delete(basename)
+      end
+    end
+
+    def _fast_build_dir(remaining, symlink_detector)
+      entry = remaining.pop
+      return if @silencer.silenced?(entry.record_dir_key, :dir)
+
+      children = entry.children # NOTE: children() implicitly tests if dir
+      symlink_detector.verify_unwatched!(entry)
+      children.each { |child| remaining << child }
+      add_dir(entry.record_dir_key)
+    rescue Errno::ENOTDIR
+      _fast_try_file(entry)
+    rescue SystemCallError, SymlinkDetector::Error
+      _fast_unset_path(entry.relative, entry.name)
+    end
+
+    def _fast_try_file(entry)
+      _fast_update_file(entry.relative, entry.name, entry.meta)
+    rescue SystemCallError
+      _fast_unset_path(entry.relative, entry.name)
+    end
+  end
+end

data/vendor/deps/listen/lib/listen/silencer/controller.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Listen
+  class Silencer
+    class Controller
+      def initialize(silencer, default_options)
+        @silencer = silencer
+
+        opts = default_options
+
+        @prev_silencer_options = {}
+        rules = [:only, :ignore, :ignore!].map do |option|
+          [option, opts[option]] if opts.key? option
+        end
+
+        _reconfigure_silencer(Hash[rules.compact])
+      end
+
+      def append_ignores(*regexps)
+        prev_ignores = Array(@prev_silencer_options[:ignore])
+        _reconfigure_silencer(ignore: [prev_ignores + regexps])
+      end
+
+      def replace_with_bang_ignores(regexps)
+        _reconfigure_silencer(ignore!: regexps)
+      end
+
+      def replace_with_only(regexps)
+        _reconfigure_silencer(only: regexps)
+      end
+
+      private
+
+      def _reconfigure_silencer(extra_options)
+        opts = extra_options.dup
+        opts = opts.map do |key, value|
+          [key, Array(value).flatten.compact]
+        end
+        opts = Hash[opts]
+
+        if opts.key?(:ignore) && opts[:ignore].empty?
+          opts.delete(:ignore)
+        end
+
+        @prev_silencer_options = opts
+        @silencer.configure(@prev_silencer_options.dup.freeze)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Listen
+  class Silencer
+    # The default list of directories that get ignored.
+    DEFAULT_IGNORED_FILES = %r{\A(?:
+    \.git
+      | \.svn
+      | \.hg
+      | \.rbx
+      | \.bundle
+      | bundle
+      | vendor/bundle
+      | log
+      | tmp
+      | vendor/ruby
+
+      # emacs temp files
+      | \#.+\#
+      | \.\#.+
+      )(/|\z)}x
+
+    # The default list of files that get ignored.
+    DEFAULT_IGNORED_EXTENSIONS = %r{(?:
+      # Kate's tmp\/swp files
+      \..*\d+\.new
+      | \.kate-swp
+
+      # Gedit tmp files
+      | \.goutputstream-.{6}
+
+      # Intellij files
+      | ___jb_bak___
+      | ___jb_old___
+
+      # Vim swap files and write test
+      | \.sw[px]
+      | \.swpx
+      | ^4913
+
+      # Sed temporary files - but without actual words, like 'sedatives'
+      | (?:\A
+         sed
+
+         (?:
+          [a-zA-Z0-9]{0}[A-Z]{1}[a-zA-Z0-9]{5} |
+          [a-zA-Z0-9]{1}[A-Z]{1}[a-zA-Z0-9]{4} |
+          [a-zA-Z0-9]{2}[A-Z]{1}[a-zA-Z0-9]{3} |
+          [a-zA-Z0-9]{3}[A-Z]{1}[a-zA-Z0-9]{2} |
+          [a-zA-Z0-9]{4}[A-Z]{1}[a-zA-Z0-9]{1} |
+          [a-zA-Z0-9]{5}[A-Z]{1}[a-zA-Z0-9]{0}
+         )
+        )
+
+      # Mutagen sync temporary files
+      | \.mutagen-temporary.*
+
+      # other files
+      | \.DS_Store
+      | \.tmp
+      | ~
+    )\z}x
+
+    # TODO: deprecate these mutators; use attr_reader instead
+    attr_accessor :only_patterns, :ignore_patterns
+
+    def initialize(**options)
+      configure(options)
+    end
+
+    # TODO: deprecate this mutator
+    def configure(options)
+      @only_patterns = options[:only] ? Array(options[:only]) : nil
+      @ignore_patterns = _init_ignores(options[:ignore], options[:ignore!])
+    end
+
+    def silenced?(relative_path, type)
+      path = relative_path.to_s # in case it is a Pathname
+
+      _ignore?(path) || (only_patterns && type == :file && !_only?(path))
+    end
+
+    private
+
+    def _ignore?(path)
+      ignore_patterns.any? { |pattern| path =~ pattern }
+    end
+
+    def _only?(path)
+      only_patterns.any? { |pattern| path =~ pattern }
+    end
+
+    def _init_ignores(ignores, overrides)
+      patterns = []
+      unless overrides
+        patterns << DEFAULT_IGNORED_FILES
+        patterns << DEFAULT_IGNORED_EXTENSIONS
+      end
+
+      patterns << ignores
+      patterns << overrides
+
+      patterns.compact.flatten
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'thread'
+
+require_relative 'logger'
+
+module Listen
+  module Thread
+    class << self
+      # Creates a new thread with the given name.
+      # Any exceptions raised by the thread will be logged with the thread name and complete backtrace.
+      # rubocop:disable Style/MultilineBlockChain
+      def new(name, &block)
+        thread_name = "listen-#{name}"
+        caller_stack = caller
+
+        ::Thread.new do
+          rescue_and_log(thread_name, caller_stack: caller_stack, &block)
+        end.tap do |thread|
+          thread.name = thread_name
+        end
+      end
+      # rubocop:enable Style/MultilineBlockChain
+
+      def rescue_and_log(method_name, *args, caller_stack: nil)
+        yield(*args)
+      rescue => exception
+        _log_exception(exception, method_name, caller_stack: caller_stack)
+      end
+
+      private
+
+      def _log_exception(exception, thread_name, caller_stack: nil)
+        complete_backtrace = if caller_stack
+          [*exception.backtrace, "--- Thread.new ---", *caller_stack]
+        else
+          exception.backtrace
+        end
+        message = "Exception rescued in #{thread_name}:\n#{_exception_with_causes(exception)}\n#{complete_backtrace * "\n"}"
+        Listen.logger.error(message)
+      end
+
+      def _exception_with_causes(exception)
+        result = +"#{exception.class}: #{exception}"
+        if exception.cause
+          result << "\n"
+          result << "--- Caused by: ---\n"
+          result << _exception_with_causes(exception.cause)
+        end
+        result
+      end
+    end
+  end
+end

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

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Listen
+  VERSION = '3.9.0'
+end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'logger'
+require 'weakref'
+require 'listen/logger'
+require 'listen/listener'
+
+# Won't print anything by default because of level - unless you've set
+# LISTEN_GEM_DEBUGGING or provided your own logger with a high enough level
+Listen.logger.info "Listen loglevel set to: #{Listen.logger.level}"
+Listen.logger.info "Listen version: #{Listen::VERSION}"
+
+module Listen
+  @listeners = Queue.new
+
+  class << self
+    # Listens to file system modifications on a either single directory or
+    # multiple directories.
+    #
+    # @param (see Listen::Listener#new)
+    #
+    # @yield [modified, added, removed] the changed files
+    # @yieldparam [Array<String>] modified the list of modified files
+    # @yieldparam [Array<String>] added the list of added files
+    # @yieldparam [Array<String>] removed the list of removed files
+    #
+    # @return [Listen::Listener] the listener
+    #
+    def to(*args, &block)
+      Listener.new(*args, &block).tap do |listener|
+        @listeners.enq(WeakRef.new(listener))
+      end
+    end
+
+    # This is used by the `listen` binary to handle Ctrl-C
+    #
+    def stop
+      while (listener = @listeners.deq(true))
+        begin
+          listener.stop
+        rescue WeakRef::RefError
+        end
+      end
+    rescue ThreadError
+    end
+  end
+end

data/vendor/deps/listen/listen.gemspec

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'listen/version'
+
+Gem::Specification.new do |gem| # rubocop:disable Metrics/BlockLength
+  gem.name        = 'listen'
+  gem.version     = Listen::VERSION
+  gem.license     = 'MIT'
+  gem.author      = 'Thibaud Guillaume-Gentil'
+  gem.email       = 'thibaud@thibaud.gg'
+  gem.homepage    = 'https://github.com/guard/listen'
+  gem.summary     = 'Listen to file modifications'
+  gem.description = 'The Listen gem listens to file modifications and '\
+    'notifies you about the changes. Works everywhere!'
+  gem.metadata = {
+    'allowed_push_host' => 'https://rubygems.org',
+    'bug_tracker_uri' => "#{gem.homepage}/issues",
+    'changelog_uri' => "#{gem.homepage}/releases",
+    'documentation_uri' => "https://www.rubydoc.info/gems/listen/#{gem.version}",
+    'homepage_uri' => gem.homepage,
+    'source_code_uri' => "#{gem.homepage}/tree/v#{gem.version}"
+  }
+
+  gem.files = `git ls-files -z`.split("\x0").select do |f|
+    %r{^(?:bin|lib)/} =~ f
+  end + %w[CHANGELOG.md CONTRIBUTING.md LICENSE.txt README.md]
+
+  gem.test_files   = []
+  gem.executable   = 'listen'
+  gem.require_path = 'lib'
+
+  gem.required_ruby_version = '>= 2.4.0' # rubocop:disable Gemspec/RequiredRubyVersion
+
+  gem.add_dependency 'logger'
+  gem.add_dependency 'rb-fsevent', '~> 0.10', '>= 0.10.3'
+  gem.add_dependency 'rb-inotify', '~> 0.9', '>= 0.9.10'
+end