# File lib/setup/install.rb, line 38
    def initialize #:yield:
      srcroot = '.'
      objroot = '.'

      @config = ConfigTable.new

      @srcdir = File.expand_path(srcroot)
      @objdir = File.expand_path(objroot)
      @currdir = '.'

      self.quiet   = ENV['quiet'] if ENV['quiet']
      self.verbose = ENV['verbose'] if ENV['verbose']
      self.no_harm = ENV['nowrite'] if ENV['nowrite']

      yield(self) if block_given?
    end

# File lib/setup/install.rb, line 683
    def binread(fname)
      File.open(fname, 'rb'){ |f|
        return f.read
      }
    end

# File lib/setup/install.rb, line 594
    def clean_dir_ext(rel)
      return unless extdir?(curr_srcdir())
      make 'clean' if File.file?('Makefile')
    end

# File lib/setup/install.rb, line 817
    def command(*args)
      $stderr.puts args.join(' ') if verbose?
      system(*args) or raise RuntimeError,
          "system(#{args.map{|a| a.inspect }.join(' ')}) failed"
    end

# File lib/setup/install.rb, line 94
    def compiles?
      !extensions.empty?
    end

# File lib/setup/install.rb, line 145
    def config_dir_ext(rel)
      extconf if extdir?(curr_srcdir())
    end

# File lib/setup/install.rb, line 874
    def curr_objdir
      "#{objdir_root()}/#{relpath()}"
    end

# File lib/setup/install.rb, line 870
    def curr_srcdir
      "#{srcdir_root()}/#{relpath()}"
    end

# File lib/setup/install.rb, line 812
    def diff?(new_content, path)
      return true unless File.exist?(path)
      new_content != binread(path)
    end

# File lib/setup/install.rb, line 843
    def directories_of(dir)
      Dir.open(dir) {|d|
        return d.select {|ent| File.dir?("#{dir}/#{ent}") } - DIR_REJECT
      }
    end

# File lib/setup/install.rb, line 621
    def distclean_dir_doc(rel)
      #rm_rf('rdoc') if File.directory?('rdoc')  # RDOC HERE
    end

# File lib/setup/install.rb, line 612
    def distclean_dir_ext(rel)
      return unless extdir?(curr_srcdir())
      make 'distclean' if File.file?('Makefile')
    end

# File lib/setup/install.rb, line 652
    def dive_into(rel)
      return unless File.dir?("#{@srcdir}/#{rel}")

      dir = File.basename(rel)
      Dir.mkdir dir unless File.dir?(dir)
      prevdir = Dir.pwd
      Dir.chdir dir
      $stderr.puts '---> ' + rel if verbose?
      @currdir = rel
      yield
      Dir.chdir prevdir
      $stderr.puts '<--- ' + rel if verbose?
      @currdir = File.dirname(rel)
    end

# File lib/setup/install.rb, line 488
    def dllext
      ConfigTable::RBCONFIG['DLEXT']
    end

# File lib/setup/install.rb, line 121
    def exec_all
      exec_config
      exec_setup
      exec_test     # TODO: stop here if fail (?)
      exec_doc
      exec_install
    end

# File lib/setup/install.rb, line 581
    def exec_clean
      exec_task_traverse 'clean'
      rm_f ConfigTable::CONFIGFILE
      #rm_f MANIFEST  # only on clobber!
    end

# File lib/setup/install.rb, line 133
    def exec_config
      report_header('config')
      config.env_config
      config.save_config
      config.show if verbose?
      puts("Configuration saved.") unless quiet?
      exec_task_traverse 'config'
    end

# File lib/setup/install.rb, line 603
    def exec_distclean
      exec_task_traverse 'distclean'
      rm_f ConfigTable::CONFIGFILE
      rm_f MANIFEST
    end

# File lib/setup/install.rb, line 326
    def exec_doc
      return if config.without_doc?
      report_header('doc')
      #exec_rdoc   unless config.without_doc?  # RDOC HERE
      exec_ri      
    end

# File lib/setup/install.rb, line 422
    def exec_install
      report_header('install')
      installation!  # we are installing
      #rm_f MANIFEST # we'll append rather then delete!
      exec_task_traverse 'install'
      $stderr.puts "Done.\n\n" unless quiet?
    end

