pluginfactory 1.0.2

data/COPYRIGHT

@@ -0,0 +1,131 @@
+
+
+
+
+			 The "Artistic License"
+
+				Preamble
+
+The intent of this document is to state the conditions under which a
+Package may be copied, such that the Copyright Holder maintains some
+semblance of artistic control over the development of the package,
+while giving the users of the package the right to use and distribute
+the Package in a more-or-less customary fashion, plus the right to make
+reasonable modifications.
+
+Definitions:
+
+	"Package" refers to the collection of files distributed by the
+	Copyright Holder, and derivatives of that collection of files
+	created through textual modification.
+
+	"Standard Version" refers to such a Package if it has not been
+	modified, or has been modified in accordance with the wishes
+	of the Copyright Holder as specified below.
+
+	"Copyright Holder" is whoever is named in the copyright or
+	copyrights for the package.
+
+	"You" is you, if you're thinking about copying or distributing
+	this Package.
+
+	"Reasonable copying fee" is whatever you can justify on the
+	basis of media cost, duplication charges, time of people involved,
+	and so on.  (You will not be required to justify it to the
+	Copyright Holder, but only to the computing community at large
+	as a market that must bear the fee.)
+
+	"Freely Available" means that no fee is charged for the item
+	itself, though there may be fees involved in handling the item.
+	It also means that recipients of the item may redistribute it
+	under the same conditions they received it.
+
+1. You may make and give away verbatim copies of the source form of the
+Standard Version of this Package without restriction, provided that you
+duplicate all of the original copyright notices and associated disclaimers.
+
+2. You may apply bug fixes, portability fixes and other modifications
+derived from the Public Domain or from the Copyright Holder.  A Package
+modified in such a way shall still be considered the Standard Version.
+
+3. You may otherwise modify your copy of this Package in any way, provided
+that you insert a prominent notice in each changed file stating how and
+when you changed that file, and provided that you do at least ONE of the
+following:
+
+    a) place your modifications in the Public Domain or otherwise make them
+    Freely Available, such as by posting said modifications to Usenet or
+    an equivalent medium, or placing the modifications on a major archive
+    site such as uunet.uu.net, or by allowing the Copyright Holder to include
+    your modifications in the Standard Version of the Package.
+
+    b) use the modified Package only within your corporation or organization.
+
+    c) rename any non-standard executables so the names do not conflict
+    with standard executables, which must also be provided, and provide
+    a separate manual page for each non-standard executable that clearly
+    documents how it differs from the Standard Version.
+
+    d) make other distribution arrangements with the Copyright Holder.
+
+4. You may distribute the programs of this Package in object code or
+executable form, provided that you do at least ONE of the following:
+
+    a) distribute a Standard Version of the executables and library files,
+    together with instructions (in the manual page or equivalent) on where
+    to get the Standard Version.
+
+    b) accompany the distribution with the machine-readable source of
+    the Package with your modifications.
+
+    c) give non-standard executables non-standard names, and clearly
+    document the differences in manual pages (or equivalent), together
+    with instructions on where to get the Standard Version.
+
+    d) make other distribution arrangements with the Copyright Holder.
+
+5. You may charge a reasonable copying fee for any distribution of this
+Package.  You may charge any fee you choose for support of this
+Package.  You may not charge a fee for this Package itself.  However,
+you may distribute this Package in aggregate with other (possibly
+commercial) programs as part of a larger (possibly commercial) software
+distribution provided that you do not advertise this Package as a
+product of your own.  You may embed this Package's interpreter within
+an executable of yours (by linking); this shall be construed as a mere
+form of aggregation, provided that the complete Standard Version of the
+interpreter is so embedded.
+
+6. The scripts and library files supplied as input to or produced as
+output from the programs of this Package do not automatically fall
+under the copyright of this Package, but belong to whoever generated
+them, and may be sold commercially, and may be aggregated with this
+Package.  If such scripts or library files are aggregated with this
+Package via the so-called "undump" or "unexec" methods of producing a
+binary executable image, then distribution of such an image shall
+neither be construed as a distribution of this Package nor shall it
+fall under the restrictions of Paragraphs 3 and 4, provided that you do
+not represent such an executable image as a Standard Version of this
+Package.
+
+7. C subroutines (or comparably compiled subroutines in other
+languages) supplied by you and linked into this Package in order to
+emulate subroutines and variables of the language defined by this
+Package shall not be considered part of this Package, but are the
+equivalent of input as in Paragraph 6, provided these subroutines do
+not change the language in any way that would cause it to fail the
+regression tests for the language.
+
+8. Aggregation of this Package with a commercial distribution is always
+permitted provided that the use of this Package is embedded; that is,
+when no overt attempt is made to make this Package's interfaces visible
+to the end user of the commercial distribution.  Such use shall not be
+construed as a distribution of this Package.
+
+9. The name of the Copyright Holder may not be used to endorse or promote
+products derived from this software without specific prior written permission.
+
+10. THIS PACKAGE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR
+IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+
+				The End

