Module: FileUtils

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

alias chdir cd

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

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 933

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 961

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 985

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 738

alias cmp compare_file

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

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

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

def self.commands
  OPT_TABLE.keys
end

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

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 745

def compare_stream(a, b)
  bsize = fu_stream_blksize(a, b)
  sa = String.new(capacity: bsize)
  sb = String.new(capacity: bsize)
  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 364

alias copy cp

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

def copy_entry(src, dest, preserve = false, dereference_root = false, remove_destination = false)
  Entry_.new(src, nil, dereference_root).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 430

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 442

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

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

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 388

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 105

alias getwd pwd

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

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 737

alias identical? compare_file

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

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 295

alias link ln

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

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 318

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 339

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 222

alias makedirs  mkdir_p

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

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 188

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 221

alias mkpath    mkdir_p

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

alias move mv

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

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
        else
          destent.remove_file if rename_cannot_overwrite_file?
        end
      end
      begin
        File.rename s, d
      rescue Errno::EXDEV
        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 1521

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

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

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

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

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

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

def pwd
  Dir.pwd
end

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

alias remove rm

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

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

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

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 611

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
  File.open(fullpath + '/.') {|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
    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 705

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

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

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 522

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

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

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 571

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 245

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 576

alias rmtree rm_rf

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

alias safe_unlink rm_f

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

alias symlink ln_s

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

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 137

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 490

def rename_cannot_overwrite_file?   #:nodoc:
  /emx/ =~ RUBY_PLATFORM
end

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

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 1468

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 1024

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

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

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

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

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

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

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 875

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

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

def fu_output_message(msg)   #:nodoc:
  @fileutils_output ||= $stderr
  @fileutils_label  ||= ''
  @fileutils_output.puts @fileutils_label + msg
end

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

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

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

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

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

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

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

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

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

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 793

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