# File fileutils.rb, line 122
def cd(dir, options = {}, &block) # :yield: dir
  fu_check_options options, OPT_TABLE['cd']
  fu_output_message "cd #{dir}" if options[:verbose]
  Dir.chdir(dir, &block)
  fu_output_message 'cd -' if options[:verbose] and block
end
            

 
               # File fileutils.rb, line 964
def chmod(mode, list, options = {})
  fu_check_options options, OPT_TABLE['chmod']
  list = fu_list(list)
  fu_output_message sprintf('chmod %o %s', mode, list.join(' ')) if options[:verbose]
  return if options[:noop]
  list.each do |path|
    Entry_.new(path).chmod(fu_mode(mode, path))
  end
end
            

 
               # File fileutils.rb, line 986
def chmod_R(mode, list, options = {})
  fu_check_options options, OPT_TABLE['chmod_R']
  list = fu_list(list)
  fu_output_message sprintf('chmod -R%s %o %s',
                            (options[:force] ? 'f' : ''),
                            mode, list.join(' ')) if options[:verbose]
  return if options[:noop]
  list.each do |root|
    Entry_.new(root).traverse do |ent|
      begin
        ent.chmod(fu_mode(mode, ent.path))
      rescue
        raise unless options[:force]
      end
    end
  end
end
            

 
               # File fileutils.rb, line 1019
def chown(user, group, list, options = {})
  fu_check_options options, OPT_TABLE['chown']
  list = fu_list(list)
  fu_output_message sprintf('chown %s%s',
                            [user,group].compact.join(':') + ' ',
                            list.join(' ')) if options[:verbose]
  return if options[:noop]
  uid = fu_get_uid(user)
  gid = fu_get_gid(group)
  list.each do |path|
    Entry_.new(path).chown uid, gid
  end
end
            

 
               # File fileutils.rb, line 1048
def chown_R(user, group, list, options = {})
  fu_check_options options, OPT_TABLE['chown_R']
  list = fu_list(list)
  fu_output_message sprintf('chown -R%s %s%s',
                            (options[:force] ? 'f' : ''),
                            [user,group].compact.join(':') + ' ',
                            list.join(' ')) if options[:verbose]
  return if options[:noop]
  uid = fu_get_uid(user)
  gid = fu_get_gid(group)
  return unless uid or gid
  list.each do |root|
    Entry_.new(root).traverse do |ent|
      begin
        ent.chown uid, gid
      rescue
        raise unless options[:force]
      end
    end
  end
end
            

 
               # File fileutils.rb, line 806
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 fileutils.rb, line 824
def compare_stream(a, b)
  bsize = fu_stream_blksize(a, b)
  sa = sb = nil
  while sa == sb
    sa = a.read(bsize)
    sb = b.read(bsize)
    unless sa and sb
      if sa.nil? and sb.nil?
        return true
      end
    end
  end
  false
end
            

 
               # File fileutils.rb, line 461
