facets 1.8.49 → 1.8.51

data/work/pore/superann.rb

@@ -1,134 +0,0 @@
-#require 'roll/metadsl'
-
-require 'yaml'
-
-class Library
-
-  #
-
-  class Annotation
-
-    def initialize( name, *args, &func )
-      @name = name
-      @args = args
-      @func = func
-    end
-
-  end
-
-  #
-
-  module Annotate
-
-    def annotations
-      @annotations ||= []
-    end
-
-    def define_annotation( sym, *args, &yld )
-      if args.empty? and not block_given?
-        if sym == :default
-          @annotation_modes = nil
-        else
-          @annotation_modes = *sym.to_s.split('_and_')
-        end
-      else
-        annotations << Annotation.new( sym, *args, &yld )
-        if @annotation_modes
-          @annotation_modes.each do |mode|
-            annotations << Annotation.new( mode, *args, &yld )
-          end
-        end
-      end
-    end
-
-    def attr( *args, &yld )
-      define_annotation( :attr, *args, &yld )
-    end
-
-    def type( *args, &yld )
-      define_annotation( :type, *args, &yld )
-    end
-
-    def method_missing( sym, *args, &yld )
-      define_annotation( sym, *args, &yld )
-    end
-
-  end
-
-
-  class Metadata
-    extend Annotate
-
-    attr :date
-    attr :title
-    attr :contact
-    attr :license
-    attr :status
-    attr :arch
-    attr :author
-    attr :email
-    attr :homepage
-    attr :created
-    attr :scope
-    attr :rules  # should be in sow package?
-    attr :description
-
-    type :rubyforge, :Rubyforge
-    type :revision , :Revision
-
-    refer :authors      , :author
-    refer :architecture , :arch
-    refer :platform     , :arch
-
-    default :license , 'Ruby/GPL'
-    default :status  , 'alpha'
-    default :arch    , 'any'
-    default :data    do Time.now.strftime("%Y-%m-%d") end
-    default :title   do name.capitalize end
-    default :contact do author end
-
-  needs
-
-    attr :name
-    attr :version # , :require => true #, :default => lambda { default_version }
-    attr :license
-    attr :summary
-
-  end
-
-
-y Metadata.annotations
-
-  #
-
-  class Rubyforge
-
-
-    belongs_to :Metadata
-
-    needs
-
-      attr :project
-      attr :username
-      attr :groupid
-
-  end
-
-  #
-
-  class Revision
-
-    belongs_to :Metadata
-
-    needs
-
-      attr :type
-
-    normal
-
-      attr :include
-      attr :exclude
-
-  end
-
-end

data/work/pore/sys.rb

