reap 5.0.0 → 5.10.10

data/doc/note/application.rb

@@ -1,124 +0,0 @@
-
-
-module Reap
-
-  class Application
-
-    def initialize
-      @tasks = {}
-    end
-
-    attr :tasks
-    attr_accessor :last_desc
-
-    def define_task( args, &block )
-      raise ArgumentError, "#{args.size} for 1" if Hash===args and args.size != 1
-      name, deps = parse_args( args )
-      new_task = Task.new( last_desc, deps, &block )
-      new_task.application = self
-      last_desc = nil
-      @tasks[name] = new_task
-    end
-
-    def attach_help( task, doc )
-      raise unless @tasks.has_key?(task.to_sym)
-      @tasks[task].help = doc
-    end
-
-    def run( task )
-      @tasks[task.to_sym].call
-    end
-
-    private
-
-    def parse_args( args )
-      if Hash === args
-        raise ArgumentError, "#{args.size} for 1" if args.size != 1
-        name, deps = *(args.to_a.flatten)
-        name = name.to_sym
-        deps = [deps].compact.collect{ |e| e.to_sym }
-      else
-        name, deps = args.to_sym, []
-      end
-      return name, deps
-    end
-
-  end
-
-
-  class Task
-
-    def initialize( name, deps, &action )
-      @name = name
-      @dependencies = deps
-      @action = action
-      @complete = false
-    end
-
-    attr :dependencies
-    attr_accessor :help, :application
-
-    def complete?
-      @complete
-    end
-
-    def call
-      @dependencies.each{ |d|
-        application.tasks[d].call unless application.tasks[d].complete?
-      }
-      @action.call
-      @complete = true
-    end
-
-    def to_proc
-      @action
-    end
-
-  end
-
-end
-
-
-
-module Reap
-
-  def application
-    @application ||= Reap::Application.new
-  end
-
-  def desc( line )
-    application.last_desc = line.gsub("\n",'')
-  end
-
-  def task( args, &block )
-    application.define_task( args, &block )
-  end
-
-  # Define help documentation for a task.
-  def help( task_name, doc )
-    application.attach_help( task_name, doc )
-  end
-
-end
-
-
-include Reap
-
-
-
-
-desc "Milk the cow!"
-task :milk do
-  puts "milk"
-end
-
-desc "Jump over the moon!"
-task :jump => [ :milk, :milk ] do
-  #milk; milk
-  puts "jump"
-end
-
-task :package, Package
-
-application.run( :jump )
-

data/doc/note/interface/rubyforge.rb

