Module: FileUtils

# File 'lib/fileutils.rb', line 145

alias chdir cd

# File 'lib/fileutils.rb', line 1012

def chmod(mode, list, noop: nil, verbose: nil)
  list = fu_list(list)
  fu_output_message sprintf('chmod %s %s', mode_to_s(mode), list.join(' ')) if verbose
  return if noop
  list.each do |path|
    Entry_.new(path).chmod(fu_mode(mode, path))
  end
end

# File 'lib/fileutils.rb', line 1029

def chmod_R(mode, list, noop: nil, verbose: nil, force: nil)
  list = fu_list(list)
  fu_output_message sprintf('chmod -R%s %s %s',
                            (force ? 'f' : ''),
                            mode_to_s(mode), list.join(' ')) if verbose
  return if noop
  list.each do |root|
    Entry_.new(root).traverse do |ent|
      begin
        ent.chmod(fu_mode(mode, ent.path))
      rescue
        raise unless force
      end
    end
  end
end

# File 'lib/fileutils.rb', line 1057

def chown(user, group, list, noop: nil, verbose: nil)
  list = fu_list(list)
  fu_output_message sprintf('chown %s %s',
                            (group ? "#{user}:#{group}" : user || ':'),
                            list.join(' ')) if verbose
  return if noop
  uid = fu_get_uid(user)
  gid = fu_get_gid(group)
  list.each do |path|
    Entry_.new(path).chown uid, gid
  end
end

# File 'lib/fileutils.rb', line 1081

def chown_R(user, group, list, noop: nil, verbose: nil, force: nil)
  list = fu_list(list)
  fu_output_message sprintf('chown -R%s %s %s',
                            (force ? 'f' : ''),
                            (group ? "#{user}:#{group}" : user || ':'),
                            list.join(' ')) if verbose
  return if noop
  uid = fu_get_uid(user)
  gid = fu_get_gid(group)
  list.each do |root|
    Entry_.new(root).traverse do |ent|
      begin
        ent.chown uid, gid
      rescue
        raise unless force
      end
    end
  end
end

# File 'lib/fileutils.rb', line 827

alias cmp compare_file

# File 'lib/fileutils.rb', line 1680

def self.collect_method(opt)
  OPT_TABLE.keys.select {|m| OPT_TABLE[m].include?(opt) }
end

# File 'lib/fileutils.rb', line 1641

def self.commands
  OPT_TABLE.keys
end

# File 'lib/fileutils.rb', line 816

def compare_file(a, b)
  return false unless File.size(a) == File.size(b)
  File.open(a, 'rb') {|fa|
    File.open(b, 'rb') {|fb|
      return compare_stream(fa, fb)
    }
  }
end

# File 'lib/fileutils.rb', line 834

def compare_stream(a, b)
  bsize = fu_stream_blksize(a, b)

  if RUBY_VERSION > "2.4"
    sa = String.new(capacity: bsize)
    sb = String.new(capacity: bsize)
  else
    sa = String.new
    sb = String.new
  end

  begin
    a.read(bsize, sa)
    b.read(bsize, sb)
    return true if sa.empty? && sb.empty?
  end while sa == sb
  false
end

# File 'lib/fileutils.rb', line 435

alias copy cp

# File 'lib/fileutils.rb', line 489

def copy_entry(src, dest, preserve = false, dereference_root = false, remove_destination = false)
  if dereference_root
    src = File.realpath(src)
  end

  Entry_.new(src, nil, false).wrap_traverse(proc do |ent|
    destent = Entry_.new(dest, ent.rel, false)
    File.unlink destent.path if remove_destination && (File.file?(destent.path) || File.symlink?(destent.path))
    ent.copy destent.path
  end, proc do |ent|
    destent = Entry_.new(dest, ent.rel, false)
    ent.copy_metadata destent.path if preserve
  end)
end

# File 'lib/fileutils.rb', line 509

def copy_file(src, dest, preserve = false, dereference = true)
  ent = Entry_.new(src, nil, dereference)
  ent.copy_file dest
  ent.copy_metadata dest if preserve
end

# File 'lib/fileutils.rb', line 521

def copy_stream(src, dest)
  IO.copy_stream(src, dest)
end

# File 'lib/fileutils.rb', line 426