data/ChangeLog

@@ -0,0 +1,102 @@
+2004-03-09 22:32  Michael Granger <ged@FaerieMUD.org>
+
+	* makedist.rb (1.1), utils.rb (1.1), docs/.cvsignore (1.1),
+	docs/CATALOG (1.1), docs/makedocs.rb (1.1):
+
+	Initial checkin.
+	
+2004-03-08 00:07  Michael Granger <ged@FaerieMUD.org>
+
+	* tests/: othersub.rb (1.2), dir/deepsubofmybase.rb (1.2):
+
+	- Fixed class/file agreement.
+	
+2004-03-08 00:06  Michael Granger <ged@FaerieMUD.org>
+
+	* tests/mybase.rb (1.2):
+
+	- Fixed derivativeDirs method.
+	
+2004-03-08 00:05  Michael Granger <ged@FaerieMUD.org>
+
+	* lib/pluginfactory.rb (1.4):
+
+	- Documentation additions
+	
+	- Refactored path-search code
+	
+2004-03-07 21:30  Michael Granger <ged@FaerieMUD.org>
+
+	* test.rb (1.3):
+
+	- Added a hook into -d that turns on logging.
+	
+2004-03-07 19:13  Martin Chase <stillflame@FaerieMUD.org>
+
+	* README (1.4):
+
+	no, this is not using the default install.rb installation process
+	
+2004-03-07 19:07  Martin Chase <stillflame@FaerieMUD.org>
+
+	* lib/pluginfactory.rb (1.3):
+
+	FactoryError now inherits from RuntimeError
+	
+2004-03-07 19:06  Martin Chase <stillflame@FaerieMUD.org>
+
+	* test.rb (1.2):
+
+	filling in
+	
+2004-03-07 19:05  Martin Chase <stillflame@FaerieMUD.org>
+
+	* tests/: mybase.rb (1.1), othersub.rb (1.1), subofmybase.rb (1.1),
+	dir/deepsubofmybase.rb (1.1):
+
+	initial import
+	
+2004-03-07 15:42  Martin Chase <stillflame@FaerieMUD.org>
+
+	* README (1.3):
+
+	reformatted
+	
+2004-03-07 15:41  Martin Chase <stillflame@FaerieMUD.org>
+
+	* install.rb (1.2):
+
+	filled in
+	
+2004-03-07 14:36  Martin Chase <stillflame@FaerieMUD.org>
+
+	* COPYRIGHT (1.2), README (1.2):
+
+	filled in
+	
+2004-03-07 10:49  Martin Chase <stillflame@FaerieMUD.org>
+
+	* lib/pluginfactory.rb (1.2):
+
+	cleaned out ties to other modules
+	
+2004-03-07 09:33  Martin Chase <stillflame@FaerieMUD.org>
+
+	* lib/: factory.rb (1.2), pluginfactory.rb (1.1):
+
+	renaming
+	
+2004-03-07 09:31  Martin Chase <stillflame@FaerieMUD.org>
+
+	* COPYRIGHT (1.1), README (1.1), install.rb (1.1), test.rb (1.1),
+	lib/factory.rb (1.1):
+
+	Initial revision
+	
+2004-03-07 09:31  Martin Chase <stillflame@FaerieMUD.org>
+
+	* COPYRIGHT (1.1.1.1), README (1.1.1.1), install.rb (1.1.1.1),
+	test.rb (1.1.1.1), lib/factory.rb (1.1.1.1) (utags: release):
+
+	initial stripping out of Arrow/MUES
+	

