facets 1.7.46 → 1.8.0

data/work/pore/superann.rb

@@ -0,0 +1,134 @@
+#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

@@ -0,0 +1,186 @@
+#!/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

@@ -0,0 +1,518 @@
+=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
+