def cp(src, dest, preserve: nil, noop: nil, verbose: nil)
  fu_output_message "cp#{preserve ? ' -p' : ''} #{[src,dest].flatten.join ' '}" if verbose
  return if noop
  fu_each_src_dest(src, dest) do |s, d|
    copy_file s, d, preserve
  end
end

# File 'lib/fileutils.rb', line 339

def cp_lr(src, dest, noop: nil, verbose: nil,
          dereference_root: true, remove_destination: false)
  fu_output_message "cp -lr#{remove_destination ? ' --remove-destination' : ''} #{[src,dest].flatten.join ' '}" if verbose
  return if noop
  fu_each_src_dest(src, dest) do |s, d|
    link_entry s, d, dereference_root, remove_destination
  end
end

# File 'lib/fileutils.rb', line 463

def cp_r(src, dest, preserve: nil, noop: nil, verbose: nil,
         dereference_root: true, remove_destination: nil)
  fu_output_message "cp -r#{preserve ? 'p' : ''}#{remove_destination ? ' --remove-destination' : ''} #{[src,dest].flatten.join ' '}" if verbose
  return if noop
  fu_each_src_dest(src, dest) do |s, d|
    copy_entry s, d, preserve, dereference_root, remove_destination
  end
end

# File 'lib/fileutils.rb', line 120

alias getwd pwd

# File 'lib/fileutils.rb', line 1661

def self.have_option?(mid, opt)
  li = OPT_TABLE[mid.to_s] or raise ArgumentError, "no such method: #{mid}"
  li.include?(opt)
end

# File 'lib/fileutils.rb', line 826

alias identical? compare_file

# File 'lib/fileutils.rb', line 862

def install(src, dest, mode: nil, owner: nil, group: nil, preserve: nil,
            noop: nil, verbose: nil)
  if verbose
    msg = +"install -c"
    msg << ' -p' if preserve
    msg << ' -m ' << mode_to_s(mode) if mode
    msg << " -o #{owner}" if owner
    msg << " -g #{group}" if group
    msg << ' ' << [src,dest].flatten.join(' ')
    fu_output_message msg
  end
  return if noop
  uid = fu_get_uid(owner)
  gid = fu_get_gid(group)
  fu_each_src_dest(src, dest) do |s, d|
    st = File.stat(s)
    unless File.exist?(d) and compare_file(s, d)
      remove_file d, true
      copy_file s, d
      File.utime st.atime, st.mtime, d if preserve
      File.chmod fu_mode(mode, st), d if mode
      File.chown uid, gid, d if uid or gid
    end
  end
end

# File 'lib/fileutils.rb', line 313

alias link ln

# File 'lib/fileutils.rb', line 406

def link_entry(src, dest, dereference_root = false, remove_destination = false)
  Entry_.new(src, nil, dereference_root).traverse do |ent|
    destent = Entry_.new(dest, ent.rel, false)
    File.unlink destent.path if remove_destination && File.file?(destent.path)
    ent.link destent.path
  end
end

# File 'lib/fileutils.rb', line 303

def ln(src, dest, force: nil, noop: nil, verbose: nil)
  fu_output_message "ln#{force ? ' -f' : ''} #{[src,dest].flatten.join ' '}" if verbose
  return if noop
  fu_each_src_dest0(src, dest) do |s,d|
    remove_file d, true if force
    File.link s, d
  end
end

# File 'lib/fileutils.rb', line 369

def ln_s(src, dest, force: nil, noop: nil, verbose: nil)
  fu_output_message "ln -s#{force ? 'f' : ''} #{[src,dest].flatten.join ' '}" if verbose
  return if noop
  fu_each_src_dest0(src, dest) do |s,d|
    remove_file d, true if force
    File.symlink s, d
  end
end

# File 'lib/fileutils.rb', line 390

def ln_sf(src, dest, noop: nil, verbose: nil)
  ln_s src, dest, force: true, noop: noop, verbose: verbose
end

# File 'lib/fileutils.rb', line 240

alias makedirs  mkdir_p

# File 'lib/fileutils.rb', line 180

def mkdir(list, mode: nil, noop: nil, verbose: nil)
  list = fu_list(list)
  fu_output_message "mkdir #{mode ? ('-m %03o ' % mode) : ''}#{list.join ' '}" if verbose
  return if noop

  list.each do |dir|
    fu_mkdir dir, mode
  end
