Vendor bundled gems for deployment

1 files changed, 909 insertions, 0 deletions

diff --git a/vendor/bundle/ruby/3.4.0/gems/pathutil-0.16.2/lib/pathutil.rb b/vendor/bundle/ruby/3.4.0/gems/pathutil-0.16.2/lib/pathutil.rb
new file mode 100644
index 0000000..1a15873
--- /dev/null
+++ b/vendor/bundle/ruby/3.4.0/gems/pathutil-0.16.2/lib/pathutil.rb
@@ -0,0 +1,909 @@
+# Frozen-string-literal: true
+# Copyright: 2015 - 2017 Jordon Bedwell - MIT License
+# Encoding: utf-8
+
+require "pathutil/helpers"
+require "forwardable/extended"
+require "find"
+
+class Pathutil
+  attr_writer :encoding
+  extend Forwardable::Extended
+  extend Helpers
+
+  # --
+  # @note A lot of this class can be compatible with Pathname.
+  # Initialize a new instance.
+  # @return Pathutil
+  # --
+  def initialize(path)
+    return @path = path if path.is_a?(String)
+    return @path = path.to_path if path.respond_to?(:to_path)
+    return @path = path.to_s
+  end
+
+  # --
+  # Make a path relative.
+  # --
+  def relative
+    return self if relative?
+    self.class.new(strip_windows_drive.gsub(
+      %r!\A(\\+|/+)!, ""
+    ))
+  end
+
+  # --
+  # Make a path absolute
+  # --
+  def absolute
+    return self if absolute?
+    self.class.new("/").join(
+      @path
+    )
+  end
+
+  # --
+  # @see Pathname#cleanpath.
+  # @note This is a wholesale rip and cleanup of Pathname#cleanpath
+  # @return Pathutil
+  # --
+  def cleanpath(symlink = false)
+    symlink ? conservative_cleanpath : aggressive_cleanpath
+  end
+
+  # --
+  # @yield Pathutil
+  # @note It will return all results that it finds across all ascending paths.
+  # @example Pathutil.new("~/").expand_path.search_backwards(".bashrc") => [#<Pathutil:/home/user/.bashrc>]
+  # Search backwards for a file (like Rakefile, _config.yml, opts.yml).
+  # @return Enum
+  # --
+  def search_backwards(file, backwards: Float::INFINITY)
+    ary = []
+
+    ascend.with_index(1).each do |path, index|
+      if index > backwards
+        break
+
+      else
+        Dir.chdir path do
+          if block_given?
+            file = self.class.new(file)
+            if yield(file)
+              ary.push(
+                file
+              )
+            end
+
+          elsif File.exist?(file)
+            ary.push(self.class.new(
+              path.join(file)
+            ))
+          end
+        end
+      end
+    end
+
+    ary
+  end
+
+  # --
+  # Read the file as a YAML file turning it into an object.
+  # @see self.class.load_yaml as this a direct alias of that method.
+  # @return Hash
+  # --
+  def read_yaml(throw_missing: false, **kwd)
+    self.class.load_yaml(
+      read, **kwd
+    )
+
+  rescue Errno::ENOENT
+    throw_missing ? raise : (
+      return {}
+    )
+  end
+
+  # --
+  # Read the file as a JSON file turning it into an object.
+  # @see self.class.read_json as this is a direct alias of that method.
+  # @return Hash
+  # --
+  def read_json(throw_missing: false)
+    JSON.parse(
+      read
+    )
+
+  rescue Errno::ENOENT
+    throw_missing ? raise : (
+      return {}
+    )
+  end
+
+  # --
+  # @note The blank part is intentionally left there so that you can rejoin.
+  # Splits the path into all parts so that you can do step by step comparisons
+  # @example Pathutil.new("/my/path").split_path # => ["", "my", "path"]
+  # @return Array<String>
+  # --
+  def split_path
+    @path.split(
+      %r!\\+|/+!
+    )
+  end
+
+  # --
+  # @see `String#==` for more details.
+  # A stricter version of `==` that also makes sure the object matches.
+  # @return true|false
+  # --
+  def ===(other)
+    other.is_a?(self.class) && @path == other
+  end
+
+  # --
+  # @example Pathutil.new("/hello") >= Pathutil.new("/") # => true
+  # @example Pathutil.new("/hello") >= Pathutil.new("/hello") # => true
+  # Checks to see if a path falls within a path and deeper or is the other.
+  # @return true|false
+  # --
+  def >=(other)
+    mine, other = expanded_paths(other)
+    return true if other == mine
+    mine.in_path?(other)
+  end
+
+  # --
+  # @example Pathutil.new("/hello/world") > Pathutil.new("/hello") # => true
+  # Strictly checks to see if a path is deeper but within the path of the other.
+  # @return true|false
+  # --
+  def >(other)
+    mine, other = expanded_paths(other)
+    return false if other == mine
+    mine.in_path?(other)
+  end
+
+  # --
+  # @example Pathutil.new("/") < Pathutil.new("/hello") # => true
+  # Strictly check to see if a path is behind other path but within it.
+  # @return true|false
+  # --
+  def <(other)
+    mine, other = expanded_paths(other)
+    return false if other == mine
+    other.in_path?(mine)
+  end
+
+  # --
+  # Check to see if a path is behind the other path but within it.
+  # @example Pathutil.new("/hello") < Pathutil.new("/hello") # => true
+  # @example Pathutil.new("/") < Pathutil.new("/hello") # => true
+  # @return true|false
+  # --
+  def <=(other)
+    mine, other = expanded_paths(other)
+    return true if other == mine
+    other.in_path?(mine)
+  end
+
+  # --
+  # @note "./" is considered relative.
+  # Check to see if the path is absolute, as in: starts with "/"
+  # @return true|false
+  # --
+  def absolute?
+    return !!(
+      @path =~ %r!\A(?:[A-Za-z]:)?(?:\\+|/+)!
+    )
+  end
+
+  # --
+  # @yield Pathutil
+  # Break apart the path and yield each with the previous parts.
+  # @example Pathutil.new("/hello/world").ascend.to_a # => ["/", "/hello", "/hello/world"]
+  # @example Pathutil.new("/hello/world").ascend { |path| $stdout.puts path }
+  # @return Enum
+  # --
+  def ascend
+    unless block_given?
+      return to_enum(
+        __method__
+      )
+    end
+
+    yield(
+      path = self
+    )
+
+    while (new_path = path.dirname)
+      if path == new_path || new_path == "."
+        break
+      else
+        path = new_path
+        yield  new_path
+      end
+    end
+
+    nil
+  end
+
+  # --
+  # @yield Pathutil
+  # Break apart the path in reverse order and descend into the path.
+  # @example Pathutil.new("/hello/world").descend.to_a # => ["/hello/world", "/hello", "/"]
+  # @example Pathutil.new("/hello/world").descend { |path| $stdout.puts path }
+  # @return Enum
+  # --
+  def descend
+    unless block_given?
+      return to_enum(
+        __method__
+      )
+    end
+
+    ascend.to_a.reverse_each do |val|
+      yield val
+    end
+
+    nil
+  end
+
+  # --
+  # @yield Pathutil
+  # @example Pathutil.new("/hello/world").each_line { |line| $stdout.puts line }
+  # Wraps `readlines` and allows you to yield on the result.
+  # @return Enum
+  # --
+  def each_line
+    return to_enum(__method__) unless block_given?
+    readlines.each do |line|
+      yield line
+    end
+
+    nil
+  end
+
+  # --
+  # @example Pathutil.new("/hello").fnmatch?("/hello") # => true
+  # Unlike traditional `fnmatch`, with this one `Regexp` is allowed.
+  # @example Pathutil.new("/hello").fnmatch?(/h/) # => true
+  # @see `File#fnmatch` for more information.
+  # @return true|false
+  # --
+  def fnmatch?(matcher)
+    matcher.is_a?(Regexp) ? !!(self =~ matcher) : \
+      File.fnmatch(matcher, self)
+  end
+
+  # --
+  # Allows you to quickly determine if the file is the root folder.
+  # @return true|false
+  # --
+  def root?
+    !!(self =~ %r!\A(?:[A-Za-z]:)?(?:\\+|/+)\z!)
+  end
+
+  # --
+  # Allows you to check if the current path is in the path you want.
+  # @return true|false
+  # --
+  def in_path?(path)
+    path = self.class.new(path).expand_path.split_path
+    mine = (symlink?? expand_path.realpath : expand_path).split_path
+    path.each_with_index { |part, index| return false if mine[index] != part }
+    true
+  end
+
+  # --
+  def inspect
+    "#<#{self.class}:#{@path}>"
+  end
+
+  # --
+  # @return Array<Pathutil>
+  # Grab all of the children from the current directory, including hidden.
+  # @yield Pathutil
+  # --
+  def children
+    ary = []
+
+    Dir.foreach(@path) do |path|
+      if path == "." || path == ".."
+        next
+      else
+        path = self.class.new(File.join(@path, path))
+        yield path if block_given?
+        ary.push(
+          path
+        )
+      end
+    end
+
+    ary
+  end
+
+  # --
+  # @yield Pathutil
+  # Allows you to glob however you wish to glob in the current `Pathutil`
+  # @see `File::Constants` for a list of flags.
+  # @return Enum
+  # --
+  def glob(pattern, flags = 0)
+    unless block_given?
+      return to_enum(
+        __method__, pattern, flags
+      )
+    end
+
+    chdir do
+      Dir.glob(pattern, flags).each do |file|
+        yield self.class.new(
+          File.join(@path, file)
+        )
+      end
+    end
+
+    nil
+  end
+
+  # --
+  # @yield &block
+  # Move to the current directory temporarily (or for good) and do work son.
+  # @note you do not need to ship a block at all.
+  # @return nil
+  # --
+  def chdir
+    if !block_given?
+      Dir.chdir(
+        @path
+      )
+
+    else
+      Dir.chdir @path do
+        yield
+      end
+    end
+  end
+
+  # --
+  # @yield Pathutil
+  # Find all files without care and yield the given block.
+  # @return Enum
+  # --
+  def find
+    return to_enum(__method__) unless block_given?
+    Find.find @path do |val|
+      yield self.class.new(val)
+    end
+  end
+
+  # --
+  # @yield Pathutil
+  # Splits the path returning each part (filename) back to you.
+  # @return Enum
+  # --
+  def each_filename
+    return to_enum(__method__) unless block_given?
+    @path.split(File::SEPARATOR).delete_if(&:empty?).each do |file|
+      yield file
+    end
+  end
+
+  # --
+  # Get the parent of the current path.
+  # @note This will simply return self if "/".
+  # @return Pathutil
+  # --
+  def parent
+    return self if @path == "/"
+    self.class.new(absolute?? File.dirname(@path) : File.join(
+      @path, ".."
+    ))
+  end
+
+  # --
+  # @yield Pathutil
+  # Split the file into its dirname and basename, so you can do stuff.
+  # @return nil
+  # --
+  def split
+    File.split(@path).collect! do |path|
+      self.class.new(path)
+    end
+  end
+
+  # --
+  # @note Your extension should start with "."
+  # Replace a files extension with your given extension.
+  # @return Pathutil
+  # --
+  def sub_ext(ext)
+    self.class.new(@path.chomp(File.extname(@path)) + ext)
+  end
+
+  # --
+  # A less complex version of `relative_path_from` that simply uses a
+  # `Regexp` and returns the full path if it cannot be determined.
+  # @return Pathutil
+  # --
+  def relative_path_from(from)
+    from = self.class.new(from).expand_path.gsub(%r!/$!, "")
+    self.class.new(expand_path.gsub(%r!^#{
+      from.regexp_escape
+    }/!, ""))
+  end
+
+  # --
+  # Expands the path and left joins the root to the path.
+  # @return Pathutil
+  # --
+  def enforce_root(root)
+    return self if !relative? && in_path?(root)
+    self.class.new(root).join(
+      self
+    )
+  end
+
+  # --
+  # Copy a directory, allowing symlinks if the link falls inside of the root.
+  # This is indented for people who wish some safety to their copies.
+  # @note Ignore is ignored on safe_copy file because it's explicit.
+  # @return nil
+  # --
+  def safe_copy(to, root: nil, ignore: [])
+    raise ArgumentError, "must give a root" unless root
+    root = self.class.new(root)
+    to   = self.class.new(to)
+
+    if directory?
+      safe_copy_directory(to, {
+        :root => root, :ignore => ignore
+      })
+
+    else
+      safe_copy_file(to, {
+        :root => root
+      })
+    end
+  end
+
+  # --
+  # @see `self.class.normalize` as this is an alias.
+  # --
+  def normalize
+    return @normalize ||= begin
+      self.class.normalize
+    end
+  end
+
+  # --
+  # @see `self.class.encoding` as this is an alias.
+  # --
+  def encoding
+    return @encoding ||= begin
+      self.class.encoding
+    end
+  end
+
+  # --
+  # @note You can set the default encodings via the class.
+  # Read took two steroid shots: it can normalize your string, and encode.
+  # @return String
+  # --
+  def read(*args, **kwd)
+    kwd[:encoding] ||= encoding
+
+    if normalize[:read]
+      File.read(self, *args, kwd).encode({
+        :universal_newline => true
+      })
+
+    else
+      File.read(
+        self, *args, kwd
+      )
+    end
+  end
+
+  # --
+  # @note You can set the default encodings via the class.
+  # Binread took two steroid shots: it can normalize your string, and encode.
+  # @return String
+  # --
+  def binread(*args, **kwd)
+    kwd[:encoding] ||= encoding
+
+    if normalize[:read]
+      File.binread(self, *args, kwd).encode({
+        :universal_newline => true
+      })
+
+    else
+      File.read(
+        self, *args, kwd
+      )
+    end
+  end
+
+  # --
+  # @note You can set the default encodings via the class.
+  # Readlines took two steroid shots: it can normalize your string, and encode.
+  # @return Array<String>
+  # --
+  def readlines(*args, **kwd)
+    kwd[:encoding] ||= encoding
+
+    if normalize[:read]
+      File.readlines(self, *args, kwd).encode({
+        :universal_newline => true
+      })
+
+    else
+      File.readlines(
+        self, *args, kwd
+      )
+    end
+  end
+
+  # --
+  # @note You can set the default encodings via the class.
+  # Write took two steroid shots: it can normalize your string, and encode.
+  # @return Fixnum<Bytes>
+  # --
+  def write(data, *args, **kwd)
+    kwd[:encoding] ||= encoding
+
+    if normalize[:write]
+      File.write(self, data.encode(
+        :crlf_newline => true
+      ), *args, kwd)
+
+    else
+      File.write(
+        self, data, *args, kwd
+      )
+    end
+  end
+
+  # --
+  # @note You can set the default encodings via the class.
+  # Binwrite took two steroid shots: it can normalize your string, and encode.
+  # @return Fixnum<Bytes>
+  # --
+  def binwrite(data, *args, **kwd)
+    kwd[:encoding] ||= encoding
+
+    if normalize[:write]
+      File.binwrite(self, data.encode(
+        :crlf_newline => true
+      ), *args, kwd)
+
+    else
+      File.binwrite(
+        self, data, *args, kwd
+      )
+    end
+  end
+
+  # --
+  def to_regexp(guard: true)
+    Regexp.new((guard ? "\\A" : "") + Regexp.escape(
+      self
+    ))
+  end
+
+  # --
+  # Strips the windows drive from the path.
+  # --
+  def strip_windows_drive(path = @path)
+    self.class.new(path.gsub(
+      %r!\A[A-Za-z]:(?:\\+|/+)!, ""
+    ))
+  end
+
+  # --
+  # rubocop:disable Metrics/AbcSize
+  # rubocop:disable Metrics/CyclomaticComplexity
+  # rubocop:disable Metrics/PerceivedComplexity
+  # --
+
+  def aggressive_cleanpath
+    return self.class.new("/") if root?
+
+    _out = split_path.each_with_object([]) do |part, out|
+      next if part == "." || (part == ".." && out.last == "")
+      if part == ".." && out.last && out.last != ".."
+        out.pop
+
+      else
+        out.push(
+          part
+        )
+      end
+    end
+
+    # --
+
+    return self.class.new("/") if _out == [""].freeze
+    return self.class.new(".") if _out.empty? && (end_with?(".") || relative?)
+    self.class.new(_out.join("/"))
+  end
+
+  # --
+  def conservative_cleanpath
+    _out = split_path.each_with_object([]) do |part, out|
+      next if part == "." || (part == ".." && out.last == "")
+      out.push(
+        part
+      )
+    end
+
+    # --
+
+    if !_out.empty? && basename == "." && _out.last != "" && _out.last != ".."
+      _out << "."
+    end
+
+    # --
+
+    return self.class.new("/") if _out == [""].freeze
+    return self.class.new(".") if _out.empty? && (end_with?(".") || relative?)
+    return self.class.new(_out.join("/")).join("") if @path =~ %r!/\z! \
+      && _out.last != "." && _out.last != ".."
+    self.class.new(_out.join("/"))
+  end
+
+  # --
+  # rubocop:enable Metrics/AbcSize
+  # rubocop:enable Metrics/CyclomaticComplexity
+  # rubocop:enable Metrics/PerceivedComplexity
+  # Expand the paths and return.
+  # --
+  private
+  def expanded_paths(path)
+    return expand_path, self.class.new(path).expand_path
+  end
+
+  # --
+  # Safely copy a file.
+  # --
+  private
+  def safe_copy_file(to, root: nil)
+    raise Errno::EPERM, "#{self} not in #{root}" unless in_path?(root)
+    FileUtils.cp(self, to, {
+      :preserve => true
+    })
+  end
+
+  # --
+  # Safely copy a directory and it's sub-files.
+  # --
+  private
+  def safe_copy_directory(to, root: nil, ignore: [])
+    ignore = [ignore].flatten.uniq
+
+    if !in_path?(root)
+      raise Errno::EPERM, "#{self} not in #{
+        root
+      }"
+
+    else
+      to.mkdir_p unless to.exist?
+      children do |file|
+        unless ignore.any? { |path| file.in_path?(path) }
+          if !file.in_path?(root)
+            raise Errno::EPERM, "#{file} not in #{
+              root
+            }"
+
+          elsif file.file?
+            FileUtils.cp(file, to, {
+              :preserve => true
+            })
+
+          else
+            path = file.realpath
+            path.safe_copy(to.join(file.basename), {
+              :root => root, :ignore => ignore
+            })
+          end
+        end
+      end
+    end
+  end
+
+  class << self
+    attr_writer :encoding
+
+    # --
+    # @note We do nothing special here.
+    # Get the current directory that Ruby knows about.
+    # @return Pathutil
+    # --
+    def pwd
+      new(
+        Dir.pwd
+      )
+    end
+
+    alias gcwd pwd
+    alias cwd  pwd
+
+    # --
+    # @note you are encouraged to override this if you need to.
+    # Aliases the default system encoding to us so that we can do most read
+    # and write operations with that encoding, instead of being crazy.
+    # --
+    def encoding
+      return @encoding ||= begin
+        Encoding.default_external
+      end
+    end
+
+    # --
+    # Normalize CRLF -> LF   on Windows reads, to ease  your troubles.
+    # Normalize LF   -> CLRF on Windows write, to ease  your troubles.
+    # --
+    def normalize
+      return @normalize ||= {
+        :read  => Gem.win_platform?,
+        :write => Gem.win_platform?
+      }
+    end
+
+    # --
+    # Make a temporary directory.
+    # @note if you adruptly exit it will not remove the dir.
+    # @note this directory is removed on exit.
+    # @return Pathutil
+    # --
+    def tmpdir(*args)
+      rtn = new(make_tmpname(*args)).tap(&:mkdir)
+      ObjectSpace.define_finalizer(rtn, proc do
+        rtn.rm_rf
+      end)
+
+      rtn
+    end
+
+    # --
+    # Make a temporary file.
+    # @note if you adruptly exit it will not remove the dir.
+    # @note this file is removed on exit.
+    # @return Pathutil
+    # --
+    def tmpfile(*args)
+      rtn = new(make_tmpname(*args)).tap(&:touch)
+      ObjectSpace.define_finalizer(rtn, proc do
+        rtn.rm_rf
+      end)
+
+      rtn
+    end
+  end
+
+  # --
+
+  rb_delegate :gcwd, :to => :"self.class"
+  rb_delegate :pwd,  :to => :"self.class"
+
+  # --
+
+  rb_delegate :sub,         :to => :@path, :wrap => true
+  rb_delegate :chomp,       :to => :@path, :wrap => true
+  rb_delegate :gsub,        :to => :@path, :wrap => true
+  rb_delegate :[],          :to => :@path
+  rb_delegate :=~,          :to => :@path
+  rb_delegate :==,          :to => :@path
+  rb_delegate :to_s,        :to => :@path
+  rb_delegate :freeze,      :to => :@path
+  rb_delegate :end_with?,   :to => :@path
+  rb_delegate :start_with?, :to => :@path
+  rb_delegate :frozen?,     :to => :@path
+  rb_delegate :to_str,      :to => :@path
+  rb_delegate :"!~",        :to => :@path
+  rb_delegate :<=>,         :to => :@path
+
+  # --
+
+  rb_delegate :chmod,        :to => :File, :args => { :after => :@path }
+  rb_delegate :lchown,       :to => :File, :args => { :after => :@path }
+  rb_delegate :lchmod,       :to => :File, :args => { :after => :@path }
+  rb_delegate :chown,        :to => :File, :args => { :after => :@path }
+  rb_delegate :basename,     :to => :File, :args => :@path, :wrap => true
+  rb_delegate :dirname,      :to => :File, :args => :@path, :wrap => true
+  rb_delegate :readlink,     :to => :File, :args => :@path, :wrap => true
+  rb_delegate :expand_path,  :to => :File, :args => :@path, :wrap => true
+  rb_delegate :realdirpath,  :to => :File, :args => :@path, :wrap => true
+  rb_delegate :realpath,     :to => :File, :args => :@path, :wrap => true
+  rb_delegate :rename,       :to => :File, :args => :@path, :wrap => true
+  rb_delegate :join,         :to => :File, :args => :@path, :wrap => true
+  rb_delegate :empty?,       :to => :file, :args => :@path
+  rb_delegate :size,         :to => :File, :args => :@path
+  rb_delegate :link,         :to => :File, :args => :@path
+  rb_delegate :atime,        :to => :File, :args => :@path
+  rb_delegate :ctime,        :to => :File, :args => :@path
+  rb_delegate :lstat,        :to => :File, :args => :@path
+  rb_delegate :utime,        :to => :File, :args => :@path
+  rb_delegate :sysopen,      :to => :File, :args => :@path
+  rb_delegate :birthtime,    :to => :File, :args => :@path
+  rb_delegate :mountpoint?,  :to => :File, :args => :@path
+  rb_delegate :truncate,     :to => :File, :args => :@path
+  rb_delegate :symlink,      :to => :File, :args => :@path
+  rb_delegate :extname,      :to => :File, :args => :@path
+  rb_delegate :zero?,        :to => :File, :args => :@path
+  rb_delegate :ftype,        :to => :File, :args => :@path
+  rb_delegate :mtime,        :to => :File, :args => :@path
+  rb_delegate :open,         :to => :File, :args => :@path
+  rb_delegate :stat,         :to => :File, :args => :@path
+
+  # --
+
+  rb_delegate :pipe?,            :to => :FileTest, :args => :@path
+  rb_delegate :file?,            :to => :FileTest, :args => :@path
+  rb_delegate :owned?,           :to => :FileTest, :args => :@path
+  rb_delegate :setgid?,          :to => :FileTest, :args => :@path
+  rb_delegate :socket?,          :to => :FileTest, :args => :@path
+  rb_delegate :readable?,        :to => :FileTest, :args => :@path
+  rb_delegate :blockdev?,        :to => :FileTest, :args => :@path
+  rb_delegate :directory?,       :to => :FileTest, :args => :@path
+  rb_delegate :readable_real?,   :to => :FileTest, :args => :@path
+  rb_delegate :world_readable?,  :to => :FileTest, :args => :@path
+  rb_delegate :executable_real?, :to => :FileTest, :args => :@path
+  rb_delegate :world_writable?,  :to => :FileTest, :args => :@path
+  rb_delegate :writable_real?,   :to => :FileTest, :args => :@path
+  rb_delegate :executable?,      :to => :FileTest, :args => :@path
+  rb_delegate :writable?,        :to => :FileTest, :args => :@path
+  rb_delegate :grpowned?,        :to => :FileTest, :args => :@path
+  rb_delegate :chardev?,         :to => :FileTest, :args => :@path
+  rb_delegate :symlink?,         :to => :FileTest, :args => :@path
+  rb_delegate :sticky?,          :to => :FileTest, :args => :@path
+  rb_delegate :setuid?,          :to => :FileTest, :args => :@path
+  rb_delegate :exist?,           :to => :FileTest, :args => :@path
+  rb_delegate :size?,            :to => :FileTest, :args => :@path
+
+  # --
+
+  rb_delegate :rm_rf,   :to => :FileUtils, :args => :@path
+  rb_delegate :rm_r,    :to => :FileUtils, :args => :@path
+  rb_delegate :rm_f,    :to => :FileUtils, :args => :@path
+  rb_delegate :rm,      :to => :FileUtils, :args => :@path
+  rb_delegate :cp_r,    :to => :FileUtils, :args => :@path
+  rb_delegate :touch,   :to => :FileUtils, :args => :@path
+  rb_delegate :mkdir_p, :to => :FileUtils, :args => :@path
+  rb_delegate :mkpath,  :to => :FileUtils, :args => :@path
+  rb_delegate :cp,      :to => :FileUtils, :args => :@path
+
+  # --
+
+  rb_delegate :each_child, :to => :children
+  rb_delegate :each_entry, :to => :children
+  rb_delegate :to_a,       :to => :children
+
+  # --
+
+  rb_delegate :opendir, :to => :Dir, :alias_of => :open
+  rb_delegate :relative?, :to => :self, :alias_of => :absolute?, :bool => :reverse
+  rb_delegate :regexp_escape, :to => :Regexp, :args => :@path, :alias_of => :escape
+  rb_delegate :shellescape, :to => :Shellwords, :args => :@path
+  rb_delegate :mkdir, :to => :Dir, :args => :@path
+
+  # --
+
+  alias + join
+  alias delete rm
+  alias rmtree rm_r
+  alias to_path to_s
+  alias last basename
+  alias entries children
+  alias make_symlink symlink
+  alias cleanpath_conservative conservative_cleanpath
+  alias cleanpath_aggressive aggressive_cleanpath
+  alias prepend enforce_root
+  alias fnmatch fnmatch?
+  alias make_link link
+  alias first dirname
+  alias rmdir rm_r
+  alias unlink rm
+  alias / join
+end