SoundSoftware Code Site

# Redmine - project management software

# Copyright (C) 2006-2011  Jean-Philippe Lang

#

# This program is free software; you can redistribute it and/or

# modify it under the terms of the GNU General Public License

# as published by the Free Software Foundation; either version 2

# of the License, or (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

require File.expand_path('../../test_helper', __FILE__)

begin

  require 'mocha'

rescue

  # Won't run some tests

end

class AccountTest < ActionController::IntegrationTest

  fixtures :users, :roles

  # Replace this with your real tests.

  def test_login

    get "my/page"

    assert_redirected_to "/login?back_url=http%3A%2F%2Fwww.example.com%2Fmy%2Fpage"

    log_user('jsmith', 'jsmith')

    get "my/account"

    assert_response :success

    assert_template "my/account"

  end

  def test_autologin

    user = User.find(1)

    Setting.autologin = "7"

    Token.delete_all

    # User logs in with 'autologin' checked

    post '/login', :username => user.login, :password => 'admin', :autologin => 1

    assert_redirected_to '/my/page'

    token = Token.find :first

    assert_not_nil token

    assert_equal user, token.user

    assert_equal 'autologin', token.action

    assert_equal user.id, session[:user_id]

    assert_equal token.value, cookies['autologin']

    # Session is cleared

    reset!

    User.current = nil

    # Clears user's last login timestamp

    user.update_attribute :last_login_on, nil

    assert_nil user.reload.last_login_on

    # User comes back with his autologin cookie

    cookies[:autologin] = token.value

    get '/my/page'

    assert_response :success

    assert_template 'my/page'

    assert_equal user.id, session[:user_id]

    assert_not_nil user.reload.last_login_on

    assert user.last_login_on.utc > 10.second.ago.utc

  end

  def test_lost_password

    Token.delete_all

    get "account/lost_password"

    assert_response :success

    assert_template "account/lost_password"

    post "account/lost_password", :mail => 'jSmith@somenet.foo'

    assert_redirected_to "/login"

    token = Token.find(:first)

    assert_equal 'recovery', token.action

    assert_equal 'jsmith@somenet.foo', token.user.mail

    assert !token.expired?

    get "account/lost_password", :token => token.value

    assert_response :success

    assert_template "account/password_recovery"

    post "account/lost_password", :token => token.value, :new_password => 'newpass', :new_password_confirmation => 'newpass'

    assert_redirected_to "/login"

    assert_equal 'Password was successfully updated.', flash[:notice]

    log_user('jsmith', 'newpass')

    assert_equal 0, Token.count

  end

  def test_register_with_automatic_activation

    Setting.self_registration = '3'

    get 'account/register'

    assert_response :success

    assert_template 'account/register'

    post 'account/register', :user => {:login => "newuser", :language => "en", :firstname => "New", :lastname => "User", :mail => "newuser@foo.bar"},

                             :password => "newpass", :password_confirmation => "newpass"

    assert_redirected_to '/my/account'

    follow_redirect!

    assert_response :success

    assert_template 'my/account'

    user = User.find_by_login('newuser')

    assert_not_nil user

    assert user.active?

    assert_not_nil user.last_login_on

  end

  def test_register_with_manual_activation

    Setting.self_registration = '2'

    post 'account/register', :user => {:login => "newuser", :language => "en", :firstname => "New", :lastname => "User", :mail => "newuser@foo.bar"},

                             :password => "newpass", :password_confirmation => "newpass"

    assert_redirected_to '/login'

    assert !User.find_by_login('newuser').active?

  end

  def test_register_with_email_activation

    Setting.self_registration = '1'

    Token.delete_all

    post 'account/register', :user => {:login => "newuser", :language => "en", :firstname => "New", :lastname => "User", :mail => "newuser@foo.bar"},

                             :password => "newpass", :password_confirmation => "newpass"

    assert_redirected_to '/login'

    assert !User.find_by_login('newuser').active?

    token = Token.find(:first)

    assert_equal 'register', token.action

    assert_equal 'newuser@foo.bar', token.user.mail

    assert !token.expired?

    get 'account/activate', :token => token.value

    assert_redirected_to '/login'

    log_user('newuser', 'newpass')

  end

  if Object.const_defined?(:Mocha)

  def test_onthefly_registration

    # disable registration

    Setting.self_registration = '0'

    AuthSource.expects(:authenticate).returns({:login => 'foo', :firstname => 'Foo', :lastname => 'Smith', :mail => 'foo@bar.com', :auth_source_id => 66})

    post 'account/login', :username => 'foo', :password => 'bar'

    assert_redirected_to '/my/page'

    user = User.find_by_login('foo')

    assert user.is_a?(User)

    assert_equal 66, user.auth_source_id

    assert user.hashed_password.blank?

  end

  def test_onthefly_registration_with_invalid_attributes

    # disable registration

    Setting.self_registration = '0'

    AuthSource.expects(:authenticate).returns({:login => 'foo', :lastname => 'Smith', :auth_source_id => 66})

    post 'account/login', :username => 'foo', :password => 'bar'

    assert_response :success

    assert_template 'account/register'

    assert_tag :input, :attributes => { :name => 'user[firstname]', :value => '' }

    assert_tag :input, :attributes => { :name => 'user[lastname]', :value => 'Smith' }

    assert_no_tag :input, :attributes => { :name => 'user[login]' }

    assert_no_tag :input, :attributes => { :name => 'user[password]' }

    post 'account/register', :user => {:firstname => 'Foo', :lastname => 'Smith', :mail => 'foo@bar.com'}

    assert_redirected_to '/my/account'

    user = User.find_by_login('foo')

    assert user.is_a?(User)

    assert_equal 66, user.auth_source_id

    assert user.hashed_password.blank?

  end

  def test_login_and_logout_should_clear_session

    get '/login'

    sid = session[:session_id]

    post '/login', :username => 'admin', :password => 'admin'

    assert_redirected_to '/my/page'

    assert_not_equal sid, session[:session_id], "login should reset session"

    assert_equal 1, session[:user_id]

    sid = session[:session_id]

    get '/'

    assert_equal sid, session[:session_id]

    get '/logout'

    assert_not_equal sid, session[:session_id], "logout should reset session"

    assert_nil session[:user_id]

  end

  else

    puts 'Mocha is missing. Skipping tests.'

  end