end

# File 'lib/fileutils.rb', line 206

def mkdir_p(list, mode: nil, noop: nil, verbose: nil)
  list = fu_list(list)
  fu_output_message "mkdir -p #{mode ? ('-m %03o ' % mode) : ''}#{list.join ' '}" if verbose
  return *list if noop

  list.map {|path| remove_trailing_slash(path)}.each do |path|
    # optimize for the most common case
    begin
      fu_mkdir path, mode
      next
    rescue SystemCallError
      next if File.directory?(path)
    end

    stack = []
    until path == stack.last   # dirname("/")=="/", dirname("C:/")=="C:/"
      stack.push path
      path = File.dirname(path)
    end
    stack.pop                 # root directory should exist
    stack.reverse_each do |dir|
      begin
        fu_mkdir dir, mode
      rescue SystemCallError
        raise unless File.directory?(dir)
      end
    end
  end

  return *list
end

# File 'lib/fileutils.rb', line 239

alias mkpath    mkdir_p

# File 'lib/fileutils.rb', line 565

alias move mv

# File 'lib/fileutils.rb', line 536

def mv(src, dest, force: nil, noop: nil, verbose: nil, secure: nil)
  fu_output_message "mv#{force ? ' -f' : ''} #{[src,dest].flatten.join ' '}" if verbose
  return if noop
  fu_each_src_dest(src, dest) do |s, d|
    destent = Entry_.new(d, nil, true)
    begin
      if destent.exist?
        if destent.directory?
          raise Errno::EEXIST, d
        end
      end
      begin
        File.rename s, d
      rescue Errno::EXDEV,
             Errno::EPERM # move from unencrypted to encrypted dir (ext4)
        copy_entry s, d, true
        if secure
          remove_entry_secure s, force
        else
          remove_entry s, force
        end
      end
    rescue SystemCallError
      raise unless force
    end
  end
end

# File 'lib/fileutils.rb', line 1650

def self.options
  OPT_TABLE.values.flatten.uniq.map {|sym| sym.to_s }
end

# File 'lib/fileutils.rb', line 1671

def self.options_of(mid)
  OPT_TABLE[mid.to_s].map {|sym| sym.to_s }
end

# File 'lib/fileutils.rb', line 107

def self.private_module_function(name)   #:nodoc:
  module_function name
  private_class_method name
end

# File 'lib/fileutils.rb', line 115

def pwd
  Dir.pwd
end

# File 'lib/fileutils.rb', line 587

alias remove rm

# File 'lib/fileutils.rb', line 805

def remove_dir(path, force = false)
  remove_entry path, force   # FIXME?? check if it is a directory
end

# File 'lib/fileutils.rb', line 777

def remove_entry(path, force = false)
  Entry_.new(path).postorder_traverse do |ent|
    begin
      ent.remove
    rescue
      raise unless force
    end
  end
rescue
  raise unless force
end

# File 'lib/fileutils.rb', line 684

def remove_entry_secure(path, force = false)
  unless fu_have_symlink?
    remove_entry path, force
    return
  end
  fullpath = File.expand_path(path)
  st = File.lstat(fullpath)
  unless st.directory?
    File.unlink fullpath
    return
  end
  # is a directory.
  parent_st = File.stat(File.dirname(fullpath))
  unless parent_st.world_writable?
    remove_entry path, force
    return
  end
  unless parent_st.sticky?
    raise ArgumentError, "parent directory is world writable, FileUtils#remove_entry_secure does not work; abort: #{path.inspect} (parent directory mode #{'%o' % parent_st.mode})"
  end

  # freeze tree root
  euid = Process.euid
  dot_file = fullpath + "/."
  begin
    File.open(dot_file) {|f|
      unless fu_stat_identical_entry?(st, f.stat)
        # symlink (TOC-to-TOU attack?)
        File.unlink fullpath
        return
      end
      f.chown euid, -1
      f.chmod 0700
    }
  rescue Errno::EISDIR # JRuby in non-native mode can't open files as dirs
    File.lstat(dot_file).tap {|fstat|
      unless fu_stat_identical_entry?(st, fstat)
        # symlink (TOC-to-TOU attack?)
        File.unlink fullpath
        return
      end
      File.chown euid, -1, dot_file
      File.chmod 0700, dot_file
    }
  end

  unless fu_stat_identical_entry?(st, File.lstat(fullpath))
    # TOC-to-TOU attack?
    File.unlink fullpath
    return
  end

  # ---- tree root is frozen ----
  root = Entry_.new(path)
  root.preorder_traverse do |ent|
    if ent.directory?
      ent.chown euid, -1
      ent.chmod 0700
    end
  end
  root.postorder_traverse do |ent|
    begin
      ent.remove
    rescue
      raise unless force
    end
  end