def copy_entry(src, dest, preserve = false, 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.copy destent.path
    ent.copy_metadata destent.path if preserve
  end
end
            

 
               # File fileutils.rb, line 475
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 fileutils.rb, line 487
def copy_stream(src, dest)
  IO.copy_stream(src, dest)
end
            

 
               # File fileutils.rb, line 391
def cp(src, dest, options = {})
  fu_check_options options, OPT_TABLE['cp']
  fu_output_message "cp#{options[:preserve] ? ' -p' : ''} #{[src,dest].flatten.join ' '}" if options[:verbose]
  return if options[:noop]
  fu_each_src_dest(src, dest) do |s, d|
    copy_file s, d, options[:preserve]
  end
end
            

 
               # File fileutils.rb, line 430
def cp_r(src, dest, options = {})
  fu_check_options options, OPT_TABLE['cp_r']
  fu_output_message "cp -r#{options[:preserve] ? 'p' : ''}#{options[:remove_destination] ? ' --remove-destination' : ''} #{[src,dest].flatten.join ' '}" if options[:verbose]
  return if options[:noop]
  options = options.dup
  options[:dereference_root] = true unless options.key?(:dereference_root)
  fu_each_src_dest(src, dest) do |s, d|
    copy_entry s, d, options[:preserve], options[:dereference_root], options[:remove_destination]
  end
end
            

 
               # File fileutils.rb, line 850
def install(src, dest, options = {})
  fu_check_options options, OPT_TABLE['install']
  fu_output_message "install -c#{options[:preserve] && ' -p'}#{options[:mode] ? (' -m 0%o' % options[:mode]) : ''} #{[src,dest].flatten.join ' '}" if options[:verbose]
  return if options[:noop]
  fu_each_src_dest(src, dest) do |s, d, st|
    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 options[:preserve]
      File.chmod options[:mode], d if options[:mode]
    end
  end
end
            

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

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

 
               # File fileutils.rb, line 368
def ln_sf(src, dest, options = {})
  fu_check_options options, OPT_TABLE['ln_sf']
  options = options.dup
  options[:force] = true
  ln_s src, dest, options
end
            

 
               # File fileutils.rb, line 169
def mkdir(list, options = {})
  fu_check_options options, OPT_TABLE['mkdir']
  list = fu_list(list)
  fu_output_message "mkdir #{options[:mode] ? ('-m %03o ' % options[:mode]) : ''}#{list.join ' '}" if options[:verbose]
  return if options[:noop]

  list.each do |dir|
    fu_mkdir dir, options[:mode]
  end
end
            

 
               # File fileutils.rb, line 199
def mkdir_p(list, options = {})
  fu_check_options options, OPT_TABLE['mkdir_p']
  list = fu_list(list)
  fu_output_message "mkdir -p #{options[:mode] ? ('-m %03o ' % options[:mode]) : ''}#{list.join ' '}" if options[:verbose]
  return *list if options[:noop]

  list.map {|path| path.chomp(?/) }.each do |path|
    # optimize for the most common case
    begin
      fu_mkdir path, options[: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.reverse_each do |dir|
      begin
        fu_mkdir dir, options[:mode]
      rescue SystemCallError
        raise unless File.directory?(dir)
      end
    end
  end

  return *list
end
            

 
               # File fileutils.rb, line 504
def mv(src, dest, options = {})
  fu_check_options options, OPT_TABLE['mv']
  fu_output_message "mv#{options[:force] ? ' -f' : ''} #{[src,dest].flatten.join ' '}" if options[:verbose]
  return if options[: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, dest
        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 options[:secure]
          remove_entry_secure s, options[:force]
        else
          remove_entry s, options[:force]
        end
      end
    rescue SystemCallError
      raise unless options[:force]
    end
  end
end
            

 
               # File fileutils.rb, line 100
def pwd
  Dir.pwd
end
            

 
               # File fileutils.rb, line 795
def remove_dir(path, force = false)
  remove_entry path, force   # FIXME?? check if it is a directory
end
            

 
               # File fileutils.rb, line 767
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 fileutils.rb, line 690
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 fileutils.rb, line 784
def remove_file(path, force = false)
  Entry_.new(path).remove_file
rescue
  raise unless force
end
            

 
               # File fileutils.rb, line 556
def rm(list, options = {})
  fu_check_options options, OPT_TABLE['rm']
  list = fu_list(list)
  fu_output_message "rm#{options[:force] ? ' -f' : ''} #{list.join ' '}" if options[:verbose]
  return if options[:noop]

  list.each do |path|
    remove_file path, options[:force]
  end
end
            

 
               # File fileutils.rb, line 581
def rm_f(list, options = {})
  fu_check_options options, OPT_TABLE['rm_f']
  options = options.dup
  options[:force] = true
  rm list, options
end
            

 
               # File fileutils.rb, line 616
def rm_r(list, options = {})
  fu_check_options options, OPT_TABLE['rm_r']
  # options[:secure] = true unless options.key?(:secure)
  list = fu_list(list)
  fu_output_message "rm -r#{options[:force] ? 'f' : ''} #{list.join ' '}" if options[:verbose]
  return if options[:noop]
  list.each do |path|
    if options[:secure]
      remove_entry_secure path, options[:force]
    else
      remove_entry path, options[:force]
    end
  end
end
            

 
               # File fileutils.rb, line 644
def rm_rf(list, options = {})
  fu_check_options options, OPT_TABLE['rm_rf']
  options = options.dup
  options[:force] = true
  rm_r list, options
end
            

 
               # File fileutils.rb, line 262
def rmdir(list, options = {})
  fu_check_options options, OPT_TABLE['rmdir']
  list = fu_list(list)
  parents = options[:parents]
  fu_output_message "rmdir #{parents ? '-p ' : ''}#{list.join ' '}" if options[:verbose]
  return if options[:noop]
  list.each do |dir|
    begin
      Dir.rmdir(dir = dir.chomp(?/))
      if parents
        until (parent = File.dirname(dir)) == '.' or parent == dir
          Dir.rmdir(dir)
        end
      end
    rescue Errno::ENOTEMPTY, Errno::ENOENT
    end
  end
end
            

 
               # File fileutils.rb, line 1125
def touch(list, options = {})
  fu_check_options options, OPT_TABLE['touch']
  list = fu_list(list)
  created = nocreate = options[:nocreate]
  t = options[:mtime]
  if options[:verbose]
    fu_output_message "touch #{nocreate ? '-c ' : ''}#{t ? t.strftime('-t %Y%m%d%H%M.%S ') : ''}#{list.join ' '}"
  end
  return if options[: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 fileutils.rb, line 145
def uptodate?(new, old_list, options = nil)
  raise ArgumentError, 'uptodate? does not accept any option' if options

  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