# File lib/setup/install.rb, line 337
    def exec_rdoc
      output    = File.join('doc', 'rdoc')
      title     = (PACKAGE_NAME.capitalize + " API").strip
      main      = Dir.glob("README{,.txt}", File::FNM_CASEFOLD).first
      template  = config.doctemplate || 'html'

      opt = []
      opt << "-U"
      opt << "-S"
      opt << "--op=#{output}"
      opt << "--template=#{template}"
      opt << "--title=#{title}"
      opt << "--main=#{main}"     if main

      if File.exist?('.document')
        files = File.read('.document').split("\n")
        files.reject!{ |l| l =~ /^\s*[#]/ || l !~ /\S/ }
        files.collect!{ |f| f.strip }
        opt << files
      else
        opt << main               if main
        opt << ["lib", "ext"]
      end

      opt = opt.flatten

      if no_harm?
        puts "rdoc " + opt.join(' ').strip
      else
        #sh "rdoc {opt.join(' ').strip}"
        require 'rdoc/rdoc'
        ::RDoc::RDoc.new.document(opt)
      end
    end

# File lib/setup/install.rb, line 374
    def exec_ri
      case config.installdirs
      when 'std'
        output = "--ri-system"
      when 'site'
        output = "--ri-site"
      when 'home'
        output = "--ri"
      else
        abort "bad config: sould not be possible -- installdirs = #{config.installdirs}"
      end

      if File.exist?('.document')
        files = File.read('.document').split("\n")
        files.reject!{ |l| l =~ /^\s*[#]/ || l !~ /\S/ }
        files.collect!{ |f| f.strip }
      else
        files = ["lib", "ext"]
      end

      opt = []
      opt << "-U"
      opt << output
      opt << files
      opt = opt.flatten

      if no_harm?
        puts "rdoc #{opt.join(' ').strip}"
      else
        # Generate in system location specified
        #sh "rdoc #{opt.join(' ').strip}"
        require 'rdoc/rdoc'
        ::RDoc::RDoc.new.document(opt)

        # Now in local directory
        opt = []
        opt << "-U"
        opt << "--ri --op 'doc/ri'"
        opt << files
        opt = opt.flatten
        ::RDoc::RDoc.new.document(opt)
      end
    end

# File lib/setup/install.rb, line 173
    def exec_setup
      report_header('setup')
      exec_task_traverse 'setup'
      puts "Ok."
    end

# File lib/setup/install.rb, line 162
    def exec_show
      config.show
    end

# File lib/setup/install.rb, line 629
    def exec_task_traverse(task)
      run_hook "pre-#{task}"
      FILETYPES.each do |type|
        if type == 'ext' and config.without_ext == 'yes'
          $stderr.puts 'skipping ext/* by user option' if verbose?
          next
        end
        traverse task, type, "#{task}_dir_#{type}"
      end
      run_hook "post-#{task}"
    end

# File lib/setup/install.rb, line 276
    def exec_test
      report_header('test')
      runner = config.testrunner
      case runner
      when 'testrb'  # TODO: needs work
        opt = []
        opt << " -v" if verbose?
        opt << " --runner #{runner}"
        if File.file?('test/suite.rb')
          notests = false
          opt << "test/suite.rb"
        else
          notests = Dir["test/**/*.rb"].empty?
          lib = ["lib"] + config.extensions.collect{ |d| File.dirname(d) }
          opt << "-I" + lib.join(':')
          opt << Dir["test/**/{test,tc}*.rb"]
        end
        opt = opt.flatten.join(' ').strip
        # run tests
        if notests
          $stderr.puts 'no test in this package' if verbose?
        else
          cmd = "testrb #{opt}"
          $stderr.puts cmd if verbose?
          system cmd  #config.ruby "-S tesrb", opt
        end
      else # autorunner
        unless File.directory?('test')
          $stderr.puts 'no test in this package' if verbose?
          return
        end
        begin
          require 'test/unit'
        rescue LoadError
          setup_rb_error 'test/unit cannot loaded.  You need Ruby 1.8 or later to invoke this task.'
        end
        autorunner = Test::Unit::AutoRunner.new(true)
        autorunner.to_run << 'test'
        autorunner.run
      end
    end

# File lib/setup/install.rb, line 551
    def exec_uninstall
      paths = File.read(MANIFEST).split("\n")
      dirs, files = paths.partition{ |f| File.dir?(f) }

      files.each do |file|
        next if /^\#/ =~ file  # skip comments
        rm_f(file) if File.exist?(file)
      end

      dirs.each do |dir|
        # okay this is over kill, but playing it safe...
        empty = Dir[File.join(dir,'*')].empty?
        begin
          if no_harm?
            $stderr.puts "rmdir #{dir}"
          else
            rmdir(dir) if empty
          end
        rescue Errno::ENOTEMPTY
          $stderr.puts "may not be empty -- #{dir}" if verbose?
        end
      end

      rm_f(MANIFEST)
    end

# File lib/setup/install.rb, line 514
    def existfiles
      glob_reject(JUNK_FILES, (files_of(curr_srcdir()) | files_of('.')))
    end

# File lib/setup/install.rb, line 154
    def extconf
      ruby "#{curr_srcdir()}/extconf.rb", config.extconfopt
    end

# File lib/setup/install.rb, line 831
    def extdir?(dir)
      File.exist?("#{dir}/MANIFEST") or File.exist?("#{dir}/extconf.rb")
    end

# File lib/setup/install.rb, line 90
    def extensions
      @extensions ||= Dir['ext/**/extconf.rb']
    end

# File lib/setup/install.rb, line 835
    def files_of(dir)
      Dir.open(dir) {|d|
        return d.select {|ent| File.file?("#{dir}/#{ent}") }
      }
    end

# File lib/setup/install.rb, line 768
    def force_remove_file(path)
      begin
        remove_file path
      rescue
      end
    end

# File lib/setup/install.rb, line 856
    def get_config(key)
      config.__send__(key)
    end

# File lib/setup/install.rb, line 529
    def glob_reject(pats, ents)
      re = globs2re(pats)
      ents.reject {|ent| re =~ ent }
    end

# File lib/setup/install.rb, line 524
    def glob_select(pat, ents)
      re = globs2re([pat])
      ents.select {|ent| re =~ ent }
    end

# File lib/setup/install.rb, line 541
    def globs2re(pats)
      /\A(?:#{
        pats.map {|pat| pat.gsub(/[\.\$\#\*]/) {|ch| GLOB2REGEX[ch] } }.join('|')
      })\z/
    end

# File lib/setup/install.rb, line 518
    def hookfiles
      %w( pre-%s post-%s pre-%s.rb post-%s.rb ).map {|fmt|
        %w( etc setup install clean ).map {|t| sprintf(fmt, t) }
      }.flatten
    end

# File lib/setup/install.rb, line 55
    def inspect
      "#<#{self.class} #{File.basename(@srcdir)}>"
    end

# File lib/setup/install.rb, line 780
    def install(from, dest, mode, prefix = nil)
      $stderr.puts "install #{from} #{dest}" if verbose?
      return if no_harm?

      realdest = prefix ? prefix + File.expand_path(dest) : dest
      realdest = File.join(realdest, File.basename(from)) if File.dir?(realdest)
      str = binread(from)
      if diff?(str, realdest)
        verbose_off {
          rm_f realdest if File.exist?(realdest)
        }
        File.open(realdest, 'wb') {|f|
          f.write str
        }
        File.chmod mode, realdest

        if prefix
          path = realdest.sub(prefix, '')
        else
          path = realdest
        end

        record_installation(path)
      end
    end

# File lib/setup/install.rb, line 430
    def install_dir_bin(rel)
      install_files targetfiles(), "#{config.bindir}/#{rel}", 0755
    end

# File lib/setup/install.rb, line 444
    def install_dir_data(rel)
      install_files targetfiles(), "#{config.datadir}/#{rel}", 0644
    end

# File lib/setup/install.rb, line 459
    def install_dir_doc(rel)
      return if config.without_doc?
      dir = "#{config.docdir}/ruby-#{PACKAGE_NAME}/#{rel}" # "#{config.docdir}/#{rel}"
      install_files targetfiles(), dir, 0644
    end

# File lib/setup/install.rb, line 466
    def install_dir_doc(rel)
    end

# File lib/setup/install.rb, line 448
    def install_dir_etc(rel)
      # FIXME: should not remove current config files
      # (rename previous file to .old/.org)
      install_files targetfiles(), "#{config.sysconfdir}/#{rel}", 0644
    end

# File lib/setup/install.rb, line 438
    def install_dir_ext(rel)
      return unless extdir?(curr_srcdir())
      install_files rubyextentions('.'),
                    "#{config.sodir}/#{File.dirname(rel)}", 0555
    end

# File lib/setup/install.rb, line 434
    def install_dir_lib(rel)
      install_files libfiles(), "#{config.rbdir}/#{rel}", 0644
    end

# File lib/setup/install.rb, line 454
    def install_dir_man(rel)
      install_files targetfiles(), "#{config.mandir}/#{rel}", 0644
    end

# File lib/setup/install.rb, line 469
    def install_files(list, dest, mode)
      mkdir_p dest, install_prefix
      list.each do |fname|
        install fname, dest, mode, install_prefix
      end
    end

# File lib/setup/install.rb, line 61
    def installation!; @installation = true; end

# File lib/setup/install.rb, line 60
    def installation?; @installation; end

# File lib/setup/install.rb, line 476
    def libfiles
      glob_reject(%w(*.y *.output), targetfiles())
    end

# File lib/setup/install.rb, line 827
    def make(task = nil)
      command(*[config.makeprog, task].compact)
    end

# File lib/setup/install.rb, line 496
    def mapdir(ents)
      ents.map {|ent|
        if File.exist?(ent)
        then ent                         # objdir
        else "#{curr_srcdir()}/#{ent}"   # srcdir
        end
      }
    end

# File lib/setup/install.rb, line 689
    def mkdir_p(dirname, prefix = nil)
      dirname = prefix + File.expand_path(dirname) if prefix
      $stderr.puts "mkdir -p #{dirname}" if verbose?
      return if no_harm?

      # Does not check '/', it's too abnormal.
      dirs = File.expand_path(dirname).split(%r<(?=/)>)
      if /\A[a-z]:\z/i =~ dirs[0]
        disk = dirs.shift
        dirs[0] = disk + dirs[0]
      end
      dirs.each_index do |idx|
        path = dirs[0..idx].join('')
        Dir.mkdir path unless File.dir?(path)
        record_installation(path)  # also record directories made
      end
    end

# File lib/setup/install.rb, line 755
    def move_file(src, dest)
      force_remove_file dest
      begin
        File.rename src, dest
      rescue
        File.open(dest, 'wb') {|f|
          f.write binread(src)
        }
        File.chmod File.stat(src).mode, dest
        File.unlink src
      end
    end

# File lib/setup/install.rb, line 222
    def new_shebang(old)
      if /\Aruby/ =~ File.basename(old.cmd)
        Shebang.new(config.rubypath, old.args)
      elsif File.basename(old.cmd) == 'env' and old.args.first == 'ruby'
        Shebang.new(config.rubypath, old.args[1..-1])
      else
        return old unless config.shebang == 'all'
        Shebang.new(config.rubypath)
      end
    end

# File lib/setup/install.rb, line 63
    def no_harm?; @no_harm; end

# File lib/setup/install.rb, line 99
    def noop(rel); end

# File lib/setup/install.rb, line 109
    def objdir_root
      @objdir
    end

# File lib/setup/install.rb, line 233
    def open_atomic_writer(path, &block)
      tmpfile = File.basename(path) + '.tmp'
      begin
        File.open(tmpfile, 'wb', &block)
        File.rename tmpfile, File.basename(path)
      ensure
        File.unlink tmpfile if File.exist?(tmpfile)
      end
    end

# File lib/setup/install.rb, line 65
    def quiet?; @quiet; end

# File lib/setup/install.rb, line 806
    def record_installation(path)
      File.open("#{objdir_root()}/#{MANIFEST}", 'a') do |f|
        f.puts(path)
      end
    end

# File lib/setup/install.rb, line 113
    def relpath
      @currdir
    end

# File lib/setup/install.rb, line 775
    def remove_file(path)
      File.chmod 0777, path
      File.unlink path
    end

# File lib/setup/install.rb, line 725
    def remove_tree(path)
      if File.symlink?(path)
        remove_file path
      elsif File.dir?(path)
        remove_tree0 path
      else
        force_remove_file path
      end
    end

# File lib/setup/install.rb, line 735
    def remove_tree0(path)
      Dir.foreach(path) do |ent|
        next if ent == '.'
        next if ent == '..'
        entpath = "#{path}/#{ent}"
        if File.symlink?(entpath)
          remove_file entpath
        elsif File.dir?(entpath)
          remove_tree0 entpath
        else
          force_remove_file entpath
        end
      end
      begin
        Dir.rmdir path
      rescue Errno::ENOTEMPTY
        # directory may not be empty
      end
    end

# File lib/setup/install.rb, line 77
    def report_header(phase)
       return if quiet?
       #center = "            "
       #c = (center.size - phase.size) / 2
       #center[c,phase.size] = phase.to_s.upcase
       line = '- ' * 4 + ' -' * 24
       #c = (line.size - phase.size) / 2
       line[5,phase.size] = " #{phase.to_s.upcase} "
       puts "\n" + line + "\n\n"
    end

# File lib/setup/install.rb, line 707
    def rm_f(path)
      $stderr.puts "rm -f #{path}" if verbose?
      return if no_harm?
      force_remove_file path
    end

# File lib/setup/install.rb, line 713
    def rm_rf(path)
      $stderr.puts "rm -rf #{path}" if verbose?
      return if no_harm?
      remove_tree path
    end

# File lib/setup/install.rb, line 719
    def rmdir(path)
      $stderr.puts "rmdir #{path}" if verbose?
      return if no_harm?
      Dir.rmdir path
    end

# File lib/setup/install.rb, line 823
    def ruby(*args)
      command config.rubyprog, *args
    end

# File lib/setup/install.rb, line 480
    def rubyextentions(dir)
      ents = glob_select("*.#{dllext}", targetfiles())
      if ents.empty?
        setup_rb_error "no ruby extention exists: 'ruby #{$0} setup' first"
      end
      ents
    end

# File lib/setup/install.rb, line 667
    def run_hook(id)
      path = [ "#{curr_srcdir()}/#{id}",
               "#{curr_srcdir()}/#{id}.rb" ].detect {|cand| File.file?(cand) }
      return unless path
      begin
        instance_eval File.read(path), path, 1
      rescue
        raise if $DEBUG
        setup_rb_error "hook #{path} failed:\n" + $!.message
      end
    end

# File lib/setup/install.rb, line 862
    def set_config(key, val)
      config[key] = val
    end

# File lib/setup/install.rb, line 179
    def setup_dir_bin(rel)
      files_of(curr_srcdir()).each do |fname|
        #update_shebang_line "#{curr_srcdir()}/#{fname}"  # HERE
      end
    end

# File lib/setup/install.rb, line 187
    def setup_dir_ext(rel)
      make if extdir?(curr_srcdir())
    end

# File lib/setup/install.rb, line 105
    def srcdir_root
      @srcdir
    end

# File lib/setup/install.rb, line 906
    def srcdirectories(path = '.')
      srcentries(path).select {|fname|
        File.dir?(File.join(curr_srcdir(), path, fname))
      }
    end

# File lib/setup/install.rb, line 886
    def srcdirectory?(path)
      File.dir?(srcfile(path))
    end

# File lib/setup/install.rb, line 894
    def srcentries(path = '.')
      Dir.open("#{curr_srcdir()}/#{path}") {|d|
        return d.to_a - %w(. ..)
      }
    end

# File lib/setup/install.rb, line 882
    def srcexist?(path)
      File.exist?(srcfile(path))
    end

# File lib/setup/install.rb, line 878
    def srcfile(path)
      "#{curr_srcdir()}/#{path}"
    end

# File lib/setup/install.rb, line 890
    def srcfile?(path)
      File.file?(srcfile(path))
    end

# File lib/setup/install.rb, line 900
    def srcfiles(path = '.')
      srcentries(path).select {|fname|
        File.file?(File.join(curr_srcdir(), path, fname))
      }
    end

# File lib/setup/install.rb, line 492
    def targetfiles
      mapdir(existfiles() - hookfiles())
    end

# File lib/setup/install.rb, line 641
    def traverse(task, rel, mid)
      dive_into(rel) {
        run_hook "pre-#{task}"
        __send__ mid, rel.sub(%r[\A.*?(?:/|\z)], '')
        directories_of(curr_srcdir()).each do |d|
          traverse task, "#{rel}/#{d}", mid
        end
        run_hook "post-#{task}"
      }
    end

# File lib/setup/install.rb, line 196
    def update_shebang_line(path)
      return if no_harm?
      return if config.shebang == 'never'
      old = Shebang.load(path)
      if old
        if old.args.size > 1
          $stderr.puts "warning: #{path}"
          $stderr.puts "Shebang line has too many args."
          $stderr.puts "It is not portable and your program may not work."
        end
        new = new_shebang(old)
        return if new.to_s == old.to_s
      else
        return unless config.shebang == 'all'
        new = Shebang.new(config.rubypath)
      end
      $stderr.puts "updating shebang: #{File.basename(path)}" if verbose?
      open_atomic_writer(path) {|output|
        File.open(path, 'rb') {|f|
          f.gets if old   # discard
          output.puts new.to_s
          output.print f.read
        }
      }
    end

# File lib/setup/install.rb, line 64
    def verbose?; @verbose; end

# File lib/setup/install.rb, line 67
    def verbose_off #:yield:
      begin
        save, @verbose = verbose?, false
        yield
      ensure
        @verbose = save
      end
    end