rescue
  raise unless force
end

# File 'lib/fileutils.rb', line 794

def remove_file(path, force = false)
  Entry_.new(path).remove_file
rescue
  raise unless force
end

# File 'lib/fileutils.rb', line 576

def rm(list, force: nil, noop: nil, verbose: nil)
  list = fu_list(list)
  fu_output_message "rm#{force ? ' -f' : ''} #{list.join ' '}" if verbose
  return if noop

  list.each do |path|
    remove_file path, force
  end
end

# File 'lib/fileutils.rb', line 595

def rm_f(list, noop: nil, verbose: nil)
  rm list, force: true, noop: noop, verbose: verbose
end

# File 'lib/fileutils.rb', line 622

def rm_r(list, force: nil, noop: nil, verbose: nil, secure: nil)
  list = fu_list(list)
  fu_output_message "rm -r#{force ? 'f' : ''} #{list.join ' '}" if verbose
  return if noop
  list.each do |path|
    if secure
      remove_entry_secure path, force
    else
      remove_entry path, force
    end
  end
end

# File 'lib/fileutils.rb', line 644

def rm_rf(list, noop: nil, verbose: nil, secure: nil)
  rm_r list, force: true, noop: noop, verbose: verbose, secure: secure
end

# File 'lib/fileutils.rb', line 263

def rmdir(list, parents: nil, noop: nil, verbose: nil)
  list = fu_list(list)
  fu_output_message "rmdir #{parents ? '-p ' : ''}#{list.join ' '}" if verbose
  return if noop
  list.each do |dir|
    Dir.rmdir(dir = remove_trailing_slash(dir))
    if parents
      begin
        until (parent = File.dirname(dir)) == '.' or parent == dir
          dir = parent
          Dir.rmdir(dir)
        end
      rescue Errno::ENOTEMPTY, Errno::EEXIST, Errno::ENOENT
      end
    end
  end
end

# File 'lib/fileutils.rb', line 649

alias rmtree rm_rf

# File 'lib/fileutils.rb', line 600

alias safe_unlink rm_f

# File 'lib/fileutils.rb', line 379

alias symlink ln_s

# File 'lib/fileutils.rb', line 1137

def touch(list, noop: nil, verbose: nil, mtime: nil, nocreate: nil)
  list = fu_list(list)
  t = mtime
  if verbose
    fu_output_message "touch #{nocreate ? '-c ' : ''}#{t ? t.strftime('-t %Y%m%d%H%M.%S ') : ''}#{list.join ' '}"
  end
  return if noop
  list.each do |path|
    created = nocreate
    begin
      File.utime(t, t, path)
    rescue Errno::ENOENT
      raise if created
      File.open(path, 'a') {
        ;
      }
      created = true
      retry if t
    end
  end
end

# File 'lib/fileutils.rb', line 155

def uptodate?(new, old_list)
  return false unless File.exist?(new)
  new_time = File.mtime(new)
  old_list.each do |old|
    if File.exist?(old)
      return false unless new_time > File.mtime(old)
    end
  end
  true
end

# File 'lib/fileutils.rb', line 1586

def fu_each_src_dest(src, dest)   #:nodoc:
  fu_each_src_dest0(src, dest) do |s, d|
    raise ArgumentError, "same file: #{s} and #{d}" if fu_same?(s, d)
    yield s, d
  end
end

# File 'lib/fileutils.rb', line 1594

def fu_each_src_dest0(src, dest)   #:nodoc:
  if tmp = Array.try_convert(src)
    tmp.each do |s|
      s = File.path(s)
      yield s, File.join(dest, File.basename(s))
    end
  else
    src = File.path(src)
    if File.directory?(dest)
      yield src, File.join(dest, File.basename(src))
    else
      yield src, File.path(dest)
    end
  end