@@ -1,186 +0,0 @@
-#!/usr/bin/env ruby
-
-#--
-# Copyright (c) 2003, 2004 Jim Weirich
-#
-# 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.
-#++
-#
-require 'ftools'
-require 'rbconfig'
-
-######################################################################
-# Sys provides a number of file manipulation tools for the convenience
-# of writing Rakefiles.  All commands in this module will announce
-# their activity on standard output if the $verbose flag is set
-# ($verbose = true is the default).  You can control this by globally
-# setting $verbose or by using the +verbose+ and +quiet+ methods.
-#
-# Sys has been deprecated in favor of the FileUtils module available
-# in Ruby 1.8.
-#
-module Sys
-  RUBY = Config::CONFIG['ruby_install_name']
-
-  # Install all the files matching +wildcard+ into the +dest_dir+
-  # directory.  The permission mode is set to +mode+.
-  def install(wildcard, dest_dir, mode)
-    Dir[wildcard].each do |fn|
-      File.install(fn, dest_dir, mode, $verbose)
-    end
-  end
-
-  # Run the system command +cmd+.
-  def run(cmd)
-    log cmd
-    system(cmd) or fail "Command Failed: [#{cmd}]"
-  end
-
-  # Run a Ruby interpreter with the given arguments.
-  def ruby(*args)
-    run "#{RUBY} #{args.join(' ')}"
-  end
-  
-  # Copy a single file from +file_name+ to +dest_file+.
-  def copy(file_name, dest_file)
-    log "Copying file #{file_name} to #{dest_file}"
-    File.copy(file_name, dest_file)
-  end
-
-  # Copy all files matching +wildcard+ into the directory +dest_dir+.
-  def copy_files(wildcard, dest_dir)
-    for_matching_files(wildcard, dest_dir) { |from, to| copy(from, to) }
-  end
-
-  # Link +file_name+ to +dest_file+.
-  def link(file_name, dest_file)
-    log "Linking file #{file_name} to #{dest_file}"
-    File.link(file_name, dest_file)
-  end
-
-  # Link all files matching +wildcard+ into the directory +dest_dir+.
-  def link_files(wildcard, dest_dir)
-    for_matching_files(wildcard, dest_dir) { |from, to| link(from, to) }
-  end
-
-  # Symlink +file_name+ to +dest_file+.
-  def symlink(file_name, dest_file)
-    log "Symlinking file #{file_name} to #{dest_file}"
-    File.symlink(file_name, dest_file)
-  end
-
-  # Symlink all files matching +wildcard+ into the directory +dest_dir+.
-  def symlink_files(wildcard, dest_dir)
-    for_matching_files(wildcard, dest_dir) { |from, to| link(from, to) }
-  end
-
-  # Remove all files matching +wildcard+.  If a matching file is a
-  # directory, it must be empty to be removed.  used +delete_all+ to
-  # recursively delete directories.
-  def delete(*wildcards)
-    wildcards.each do |wildcard|
-      Dir[wildcard].each do |fn|
-	if File.directory?(fn)
-	  log "Deleting directory #{fn}"
-	  Dir.delete(fn)
-	else
-	  log "Deleting file #{fn}"
-	  File.delete(fn)
-	end
-      end
-    end
-  end
-
-  # Recursively delete all files and directories matching +wildcard+.
-  def delete_all(*wildcards)
-    wildcards.each do |wildcard|
-      Dir[wildcard].each do |fn|
-	next if ! File.exist?(fn)
-	if File.directory?(fn)
-	  Dir["#{fn}/*"].each do |subfn|
-	    next if subfn=='.' || subfn=='..'
-	    delete_all(subfn)
-	  end
-	  log "Deleting directory #{fn}"
-	  Dir.delete(fn)
-	else
-	  log "Deleting file #{fn}"
-	  File.delete(fn)
-	end
-      end
-    end
-  end
-
-  # Make the directories given in +dirs+.
-  def makedirs(*dirs)
-    dirs.each do |fn|
-      log "Making directory #{fn}"
-      File.makedirs(fn)
-    end
-  end
-  
-  # Write a message to standard out if $verbose is enabled.
-  def log(msg)
-    print "  " if $trace && $verbose
-    puts msg if $verbose
-  end
-
-  # Perform a block with $verbose disabled.
-  def quiet(&block)
-    with_verbose(false, &block)
-  end
-
-  # Perform a block with $verbose enabled.
-  def verbose(&block)
-    with_verbose(true, &block)
-  end
-
-  # Perform a block with each file matching a set of wildcards.
-  def for_files(*wildcards)
-    wildcards.each do |wildcard|
-      Dir[wildcard].each do |fn|
-	yield(fn)
-      end
-    end
-  end
-
-  extend(self)
-
-  private # ----------------------------------------------------------
-
-  def for_matching_files(wildcard, dest_dir)
-    Dir[wildcard].each do |fn|
-      dest_file = File.join(dest_dir, fn)
-      parent = File.dirname(dest_file)
-      makedirs(parent) if ! File.directory?(parent)
-      yield(fn, dest_file)
-    end
-  end
-
-  def with_verbose(v)
-    oldverbose = $verbose
-    $verbose = v
-    yield
-  ensure
-    $verbose = oldverbose
-  end
-
-end
-

data/work/pore/utils.rb

