871
872
873
874
875
876
877
878
879

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

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 mode
  end
end

892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908

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

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 mode
      rescue
        raise unless options[:force]
      end
    end
  end
end

925
926
927
928
929
930
931
932
933
934
935
936
937

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

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

954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974

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

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

800
801
802
803
804
805
806
807

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

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

818
819
820
821
822
823
824
825
826
827
828
829
830
831

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

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

460
461
462
463
464
465
466
467

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

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

474
475
476
477
478

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

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

486
487
488

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

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

387
388
389
390
391
392
393
394

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

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

429
430
431
432
433
434
435
436
437
438

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

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

740
741
742
743
744
745
746

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

def fu_have_symlink?   #:nodoc
  File.symlink nil, nil
rescue NotImplementedError
  return false
rescue
  return true
end

237
238
239
240
241
242
243
244
245

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

def fu_mkdir(path, mode)   #:nodoc:
  path = path.sub(%r</\z>, '')
  if mode
    Dir.mkdir path, mode
    File.chmod mode, path
  else
    Dir.mkdir path
  end
end

749
750
751

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

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

844
845
846
847
848
849
850
851
852
853
854
855
856

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

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

302
303
304
305
306
307
308
309
310

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

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

341
342
343
344
345
346
347
348
349

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

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

364
365
366
367
368
369

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

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

165
166
167
168
169
170
171
172
173
174

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

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

195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225

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

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.sub(%r</\z>, '') }.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 => err
        raise unless File.directory?(dir)
      end
    end
  end

  return *list
end

503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531

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

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

100
101
102

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

def pwd
  Dir.pwd
end

789
790
791

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

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

761
762
763
764
765
766
767
768
769
770
771

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

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

689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737

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

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
  }
  # ---- 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

778
779
780
781
782

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

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

540
541
542

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

def rename_cannot_overwrite_file?   #:nodoc:
  /cygwin|mswin|mingw|bccwin|emx/ =~ RUBY_PLATFORM
end

555
556
557
558
559
560
561
562
563
564

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

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

580
581
582
583
584
585

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

def rm_f(list, options = {})
  fu_check_options options, OPT_TABLE['rm_f']
  options = options.dup
  options[:force] = true
  rm list, options
end

615
616
617
618
619
620
621
622
623
624
625
626
627
628

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

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

643
644
645
646
647
648

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

def rm_rf(list, options = {})
  fu_check_options options, OPT_TABLE['rm_rf']
  options = options.dup
  options[:force] = true
  rm_r list, options
end

258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275

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

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.sub(%r</\z>, ''))
      if parents
        until (parent = File.dirname(dir)) == '.' or parent == dir
          Dir.rmdir(dir)
        end
      end
    rescue Errno::ENOTEMPTY, Errno::ENOENT
    end
  end
end

1022
1023
1024
1025
1026
1027
1028
1029

# File 'lib/rake.rb', line 1022

def ruby(*args,&block)
  options = (Hash === args.last) ? args.pop : {}
  if args.length > 1 then
    sh(*([RUBY] + args + [options]), &block)
  else
    sh("#{RUBY} #{args.first}", options, &block)
  end
end

1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046

# File 'lib/rake.rb', line 1035

def safe_ln(*args)
  unless LN_SUPPORTED[0]
    cp(*args)
  else
    begin
      ln(*args)
    rescue StandardError, NotImplementedError => ex
      LN_SUPPORTED[0] = false
      cp(*args)
    end
  end
end

986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010

# File 'lib/rake.rb', line 986

def sh(*cmd, &block)
  options = (Hash === cmd.last) ? cmd.pop : {}
  unless block_given?
    show_command = cmd.join(" ")
    show_command = show_command[0,42] + "..." unless $trace
    # TODO code application logic heref show_command.length > 45
    block = lambda { |ok, status|
      ok or fail "Command failed with status (#{status.exitstatus}): [#{show_command}]"
    }
  end
  if RakeFileUtils.verbose_flag == :default
    options[:verbose] = true
  else
    options[:verbose] ||= RakeFileUtils.verbose_flag
  end
  options[:noop]    ||= RakeFileUtils.nowrite_flag
  rake_check_options options, :noop, :verbose
  rake_output_message cmd.join(" ") if options[:verbose]
  unless options[:noop]
    res = rake_system(*cmd)
    status = $?
    status = PseudoStatus.new(1) if !res && status.nil?
    block.call(res, status)
  end
end

1053
1054
1055
1056
1057
1058

# File 'lib/rake.rb', line 1053

def split_all(path)
  head, tail = File.split(path)
  return [tail] if head == '.' || tail == '/'
  return [head, tail] if head == '/'
  return split_all(head) + [tail]
end

1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053

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

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

141
142
143
144
145
146
147
148
149
150
151
152

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

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