Installer class handles the actual install procedure, as well as the other tasks, such as testing.

Methods
ask binread clean_dir_bin clean_dir_data clean_dir_doc clean_dir_etc clean_dir_ext clean_dir_lib clean_dir_man command compiles? config_dir_bin config_dir_data config_dir_doc config_dir_etc config_dir_ext config_dir_lib config_dir_man curr_objdir curr_srcdir diff? directories_of distclean_dir_bin distclean_dir_data distclean_dir_doc distclean_dir_etc distclean_dir_ext distclean_dir_lib distclean_dir_man dive_into dllext exec_all exec_clean exec_config exec_distclean exec_doc exec_install exec_rdoc exec_ri exec_setup exec_show exec_task_traverse exec_test exec_uninstall existfiles extconf extdir? extensions files_of force_remove_file get_config glob_reject glob_select globs2re hookfiles inspect install install_dir_bin install_dir_data install_dir_doc install_dir_doc install_dir_etc install_dir_ext install_dir_lib install_dir_man install_files installation! installation? libfiles make mapdir mkdir_p move_file new new_shebang no_harm? noop objdir_root open_atomic_writer quiet? record_installation relpath remove_file remove_tree remove_tree0 report_header rm_f rm_rf rmdir ruby rubyextentions run_hook set_config setup_dir_bin setup_dir_data setup_dir_doc setup_dir_etc setup_dir_ext setup_dir_lib setup_dir_man srcdir_root srcdirectories srcdirectory? srcentries srcexist? srcfile srcfile? srcfiles targetfiles traverse update_shebang_line verbose? verbose_off
Classes and Modules
Class Setup::Installer::Shebang
Constants
MANIFEST = '.cache/setup/installedfiles'
FILETYPES = %w( bin lib ext data etc man doc )
JUNK_FILES = %w( core RCSLOG tags TAGS .make.state .nse_depinfo #* .#* cvslog.* ,* .del-* *.olb *~ *.old *.bak *.BAK *.orig *.rej _$* *$ *.org *.in .* )
  picked up many entries from cvs-1.11.1/src/ignore.c
GLOB2REGEX = { '.' => '\.', '$' => '\$', '#' => '\#', '*' => '.*'
DIR_REJECT = %w( . .. CVS SCCS RCS CVS.adm .svn )
Attributes
[R] config Configuration
[RW] install_no_test
[RW] install_prefix
[W] no_harm
[W] quiet
[W] verbose
Public Class methods
new(config=nil) {|| ...}

New Installer.

# File lib/setup/install.rb, line 39
    def initialize(config=nil) #:yield:
      srcroot = '.'
      objroot = '.'

      @config = 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
Public Instance methods
ask(question, answers=nil)

Ask a question of the user.

# File lib/setup/install.rb, line 885
    def ask(question, answers=nil)
      $stdout << "#{question}"
      $stdout << " [#{answers}] " if answers
      until inp = $stdin.gets ; sleep 1 ; end
      inp.strip
    end
binread(fname)

File Operations

This module requires: verbose?, no_harm?

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

Alias for noop

clean_dir_data(rel)

Alias for noop

clean_dir_doc(rel)

Alias for noop

clean_dir_etc(rel)

Alias for noop

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

Alias for noop

clean_dir_man(rel)

Alias for noop

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

Alias for noop

config_dir_data(rel)

Alias for noop

config_dir_doc(rel)

Alias for noop

config_dir_etc(rel)

Alias for noop

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

Alias for noop

config_dir_man(rel)

Alias for noop

curr_objdir()
# File lib/setup/install.rb, line 919
    def curr_objdir
      "#{objdir_root()}/#{relpath()}"
    end
curr_srcdir()
# File lib/setup/install.rb, line 915
    def curr_srcdir
      "#{srcdir_root()}/#{relpath()}"
    end
diff?(new_content, path)
# File lib/setup/install.rb, line 847
    def diff?(new_content, path)
      return true unless File.exist?(path)
      new_content != binread(path)
    end
directories_of(dir)
# File lib/setup/install.rb, line 878
    def directories_of(dir)
      Dir.open(dir) {|d|
        return d.select {|ent| File.dir?("#{dir}/#{ent}") } - DIR_REJECT
      }
    end
distclean_dir_bin(rel)

Alias for noop

distclean_dir_data(rel)

Alias for noop

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

Alias for noop

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

Alias for noop

distclean_dir_man(rel)

Alias for noop

dive_into(rel) {|| ...}
# File lib/setup/install.rb, line 684
    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
dllext()
# File lib/setup/install.rb, line 504
    def dllext
      ConfigTable::RBCONFIG['DLEXT']
    end
exec_all()

Task all

# File lib/setup/install.rb, line 122
    def exec_all
      exec_config
      exec_setup
      exec_test
      exec_doc
      exec_install
    end
exec_clean()

TASK clean

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

TASK config

# File lib/setup/install.rb, line 134
    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
exec_distclean()

TASK distclean

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

TASK doc

NOT USED YET.

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

TASK install

# File lib/setup/install.rb, line 438
    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
exec_rdoc()

Generate rdocs.

# File lib/setup/install.rb, line 353
    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
exec_ri()

Generate ri documentation.

# File lib/setup/install.rb, line 390
    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
exec_setup()

TASK setup

FIXME: Update shebang at time of install not before. for now I‘ve commented out the shebang.

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

TASK show

# File lib/setup/install.rb, line 163
    def exec_show
      config.show
    end
exec_task_traverse(task)

Traversing

# File lib/setup/install.rb, line 660
    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
exec_test()

TASK test

Complexities arise in trying to figure out what test framework is used, and how to run tests. To simplify the process, this method simply looks for a script, either ’.config/setup/testrc.rb’, or ‘script/test’ or ‘task/test’ and runs it if found.

# File lib/setup/install.rb, line 280
    def exec_test
      return if install_no_test
      file   = nil
      file ||= Dir.glob('.config/setup/test{,rc}{,.rb}', File::FNM_CASEFOLD).first
      file ||= Dir.glob('{script,task}/test', File::FNM_CASEFOLD).first
      if file
        report_header('test')
        ruby(file)
      end
    end
exec_uninstall()

TASK uninstall

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

      remove = []
      files.uniq.each do |file|
        next if /^\#/ =~ file  # skip comments
        remove << file if File.exist?(file)
      end

      if verbose? && !no_harm?
        puts remove.collect{ |f| "rm #{f}" }.join("\n")
        ans = ask("Continue?", "yN")
        case ans
        when 'y', 'Y', 'yes'
        else
          return # abort?
        end
      end

      remove.each do |file|
        rm_f(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
existfiles()
# File lib/setup/install.rb, line 530
    def existfiles
      glob_reject(JUNK_FILES, (files_of(curr_srcdir()) | files_of('.')))
    end
extconf()
# File lib/setup/install.rb, line 155
    def extconf
      ruby "#{curr_srcdir()}/extconf.rb", config.extconfopt
    end
extdir?(dir)
# File lib/setup/install.rb, line 866
    def extdir?(dir)
      File.exist?("#{dir}/MANIFEST") or File.exist?("#{dir}/extconf.rb")
    end
extensions()

Added these for future use in simplificaiton of design.

# File lib/setup/install.rb, line 91
    def extensions
      @extensions ||= Dir['ext/**/extconf.rb']
    end
files_of(dir)
# File lib/setup/install.rb, line 870
    def files_of(dir)
      Dir.open(dir) {|d|
        return d.select {|ent| File.file?("#{dir}/#{ent}") }
      }
    end
force_remove_file(path)
# File lib/setup/install.rb, line 802
    def force_remove_file(path)
      begin
        remove_file path
      rescue
      end
    end
get_config(key)
# File lib/setup/install.rb, line 899
    def get_config(key)
      config[key]
    end
glob_reject(pats, ents)
# File lib/setup/install.rb, line 545
    def glob_reject(pats, ents)
      re = globs2re(pats)
      ents.reject {|ent| re =~ ent }
    end
glob_select(pat, ents)
# File lib/setup/install.rb, line 540
    def glob_select(pat, ents)
      re = globs2re([pat])
      ents.select {|ent| re =~ ent }
    end
globs2re(pats)
# File lib/setup/install.rb, line 557
    def globs2re(pats)
      /\A(?:#{
        pats.map {|pat| pat.gsub(/[\.\$\#\*]/) {|ch| GLOB2REGEX[ch] } }.join('|')
      })\z/
    end
hookfiles()
# File lib/setup/install.rb, line 534
    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
inspect()
# File lib/setup/install.rb, line 56
    def inspect
      "#<#{self.class} #{File.basename(@srcdir)}>"
    end
install(from, dest, mode, prefix = nil)
# File lib/setup/install.rb, line 814
    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
install_dir_bin(rel)
# File lib/setup/install.rb, line 446
    def install_dir_bin(rel)
      install_files targetfiles(), "#{config.bindir}/#{rel}", 0755
    end
install_dir_data(rel)
# File lib/setup/install.rb, line 460
    def install_dir_data(rel)
      install_files targetfiles(), "#{config.datadir}/#{rel}", 0644
    end
install_dir_doc(rel)

doc installs to directory named: "ruby-#{package}"

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

doc installs to directory named: "ruby-#{package}"

# File lib/setup/install.rb, line 475
    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
install_dir_etc(rel)
# File lib/setup/install.rb, line 464
    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
install_dir_ext(rel)
# File lib/setup/install.rb, line 454
    def install_dir_ext(rel)
      return unless extdir?(curr_srcdir())
      install_files rubyextentions('.'),
                    "#{config.sodir}/#{File.dirname(rel)}", 0555
    end
install_dir_lib(rel)
# File lib/setup/install.rb, line 450
    def install_dir_lib(rel)
      install_files libfiles(), "#{config.rbdir}/#{rel}", 0644
    end
install_dir_man(rel)
# File lib/setup/install.rb, line 470
    def install_dir_man(rel)
      install_files targetfiles(), "#{config.mandir}/#{rel}", 0644
    end
install_files(list, dest, mode)
# File lib/setup/install.rb, line 485
    def install_files(list, dest, mode)
      mkdir_p dest, install_prefix
      list.each do |fname|
        install fname, dest, mode, install_prefix
      end
    end
installation!()
# File lib/setup/install.rb, line 62
    def installation!; @installation = true; end
installation?()

Are we running an installation?

# File lib/setup/install.rb, line 61
    def installation?; @installation; end
libfiles()
# File lib/setup/install.rb, line 492
    def libfiles
      glob_reject(%w(*.y *.output), targetfiles())
    end
make(task = nil)
# File lib/setup/install.rb, line 862
    def make(task = nil)
      command(*[config.makeprog, task].compact)
    end
mapdir(ents)
# File lib/setup/install.rb, line 512
    def mapdir(ents)
      ents.map {|ent|
        if File.exist?(ent)
        then ent                         # objdir
        else "#{curr_srcdir()}/#{ent}"   # srcdir
        end
      }
    end
mkdir_p(dirname, prefix = nil)
# File lib/setup/install.rb, line 723
    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
move_file(src, dest)
# File lib/setup/install.rb, line 789
    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
new_shebang(old)
# File lib/setup/install.rb, line 223
    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
no_harm?()
# File lib/setup/install.rb, line 64
    def no_harm? ; @no_harm ; end
objdir_root()
# File lib/setup/install.rb, line 110
    def objdir_root
      @objdir
    end
open_atomic_writer(path, &block)
# File lib/setup/install.rb, line 234
    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
quiet?()
# File lib/setup/install.rb, line 66
    def quiet?   ; @quiet   ; end
record_installation(path)
# File lib/setup/install.rb, line 840
    def record_installation(path)
      FileUtils.mkdir_p(File.dirname("#{objdir_root()}/#{MANIFEST}"))
      File.open("#{objdir_root()}/#{MANIFEST}", 'a') do |f|
        f.puts(path)
      end
    end
relpath()
# File lib/setup/install.rb, line 114
    def relpath
      @currdir
    end
remove_file(path)
# File lib/setup/install.rb, line 809
    def remove_file(path)
      File.chmod 0777, path
      File.unlink path
    end
remove_tree(path)
# File lib/setup/install.rb, line 759
    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
remove_tree0(path)
# File lib/setup/install.rb, line 769
    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
report_header(phase)
# File lib/setup/install.rb, line 78
    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
rm_f(path)
# File lib/setup/install.rb, line 741
    def rm_f(path)
      $stderr.puts "rm -f #{path}" if verbose?
      return if no_harm?
      force_remove_file path
    end
rm_rf(path)
# File lib/setup/install.rb, line 747
    def rm_rf(path)
      $stderr.puts "rm -rf #{path}" if verbose?
      return if no_harm?
      remove_tree path
    end
rmdir(path)
# File lib/setup/install.rb, line 753
    def rmdir(path)
      $stderr.puts "rmdir #{path}" if verbose?
      return if no_harm?
      Dir.rmdir path
    end
ruby(*args)
# File lib/setup/install.rb, line 858
    def ruby(*args)
      command config.rubyprog, *args
    end
rubyextentions(dir)
# File lib/setup/install.rb, line 496
    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
run_hook(id)
# File lib/setup/install.rb, line 700
    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
set_config(key, val)

obsolete: use metaconfig to change configuration TODO: what to do with?

# File lib/setup/install.rb, line 905
    def set_config(key, val)
      config[key] = val
    end
setup_dir_bin(rel)
# File lib/setup/install.rb, line 180
    def setup_dir_bin(rel)
      files_of(curr_srcdir()).each do |fname|
        #update_shebang_line "#{curr_srcdir()}/#{fname}"  # HERE
      end
    end
setup_dir_data(rel)

Alias for noop

setup_dir_doc(rel)

Alias for noop

setup_dir_etc(rel)

Alias for noop

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

Alias for noop

setup_dir_man(rel)

Alias for noop

srcdir_root()

Hook Script API bases

# File lib/setup/install.rb, line 106
    def srcdir_root
      @srcdir
    end
srcdirectories(path = '.')
# File lib/setup/install.rb, line 951
    def srcdirectories(path = '.')
      srcentries(path).select {|fname|
        File.dir?(File.join(curr_srcdir(), path, fname))
      }
    end
srcdirectory?(path)
# File lib/setup/install.rb, line 931
    def srcdirectory?(path)
      File.dir?(srcfile(path))
    end
srcentries(path = '.')
# File lib/setup/install.rb, line 939
    def srcentries(path = '.')
      Dir.open("#{curr_srcdir()}/#{path}") {|d|
        return d.to_a - %w(. ..)
      }
    end
srcexist?(path)
# File lib/setup/install.rb, line 927
    def srcexist?(path)
      File.exist?(srcfile(path))
    end
srcfile(path)
# File lib/setup/install.rb, line 923
    def srcfile(path)
      "#{curr_srcdir()}/#{path}"
    end
srcfile?(path)
# File lib/setup/install.rb, line 935
    def srcfile?(path)
      File.file?(srcfile(path))
    end
srcfiles(path = '.')
# File lib/setup/install.rb, line 945
    def srcfiles(path = '.')
      srcentries(path).select {|fname|
        File.file?(File.join(curr_srcdir(), path, fname))
      }
    end
targetfiles()
# File lib/setup/install.rb, line 508
    def targetfiles
      mapdir(existfiles() - hookfiles())
    end
traverse(task, rel, mid)
# File lib/setup/install.rb, line 672
    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
update_shebang_line(path)
# File lib/setup/install.rb, line 197
    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
verbose?()
# File lib/setup/install.rb, line 65
    def verbose? ; @verbose ; end
verbose_off( {|| ...}
# File lib/setup/install.rb, line 68
    def verbose_off #:yield:
      begin
        save, @verbose = verbose?, false
        yield
      ensure
        @verbose = save
      end
    end