@@ -1,247 +0,0 @@
-
-require "enumerator"
-require "http-access2"
-
-require 'reap/iface/interface.rb'
-
-
-class RubyForgeInterface < Interface
-
-  attr_accessor :username, :password, :cookie_jar
-
-  def initialize( master, section )
-
-    @name = master['name']
-
-    @username = master['rubyforge']['username'] || section['username']
-
-    @packge_id = section['package_id']
-    @lockfile_id = section['lockfile_id']
-
-    @group_id = section['group_id'] || 1024 # this is codeforpeople.  it's just a default...
-    @private = section['private'] ? 0 : 1
-
-    # internal use
-    @uri = "http://rubyforge.org"
-    @cookie_jar  = File::join(File::expand_path("~"), ".rubyforge.cookie_jar")
-
-  end
-
-
-#    config = {
-#      "username"    => "username", # this must be your username
-#      "password"    => "password", # this must be your password
-# 
-#      "group_id"    => 1024,       # this is codeforpeople.  it's just a default...
-# 
-#      "package_ids" => {           # configure shortcuts for your packages here
-#        "traits"   => 1241,
-#        "lockfile" => 1242,
-#      },
-# 
-#      "uri"         => "http://rubyforge.org",
-#      "cookie_jar"  => File::join(File::expand_path("~"), ".rubyforge.cookie_jar"),
-#    }
-# 
-#    opts =
-#      GetoptLong::new(
-#        [ "--username"   , "-u" , GetoptLong::REQUIRED_ARGUMENT ] ,
-#        [ "--password"   , "-p" , GetoptLong::REQUIRED_ARGUMENT ] ,
-#        [ "--cookie_jar" , "-c" , GetoptLong::REQUIRED_ARGUMENT ]
-#      ).enum_for.inject({}){|h,kv| h.update Hash[*kv]}
-# 
-#    username = opts['username'] || config['username']
-#    password = opts['password'] || config['password']
-#    cookie_jar = opts["cookie_jar"] || config['cookie_jar']
-#
-# setup
-#
-#   mode = ARGV.shift
-#   abort "#{ $0 } [login|create_package (package_name)|add_package (package_id release_name release.ext)]" unless mode
-
-  def setup
-
-    page, form, method = nil
-    extheader = {}
-
-    case mode
-
-    when %r/login/
-      page = "/account/login.php"
-      method = "post_content"
-
-      form = {
-        "return_to" => "",
-        "form_loginname" => username,
-        "form_pw" => password,
-        "login" => "Login"
-      }
-
-    when %r/create_package/
-      page = "/frs/admin/index.php"
-      method = "post_content"
-
-      opts =
-        GetoptLong::new(
-          [ "--group_id"   , "-g" , GetoptLong::REQUIRED_ARGUMENT ] ,
-          [ "--is_private" , "-P" , GetoptLong::REQUIRED_ARGUMENT ]
-        ).enum_for.inject({}){|h,kv| h.update Hash[*kv]}
-
-       package_name = ARGV.shift
-       abort "#{ $0 } package_name" unless package_name
-
-       group_id = opts["group_id"] || config["group_id"]
-       is_public = opts["is_private"] ? 0 : 1
-
-       form = {
-         "group_id"     => group_id,
-         "package_name" => package_name,
-         "func"         => "add_package",
-         "is_public"    => is_public,
-         "submit"       => "Create This Package",
-       }
-
-     when %r/add_release/
-       page = "/frs/admin/qrs.php"
-       method = "post_content"
-
-       opts =
-         GetoptLong::new(
-           [ "--group_id"        , "-g" , GetoptLong::REQUIRED_ARGUMENT ] ,
-           [ "--release_date"    , "-r" , GetoptLong::REQUIRED_ARGUMENT ] ,
-           [ "--type_id"         , "-t" , GetoptLong::REQUIRED_ARGUMENT ] ,
-           [ "--processor_id"    , "-P" , GetoptLong::REQUIRED_ARGUMENT ] ,
-           [ "--release_nots"    , "-n" , GetoptLong::REQUIRED_ARGUMENT ] ,
-           [ "--release_changes" , "-a" , GetoptLong::REQUIRED_ARGUMENT ]
-         ).enum_for.inject({}){|h,kv| h.update Hash[*kv]}
-
-       package_id, release_name, userfile, ignored = ARGV
-       abort "#{ $0 } package_name" unless
-         package_id and release_name and userfile
-
-       package_id = config["package_ids"][package_id] unless
-         package_id =~ %r/^\d+$/
-
-       group_id = opts["group_id"] || config["group_id"]
-       release_date = opts["release_date"] || Time::now.strftime('%Y-%m-%d %H:%M')
-
-       type_id = opts['type_id'] || userfile[%r|\.[^\./]+$|]
-       type_id = {
-         ".deb"     => 1000,
-         ".rpm"     => 2000,
-         ".zip"     => 3000,
-         ".bz2"     => 3100,
-         ".gz"      => 3110,
-         ".src.zip" => 5000,
-         ".src.bz2" => 5010,
-         ".src.gz"  => 5020,
-         ".src.rpm" => 5100,
-         ".src"     => 5900,
-         ".jpg"     => 8000,
-         ".txt"     => 8100,
-         ".text"    => 8100,
-         ".htm"     => 8200,
-         ".html"    => 8200,
-         ".pdf"     => 8300,
-         ".oth"     => 9999,
-         ".ebuild"  => 1300,
-         ".exe"     => 1100,
-         ".dmg"     => 1200,
-         ".tar.gz"  => 5000,
-         ".tgz"     => 5000,
-         ".gem"     => 1400,
-         ".pgp"     => 8150,
-         ".sig"     => 8150,
-       }[type_id]
-
-       processor_id = opts['processor_id'] || 'Any'
-       processor_id = {
-         "i386"       => 1000,
-         "IA64"       => 6000,
-         "Alpha"      => 7000,
-         "Any"        => 8000,
-         "PPC"        => 2000,
-         "MIPS"       => 3000,
-         "Sparc"      => 4000,
-         "UltraSparc" => 5000,
-         "Other"      => 9999,
-       }[processor_id]
-
-       release_notes = opts['release_notes'] || nil
-       release_notes = open(release_notes) if release_notes
-
-       release_changes = opts['release_changes'] || nil
-       release_changes = open(release_changes) if release_changes
-
-       userfile = open(userfile)
-
-       preformatted = '1'
-
-       form = {
-         "group_id"     => group_id,
-         "package_id"   => package_id,
-         "release_name" => release_name,
-         "release_date" => release_date,
-         "type_id"      => type_id,
-         "processor_id" => processor_id,
-         "preformatted" => preformatted,
-         "userfile"     => userfile,
-         "submit"       => "Release File"
-       }
-
-       boundary = Array::new(8){ "%2.2d" % rand(42) }.join('__')
-       extheader['content-type'] = "multipart/form-data; boundary=___#{ boundary }___"
-
-     else
-       abort "#{ $0 } login create_package add_release"
-
-   end
-#
-# http transaction
-#
-   client = HTTPAccess2::Client::new ENV['HTTP_PROXY']
-   client.debug_dev = STDERR if ENV['DEBUG']
-
-   client.set_cookie_store cookie_jar
-
-   # fixes http-access2 bug
-   client.redirect_uri_callback = lambda do |res|
-     page = res.header['location'].first
-     page = page =~ %r/http/ ? page : "#{ config['uri'] }/#{ page }"
-     page
-   end
-
-   response = client.send "#{ method }", "#{ config['uri'] }/#{ page }", form, extheader
-
-   client.save_cookie_store
-
-# fixes http-access2 bug
-BEGIN {
-   require "http-access2"
-   module WebAgent::CookieUtils
-     def domain_match(host, domain)
-       case domain
-       when /\d+\.\d+\.\d+\.\d+/
-         return (host == domain)
-       when '.'
-         return true
-       when /^\./
-         #return tail_match?(domain, host)
-         return tail_match?(host, domain)
-       else
-         return (host == domain)
-       end
-     end
-   end
-
-}
-
-
-
-
-
-
-end
-
-
-