@@ -1,518 +0,0 @@
-=begin
-
-  = Utils
-  
-  Utils is simply a plethora of functions that one might use for degugging, testing,
-  finding certain files, etc. It's really a place to put methods related to progrmming task,
-  that while useful simply don't have a specifc home elsehwere. It is possible that they will
-  evetnually find said home and go live there.
- 
-  Most of this was shamelessly ripped form the CrossCase distribution labeled 
-  'Install/distribution utility functions'. But this will evolove over time.
-  
-  == Authors
-  
-  * Michael Granger <ged@FaerieMUD.org>
-  
-  == Version
-    
-  $Id: utils.rb,v 1.1.1.1 2003/07/25 15:43:29 deveiant Exp $
-
-  == Legal
-  
-  Parital Copyright (c) 2001-2003, The FaerieMUD Consortium.
-
-  This is free software. You may use, modify, and/or redistribute this
-  software under the terms of the Perl Artistic License. (See
-  http://language.perl.com/misc/Artistic.html)
-
-=end
-
-=begin
-BEGIN {
-    begin
-        require 'readline'
-        include Readline
-    rescue LoadError => e
-        $stderr.puts "Faking readline..."
-        def readline( prompt )
-            $stderr.print prompt.chomp
-            return $stdin.gets.chomp
-        end
-    end
-
-    begin
-        require 'yaml'
-        $yaml = true
-    rescue LoadError => e
-        $stderr.puts "No YAML; try() will use .inspect instead."
-        $yaml = false
-    end
-}
-=end
-
-module UtilityFunctions
-
-    # The list of regexen that eliminate files from the MANIFEST
-    ANTIMANIFEST = [
-        /makedist\.rb/,
-        /\bCVS\b/,
-        /~$/,
-        /^#/,
-        %r{docs/html},
-        %r{docs/man},
-        /^TEMPLATE/,
-        /\.cvsignore/,
-        /\.s?o$/
-    ]
-
-    # Set some ANSI escape code constants (Shamelessly stolen from Perl's
-    # Term::ANSIColor by Russ Allbery <rra@stanford.edu> and Zenin <zenin@best.com>
-    AnsiAttributes = {
-        'clear'      => 0,
-        'reset'      => 0,
-        'bold'       => 1,
-        'dark'       => 2,
-        'underline'  => 4,
-        'underscore' => 4,
-        'blink'      => 5,
-        'reverse'    => 7,
-        'concealed'  => 8,
-
-        'black'      => 30,   'on_black'   => 40, 
-        'red'        => 31,   'on_red'     => 41, 
-        'green'      => 32,   'on_green'   => 42, 
-        'yellow'     => 33,   'on_yellow'  => 43, 
-        'blue'       => 34,   'on_blue'    => 44, 
-        'magenta'    => 35,   'on_magenta' => 45, 
-        'cyan'       => 36,   'on_cyan'    => 46, 
-        'white'      => 37,   'on_white'   => 47
-    }
-
-    ErasePreviousLine = "\033[A\033[K"
-
-
-    ###############
-    module_function
-    ###############
-
-    # Create a string that contains the ANSI codes specified and return it
-    def ansiCode( *attributes )
-      return '' unless /(?:vt10[03]|xterm(?:-color)?|linux)/i =~ ENV['TERM']
-      attr = attributes.collect {|a| AnsiAttributes[a] ? AnsiAttributes[a] : nil}.compact.join(';')
-      if attr.empty? 
-        return ''
-      else
-        return "\e[%sm" % attr
-      end
-    end
-
-    # Test for the presence of the specified <tt>library</tt>, and output a
-    # message describing the test using <tt>nicename</tt>. If <tt>nicename</tt>
-    # is <tt>nil</tt>, the value in <tt>library</tt> is used to build a default.
-    def testForLibrary( library, nicename=nil )
-      nicename ||= library
-      message( "Testing for the #{nicename} library..." )
-      if $:.detect{ |dir| 
-        File.exists?(File.join(dir,"#{library}.rb")) || File.exists?(File.join(dir,"#{library}.so"))
-      }
-        message( "found.\n" )
-        return true
-      else
-        message( "not found.\n" )
-        return false
-      end
-    end
-
-    # Test for the presence of the specified <tt>library</tt>, and output a
-    # message describing the problem using <tt>nicename</tt>. If
-    # <tt>nicename</tt> is <tt>nil</tt>, the value in <tt>library</tt> is used
-    # to build a default. If <tt>raaUrl</tt> and/or <tt>downloadUrl</tt> are
-    # specified, they are also use to build a message describing how to find the
-    # required library. If <tt>fatal</tt> is <tt>true</tt>, a missing library
-    # will cause the program to abort.
-    def testForRequiredLibrary( library, nicename=nil, raaUrl=nil, downloadUrl=nil, fatal=true )
-      nicename ||= library
-      unless testForLibrary( library, nicename )
-        msgs = [ "You are missing the required #{nicename} library.\n" ]
-        msgs << "RAA: #{raaUrl}\n" if raaUrl
-        msgs << "Download: #{downloadUrl}\n" if downloadUrl
-        if fatal
-          abort msgs.join('')
-        else
-          errorMessage msgs.join('')
-        end
-      end
-      return true
-    end
-
-    ### Output <tt>msg</tt> as a ANSI-colored program/section header (white on
-    ### blue).
-    def header( msg )
-      msg.chomp!
-      $stderr.puts ansiCode( 'bold', 'white', 'on_blue' ) + msg + ansiCode( 'reset' )
-      $stderr.flush
-    end
-
-    ### Output <tt>msg</tt> to STDERR and flush it.
-    def message( msg )
-      $stderr.print ansiCode( 'cyan' ) + msg + ansiCode( 'reset' )
-      $stderr.flush
-    end
-
-    ### Output the specified <tt>msg</tt> as an ANSI-colored error message
-    ### (white on red).
-    def errorMessage( msg )
-      message ansiCode( 'bold', 'white', 'on_red' ) + msg + ansiCode( 'reset' )
-    end
-
-    ### Output the specified <tt>msg</tt> as an ANSI-colored debugging message
-    ### (yellow on blue).
-    def debugMsg( msg )
-      return unless $DEBUG
-      msg.chomp!
-      $stderr.puts ansiCode( 'bold', 'yellow', 'on_blue' ) + ">>> #{msg}" + ansiCode( 'reset' )
-      $stderr.flush
-    end
-
-    ### Erase the previous line (if supported by your terminal) and output the
-    ### specified <tt>msg</tt> instead.
-    def replaceMessage( msg )
-      print ErasePreviousLine
-      message( msg )
-    end
-
-    ### Output a divider made up of <tt>length</tt> hyphen characters.
-    def divider( length=75 )
-      puts "\r" + ("-" * length )
-    end
-    alias :writeLine :divider
-
-    ### Output the specified <tt>msg</tt> colored in ANSI red and exit with a
-    ### status of 1.
-    def abort( msg )
-      print ansiCode( 'bold', 'red' ) + "Aborted: " + msg.chomp + ansiCode( 'reset' ) + "\n\n"
-      Kernel.exit!( 1 )
-    end
-
-    ### Output the specified <tt>promptString</tt> as a prompt (in green) and
-    ### return the user's input with leading and trailing spaces removed.
-    def prompt( promptString )
-      promptString.chomp!
-      return readline( ansiCode('bold', 'green') + "#{promptString}: " + ansiCode('reset') ).strip
-    end
-
-    ### Prompt the user with the given <tt>promptString</tt> via #prompt,
-    ### substituting the given <tt>default</tt> if the user doesn't input
-    ### anything.
-    def promptWithDefault( promptString, default )
-      response = prompt( "%s [%s]" % [ promptString, default ] )
-      if response.empty?
-        return default
-      else
-        return response
-      end
-    end
-
-    ### Search for the program specified by the given <tt>progname</tt> in the
-    ### user's <tt>PATH</tt>, and return the full path to it, or <tt>nil</tt> if
-    ### no such program is in the path.
-    def findProgram( progname )
-      ENV['PATH'].split(File::PATH_SEPARATOR).each {|d|
-        file = File.join( d, progname )
-        return file if File.executable?( file )
-      }
-      return nil
-    end
-
-    ### Using the CVS log for the given <tt>file</tt> attempt to guess what the
-    ### next release version might be. This only works if releases are tagged
-    ### with tags like 'RELEASE_x_y'.
-    def extractNextVersionFromTags( file )
-        message "Attempting to extract next release version from CVS tags for #{file}...\n"
-        raise RuntimeError, "No such file '#{file}'" unless File.exists?( file )
-        cvsPath = findProgram( 'cvs' ) or
-            raise RuntimeError, "Cannot find the 'cvs' program. Aborting."
-
-        output = %x{#{cvsPath} log #{file}}
-        release = [ 0, 0 ]
-        output.scan( /RELEASE_(\d+)_(\d+)/ ) {|match|
-            if $1.to_i > release[0] || $2.to_i > release[1]
-                release = [ $1.to_i, $2.to_i ]
-                replaceMessage( "Found %d.%02d...\n" % release )
-            end
-        }
-
-        if release[1] >= 99
-            release[0] += 1
-            release[1] = 1
-        else
-            release[1] += 1
-        end
-
-        return "%d.%02d" % release
-    end
-
-    ### Extract the project name (CVS Repository name) for the given directory.
-    def extractProjectName
-        File.open( "CVS/Repository", "r").readline.chomp
-    end
-
-    ### Read the specified <tt>manifestFile</tt>, which is a text file
-    ### describing which files to package up for a distribution. The manifest
-    ### should consist of one or more lines, each containing one filename or
-    ### shell glob pattern.
-    def readManifest( manifestFile="MANIFEST" )
-        message "Building manifest..."
-        raise "Missing #{manifestFile}, please remake it" unless File.exists? manifestFile
-
-        manifest = IO::readlines( manifestFile ).collect{ |line|
-          line.chomp
-        }.select{ |line|
-          line !~ /^(\s*(#.*)?)?$/
-        }
-
-        filelist = []
-        for pat in manifest
-            $stderr.puts "Adding files that match '#{pat}' to the file list" if $VERBOSE
-            filelist |= Dir.glob( pat ).find_all {|f| FileTest.file?(f)}
-        end
-
-        message "found #{filelist.length} files.\n"
-        return filelist
-    end
-
-    ### Given a <tt>filelist</tt> like that returned by #readManifest, remove
-    ### the entries therein which match the Regexp objects in the given
-    ### <tt>antimanifest</tt> and return the resultant Array.
-    def vetManifest( filelist, antimanifest=ANITMANIFEST )
-        origLength = filelist.length
-        message "Vetting manifest..."
-
-        for regex in antimanifest
-            if $VERBOSE
-                message "\n\tPattern /#{regex.source}/ removed: " +
-                    filelist.find_all {|file| regex.match(file)}.join(', ')
-            end
-            filelist.delete_if {|file| regex.match(file)}
-        end
-
-        message "removed #{origLength - filelist.length} files from the list.\n"
-        return filelist
-    end
-
-    ### Combine a call to #readManifest with one to #vetManifest.
-    def getVettedManifest( manifestFile="MANIFEST", antimanifest=ANTIMANIFEST )
-        vetManifest( readManifest(manifestFile), antimanifest )
-    end
-
-    ### Given a documentation <tt>catalogFile</tt>, which is in the same format
-    ### as that described by #readManifest, read and expand it, and then return
-    ### a list of those files which appear to have RDoc documentation in
-    ### them. If <tt>catalogFile</tt> is nil or does not exist, the MANIFEST
-    ### file is used instead.
-    def findRdocableFiles( catalogFile="docs/CATALOG" )
-        startlist = []
-        if File.exists? catalogFile
-            message "Using CATALOG file (%s).\n" % catalogFile
-            startlist = getVettedManifest( catalogFile )
-        else
-            message "Using default MANIFEST\n"
-            startlist = getVettedManifest()
-        end
-
-        message "Looking for RDoc comments in:\n" if $VERBOSE
-        startlist.select {|fn|
-            message "  #{fn}: " if $VERBOSE
-            found = false
-            File::open( fn, "r" ) {|fh|
-                fh.each {|line|
-                    if line =~ /^(\s*#)?\s*=/ || line =~ /:\w+:/ || line =~ %r{/\*}
-                        found = true
-                        break
-                    end
-                }
-            }
-
-            message( (found ? "yes" : "no") + "\n" ) if $VERBOSE
-            found
-        }
-    end
-
-    ### Open a file and filter each of its lines through the given block a
-    ### <tt>line</tt> at a time. The return value of the block is used as the
-    ### new line, or omitted if the block returns <tt>nil</tt> or
-    ### <tt>false</tt>.
-    def editInPlace( file ) # :yields: line
-        raise "No block specified for editing operation" unless block_given?
-
-        tempName = "#{file}.#{$$}"
-        File::open( tempName, File::RDWR|File::CREAT, 0600 ) {|tempfile|
-            File::unlink( tempName )
-            File::open( file, File::RDONLY ) {|fh|
-                fh.each {|line|
-                    newline = yield( line ) or next
-                    tempfile.print( newline )
-                }
-            }
-
-            tempfile.seek(0)
-
-            File::open( file, File::TRUNC|File::WRONLY, 0644 ) {|newfile|
-                newfile.print( tempfile.read )
-            }
-        }
-    end
-
-    ### Execute the specified shell <tt>command</tt>, read the results, and
-    ### return them. Like a %x{} that returns an Array instead of a String.
-    def shellCommand( *command )
-        raise "Empty command" if command.empty?
-
-        cmdpipe = IO::popen( command.join(' '), 'r' )
-        return cmdpipe.readlines
-    end
-
-    ### Execute a block with $VERBOSE set to +false+, restoring it to its
-    ### previous value before returning.
-    def verboseOff
-        raise LocalJumpError, "No block given" unless block_given?
-
-        thrcrit = Thread.critical
-        oldverbose = $VERBOSE
-        begin
-            Thread.critical = true
-            $VERBOSE = false
-            yield
-        ensure
-            $VERBOSE = oldverbose
-            Thread.critical = false
-        end
-    end
-
-
-    ### Try the specified code block, printing the given 
-    def try( msg, bind=nil )  #:yield:
-      result = nil
-      message "Trying #{msg}..."
-
-      begin
-          rval = nil
-          if block_given?
-              rval = yield
-          else
-              file, line = caller(1)[0].split(/:/,2)
-              rval = eval( msg, bind, file, line.to_i )
-          end
-
-          if $yaml
-              result = rval.to_yaml
-          else
-              result = rval.inspect
-          end
-      rescue Exception => err
-          nicetrace = err.backtrace.delete_if {|frame|
-              /in `(try|eval)'/ =~ frame
-          }.join("\n\t")
-          result = err.message + "\n\t" + nicetrace
-      ensure
-          puts result
-      end
-    end
- 
-   
-  # Run a block, with $VERBOSE set to v.  No other threads will
-  # run while this block is being executed.
-  def verbose_block(v = true, &block)
-    Thread.critical = true
-    tmp = $VERBOSE
-    $VERBOSE = v
-    begin
-      yield
-    ensure
-      $VERBOSE = tmp
-      Thread.critical = false
-    end
-  end
-  
-  # Run a block, with $VERBOSE set to false.  No other threads will
-  # run while this block is being executed.
-  def terse_block(&block)
-    verbose_block(false, &block)
-  end
-  
-
-  # Ensures that the version number of the installed ruby 
-  # is greater than or equal to the version string supplied.
-  # Credit to Robert Klemme for posting this on ruby-talk.
-  #
-  #  ensure_version "1.7.0"
-  #  ensure_version "1.8.0"
-  #  ensure_version "1.8.1"
-  def ensure_version( ver )
-    if ( RUBY_VERSION.split(/\./).map{|x|x.to_i} <=> ver.split(/\./).map{|x|x.to_i} ) < 0
-      throw "Version error: should be #{ver} but is #{RUBY_VERSION}"
-    end
-  end
-
-
-
-  # Adapted from Minero Aoki's rubyloader.rb
-  
-  require 'rbconfig'
-  
-  module RubyLoader
-  
-    ###############
-    module_function
-    ###############
-    
-    def find_feature( feature )
-      with_ext( feature ) do |fname|
-        $LOAD_PATH.each do |dir|
-          path = dir + '/' + fname
-          if File.file? path then
-            return path
-          end
-        end
-      end
-      nil
-    end
-  
-    def provided?( feature )
-      with_ext( feature ) do |fn|
-        $".index fn and return true
-      end
-  
-      false
-    end
-    alias required? provided?
-  
-    def provide( feature )
-      $".push feature
-    end
-  
-    def with_ext( feature )
-      if /\.(?:rb|#{Config::CONFIG['DLEXT']})\z/o === feature then
-        yield feature
-      else
-        [ 'rb', Config::CONFIG['DLEXT'] ].each do |ext|
-          yield feature + '.' + ext
-        end
-      end
-    end
-  
-  end
-
-
-end
-
-
-# --- test ---
-
-if $0 == __FILE__
-
-  p Utils::RubyLoader.find_feature("enumerator")
-  
-end
-