end

# File 'lib/fileutils.rb', line 1116

def fu_get_gid(group)   #:nodoc:
  return nil unless group
  case group
  when Integer
    group
  when /\A\d+\z/
    group.to_i
  else
    require 'etc'
    Etc.getgrnam(group) ? Etc.getgrnam(group).gid : nil
  end
end

# File 'lib/fileutils.rb', line 1102

def fu_get_uid(user)   #:nodoc:
  return nil unless user
  case user
  when Integer
    user
  when /\A\d+\z/
    user.to_i
  else
    require 'etc'
    Etc.getpwnam(user) ? Etc.getpwnam(user).uid : nil
  end
end

# File 'lib/fileutils.rb', line 1581

def fu_list(arg)   #:nodoc:
  [arg].flatten.map {|path| File.path(path) }
end

# File 'lib/fileutils.rb', line 244

def fu_mkdir(path, mode)   #:nodoc:
  path = remove_trailing_slash(path)
  if mode
    Dir.mkdir path, mode
    File.chmod mode, path
  else
    Dir.mkdir path
  end
end

# File 'lib/fileutils.rb', line 971

def fu_mode(mode, path)  #:nodoc:
  mode.is_a?(String) ? symbolic_modes_to_i(mode, path) : mode
end

# File 'lib/fileutils.rb', line 1616

def fu_output_message(msg)   #:nodoc:
  output = @fileutils_output if defined?(@fileutils_output)
  output ||= $stderr
  if defined?(@fileutils_label)
    msg = @fileutils_label + msg
  end
  output.puts msg
end

# File 'lib/fileutils.rb', line 1611

def fu_same?(a, b)   #:nodoc:
  File.identical?(a, b)
end

# File 'lib/fileutils.rb', line 765

def fu_stat_identical_entry?(a, b)   #:nodoc:
  a.dev == b.dev and a.ino == b.ino
end

# File 'lib/fileutils.rb', line 976

def mode_to_s(mode)  #:nodoc:
  mode.is_a?(String) ? mode : "%o" % mode
end

# File 'lib/fileutils.rb', line 167

def remove_trailing_slash(dir)   #:nodoc:
  dir == '/' ? dir : dir.chomp(?/)
end

# File 'lib/fileutils.rb', line 919

def symbolic_modes_to_i(mode_sym, path)  #:nodoc:
  mode = if File::Stat === path
           path.mode
         else
           File.stat(path).mode
         end
  mode_sym.split(/,/).inject(mode & 07777) do |current_mode, clause|
    target, *actions = clause.split(/([=+-])/)
    raise ArgumentError, "invalid file mode: #{mode_sym}" if actions.empty?
    target = 'a' if target.empty?
    user_mask = user_mask(target)
    actions.each_slice(2) do |op, perm|
      need_apply = op == '='
      mode_mask = (perm || '').each_char.inject(0) do |mask, chr|
        case chr
        when "r"
          mask | 0444
        when "w"
          mask | 0222
        when "x"
          mask | 0111
        when "X"
          if FileTest.directory? path
            mask | 0111
          else
            mask
          end
        when "s"
          mask | 06000
        when "t"
          mask | 01000
        when "u", "g", "o"
          if mask.nonzero?
            current_mode = apply_mask(current_mode, user_mask, op, mask)
          end
          need_apply = false
          copy_mask = user_mask(chr)
          (current_mode & copy_mask) / (copy_mask & 0111) * (user_mask & 0111)
        else
          raise ArgumentError, "invalid `perm' symbol in file mode: #{chr}"
        end
      end

      if mode_mask.nonzero? || need_apply
        current_mode = apply_mask(current_mode, user_mask, op, mode_mask)
      end
    end
    current_mode
  end
end

# File 'lib/fileutils.rb', line 889

def user_mask(target)  #:nodoc:
  target.each_char.inject(0) do |mask, chr|
    case chr
    when "u"
      mask | 04700
    when "g"
      mask | 02070
    when "o"
      mask | 01007
    when "a"
      mask | 07777
    else
      raise ArgumentError, "invalid `who' symbol in file mode: #{chr}"
    end
  end
end