data/doc/note/intro.txt

@@ -1,42 +0,0 @@
-
-An Introduction to Reap
-A Ruby Package Assitant
-
-
-
-  task :name do
-
-    when { projectfile? }
-
-    help <<-end
-      Help information.
-    end
-
-    run do |x|
-      # do the task
-    end
-
-  end
-
-
-
-
-  desc "This is a description"
-
-  task :name do |x|
-    # do the task
-  end
-
-  cont do
-
-    help <<-end
-      This is help text.
-    end
-
-    when do
-      projectfile?
-    end
-
-  end
-
-

data/doc/note/package.rb

@@ -1,629 +0,0 @@
-require 'rbconfig'
-require 'fileutils'
-require 'pp'
-require 'optparse'
-require 'yaml'
-
-module Package
-
-class SpecificationError < StandardError; end
-# forward declaration of the specification classes so we can keep all
-# constants here
-class PackageSpecification_1_0; end
-# Default semantics
-PackageSpecification = PackageSpecification_1_0
-
-#TODO: could get this collected automatically with Class#inherited etc
-SEMANTICS = { "1.0" => PackageSpecification_1_0 }
-
-KINDS = [
-  :bin, :lib, :ext, :data, :conf, :doc
-]
-
-#{{{ list of files to be ignored stolen from setup.rb
-mapping = { '.' => '\.', '$' => '\$', '#' => '\#', '*' => '.*' }
-ignore_files = %w[core RCSLOG tags TAGS .make.state .nse_depinfo 
-      #* .#* cvslog.* ,* .del-* *.olb *~ *.old *.bak *.BAK *.orig *.rej _$* *$
-      *.org *.in .* ] 
-#end of robbery
-IGNORE_FILES = ignore_files.map do |x|
-  Regexp.new('\A' + x.gsub(/[\.\$\#\*]/){|c| mapping[c]} + '\z')
-end
-
-def self.config(name)
-  # XXX use pathname
-  prefix = Regexp.quote(Config::CONFIG["prefix"])
-  exec_prefix = Regexp.quote(Config::CONFIG["exec_prefix"])
-  Config::CONFIG[name].gsub(/\A\/?(#{prefix}|#{exec_prefix})\/?/, '')
-end
-
-SITE_DIRS = {
-  :bin  => config("bindir"),
-  :lib  => config("sitelibdir"),
-  :ext  => config("sitearchdir"),
-  :data => config("datadir"),
-  :conf => config("sysconfdir"),
-  :doc  => File.join(config("datadir"), "doc"),
-}
-
-VENDOR_DIRS = {
-  :bin  => config("bindir"),
-  :lib  => config("rubylibdir"),
-  :ext  => config("archdir"),
-  :data => config("datadir"),
-  :conf => config("sysconfdir"),
-  :doc  => File.join(config("datadir"), "doc"),
-}
-
-MODES = {
-  :bin  => 0755,
-  :lib  => 0644,
-  :ext  => 0755,  # was: 0555,
-  :data => 0644,
-  :conf => 0644,
-  :doc  => 0644,
-}
-
-
-SETUP_OPTIONS = {:parse_cmdline => true, :load_conf => true, :run_tasks => true}
-
-def self.setup(version, options = {}, &instructions)
-  prefixes = dirs = nil
-  options = SETUP_OPTIONS.dup.update(options)
-
-  if options[:load_conf] && File.exist?("config.save")
-    config = YAML.load_file "config.save"
-    prefixes = config[:prefixes]
-    dirs = config[:dirs]
-  end
-
-  pkg = package_specification_with_semantics(version).new(prefixes, dirs)
-  pkg.parse_command_line if options[:parse_cmdline]
-  pkg.instance_eval(&instructions)
-
-  pkg.run_tasks if options[:run_tasks]
-
-#   pkg.install
-  pkg
-end
-
-def self.package_specification_with_semantics(version)
-  #XXX: implement the full x.y(.z)? semantics
-  r = SEMANTICS[version]
-  raise SpecificationError, "Unknown version #{version}." unless r
-  r
-end
-
-
-module Actions
-  
-  class InstallFile
-
-    attr_reader :source, :destination, :mode
-
-    def initialize(source, destination, mode, options)
-      @source = source
-      @destination = destination
-      @mode = mode
-      @options = options
-    end
-
-    def install
-      FileUtils.install @source, File.join(@options.destdir, @destination),
-                                 {:verbose => @options.verbose,
-                                  :noop => @options.noop, :mode => @mode }
-    end
-
-    def hash
-      [@source.hash, @destination.hash].hash
-    end
-
-    def eql?(other)
-      self.class == other.class && 
-        @source == other.source &&
-          @destination == other.destination &&
-            @mode == other.mode
-    end
-
-    def <=>(other)
-      FULL_ORDER[self, other] || self.destination <=> other.destination
-    end
-  end
-
-  class MkDir
-
-    attr_reader :directory
-
-    def initialize(directory, options)
-      @directory = directory
-      @options = options
-    end
-
-    def install
-      FileUtils.mkdir_p File.join(@options.destdir, @directory),
-                                  {:verbose => @options.verbose,
-                                   :noop => @options.noop }
-    end
-
-    def <=>(other)
-      FULL_ORDER[self, other] || self.directory <=> other.directory 
-    end
-  end
-
-  class FixShebang
-
-    attr_reader :destination
-
-    def initialize(destination, options)
-      @options = options
-      @destination = destination
-    end
-
-    def install
-      path = File.join(@options.destdir, @destination)
-      fix_shebang(path)
-    end
-
-    # taken from rpa-base, originally based on setup.rb's
-    # modify: #!/usr/bin/ruby
-    # modify: #! /usr/bin/ruby
-    # modify: #!ruby
-    # not modify: #!/usr/bin/env ruby
-    SHEBANG_RE = /\A\#!\s*\S*ruby\S*/
-
-    #TODO allow the ruby-prog to be placed in the shebang line to be passed as
-    # an option
-    def fix_shebang(path)
-      tmpfile = path + '.tmp'
-      begin
-        #XXX: needed at all?
-        # it seems that FileUtils doesn't expose its default output
-        #   @fileutils_output = $stderr
-        # we might want to allow this to be redirected.
-        $stderr.puts "shebang:open #{tmpfile}" if @options.verbose
-        unless @options.noop
-          File.open(path) do |r|
-            File.open(tmpfile, 'w', 0755) do |w|
-              first = r.gets
-              return unless SHEBANG_RE =~ first
-              w.print first.sub(SHEBANG_RE, '#!' + Config::CONFIG['ruby-prog'])
-              w.write r.read
-            end
-          end
-        end
-        FileUtils.mv(tmpfile, path, :verbose => @options.verbose,
-                     :noop => @options.noop)
-      ensure
-        FileUtils.rm_f(tmpfile, :verbose => @options.verbose,
-                       :noop => @options.noop)
-      end
-    end
-
-    def <=>(other)
-      FULL_ORDER[self, other] || self.destination <=> other.destination
-    end
-
-    def hash
-      @destination.hash
-    end
-
-    def eql?(other)
-      self.class == other.class && self.destination == other.destination
-    end
-  end
-
-  order = [MkDir, InstallFile, FixShebang]
-  FULL_ORDER = lambda do |me, other|
-    a, b = order.index(me.class), order.index(other.class)
-    if a && b
-      (r = a - b) == 0 ? nil : r
-    else
-      -1 # arbitrary
-    end
-  end
-
-  class ActionList < Array
-
-    def directories!(options)
-      dirnames = []
-      map! { |d|
-        if d.kind_of?(InstallFile) && !dirnames.include?(File.dirname(d.destination))
-          dirnames << File.dirname(d.destination)
-          [MkDir.new(File.dirname(d.destination), options), d]
-        else
-          d
-        end
-      }
-      flatten!
-    end
-
-    def run(task)
-      each { |action| action.__send__ task }
-    end
-  end
-
-end # module Actions
-
-Options = Struct.new(:noop, :verbose, :destdir)
-
-class PackageSpecification_1_0
-
-  TASKS = %w[config setup install test show]
-  # default options for translate(foo => bar)
-  TRANSLATE_DEFAULT_OPTIONS = { :inherit => true }
-
-  def self.declare_file_type(args, &handle_arg)
-    str_arr_p = lambda{|x| Array === x && x.all?{|y| String === y}}
-
-    # strict type checking --- we don't want this to be extended arbitrarily
-    unless args.size == 1 && Hash === args.first && 
-           args.first.all?{|f,r| [Proc, String, NilClass].include?(r.class) &&
-                                 (String === f || str_arr_p[f])} or
-           args.all?{|x| String === x || str_arr_p[x]}
-      raise SpecificationError, 
-        "Unspecified semantics for the given arguments: #{args.inspect}"
-    end
-
-    if args.size == 1 && Hash === args.first 
-      args.first.to_a.each do |file, rename_info|
-        if Array === file
-          # ignoring boring files
-          handle_arg.call(file, true, rename_info)
-        else
-          # we do want "boring" files given explicitly
-          handle_arg.call([file], false, rename_info)
-        end
-      end
-    else
-      args.each do |a|
-        if Array === a
-          a.each{|file| handle_arg.call(file, true, nil)}
-        else
-          handle_arg.call(a, false, nil)
-        end
-      end
-    end
-  end
-
-  #{{{ define the file tagging methods
-  KINDS.each { |kind|
-    define_method(kind) { |*args| # if this were 1.9 we could also take a block
-      bin_callback = lambda do |kind_, type, dest, options|
-        next if kind_ != :bin || type == :dir
-        @actions << Actions::FixShebang.new(dest, options)
-      end
-      #TODO: refactor
-      self.class.declare_file_type(args) do |files, ignore_p, opt_rename_info|
-        files.each do |file|
-          next if ignore_p && IGNORE_FILES.any?{|re| re.match(file)}
-          add_file(kind, file, opt_rename_info, &bin_callback)
-        end
-      end
-    }
-  }
-
-  def unit_test(*files)
-    @unit_tests.concat files.flatten
-  end
-
-  attr_accessor :actions, :options
-
-  def self.metadata(name)
-    define_method(name) { |*args|
-      if args.size == 1
-        @metadata[name] = args.first
-      end
-      @metadata[name]
-    }
-  end
-
-  metadata :name
-  metadata :version
-  metadata :author
-
-
-  def translate_dir(kind, dir)
-    replaced_dir_parts = dir.split(%r{/})
-    kept_dir_parts = []
-    loop do
-      replaced_path = replaced_dir_parts.join("/")
-      target, options = @translate[kind][replaced_path]
-      options ||= TRANSLATE_DEFAULT_OPTIONS
-      if target && (replaced_path == dir || options[:inherit])
-        dir = (target != '' ? File.join(target, *kept_dir_parts) : 
-                              File.join(*kept_dir_parts))
-        break
-      end
-      break if replaced_dir_parts.empty?
-      kept_dir_parts.unshift replaced_dir_parts.pop
-    end
-    dir
-  end
-
-  def add_file(kind, filename, new_filename_info, &callback)
-    #TODO: refactor!!!
-    if File.directory? filename #XXX setup.rb and rpa-base defined File.dir?
-                                #    to cope with some win32 issue
-      dir = filename.sub(/\A\.\//, "").sub(/\/\z/, "")
-      dest = File.join(@prefixes[kind], @dirs[kind], translate_dir(kind, dir))
-      @actions << Actions::MkDir.new(dest, @options)
-      callback.call(kind, :dir, dest, @options) if block_given?
-    else
-      if new_filename_info
-        case new_filename_info
-        when Proc
-          dest_name = new_filename_info.call(filename.dup)
-        else
-          dest_name = new_filename_info.dup
-        end
-      else
-        dest_name = filename.dup
-      end
-
-      dirname = File.dirname(dest_name)
-      dirname = "" if dirname == "."
-      dest_name = File.join(translate_dir(kind, dirname), File.basename(dest_name))
-
-      dest = File.join(@prefixes[kind], @dirs[kind], dest_name)
-      @actions << Actions::InstallFile.new(filename, dest, MODES[kind], @options)
-      callback.call(kind, :file, dest, @options) if block_given?
-    end
-  end
-
-  def initialize(prefixes = nil, dirs = nil)
-    @prefix = Config::CONFIG["prefix"].gsub(/\A\//, '')
-    @translate = {}
-    @prefixes = (prefixes || {}).dup
-    KINDS.each { |kind|
-      @prefixes[kind] = @prefix unless prefixes
-      @translate[kind] = {}
-    }
-
-    @dirs = (dirs || {}).dup
-    @dirs.update SITE_DIRS unless dirs
-
-    @actions = Actions::ActionList.new
-
-    @metadata = {}
-    @unit_tests = []
-
-    @options = Options.new
-    @options.verbose = true
-    @options.noop = true                # XXX for testing
-    @options.destdir = ''
-
-    @tasks = []
-  end
-
-  def aoki
-    (KINDS - [:ext]).each { |kind|
-      translate(kind, kind.to_s => "", :inherit => true)
-      __send__ kind, Dir["#{kind}/**/*"]
-    }
-    translate(:ext, "ext/*" => "", :inherit => true)
-    ext Dir["ext/**/*.#{Config::CONFIG['DLEXT']}"]
-  end
-
-  def install
-    puts "Installing #{name || "unknown package"} #{version}..."  if options.verbose
-
-    actions.uniq!
-    actions.sort!
-    actions.directories!(options)
-
-    #pp self
-
-    actions.run :install
-  end
-
-  def test
-    unless @unit_tests.empty?
-      puts "Testing #{name || "unknown package"} #{version}..."  if options.verbose
-      require 'test/unit'
-      unless options.noop
-        t = Test::Unit::AutoRunner.new(true)
-        t.process_args(@unit_tests)
-        t.run  
-      end
-    end
-  end
-
-  def config
-    File.open("config.save", "w") { |f|
-      YAML.dump({:prefixes => @prefixes, :dirs => @dirs}, f)
-    }
-  end
-
-  def show
-    KINDS.each { |kind|
-      puts "#{kind}\t#{File.join(options.destdir, @prefixes[kind], @dirs[kind])}"
-    }
-  end
-
-  def translate(kind, additional_translations)
-    default_opts = TRANSLATE_DEFAULT_OPTIONS.dup
-    key_val_pairs = additional_translations.to_a
-    option_pairs = key_val_pairs.select{|(k,v)| Symbol === k}
-    default_opts.update(Hash[*option_pairs.flatten])
-
-    (key_val_pairs - option_pairs).each do |key, val|
-      add_translation(kind, key, val, default_opts)
-    end
-  end
-
-  def add_translation(kind, src, dest, options)
-    if is_glob?(src)
-      dirs = expand_dir_glob(src)
-    else
-      dirs = [src]
-    end
-    dirs.each do |dirname|
-      dirname = dirname.sub(%r{\A\./}, "").sub(%r{/\z}, "")
-      @translate[kind].update({dirname => [dest, options]})
-    end
-  end
-
-  def is_glob?(x)
-    /(^|[^\\])[*?{\[]/.match(x)
-  end
-
-  def expand_dir_glob(src)
-    Dir[src].select{|x| File.directory?(x)}
-  end
-
-  def clean_path(path)
-    path.gsub(/\A\//, '').gsub(/\/+\Z/, '').squeeze("/")
-  end
-
-  def parse_command_line
-    opts = OptionParser.new(nil, 24, ' ') { |opts|
-      opts.banner = "Usage: setup.rb [options] [task]"
-
-      opts.separator ""
-      opts.separator "Tasks:"
-      opts.separator "    config     configures paths"
-      opts.separator "    show       shows paths"
-      opts.separator "    setup      compiles ruby extentions and others XXX"
-      opts.separator "    install    installs files"
-      opts.separator "    test       runs unit tests"
-
-      opts.separator ""
-      opts.separator "Specific options:"
-
-      opts.on "--prefix=PREFIX",
-              "path prefix of target environment [#@prefix]" do |prefix|
-        @prefix.replace clean_path(prefix)  # Shared!
-      end
-
-      opts.separator ""
-
-      KINDS.each { |kind|
-        opts.on "--#{kind}prefix=PREFIX",
-                "path prefix for #{kind} files [#{@prefixes[kind]}]" do |prefix|
-          @prefixes[kind] = clean_path(prefix)
-        end
-      }
-
-      opts.separator ""
-
-      KINDS.each { |kind|
-        opts.on "--#{kind}dir=PREFIX",
-                "directory for #{kind} files [#{@dirs[kind]}]" do |prefix|
-          @dirs[kind] = clean_path(prefix)
-        end
-      }
-
-      opts.separator ""
-
-      KINDS.each { |kind|
-        opts.on "--#{kind}=PREFIX",
-                "absolute directory for #{kind} files [#{File.join(@prefixes[kind], @dirs[kind])}]" do |prefix|
-          @prefixes[kind] = clean_path(prefix)
-        end
-      }
-
-      opts.separator ""
-      opts.separator "Predefined path configurations:"
-      opts.on "--site", "install into site-local directories (default)" do
-        @dirs.update SITE_DIRS
-      end
-
-      opts.on "--vendor", "install into distribution directories (for packagers)" do
-        @dirs.update VENDOR_DIRS
-      end
-
-      opts.separator ""
-      opts.separator "General options:"
-
-      opts.on "--destdir=DESTDIR",
-              "install all files relative to DESTDIR (/)" do |destdir|
-        @options.destdir = destdir
-      end
-
-      opts.on "--dry-run", "only display what to do if given [#{@options.noop}]" do
-        @options.noop = true
-      end
-
-      opts.on "--no-harm", "only display what to do if given" do
-        @options.noop = true
-      end
-
-      opts.on "--[no-]verbose", "output messages verbosely [#{@options.verbose}]" do |verbose|
-        @options.verbose = verbose
-      end
-
-      opts.on_tail("-h", "--help", "Show this message") do
-        puts opts
-        exit
-      end
-    }
-
-    opts.parse! ARGV
-
-    if (ARGV - TASKS).empty?    # Only existing tasks?
-      @tasks = ARGV
-      @tasks = ["install"]  if @tasks.empty?
-    else
-      abort "Unknown task(s) #{(ARGV-TASKS).join ", "}."
-    end
-  end
-
-  def run_tasks
-    @tasks.each { |task| __send__ task }
-  end
-end
-
-end # module Package
-
-#XXX incomplete setup.rb support for the hooks
-require 'rbconfig'
-def config(x)
-  Config::CONFIG[x]
-end
-
-
-if $0 == __FILE__
-
-version = "4.5.1"
-
-Package.setup("1.0") {
-
-  translate :bin, 'bin' => ''
-  bin  *Dir['bin/**/*']
-
-  translate :lib, 'lib/reap' => "reap/#{version}"
-  lib  *Dir['lib/**/*']
-
-  translate :doc, 'doc' => "reap/#{version}"
-  doc  *Dir['doc/**/*']
-
-  translate :ext, 'ext' => "reap/#{version}"
-  ext  *Dir['ext/**/*']
-
-  translate :data, 'data/reap' => "reap/#{version}"
-  data *Dir['data/**/*']
-
-  translate :conf, 'conf/reap' => "reap/#{version}"
-  conf *Dir['conf/**/*']
-
-  #translate(:lib, '' => 'fuutils', 'blerg' => '', 'blorg' => 'borg')
-  #lib "feeble.rb", "fooble.rb", "fuuble.rb"
-  #lib "fooble.rb"
-  #lib "blerg/foo.rb", "blorg/foo.rb"
-  #lib "fruubar.rb" => "fuubar.rb"
-  #lib "friibar.rb" => lambda{|x| "fiibar.rb"}
-  #lib ["stuff.orig", "core", ".bla.rb.swp"] # will be ignored
-  #doc "bla.orig"              # will not be ignored
-  #doc "foo.orig" => "bla.txt" # ditto
-  #lib ["lfoo1", "lbar1"]
-  #lib ["lfoo", "lbar"] => lambda{|x| "#{x}.rb"}
-  #translate(:data, '_darcs' => 'DARCS')
-  #data "_darcs/"  # just to test MkDir generation
-
-  #pp self
-}
-
-end
-
-
-# vim: sw=2 sts=2 et ts=8