data/README

@@ -0,0 +1,39 @@
+= The PluginFactory mixin
+
+A mixin implementing a factory pattern, modified to load in subclasses on
+request.
+
+== Install
+
+$ sudo ./install.rb
+
+== Tests
+
+$ ./test.rb
+
+== Authors
+
+Michael Granger <ged@FaerieMUD.org>
+
+== Contributors
+
+Martin Chase <stillflame@FaerieMUD.org>
+
+== License/Legal
+
+All assets of the project are copyright (c) 2003-2004, The FaerieMUD
+Consortium. All rights reserved.
+
+You may use, modify, and/or redistribute this software under the terms of the
+Perl Artistic License, a copy of which should have been included in this
+distribution (See the file COPYRIGHT). If it was not, a copy of it may be
+obtained from http://language.perl.com/misc/Artistic.html or
+http://www.faeriemud.org/artistic.html).
+
+THIS PACKAGE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES,
+INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND
+FITNESS FOR A PARTICULAR PURPOSE.
+
+== Rcsid
+
+   $Id: README 14 2004-03-08 03:13:38Z stillflame $

data/install.rb

@@ -0,0 +1,172 @@
+#!/usr/bin/ruby
+#
+#	Module Install Script
+#	$Id: install.rb 31 2004-11-21 17:14:13Z ged $
+#
+#	Thanks to Masatoshi SEKI for ideas found in his install.rb.
+#
+#	Copyright (c) 2001-2004 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)
+#
+
+require './utils.rb'
+include UtilityFunctions
+
+require 'rbconfig'
+include Config
+
+require 'find'
+require 'ftools'
+require 'optparse'
+
+$version	= %q$Revision: 31 $
+$rcsId		= %q$Id: install.rb 31 2004-11-21 17:14:13Z ged $
+
+# Define required libraries
+RequiredLibraries = [
+	# libraryname, nice name, RAA URL, Download URL, e.g.,
+	#[ 'strscan', "Strscan", 
+	#	'http://www.ruby-lang.org/en/raa-list.rhtml?name=strscan',
+	#	'http://i.loveruby.net/archive/strscan/strscan-0.6.7.tar.gz',
+	#],
+]
+
+class Installer
+
+	@@PrunePatterns = [
+		/CVS/,
+		/~$/,
+		%r:(^|/)\.:,
+		/\.tpl$/,
+	]
+
+	def initialize( testing=false )
+		@ftools = (testing) ? self : File
+	end
+
+	### Make the specified dirs (which can be a String or an Array of Strings)
+	### with the specified mode.
+	def makedirs( dirs, mode=0755, verbose=false )
+		dirs = [ dirs ] unless dirs.is_a? Array
+
+		oldumask = File::umask
+		File::umask( 0777 - mode )
+
+		for dir in dirs
+			if @ftools == File
+				File::mkpath( dir, $verbose )
+			else
+				$stderr.puts "Make path %s with mode %o" % [ dir, mode ]
+			end
+		end
+
+		File::umask( oldumask )
+	end
+
+	def install( srcfile, dstfile, mode=nil, verbose=false )
+		dstfile = File.catname(srcfile, dstfile)
+		unless FileTest.exist? dstfile and File.cmp srcfile, dstfile
+			$stderr.puts "   install #{srcfile} -> #{dstfile}"
+		else
+			$stderr.puts "   skipping #{dstfile}: unchanged"
+		end
+	end
+
+	public
+
+	def installFiles( src, dstDir, mode=0444, verbose=false )
+		directories = []
+		files = []
+		
+		if File.directory?( src )
+			Find.find( src ) {|f|
+				Find.prune if @@PrunePatterns.find {|pat| f =~ pat}
+				next if f == src
+
+				if FileTest.directory?( f )
+					directories << f.gsub( /^#{src}#{File::Separator}/, '' )
+					next 
+
+				elsif FileTest.file?( f )
+					files << f.gsub( /^#{src}#{File::Separator}/, '' )
+
+				else
+					Find.prune
+				end
+			}
+		else
+			files << File.basename( src )
+			src = File.dirname( src )
+		end
+		
+		dirs = [ dstDir ]
+		dirs |= directories.collect {|d| File.join(dstDir,d)}
+		makedirs( dirs, 0755, verbose )
+		files.each {|f|
+			srcfile = File.join(src,f)
+			dstfile = File.dirname(File.join( dstDir,f ))
+
+			if verbose
+				if mode
+					$stderr.puts "Install #{srcfile} -> #{dstfile} (mode %o)" % mode
+				else
+					$stderr.puts "Install #{srcfile} -> #{dstfile}"
+				end
+			end
+
+			@ftools.install( srcfile, dstfile, mode, verbose )
+		}
+	end
+
+end
+
+
+if $0 == __FILE__
+	for lib in RequiredLibraries
+		testForRequiredLibrary( *lib )
+	end
+
+	dryrun = false
+
+	# Parse command-line switches
+	ARGV.options {|oparser|
+		oparser.banner = "Usage: #$0 [options]\n"
+
+		oparser.on( "--verbose", "-v", TrueClass, "Make progress verbose" ) {
+			$VERBOSE = true
+			debugMsg "Turned verbose on."
+		}
+
+		oparser.on( "--dry-run", "-n", TrueClass, "Don't really install anything" ) {
+			debugMsg "Turned dry-run on."
+			dryrun = true
+		}
+
+		# Handle the 'help' option
+		oparser.on( "--help", "-h", "Display this text." ) {
+			$stderr.puts oparser
+			exit!(0)
+		}
+
+		oparser.parse!
+	}
+
+	debugMsg "Sitelibdir = '#{CONFIG['sitelibdir']}'"
+	sitelibdir = CONFIG['sitelibdir']
+	debugMsg "Sitearchdir = '#{CONFIG['sitearchdir']}'"
+	sitearchdir = CONFIG['sitearchdir']
+
+	message "Installing..."
+	i = Installer.new( dryrun )
+	#i.installFiles( "redist", sitelibdir, 0444, verbose )
+	i.installFiles( "lib", sitelibdir, 0444, $VERBOSE )
+
+	message "done.\n"
+end
+	
+
+
+

data/lib/pluginfactory.rb

@@ -0,0 +1,389 @@
+#!/usr/bin/env ruby -w
+#
+# This module contains the PluginFactory mixin. Including PluginFactory in your
+# class turns it into a factory for its derivatives, capable of searching for
+# and loading them by name. This is useful when you have an abstract base class
+# which defines an interface and basic functionality for a part of a larger
+# system, and a collection of subclasses which implement the interface for
+# different underlying functionality.
+#
+# An example of where this might be useful is in a program which talks to a
+# database. To avoid coupling it to a specific database, you use a Driver class
+# which encapsulates your program's interaction with the database behind a
+# useful interface. Now you can create a concrete implementation of the Driver
+# class for each kind of database you wish to talk to. If you make the base
+# Driver class a PluginFactory, too, you can add new drivers simply by dropping
+# them in a directory and using the Driver's <tt>create</tt> method to
+# instantiate them:
+#
+# == Creation Argument Variants
+#
+# The +create+ class method added to your class by PluginFactory searches for your module using 
+#
+# == Synopsis
+# 
+# in driver.rb:
+# 
+#	require "PluginFactory"
+#
+#	class Driver
+#		include PluginFactory
+#		def self::derivative_dirs
+#		   ["drivers"]
+#		end
+#	end
+# 
+# in drivers/mysql.rb:
+# 
+#	require 'driver'
+#
+#	class MysqlDriver < Driver
+#		...implementation...
+#	end
+# 
+# in /usr/lib/ruby/1.8/PostgresDriver.rb:
+# 
+#	require 'driver'
+#
+#	class PostgresDriver < Driver
+#		...implementation...
+#	end
+# 
+# elsewhere
+# 
+#	require 'driver'
+#
+#	config[:driver_type] #=> "mysql"
+#	driver = Driver.create( config[:driver_type] )
+#	driver.class #=> MysqlDriver
+#	pgdriver = Driver.create( "PostGresDriver" )
+# 
+# == Subversion ID
+# 
+# $Id: pluginfactory.rb 38 2007-03-13 18:20:58Z deveiant $
+# 
+# == Authors
+# 
+# * Martin Chase <stillflame@FaerieMUD.org>
+# * Michael Granger <ged@FaerieMUD.org>
+# 
+#:include: COPYRIGHT
+#
+#---
+#
+# Please see the file docs/COPYRIGHT for licensing details.
+#
+
+
+### An exception class for PluginFactory specific errors.
+class FactoryError < RuntimeError
+	def initialize( *args )
+		if ! args.empty?
+			msg = args.collect {|a| a.to_s}.join
+			super( msg )
+		else
+			super( message )
+		end					
+	end
+end # class FactoryError
+
+
+### A mixin that adds PluginFactory class methods to a base class, so that
+### subclasses may be instantiated by name.
+module PluginFactory
+
+	### A callback for logging the various debug and information this module
+	### has to log.  Should take two arguments, the log level, possibly as a
+	### symbol, and the log message itself.
+	@logger_callback = nil
+	class << self
+		attr_accessor :logger_callback
+	end
+
+	### If the logger callback is set, use it to pass on a log entry.  First argument is 
+	def self::log(level, *msg)
+		@logger_callback.call(level, msg.join) if @logger_callback
+	end
+
+
+	### Inclusion callback -- extends the including class.
+	def self::included( klass )
+		klass.extend( self )
+	end
+
+
+	### Raise an exception if the object being extended is anything but a
+	### class.
+	def self::extend_object( obj )
+		unless obj.is_a?( Class )
+			raise TypeError, "Cannot extend a #{obj.class.name}", caller(1)
+		end
+		obj.instance_variable_set( :@derivatives, {} )
+		super
+	end
+
+
+	#############################################################
+	###	M I X I N   M E T H O D S
+	#############################################################
+
+	### Return the Hash of derivative classes, keyed by various versions of
+	### the class name.
+	def derivatives
+		ancestors.each {|klass|
+			if klass.instance_variables.include?( "@derivatives" )
+				break klass.instance_variable_get( :@derivatives )
+			end
+		}
+	end
+
+
+	### Returns the type name used when searching for a derivative.
+	def factory_type
+		base = nil
+		self.ancestors.each {|klass|
+			if klass.instance_variables.include?( "@derivatives" )
+				base = klass
+				break
+			end
+		}
+
+		raise FactoryError, "Couldn't find factory base for #{self.name}" if
+			base.nil?
+
+		if base.name =~ /^.*::(.*)/
+			return $1
+		else
+			return base.name
+		end
+	end
+	alias_method :factoryType, :factory_type
+
+	
+	### Inheritance callback -- Register subclasses in the derivatives hash
+	### so that ::create knows about them.
+	def inherited( subclass )
+		keys = [ subclass.name, subclass.name.downcase, subclass ]
+
+		# Handle class names like 'FooBar' for 'Bar' factories.
+		if subclass.name.match( /(?:.*::)?(\w+)(?:#{self.factory_type})/i )
+			keys << Regexp.last_match[1].downcase
+		else
+			keys << subclass.name.sub( /.*::/, '' ).downcase
+		end
+
+		keys.uniq.each {|key|
+			#PluginFactory::log :info, "Registering %s derivative of %s as %p" %
+			#	[ subclass.name, self.name, key ]
+			self.derivatives[ key ] = subclass
+		}
+		super
+	end
+
+
+	### Returns an Array of registered derivatives
+	def derivative_classes
+		self.derivatives.values.uniq
+	end
+	alias_method :derivativeClasses, :derivative_classes
+
+
+	### Given the <tt>className</tt> of the class to instantiate, and other
+	### arguments bound for the constructor of the new object, this method
+	### loads the derivative class if it is not loaded already (raising a
+	### LoadError if an appropriately-named file cannot be found), and
+	### instantiates it with the given <tt>args</tt>. The <tt>className</tt>
+	### may be the the fully qualified name of the class, the class object
+	### itself, or the unique part of the class name. The following examples
+	### would all try to load and instantiate a class called "FooListener"
+	### if Listener included Factory
+	###   obj = Listener::create( 'FooListener' )
+	###   obj = Listener::create( FooListener )
+	###   obj = Listener::create( 'Foo' )
+	def create( subType, *args, &block )
+		subclass = get_subclass( subType )
+
+		return subclass.new( *args, &block )
+	rescue => err
+		nicetrace = err.backtrace.reject {|frame| /#{__FILE__}/ =~ frame}
+		msg = "When creating '#{subType}': " + err.message
+		Kernel::raise( err.class, msg, nicetrace )
+	end
+
+
+	### Given a <tt>className</tt> like that of the first argument to
+	### #create, attempt to load the corresponding class if it is not
+	### already loaded and return the class object.
+	def get_subclass( className )
+		return self if ( self.name == className || className == '' )
+		return className if className.is_a?( Class ) && className >= self
+
+		unless self.derivatives.has_key?( className.downcase )
+			self.load_derivative( className )
+
+			unless self.derivatives.has_key?( className.downcase )
+				raise FactoryError,
+					"load_derivative(%s) didn't add a '%s' key to the "\
+					"registry for %s" %
+					[ className, className.downcase, self.name ]
+			end
+
+			subclass = self.derivatives[ className.downcase ]
+			unless subclass.is_a?( Class )
+				raise FactoryError,
+					"load_derivative(%s) added something other than a class "\
+					"to the registry for %s: %p" %
+					[ className, self.name, subclass ]
+			end
+		end
+
+		return self.derivatives[ className.downcase ]
+	end
+	alias_method :getSubclass, :get_subclass
+	
+
+	### Calculates an appropriate filename for the derived class using the
+	### name of the base class and tries to load it via <tt>require</tt>. If
+	### the including class responds to a method named
+	### <tt>derivativeDirs</tt>, its return value (either a String, or an
+	### array of Strings) is added to the list of prefix directories to try
+	### when attempting to require a modules. Eg., if
+	### <tt>class.derivativeDirs</tt> returns <tt>['foo','bar']</tt> the
+	### require line is tried with both <tt>'foo/'</tt> and <tt>'bar/'</tt>
+	### prepended to it.
+	def load_derivative( className )
+		className = className.to_s
+
+		#PluginFactory::log :debug, "Loading derivative #{className}"
+
+		# Get the unique part of the derived class name and try to
+		# load it from one of the derivative subdirs, if there are
+		# any.
+		mod_name = self.get_module_name( className )
+		self.require_derivative( mod_name )
+
+		# Check to see if the specified listener is now loaded. If it
+		# is not, raise an error to that effect.
+		unless self.derivatives[ className.downcase ]
+			raise FactoryError,
+				"Couldn't find a %s named '%s'. Loaded derivatives are: %p" % [
+				self.factory_type,
+				className.downcase,
+				self.derivatives.keys,
+			], caller(3)
+		end
+
+		return true
+	end
+	alias_method :loadDerivative, :load_derivative
+
+
+	### Build and return the unique part of the given <tt>className</tt>
+	### either by stripping leading namespaces if the name already has the
+	### name of the factory type in it (eg., 'My::FooService' for Service,
+	### or by appending the factory type if it doesn't.
+	def get_module_name( className )
+		if className =~ /\w+#{self.factory_type}/
+			mod_name = className.sub( /(?:.*::)?(\w+)(?:#{self.factory_type})/, "\\1" )
+		else
+			mod_name = className
+		end
+
+		return mod_name
+	end
+	alias_method :getModuleName, :get_module_name
+
+
+	### If the factory responds to the #derivativeDirs method, call
+	### it and use the returned array as a list of directories to
+	### search for the module with the specified <tt>mod_name</tt>.
+	def require_derivative( mod_name )
+
+		# See if we have a list of special subdirs that derivatives
+		# live in
+		if ( self.respond_to?(:derivative_dirs) )
+			subdirs = self.derivative_dirs
+
+		elsif ( self.respond_to?(:derivativeDirs) )
+			subdirs = self.derivativeDirs
+
+		# If not, just try requiring it from $LOAD_PATH
+		else
+			subdirs = ['']
+		end
+
+		subdirs = [ subdirs ] unless subdirs.is_a?( Array )
+		PluginFactory::log :debug, "Subdirs are: %p" % [subdirs]
+		fatals = []
+
+		# Iterate over the subdirs until we successfully require a
+		# module.
+		catch( :found ) {
+			subdirs.collect {|dir| dir.strip}.each do |subdir|
+				self.make_require_path( mod_name, subdir ).each {|path|
+					PluginFactory::log :debug, "Trying #{path}..."
+
+					# Try to require the module, saving errors and jumping
+					# out of the catch block on success.
+					begin
+						require( path.untaint )
+					rescue LoadError => err
+						PluginFactory::log :debug,
+							"No module at '%s', trying the next alternative: '%s'" %
+							[ path, err.message ]
+					rescue ScriptError,StandardError => err
+						fatals << err
+						PluginFactory::log :error,
+							"Found '#{path}', but encountered an error: %s\n\t%s" %
+							[ err.message, err.backtrace.join("\n\t") ]
+					else
+						#PluginFactory::log :debug, 
+						#	"Found '#{path}'. Throwing :found"
+						throw :found
+					end
+				}
+			end
+
+			#PluginFactory::log :debug, "fatals = %p" % [ fatals ]
+
+			# Re-raise is there was a file found, but it didn't load for
+			# some reason.
+			if ! fatals.empty?
+				#PluginFactory::log :debug, "Re-raising first fatal error"
+				Kernel::raise( fatals.first )
+			end
+
+			nil
+		}
+	end
+	alias_method :requireDerivative, :require_derivative
+
+
+	### Make a list of permutations of the given +modname+ for the given
+	### +subdir+. Called on a +DataDriver+ class with the arguments 'Socket' and
+	### 'drivers', returns:
+	###   ["drivers/socketdatadriver", "drivers/socketDataDriver",
+	###    "drivers/SocketDataDriver", "drivers/socket", "drivers/Socket"]
+	def make_require_path( modname, subdir )
+		path = []
+		myname = self.factory_type
+
+		# Make permutations of the two parts
+		path << modname
+		path << modname.downcase
+		path << modname			 + myname
+		path << modname.downcase + myname
+		path << modname.downcase + myname.downcase
+
+		# If a non-empty subdir was given, prepend it to all the items in the
+		# path
+		unless subdir.nil? or subdir.empty?
+			path.collect! {|m| File::join(subdir, m)}
+		end
+
+		PluginFactory::log :debug, "Path is: #{path.uniq.reverse.inspect}..."
+		return path.uniq.reverse
+	end
+	alias_method :makeRequirePath, :make_require_path
+
+end # module Factory