Redmine

# redMine - project management software

# Copyright (C) 2006-2007  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.

class AWSProjectWithRepository < ActionWebService::Struct

  member :id,              :int

  member :identifier,      :string

  member :name,            :string

  member :is_public,       :bool

  member :repository,      Repository

end

class SysApi < ActionWebService::API::Base

  api_method :projects_with_repository_enabled,

             :expects => [],

             :returns => [[AWSProjectWithRepository]]

  api_method :repository_created,

             :expects => [:string, :string, :string],

             :returns => [:int]

end

# redMine - project management software

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

  wsdl_service_name 'Sys'

  web_service_api SysApi

  web_service_scaffold :invoke

  before_invocation :check_enabled

  # Returns the projects list, with their repositories

  def projects_with_repository_enabled

    Project.has_module(:repository).find(:all, :include => :repository, :order => 'identifier')

  # Registers a repository for the given project identifier

  def repository_created(identifier, vendor, url)

    project = Project.find_by_identifier(identifier)

    # Do not create the repository if the project has already one

    return 0 unless project && project.repository.nil?

    logger.debug "Repository for #{project.name} was created"

    repository = Repository.factory(vendor, :project => project, :url => url)

    repository.save

    repository.id || 0

  end

protected

  def check_enabled(name, args)

    Setting.sys_api_enabled?

  # Allow downloading Web Service WSDL as a file with an extension

  # instead of a file named 'wsdl'

  map.connect ':controller/service.wsdl', :action => 'wsdl'

require 'soap/wsdlDriver'

Version = "1.1"

wsdl_url = "#{$redmine_host}/sys/service.wsdl";

  soap = SOAP::WSDLDriverFactory.new(wsdl_url).create_rpc_driver

  log("Unable to connect to #{wsdl_url} : #{e}", :exit => true)

projects = soap.ProjectsWithRepositoryEnabled

    if $force == false and not project.repository.nil?

      ret = soap.RepositoryCreated project.identifier, $scm, "#{$svn_url}#{project.identifier}"

      if ret > 0

      else

        log("\trepository #{repos_path} not registered in Redmine. Look in your log to find why.");

require File.dirname(__FILE__) + '/../test_helper'

require 'sys_controller'

# Re-raise errors caught by the controller.

class SysController; def rescue_action(e) raise e end; end

class SysControllerTest < Test::Unit::TestCase

  fixtures :projects, :enabled_modules, :repositories

  def setup

    @controller = SysController.new

    @request = ActionController::TestRequest.new

    @response = ActionController::TestResponse.new

    # Enable WS

    Setting.sys_api_enabled = 1

  end

  def test_projects_with_repository_enabled

    result = invoke :projects_with_repository_enabled

    assert_equal EnabledModule.count(:all, :conditions => {:name => 'repository'}), result.size

    project = result.first

    assert project.is_a?(AWSProjectWithRepository)

    assert project.respond_to?(:id)

    assert_equal 1, project.id

    assert project.respond_to?(:identifier)

    assert_equal 'ecookbook', project.identifier

    assert project.respond_to?(:name)

    assert_equal 'eCookbook', project.name

    assert project.respond_to?(:is_public)

    assert project.is_public

    assert project.respond_to?(:repository)

    assert project.repository.is_a?(Repository)

  end

  def test_repository_created

    project = Project.find(3)

    assert_nil project.repository

    assert invoke(:repository_created, project.identifier, 'Subversion', 'http://localhost/svn')

    project.reload

    assert_not_nil project.repository

    assert project.repository.is_a?(Repository::Subversion)

    assert_equal 'http://localhost/svn', project.repository.url

  end

end

require 'rubygems'

require 'rake'

require 'rake/testtask'

require 'rake/rdoctask'

require 'rake/packagetask'

require 'rake/gempackagetask'

require 'rake/contrib/rubyforgepublisher'

require 'fileutils'

require File.join(File.dirname(__FILE__), 'lib', 'action_web_service', 'version')

PKG_BUILD     = ENV['PKG_BUILD'] ? '.' + ENV['PKG_BUILD'] : ''

PKG_NAME      = 'actionwebservice'

PKG_VERSION   = ActionWebService::VERSION::STRING + PKG_BUILD

PKG_FILE_NAME   = "#{PKG_NAME}-#{PKG_VERSION}"

PKG_DESTINATION = ENV["RAILS_PKG_DESTINATION"] || "../#{PKG_NAME}"