end

#

# setup.rb

#

# Copyright (c) 2000-2005 Minero Aoki

#

# This program is free software.

# You can distribute/modify this program under the terms of

# the GNU LGPL, Lesser General Public License version 2.1.

#

unless Enumerable.method_defined?(:map)   # Ruby 1.4.6

  module Enumerable

    alias map collect

  end

end

unless File.respond_to?(:read)   # Ruby 1.6

  def File.read(fname)

    open(fname) {|f|

      return f.read

    }

  end

end

unless Errno.const_defined?(:ENOTEMPTY)   # Windows?

  module Errno

    class ENOTEMPTY

      # We do not raise this exception, implementation is not needed.

    end

  end

end

def File.binread(fname)

  open(fname, 'rb') {|f|

    return f.read

  }

end

# for corrupted Windows' stat(2)

def File.dir?(path)

  File.directory?((path[-1,1] == '/') ? path : path + '/')

end

class ConfigTable

  include Enumerable

  def initialize(rbconfig)

    @rbconfig = rbconfig

    @items = []

    @table = {}

    # options

    @install_prefix = nil

    @config_opt = nil

    @verbose = true

    @no_harm = false

  end

  attr_accessor :install_prefix

  attr_accessor :config_opt

  attr_writer :verbose

  def verbose?

    @verbose

  end

  attr_writer :no_harm

  def no_harm?

    @no_harm

  end

  def [](key)

    lookup(key).resolve(self)

  end

  def []=(key, val)

    lookup(key).set val

  end

  def names

    @items.map {|i| i.name }

  end

  def each(&block)

    @items.each(&block)

  end

  def key?(name)

    @table.key?(name)

  end

  def lookup(name)

    @table[name] or setup_rb_error "no such config item: #{name}"

  end

  def add(item)

    @items.push item

    @table[item.name] = item

  end

  def remove(name)

    item = lookup(name)

    @items.delete_if {|i| i.name == name }

    @table.delete_if {|name, i| i.name == name }

    item

  end

  def load_script(path, inst = nil)

    if File.file?(path)

      MetaConfigEnvironment.new(self, inst).instance_eval File.read(path), path

    end

  end

  def savefile

    '.config'

  end

  def load_savefile

    begin

      File.foreach(savefile()) do |line|

        k, v = *line.split(/=/, 2)

        self[k] = v.strip

      end

    rescue Errno::ENOENT

      setup_rb_error $!.message + "\n#{File.basename($0)} config first"

    end

  end

  def save

    @items.each {|i| i.value }

    File.open(savefile(), 'w') {|f|

      @items.each do |i|

        f.printf "%s=%s\n", i.name, i.value if i.value? and i.value

      end

    }

  end

  def load_standard_entries

    standard_entries(@rbconfig).each do |ent|

      add ent

    end

  end

  def standard_entries(rbconfig)

    c = rbconfig

    rubypath = File.join(c['bindir'], c['ruby_install_name'] + c['EXEEXT'])

    major = c['MAJOR'].to_i

    minor = c['MINOR'].to_i

    teeny = c['TEENY'].to_i

    version = "#{major}.#{minor}"

    # ruby ver. >= 1.4.4?

    newpath_p = ((major >= 2) or

                 ((major == 1) and

                  ((minor >= 5) or

                   ((minor == 4) and (teeny >= 4)))))

    if c['rubylibdir']

      # V > 1.6.3

      libruby         = "#{c['prefix']}/lib/ruby"

      librubyver      = c['rubylibdir']

      librubyverarch  = c['archdir']

      siteruby        = c['sitedir']

      siterubyver     = c['sitelibdir']

      siterubyverarch = c['sitearchdir']

    elsif newpath_p

      # 1.4.4 <= V <= 1.6.3

      libruby         = "#{c['prefix']}/lib/ruby"

      librubyver      = "#{c['prefix']}/lib/ruby/#{version}"

      librubyverarch  = "#{c['prefix']}/lib/ruby/#{version}/#{c['arch']}"

      siteruby        = c['sitedir']

      siterubyver     = "$siteruby/#{version}"

      siterubyverarch = "$siterubyver/#{c['arch']}"

    else

      # V < 1.4.4

      libruby         = "#{c['prefix']}/lib/ruby"

      librubyver      = "#{c['prefix']}/lib/ruby/#{version}"

      librubyverarch  = "#{c['prefix']}/lib/ruby/#{version}/#{c['arch']}"

      siteruby        = "#{c['prefix']}/lib/ruby/#{version}/site_ruby"

      siterubyver     = siteruby

      siterubyverarch = "$siterubyver/#{c['arch']}"

    end

    parameterize = lambda {|path|

      path.sub(/\A#{Regexp.quote(c['prefix'])}/, '$prefix')

    }

    if arg = c['configure_args'].split.detect {|arg| /--with-make-prog=/ =~ arg }

      makeprog = arg.sub(/'/, '').split(/=/, 2)[1]

    else

      makeprog = 'make'

    end

    [

      ExecItem.new('installdirs', 'std/site/home',

                   'std: install under libruby; site: install under site_ruby; home: install under $HOME')\

          {|val, table|

            case val

            when 'std'

              table['rbdir'] = '$librubyver'

              table['sodir'] = '$librubyverarch'

            when 'site'

              table['rbdir'] = '$siterubyver'

              table['sodir'] = '$siterubyverarch'

            when 'home'

              setup_rb_error '$HOME was not set' unless ENV['HOME']

              table['prefix'] = ENV['HOME']

              table['rbdir'] = '$libdir/ruby'

              table['sodir'] = '$libdir/ruby'

            end

          },

      PathItem.new('prefix', 'path', c['prefix'],

                   'path prefix of target environment'),

      PathItem.new('bindir', 'path', parameterize.call(c['bindir']),

                   'the directory for commands'),

      PathItem.new('libdir', 'path', parameterize.call(c['libdir']),

                   'the directory for libraries'),

      PathItem.new('datadir', 'path', parameterize.call(c['datadir']),

                   'the directory for shared data'),

      PathItem.new('mandir', 'path', parameterize.call(c['mandir']),

                   'the directory for man pages'),

      PathItem.new('sysconfdir', 'path', parameterize.call(c['sysconfdir']),

                   'the directory for system configuration files'),

      PathItem.new('localstatedir', 'path', parameterize.call(c['localstatedir']),

                   'the directory for local state data'),

      PathItem.new('libruby', 'path', libruby,

                   'the directory for ruby libraries'),

      PathItem.new('librubyver', 'path', librubyver,

                   'the directory for standard ruby libraries'),

      PathItem.new('librubyverarch', 'path', librubyverarch,

                   'the directory for standard ruby extensions'),

      PathItem.new('siteruby', 'path', siteruby,

          'the directory for version-independent aux ruby libraries'),

      PathItem.new('siterubyver', 'path', siterubyver,

                   'the directory for aux ruby libraries'),

      PathItem.new('siterubyverarch', 'path', siterubyverarch,

                   'the directory for aux ruby binaries'),

      PathItem.new('rbdir', 'path', '$siterubyver',

                   'the directory for ruby scripts'),

      PathItem.new('sodir', 'path', '$siterubyverarch',

                   'the directory for ruby extentions'),

      PathItem.new('rubypath', 'path', rubypath,

                   'the path to set to #! line'),

      ProgramItem.new('rubyprog', 'name', rubypath,

                      'the ruby program using for installation'),

      ProgramItem.new('makeprog', 'name', makeprog,

                      'the make program to compile ruby extentions'),

      SelectItem.new('shebang', 'all/ruby/never', 'ruby',

                     'shebang line (#!) editing mode'),

      BoolItem.new('without-ext', 'yes/no', 'no',

                   'does not compile/install ruby extentions')

    ]

  end

  private :standard_entries

  def load_multipackage_entries

    multipackage_entries().each do |ent|

      add ent

    end

  end

  def multipackage_entries

    [

      PackageSelectionItem.new('with', 'name,name...', '', 'ALL',

                               'package names that you want to install'),

      PackageSelectionItem.new('without', 'name,name...', '', 'NONE',

                               'package names that you do not want to install')

    ]

  end

  private :multipackage_entries

  ALIASES = {

    'std-ruby'         => 'librubyver',

    'stdruby'          => 'librubyver',

    'rubylibdir'       => 'librubyver',

    'archdir'          => 'librubyverarch',

    'site-ruby-common' => 'siteruby',     # For backward compatibility

    'site-ruby'        => 'siterubyver',  # For backward compatibility

    'bin-dir'          => 'bindir',

    'bin-dir'          => 'bindir',

    'rb-dir'           => 'rbdir',

    'so-dir'           => 'sodir',

    'data-dir'         => 'datadir',

    'ruby-path'        => 'rubypath',

    'ruby-prog'        => 'rubyprog',

    'ruby'             => 'rubyprog',

    'make-prog'        => 'makeprog',

    'make'             => 'makeprog'

  }

  def fixup

    ALIASES.each do |ali, name|

      @table[ali] = @table[name]

    end

    @items.freeze

    @table.freeze

    @options_re = /\A--(#{@table.keys.join('|')})(?:=(.*))?\z/

  end

  def parse_opt(opt)

    m = @options_re.match(opt) or setup_rb_error "config: unknown option #{opt}"

    m.to_a[1,2]

  end

  def dllext

    @rbconfig['DLEXT']

  end

  def value_config?(name)

    lookup(name).value?

  end

  class Item

    def initialize(name, template, default, desc)

      @name = name.freeze

      @template = template

      @value = default

      @default = default

      @description = desc

    end

    attr_reader :name

    attr_reader :description

    attr_accessor :default

    alias help_default default

    def help_opt

      "--#{@name}=#{@template}"

    end

    def value?

      true

    end

    def value

      @value

    end

    def resolve(table)

      @value.gsub(%r<\$([^/]+)>) { table[$1] }

    end

    def set(val)

      @value = check(val)

    end

    private

    def check(val)

      setup_rb_error "config: --#{name} requires argument" unless val

      val

    end

  end

  class BoolItem < Item

    def config_type

      'bool'

    end

    def help_opt

      "--#{@name}"

    end

    private

    def check(val)

      return 'yes' unless val

      case val

      when /\Ay(es)?\z/i, /\At(rue)?\z/i then 'yes'

      when /\An(o)?\z/i, /\Af(alse)\z/i  then 'no'

      else

        setup_rb_error "config: --#{@name} accepts only yes/no for argument"

      end

    end

  end

  class PathItem < Item

    def config_type

      'path'

    end

    private

    def check(path)

      setup_rb_error "config: --#{@name} requires argument"  unless path

      path[0,1] == '$' ? path : File.expand_path(path)

    end

  end

  class ProgramItem < Item

    def config_type

      'program'

    end

  end

  class SelectItem < Item

    def initialize(name, selection, default, desc)

      super

      @ok = selection.split('/')

    end

    def config_type

      'select'

    end

    private

    def check(val)

      unless @ok.include?(val.strip)

        setup_rb_error "config: use --#{@name}=#{@template} (#{val})"

      end

      val.strip

    end

  end

  class ExecItem < Item

    def initialize(name, selection, desc, &block)

      super name, selection, nil, desc

      @ok = selection.split('/')

      @action = block

    end

    def config_type

      'exec'

    end

    def value?

      false

    end

    def resolve(table)

      setup_rb_error "$#{name()} wrongly used as option value"

    end

    undef set

    def evaluate(val, table)

      v = val.strip.downcase

      unless @ok.include?(v)

        setup_rb_error "invalid option --#{@name}=#{val} (use #{@template})"

      end

      @action.call v, table

    end

  end

  class PackageSelectionItem < Item

    def initialize(name, template, default, help_default, desc)

      super name, template, default, desc

      @help_default = help_default

    end

    attr_reader :help_default

    def config_type

      'package'

    end

    private

    def check(val)

      unless File.dir?("packages/#{val}")

        setup_rb_error "config: no such package: #{val}"

      end

      val

    end

  end

  class MetaConfigEnvironment

    def initialize(config, installer)

      @config = config

      @installer = installer

    end

    def config_names

      @config.names

    end

    def config?(name)

      @config.key?(name)

    end

    def bool_config?(name)

      @config.lookup(name).config_type == 'bool'

    end

    def path_config?(name)

      @config.lookup(name).config_type == 'path'

    end

    def value_config?(name)

      @config.lookup(name).config_type != 'exec'

    end

    def add_config(item)

      @config.add item

    end

    def add_bool_config(name, default, desc)

      @config.add BoolItem.new(name, 'yes/no', default ? 'yes' : 'no', desc)

    end

    def add_path_config(name, default, desc)

      @config.add PathItem.new(name, 'path', default, desc)

    end

    def set_config_default(name, default)

      @config.lookup(name).default = default

    end

    def remove_config(name)

      @config.remove(name)

    end

    # For only multipackage

    def packages

      raise '[setup.rb fatal] multi-package metaconfig API packages() called for single-package; contact application package vendor' unless @installer

      @installer.packages

    end

    # For only multipackage

    def declare_packages(list)

      raise '[setup.rb fatal] multi-package metaconfig API declare_packages() called for single-package; contact application package vendor' unless @installer

      @installer.packages = list

    end

  end

end   # class ConfigTable

# This module requires: #verbose?, #no_harm?

module FileOperations

  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)

    end

  end

  def rm_f(path)

    $stderr.puts "rm -f #{path}" if verbose?

    return if no_harm?

    force_remove_file path

  end

  def rm_rf(path)

    $stderr.puts "rm -rf #{path}" if verbose?

    return if no_harm?

    remove_tree path

  end

  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

  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

  def move_file(src, dest)

    force_remove_file dest

    begin

      File.rename src, dest

    rescue

      File.open(dest, 'wb') {|f|

        f.write File.binread(src)

      }

      File.chmod File.stat(src).mode, dest

      File.unlink src

    end

  end

  def force_remove_file(path)

    begin

      remove_file path

    rescue

    end

  end

  def remove_file(path)

    File.chmod 0777, path

    File.unlink path

  end

  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 = File.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

      File.open("#{objdir_root()}/InstalledFiles", 'a') {|f|

        if prefix

          f.puts realdest.sub(prefix, '')

        else

          f.puts realdest

        end

      }

    end

  end

  def diff?(new_content, path)

    return true unless File.exist?(path)

    new_content != File.binread(path)

  end

  def command(*args)

    $stderr.puts args.join(' ') if verbose?

    system(*args) or raise RuntimeError,

        "system(#{args.map{|a| a.inspect }.join(' ')}) failed"

  end

  def ruby(*args)

    command config('rubyprog'), *args

  end

  def make(task = nil)

    command(*[config('makeprog'), task].compact)

  end

  def extdir?(dir)

    File.exist?("#{dir}/MANIFEST") or File.exist?("#{dir}/extconf.rb")

  end

  def files_of(dir)

    Dir.open(dir) {|d|

      return d.select {|ent| File.file?("#{dir}/#{ent}") }

    }

  end

  DIR_REJECT = %w( . .. CVS SCCS RCS CVS.adm .svn )

  def directories_of(dir)

    Dir.open(dir) {|d|

      return d.select {|ent| File.dir?("#{dir}/#{ent}") } - DIR_REJECT

    }

  end

end

# This module requires: #srcdir_root, #objdir_root, #relpath

module HookScriptAPI

  def get_config(key)

    @config[key]

  end

  alias config get_config

  # obsolete: use metaconfig to change configuration

  def set_config(key, val)

    @config[key] = val

  end

  #

  # srcdir/objdir (works only in the package directory)

  #

  def curr_srcdir

    "#{srcdir_root()}/#{relpath()}"

  end

  def curr_objdir

    "#{objdir_root()}/#{relpath()}"

  end

  def srcfile(path)

    "#{curr_srcdir()}/#{path}"

  end

  def srcexist?(path)

    File.exist?(srcfile(path))

  end

  def srcdirectory?(path)

    File.dir?(srcfile(path))

  end

  def srcfile?(path)

    File.file?(srcfile(path))

  end

  def srcentries(path = '.')

    Dir.open("#{curr_srcdir()}/#{path}") {|d|

      return d.to_a - %w(. ..)

    }

  end

  def srcfiles(path = '.')

    srcentries(path).select {|fname|

      File.file?(File.join(curr_srcdir(), path, fname))

    }

  end

  def srcdirectories(path = '.')

    srcentries(path).select {|fname|

      File.dir?(File.join(curr_srcdir(), path, fname))

    }

  end

end

class ToplevelInstaller

  Version   = '3.4.1'

  Copyright = 'Copyright (c) 2000-2005 Minero Aoki'

  TASKS = [

    [ 'all',      'do config, setup, then install' ],

    [ 'config',   'saves your configurations' ],

    [ 'show',     'shows current configuration' ],

    [ 'setup',    'compiles ruby extentions and others' ],

    [ 'install',  'installs files' ],

    [ 'test',     'run all tests in test/' ],

    [ 'clean',    "does `make clean' for each extention" ],

    [ 'distclean',"does `make distclean' for each extention" ]

  ]

  def ToplevelInstaller.invoke

    config = ConfigTable.new(load_rbconfig())

    config.load_standard_entries

    config.load_multipackage_entries if multipackage?

    config.fixup

    klass = (multipackage?() ? ToplevelInstallerMulti : ToplevelInstaller)

    klass.new(File.dirname($0), config).invoke

  end

  def ToplevelInstaller.multipackage?

    File.dir?(File.dirname($0) + '/packages')

  end

  def ToplevelInstaller.load_rbconfig

    if arg = ARGV.detect {|arg| /\A--rbconfig=/ =~ arg }

      ARGV.delete(arg)

      load File.expand_path(arg.split(/=/, 2)[1])

      $".push 'rbconfig.rb'

    else

      require 'rbconfig'

    end

    ::Config::CONFIG

  end

  def initialize(ardir_root, config)

    @ardir = File.expand_path(ardir_root)

    @config = config

    # cache

    @valid_task_re = nil

  end

  def config(key)

    @config[key]

  end

  def inspect

    "#<#{self.class} #{__id__()}>"

  end

  def invoke

    run_metaconfigs

    case task = parsearg_global()

    when nil, 'all'

      parsearg_config

      init_installers

      exec_config

      exec_setup

      exec_install

    else

      case task

      when 'config', 'test'

        ;

      when 'clean', 'distclean'

        @config.load_savefile if File.exist?(@config.savefile)

      else

        @config.load_savefile

      end

      __send__ "parsearg_#{task}"

      init_installers

      __send__ "exec_#{task}"

    end

  end

  def run_metaconfigs

    @config.load_script "#{@ardir}/metaconfig"

  end

  def init_installers

    @installer = Installer.new(@config, @ardir, File.expand_path('.'))

  end

  #

  # Hook Script API bases

  #

  def srcdir_root

    @ardir

  end

  def objdir_root

    '.'

  end

  def relpath

    '.'

  end

  #

  # Option Parsing

  #

  def parsearg_global

    while arg = ARGV.shift

      case arg

      when /\A\w+\z/

        setup_rb_error "invalid task: #{arg}" unless valid_task?(arg)

        return arg

      when '-q', '--quiet'

        @config.verbose = false

      when '--verbose'

        @config.verbose = true

      when '--help'

        print_usage $stdout

        exit 0

      when '--version'

        puts "#{File.basename($0)} version #{Version}"

        exit 0

      when '--copyright'

        puts Copyright

        exit 0

      else

        setup_rb_error "unknown global option '#{arg}'"

      end

    end

    nil

  end

  def valid_task?(t)

    valid_task_re() =~ t

  end

  def valid_task_re

    @valid_task_re ||= /\A(?:#{TASKS.map {|task,desc| task }.join('|')})\z/

  end

  def parsearg_no_options

    unless ARGV.empty?

      task = caller(0).first.slice(%r<`parsearg_(\w+)'>, 1)

      setup_rb_error "#{task}: unknown options: #{ARGV.join(' ')}"

    end

  end

  alias parsearg_show       parsearg_no_options

  alias parsearg_setup      parsearg_no_options

  alias parsearg_test       parsearg_no_options

  alias parsearg_clean      parsearg_no_options

  alias parsearg_distclean  parsearg_no_options

  def parsearg_config

    evalopt = []

    set = []

    @config.config_opt = []

    while i = ARGV.shift

      if /\A--?\z/ =~ i

        @config.config_opt = ARGV.dup

        break

      end

      name, value = *@config.parse_opt(i)

      if @config.value_config?(name)

        @config[name] = value

      else

        evalopt.push [name, value]

      end

      set.push name

    end

    evalopt.each do |name, value|

      @config.lookup(name).evaluate value, @config

    end

    # Check if configuration is valid

    set.each do |n|

      @config[n] if @config.value_config?(n)

    end

  end

  def parsearg_install

    @config.no_harm = false

    @config.install_prefix = ''

    while a = ARGV.shift

      case a

      when '--no-harm'

        @config.no_harm = true

      when /\A--prefix=/

        path = a.split(/=/, 2)[1]

        path = File.expand_path(path) unless path[0,1] == '/'

        @config.install_prefix = path

      else

        setup_rb_error "install: unknown option #{a}"

      end

    end

  end

  def print_usage(out)

    out.puts 'Typical Installation Procedure:'

    out.puts "  $ ruby #{File.basename $0} config"

    out.puts "  $ ruby #{File.basename $0} setup"

    out.puts "  # ruby #{File.basename $0} install (may require root privilege)"

    out.puts

    out.puts 'Detailed Usage:'

    out.puts "  ruby #{File.basename $0} <global option>"

    out.puts "  ruby #{File.basename $0} [<global options>] <task> [<task options>]"

    fmt = "  %-24s %s\n"

    out.puts

    out.puts 'Global options:'

    out.printf fmt, '-q,--quiet',   'suppress message outputs'

    out.printf fmt, '   --verbose', 'output messages verbosely'

    out.printf fmt, '   --help',    'print this message'

    out.printf fmt, '   --version', 'print version and quit'

    out.printf fmt, '   --copyright',  'print copyright and quit'

    out.puts

    out.puts 'Tasks:'

    TASKS.each do |name, desc|

      out.printf fmt, name, desc

    end

    fmt = "  %-24s %s [%s]\n"

    out.puts

    out.puts 'Options for CONFIG or ALL:'

    @config.each do |item|

      out.printf fmt, item.help_opt, item.description, item.help_default

    end

    out.printf fmt, '--rbconfig=path', 'rbconfig.rb to load',"running ruby's"

    out.puts

    out.puts 'Options for INSTALL:'

    out.printf fmt, '--no-harm', 'only display what to do if given', 'off'

    out.printf fmt, '--prefix=path',  'install path prefix', ''

    out.puts

  end

  #

  # Task Handlers

  #

  def exec_config

    @installer.exec_config

    @config.save   # must be final

  end

  def exec_setup

    @installer.exec_setup

  end

  def exec_install

    @installer.exec_install

  end

  def exec_test

    @installer.exec_test

  end

  def exec_show

    @config.each do |i|

      printf "%-20s %s\n", i.name, i.value if i.value?

    end

  end

  def exec_clean

    @installer.exec_clean

  end

  def exec_distclean

    @installer.exec_distclean

  end

end   # class ToplevelInstaller

class ToplevelInstallerMulti < ToplevelInstaller

  include FileOperations

  def initialize(ardir_root, config)

    super

    @packages = directories_of("#{@ardir}/packages")

    raise 'no package exists' if @packages.empty?

    @root_installer = Installer.new(@config, @ardir, File.expand_path('.'))

  end

  def run_metaconfigs

    @config.load_script "#{@ardir}/metaconfig", self

    @packages.each do |name|

      @config.load_script "#{@ardir}/packages/#{name}/metaconfig"

    end