RELEASE_NAME  = "REL #{PKG_VERSION}"

RUBY_FORGE_PROJECT = "aws"

RUBY_FORGE_USER    = "webster132"

desc "Default Task"

task :default => [ :test ]

# Run the unit tests

Rake::TestTask.new { |t|

  t.libs << "test"

  t.test_files = Dir['test/*_test.rb']

  t.verbose = true

}

SCHEMA_PATH = File.join(File.dirname(__FILE__), *%w(test fixtures db_definitions))

desc 'Build the MySQL test database'

task :build_database do 

  %x( mysqladmin  create actionwebservice_unittest )

  %x( mysql  actionwebservice_unittest < #{File.join(SCHEMA_PATH, 'mysql.sql')} )

end

# Generate the RDoc documentation

Rake::RDocTask.new { |rdoc|

  rdoc.rdoc_dir = 'doc'

  rdoc.title    = "Action Web Service -- Web services for Action Pack"

  rdoc.options << '--line-numbers' << '--inline-source'

  rdoc.options << '--charset' << 'utf-8'

  rdoc.template = "#{ENV['template']}.rb" if ENV['template']

  rdoc.rdoc_files.include('README')

  rdoc.rdoc_files.include('CHANGELOG')

  rdoc.rdoc_files.include('lib/action_web_service.rb')

  rdoc.rdoc_files.include('lib/action_web_service/*.rb')

  rdoc.rdoc_files.include('lib/action_web_service/api/*.rb')

  rdoc.rdoc_files.include('lib/action_web_service/client/*.rb')

  rdoc.rdoc_files.include('lib/action_web_service/container/*.rb')

  rdoc.rdoc_files.include('lib/action_web_service/dispatcher/*.rb')

  rdoc.rdoc_files.include('lib/action_web_service/protocol/*.rb')

  rdoc.rdoc_files.include('lib/action_web_service/support/*.rb')

}

# Create compressed packages

spec = Gem::Specification.new do |s|

  s.platform = Gem::Platform::RUBY

  s.name = PKG_NAME

  s.summary = "Web service support for Action Pack."

  s.description = %q{Adds WSDL/SOAP and XML-RPC web service support to Action Pack}

  s.version = PKG_VERSION

  s.author = "Leon Breedt"

  s.email = "[email protected]"

  s.rubyforge_project = "aws"

  s.homepage = "http://www.rubyonrails.org"

  s.add_dependency('actionpack', '= 1.13.5' + PKG_BUILD)

  s.add_dependency('activerecord', '= 1.15.5' + PKG_BUILD)

  s.has_rdoc = true

  s.requirements << 'none'

  s.require_path = 'lib'

  s.autorequire = 'action_web_service'

  s.files = [ "Rakefile", "setup.rb", "README", "TODO", "CHANGELOG", "MIT-LICENSE" ]

  s.files = s.files + Dir.glob( "examples/**/*" ).delete_if { |item| item.include?( "\.svn" ) }

  s.files = s.files + Dir.glob( "lib/**/*" ).delete_if { |item| item.include?( "\.svn" ) }

  s.files = s.files + Dir.glob( "test/**/*" ).delete_if { |item| item.include?( "\.svn" ) }

end

Rake::GemPackageTask.new(spec) do |p|

  p.gem_spec = spec

  p.need_tar = true

  p.need_zip = true

end

# Publish beta gem

desc "Publish the API documentation"

task :pgem => [:package] do 

  Rake::SshFilePublisher.new("[email protected]", "public_html/gems/gems", "pkg", "#{PKG_FILE_NAME}.gem").upload

  `ssh [email protected] './gemupdate.sh'`

end

# Publish documentation

desc "Publish the API documentation"

task :pdoc => [:rdoc] do 

  Rake::SshDirPublisher.new("[email protected]", "public_html/aws", "doc").upload

end

def each_source_file(*args)

	prefix, includes, excludes, open_file = args

	prefix ||= File.dirname(__FILE__)

	open_file = true if open_file.nil?

	includes ||= %w[lib\/action_web_service\.rb$ lib\/action_web_service\/.*\.rb$]

	excludes ||= %w[lib\/action_web_service\/vendor]

	Find.find(prefix) do |file_name|

		next if file_name =~ /\.svn/

		file_name.gsub!(/^\.\//, '')

		continue = false

		includes.each do |inc|

			if file_name.match(/#{inc}/)

				continue = true

				break

			end

		end

		next unless continue

		excludes.each do |exc|

			if file_name.match(/#{exc}/)

				continue = false

				break

			end

		end

		next unless continue

		if open_file

			File.open(file_name) do |f|

				yield file_name, f

			end

		else

			yield file_name

		end

	end

end

desc "Count lines of the AWS source code"

task :lines do

  total_lines = total_loc = 0

  puts "Per File:"

	each_source_file do |file_name, f|

    file_lines = file_loc = 0

    while line = f.gets

      file_lines += 1

      next if line =~ /^\s*$/

      next if line =~ /^\s*#/

      file_loc += 1

    end

    puts "  #{file_name}: Lines #{file_lines}, LOC #{file_loc}"

    total_lines += file_lines

    total_loc += file_loc

  end

  puts "Total:"

  puts "  Lines #{total_lines}, LOC #{total_loc}"

end

desc "Publish the release files to RubyForge."

task :release => [ :package ] do

  require 'rubyforge'

  packages = %w( gem tgz zip ).collect{ |ext| "pkg/#{PKG_NAME}-#{PKG_VERSION}.#{ext}" }

  rubyforge = RubyForge.new

  rubyforge.login

  rubyforge.add_release(PKG_NAME, PKG_NAME, "REL #{PKG_VERSION}", *packages)

end

#

# setup.rb

#

# Copyright (c) 2000-2004 Minero Aoki

#

# Permission is hereby granted, free of charge, to any person obtaining

# a copy of this software and associated documentation files (the

# "Software"), to deal in the Software without restriction, including

# without limitation the rights to use, copy, modify, merge, publish,

# distribute, sublicense, and/or sell copies of the Software, and to

# permit persons to whom the Software is furnished to do so, subject to

# the following conditions:

#

# The above copyright notice and this permission notice shall be

# included in all copies or substantial portions of the Software.

#

# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE

# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION

# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION

# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

#

# Note: Originally licensed under LGPL v2+. Using MIT license for Rails

# with permission of Minero Aoki.

#

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

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 SetupError < StandardError; end

def setup_rb_error(msg)

  raise SetupError, msg

end

#

# Config

#

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

  ARGV.delete(arg)

  require arg.split(/=/, 2)[1]

  $".push 'rbconfig.rb'

else

  require 'rbconfig'

end

def multipackage_install?

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

end

class ConfigItem

  def initialize(name, template, default, desc)

    @name = name.freeze

    @template = template

    @value = default

    @default = default.dup.freeze

    @description = desc

  end

  attr_reader :name

  attr_reader :description

  attr_accessor :default

  alias help_default default

  def help_opt

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

  end

  def value

    @value

  end

  def eval(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 < ConfigItem

  def config_type

    'bool'

  end

  def help_opt

    "--#{@name}"

  end

  private

  def check(val)

    return 'yes' unless val

    unless /\A(y(es)?|n(o)?|t(rue)?|f(alse))\z/i =~ val

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

    end

    (/\Ay(es)?|\At(rue)/i =~ value) ? 'yes' : 'no'

  end

end

class PathItem < ConfigItem

  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 < ConfigItem

  def config_type

    'program'

  end

end

class SelectItem < ConfigItem

  def initialize(name, template, default, desc)

    super

    @ok = template.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 PackageSelectionItem < ConfigItem

  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 ConfigTable_class

  def initialize(items)

    @items = items

    @table = {}

    items.each do |i|

      @table[i.name] = i

    end

    ALIASES.each do |ali, name|

      @table[ali] = @table[name]

    end

  end

  include Enumerable

  def each(&block)

    @items.each(&block)

  end

  def key?(name)

    @table.key?(name)

  end

  def lookup(name)

    @table[name] or raise ArgumentError, "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 new

    dup()

  end

  def savefile

    '.config'

  end

  def load

    begin

      t = dup()

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

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

        t[k] = v.strip

      end

      t

    rescue Errno::ENOENT

      setup_rb_error $!.message + "#{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

      end

    }

  end

  def [](key)

    lookup(key).eval(self)

  end

  def []=(key, val)

    lookup(key).set val

  end

end

c = ::Config::CONFIG

rubypath = c['bindir'] + '/' + c['ruby_install_name']

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

  _stdruby         = c['rubylibdir']

  _siteruby        = c['sitedir']

  _siterubyver     = c['sitelibdir']

  _siterubyverarch = c['sitearchdir']

elsif newpath_p

  # 1.4.4 <= V <= 1.6.3

  _stdruby         = "$prefix/lib/ruby/#{version}"

  _siteruby        = c['sitedir']

  _siterubyver     = "$siteruby/#{version}"

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

else

  # V < 1.4.4

  _stdruby         = "$prefix/lib/ruby/#{version}"

  _siteruby        = "$prefix/lib/ruby/#{version}/site_ruby"

  _siterubyver     = _siteruby

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

end

libdir = '-* dummy libdir *-'

stdruby = '-* dummy rubylibdir *-'

siteruby = '-* dummy site_ruby *-'

siterubyver = '-* dummy site_ruby version *-'

parameterize = lambda {|path|

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

      .sub(/\A#{Regexp.quote(libdir)}/,      '$libdir')\

      .sub(/\A#{Regexp.quote(stdruby)}/,     '$stdruby')\

      .sub(/\A#{Regexp.quote(siteruby)}/,    '$siteruby')\

      .sub(/\A#{Regexp.quote(siterubyver)}/, '$siterubyver')

}

libdir          = parameterize.call(c['libdir'])

stdruby         = parameterize.call(_stdruby)

siteruby        = parameterize.call(_siteruby)

siterubyver     = parameterize.call(_siterubyver)

siterubyverarch = parameterize.call(_siterubyverarch)

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

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

else

  makeprog = 'make'

end

common_conf = [

  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', 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 man pages'),

  PathItem.new('stdruby', 'path', stdruby,

               'the directory for standard ruby libraries'),

  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')

]

class ConfigTable_class   # open again

  ALIASES = {

    'std-ruby'         => 'stdruby',

    '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'

  }

end

multipackage_conf = [

  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')

]

if multipackage_install?

  ConfigTable = ConfigTable_class.new(common_conf + multipackage_conf)

else

  ConfigTable = ConfigTable_class.new(common_conf)

end

module MetaConfigAPI

  def eval_file_ifexist(fname)

    instance_eval File.read(fname), fname, 1 if File.file?(fname)

  end

  def config_names

    ConfigTable.map {|i| i.name }

  end

  def config?(name)

    ConfigTable.key?(name)

  end

  def bool_config?(name)

    ConfigTable.lookup(name).config_type == 'bool'

  end

  def path_config?(name)

    ConfigTable.lookup(name).config_type == 'path'

  end

  def value_config?(name)

    case ConfigTable.lookup(name).config_type

    when 'bool', 'path'

      true

    else

      false

    end

  end

  def add_config(item)

    ConfigTable.add item

  end

  def add_bool_config(name, default, desc)

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

  end

  def add_path_config(name, default, desc)

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

  end

  def set_config_default(name, default)

    ConfigTable.lookup(name).default = default

  end

  def remove_config(name)

    ConfigTable.remove(name)

  end

end

#

# File Operations

#

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 case

    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(fname)

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

    return if no_harm?

    if File.exist?(fname) or File.symlink?(fname)

      File.chmod 0777, fname

      File.unlink fname

    end

  end

  def rm_rf(dn)

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

    return if no_harm?

    Dir.chdir dn

    Dir.foreach('.') do |fn|

      next if fn == '.'

      next if fn == '..'

      if File.dir?(fn)

        verbose_off {

          rm_rf fn

        }

      else

        verbose_off {

          rm_f fn

        }

      end

    end

    Dir.chdir '..'

    Dir.rmdir dn

  end

  def move_file(src, dest)

    File.unlink dest if File.exist?(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 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(str)

    $stderr.puts str if verbose?

    system str or raise RuntimeError, "'system #{str}' failed"

  end

  def ruby(str)

    command config('rubyprog') + ' ' + str

  end

  def make(task = '')

    command config('makeprog') + ' ' + task

  end

  def extdir?(dir)

    File.exist?(dir + '/MANIFEST')

  end

  def all_files_in(dirname)

    Dir.open(dirname) {|d|

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

    }

  end

  REJECT_DIRS = %w(

    CVS SCCS RCS CVS.adm .svn

  )

  def all_dirs_in(dirname)

    Dir.open(dirname) {|d|

      return d.select {|n| File.dir?("#{dirname}/#{n}") } - %w(. ..) - REJECT_DIRS

    }

  end

end

#

# Main Installer

#

module HookUtils

  def run_hook(name)

    try_run_hook "#{curr_srcdir()}/#{name}" or

    try_run_hook "#{curr_srcdir()}/#{name}.rb"

  end

  def try_run_hook(fname)

    return false unless File.file?(fname)

    begin

      instance_eval File.read(fname), fname, 1

    rescue

      setup_rb_error "hook #{fname} failed:\n" + $!.message

    end

    true

  end

end

module HookScriptAPI

  def get_config(key)

    @config[key]

  end

  alias config get_config

  def set_config(key, val)

    @config[key] = val

  end

  #

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

  #

  #abstract srcdir_root

  #abstract objdir_root

  #abstract relpath

  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.3.1'

  Copyright = 'Copyright (c) 2000-2004 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' ],

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

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

  ]

  def ToplevelInstaller.invoke

    instance().invoke

  end

  @singleton = nil

  def ToplevelInstaller.instance

    @singleton ||= new(File.dirname($0))

    @singleton

  end

  include MetaConfigAPI

  def initialize(ardir_root)

    @config = nil

    @options = { 'verbose' => true }

    @ardir = File.expand_path(ardir_root)

  end

  def inspect

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

  end

  def invoke

    run_metaconfigs

    case task = parsearg_global()

    when nil, 'all'

      @config = load_config('config')

      parsearg_config

      init_installers

      exec_config

      exec_setup

      exec_install

    else

      @config = load_config(task)

      __send__ "parsearg_#{task}"

      init_installers

      __send__ "exec_#{task}"

    end

  end

  def run_metaconfigs

    eval_file_ifexist "#{@ardir}/metaconfig"

  end

  def load_config(task)

    case task

    when 'config'

      ConfigTable.new

    when 'clean', 'distclean'

      if File.exist?(ConfigTable.savefile)

      then ConfigTable.load

      else ConfigTable.new

      end

    else

      ConfigTable.load

    end

  end

  def init_installers

    @installer = Installer.new(@config, @options, @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

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

    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'

        @options['verbose'] = false

      when       '--verbose'

        @options['verbose'] = true

      when '-h', '--help'

        print_usage $stdout

        exit 0

      when '-v', '--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 parsearg_no_options

    unless ARGV.empty?

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

    end

  end

  alias parsearg_show       parsearg_no_options

  alias parsearg_setup      parsearg_no_options

  alias parsearg_clean      parsearg_no_options

  alias parsearg_distclean  parsearg_no_options

  def parsearg_config

    re = /\A--(#{ConfigTable.map {|i| i.name }.join('|')})(?:=(.*))?\z/

    @options['config-opt'] = []

    while i = ARGV.shift

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

        @options['config-opt'] = ARGV.dup

        break

      end

      m = re.match(i)  or setup_rb_error "config: unknown option #{i}"

      name, value = *m.to_a[1,2]

      @config[name] = value

    end

  end

  def parsearg_install

    @options['no-harm'] = false

    @options['install-prefix'] = ''

    while a = ARGV.shift

      case a

      when /\A--no-harm\z/

        @options['no-harm'] = true

      when /\A--prefix=(.*)\z/

        path = $1

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

        @options['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, '-h,--help',    'print this message'

    out.printf fmt, '-v,--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:'

    ConfigTable.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', '$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_show

    ConfigTable.each do |i|

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

    end

  end

  def exec_clean

    @installer.exec_clean

  end

  def exec_distclean

    @installer.exec_distclean

  end

end

class ToplevelInstallerMulti < ToplevelInstaller

  include HookUtils

  include HookScriptAPI

  include FileOperations

  def initialize(ardir)

    super

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

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

  end

  def run_metaconfigs

    eval_file_ifexist "#{@ardir}/metaconfig"

    @packages.each do |name|

      eval_file_ifexist "#{@ardir}/packages/#{name}/metaconfig"

    end

  end

  def init_installers

    @installers = {}

    @packages.each do |pack|

      @installers[pack] = Installer.new(@config, @options,

                                       "#{@ardir}/packages/#{pack}",

                                       "packages/#{pack}")

    end

    with    = extract_selection(config('with'))

    without = extract_selection(config('without'))

    @selected = @installers.keys.select {|name|

                  (with.empty? or with.include?(name)) \

                      and not without.include?(name)

                }

  end

  def extract_selection(list)

    a = list.split(/,/)

    a.each do |name|

      setup_rb_error "no such package: #{name}"  unless @installers.key?(name)

    end

    a

  end

  def print_usage(f)

    super

    f.puts 'Included packages:'

    f.puts '  ' + @packages.sort.join(' ')

    f.puts