lafcadio 0.6.0 → 0.6.1

data/lib/lafcadio.rb

@@ -16,7 +16,7 @@
 # http://lafcadio.rubyforge.org/tutorial.html.
 
 module Lafcadio
-	Version = "0.6.0"
+	Version = "0.6.1"
 
 	require 'lafcadio/dateTime'
 	require 'lafcadio/depend'
@@ -26,6 +26,5 @@ module Lafcadio
 	require 'lafcadio/objectStore'
 	require 'lafcadio/query'
 	require 'lafcadio/schema'
-	require 'lafcadio/test'
 	require 'lafcadio/util'
 end

data/lib/lafcadio.rb~

@@ -16,7 +16,7 @@
 # http://lafcadio.rubyforge.org/tutorial.html.
 
 module Lafcadio
-	Version = "0.5.2"
+	Version = "0.6.0"
 
 	require 'lafcadio/dateTime'
 	require 'lafcadio/depend'
@@ -26,6 +26,5 @@ module Lafcadio
 	require 'lafcadio/objectStore'
 	require 'lafcadio/query'
 	require 'lafcadio/schema'
-	require 'lafcadio/test'
 	require 'lafcadio/util'
 end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.8.1
 specification_version: 1
 name: lafcadio
 version: !ruby/object:Gem::Version 
-  version: 0.6.0
-date: 2005-01-02
+  version: 0.6.1
+date: 2005-01-20
 summary: Lafcadio is an object-relational mapping layer
 require_paths: 
   - lib
@@ -36,7 +36,6 @@ files:
   - lib/lafcadio/dateTime.rb
   - lib/lafcadio/depend.rb
   - lib/lafcadio/domain.rb
-  - lib/lafcadio/domain.rb~
   - lib/lafcadio/mock.rb
   - lib/lafcadio/objectField.rb
   - lib/lafcadio/objectStore.rb
@@ -45,9 +44,7 @@ files:
   - lib/lafcadio/test
   - lib/lafcadio/test.rb
   - lib/lafcadio/util.rb
-  - lib/lafcadio/util.rb~
   - lib/lafcadio/test/testconfig.dat
-  - lib/lafcadio/test/testconfig.dat~
 test_files: []
 rdoc_options: []
 extra_rdoc_files: []

data/lib/lafcadio/domain.rb~

@@ -1,641 +0,0 @@
-require 'lafcadio/objectField'
-require 'lafcadio/util'
-require 'rexml/document'
-
-module Lafcadio
-	class ClassDefinitionXmlParser # :nodoc: all
-		def initialize( domain_class, xml )
-			@domain_class = domain_class
-			@xmlDocRoot = REXML::Document.new( xml ).root
-			@namesProcessed = {}
-		end
-		
-		def get_class_field( fieldElt )
-			className = fieldElt.attributes['class'].to_s
-			name = fieldElt.attributes['name']
-			if className != ''
-				fieldClass = Class.by_name( 'Lafcadio::' + className )
-				register_name( name )
-				field = fieldClass.instantiate_from_xml( @domain_class, fieldElt )
-				set_field_attributes( field, fieldElt )
-			else
-				msg = "Couldn't find field class '#{ className }' for field " +
-				      "'#{ name }'"
-				raise( MissingError, msg, caller )
-			end
-			field
-		end
-
-		def get_class_fields
-			namesProcessed = {}
-			pk_field = PrimaryKeyField.new( @domain_class )
-			if ( spkn = @xmlDocRoot.attributes['sql_primary_key_name'] )
-				pk_field.db_field_name = spkn
-			end
-			fields = [ pk_field ]
-			@xmlDocRoot.elements.each('field') { |fieldElt|
-				fields << get_class_field( fieldElt )
-			}
-			fields
-		end
-		
-		def possible_field_attributes
-			fieldAttr = []
-			fieldAttr << FieldAttribute.new( 'size', FieldAttribute::INTEGER )
-			fieldAttr << FieldAttribute.new( 'unique', FieldAttribute::BOOLEAN )
-			fieldAttr << FieldAttribute.new( 'not_null', FieldAttribute::BOOLEAN )
-			fieldAttr << FieldAttribute.new( 'enum_type', FieldAttribute::ENUM,
-																			 BooleanField )
-			fieldAttr << FieldAttribute.new( 'enums', FieldAttribute::HASH )
-			fieldAttr << FieldAttribute.new( 'range', FieldAttribute::ENUM,
-																			 DateField )
-			fieldAttr << FieldAttribute.new( 'large', FieldAttribute::BOOLEAN )
-		end
-
-		def register_name( name )
-			raise InvalidDataError if @namesProcessed[name]
-			@namesProcessed[name] = true
-		end
-		
-		def set_field_attributes( field, fieldElt )
-			possible_field_attributes.each { |fieldAttr|
-				fieldAttr.maybe_set_field_attr( field, fieldElt )
-			}
-		end
-
-		def table_name
-			@xmlDocRoot.attributes['table_name']
-		end
-		
-		class FieldAttribute
-			INTEGER = 1
-			BOOLEAN = 2
-			ENUM    = 3
-			HASH    = 4
-			
-			attr_reader :name, :value_class
-		
-			def initialize( name, value_class, objectFieldClass = nil )
-				@name = name; @value_class = value_class
-				@objectFieldClass = objectFieldClass
-			end
-			
-			def maybe_set_field_attr( field, fieldElt )
-				setterMethod = "#{ name }="
-				if field.respond_to?( setterMethod )
-					if value_class != FieldAttribute::HASH
-						if ( attrStr = fieldElt.attributes[name] )
-							field.send( setterMethod, value_from_string( attrStr ) )
-						end
-					else
-						if ( attrElt = fieldElt.elements[name] )
-							field.send( setterMethod, value_from_elt( attrElt ) )
-						end
-					end
-				end
-			end
-
-			def value_from_elt( elt )
-				hash = {}
-				elt.elements.each( English.singular( @name ) ) { |subElt|
-					key = subElt.attributes['key'] == 'true'
-					value = subElt.text.to_s
-					hash[key] = value
-				}
-				hash
-			end
-			
-			def value_from_string( valueStr )
-				if @value_class == INTEGER
-					valueStr.to_i
-				elsif @value_class == BOOLEAN
-					valueStr == 'y'
-				elsif @value_class == ENUM
-					eval "#{ @objectFieldClass.name }::#{ valueStr }"
-				end
-			end
-		end
-
-		class InvalidDataError < ArgumentError; end
-	end
-
-	module DomainComparable
-		include Comparable
-
-		# A DomainObject or DomainObjectProxy is compared by +domain_class+ and by
-		# +pk_id+. 
-		def <=>(anOther)
-			if anOther.respond_to?( 'domain_class' )
-				if self.domain_class == anOther.domain_class
-					self.pk_id <=> anOther.pk_id
-				else
-					self.domain_class.name <=> anOther.domain_class.name
-				end
-			else
-				nil
-			end
-		end
-		
-		def eql?(otherObj)
-			self == otherObj
-		end
-
-		def hash; "#{ self.class.name } #{ pk_id }".hash; end
-	end
-
-	# All classes that correspond to a table in the database need to be children 
-	# of DomainObject.
-	#
-	# = Defining fields
-	# There are two ways to define the fields of a DomainObject subclass.
-	# 1. Defining fields in an XML file. To do this,
-	#    1. Set one directory to contain all your XML files, by setting
-	#       +classDefinitionDir+ in your LafcadioConfig file.
-	#    2. Write one XML file per domain class. For example, a User.xml file
-	#       might look like:
-	#         <lafcadio_class_definition name="User">
-	#           <field name="lastName" class="TextField"/>
-	#           <field name="email" class="TextField"/>
-	#           <field name="password" class="TextField"/>
-	#           <field name="birthday" class="DateField"/>
-	#         </lafcadio_class_definition>
-	# 2. Overriding DomainObject.get_class_fields. The method should return an Array
-	#    of instances of ObjectField or its children. The order is unimportant.
-	#    For example:
-	#      class User < DomainObject 
-	#        def User.get_class_fields 
-	#          fields = [] 
-	#          fields << TextField.new(self, 'firstName') 
-	#          fields << TextField.new(self, 'lastName') 
-	#          fields << TextField.new(self, 'email') 
-	#          fields << TextField.new(self, 'password') 
-	#          fields << DateField.new(self, 'birthday') 
-	#          fields 
-	#        end 
-	#      end
-	#
-	# = Setting and retrieving fields
-	# Once your fields are defined, you can create an instance by passing in a
-	# hash of field names and values.
-	#   john = User.new( 'firstName' => 'John', 'lastName' => 'Doe',
-	#                    'email' => 'john.doe@email.com',
-	#                    'password' => 'my_password',
-	#                    'birthday' => tenYearsAgo )
-	#
-	# You can read and write these fields like normal instance attributes.
-	#   john.email => 'john.doe@email.com'
-	#   john.email = 'john.doe@mail.email.com'
-	#
-	# If your domain class has fields that refer to other domain classes, or even
-	# to another row in the same table, you can use a LinkField to express the
-	# relation.
-	#   <lafcadio_class_definition name="Message">
-	#     <field name="subject" class="TextField" />
-	#     <field name="body" class="TextField" />
-	#     <field name="author" class="LinkField" linked_type="User" />
-	#     <field name="recipient" class="LinkField" linked_type="User" />
-	#     <field name="dateSent" class="DateField" />
-	#   </lafcadio_class_definition>
- 	#
- 	#   msg = Message.new( 'subject' => 'hi there',
- 	#                      'body' => 'You wanna go to the movies on Saturday?',
- 	#                      'author' => john, 'recipient' => jane,
- 	#                      'dateSent' => Date.today )
-	#
-	# = pk_id and committing
-	# Lafcadio requires that each table has a numeric primary key. It assumes that
-	# this key is named +pk_id+ in the database, though that can be overridden.
-	#
-	# When you create a domain object by calling new, you should not assign a
-	# +pk_id+ to the new instance. The pk_id will automatically be set when you
-	# commit the object by calling DomainObject#commit.
-	#
-	# However, you may want to manually set +pk_id+ when setting up a test case, so
-	# you can ensure that a domain object has a given primary key.
-	#
-	# = Naming assumptions, and how to override them
-	# By default, Lafcadio assumes that every domain object is indexed by the
-	# field +pk_id+ in the database schema. If you're dealing with a table that 
-	# uses a different field name, override DomainObject.sql_primary_key_name.
-	# However, you will always use +pk_id+ in your Ruby code.
-	#
-	# Lafcadio assumes that a domain class corresponds to a table whose name is 
-	# the plural of the class name, and whose first letter is lowercase. A User 
-	# class is assumed to be stored in a "users" table, while a ProductCategory 
-	# class is assumed to be stored in a "productCategories" table. Override
-	# DomainObject.table_name to override this behavior.
-	#
-	# = Inheritance
-	# Domain classes can inherit from other domain classes; they have all the 
-	# fields of any concrete superclasses plus any new fields defined for 
-	# themselves. You can use normal inheritance to define this:
-	#   class User < DomainObject
-	#     ...
-	#   end
-	#
-	#   class Administrator < User
-	#     ...
-	#   end
-	#
-	# Lafcadio assumes that each concrete class has a corresponding table, and
-	# that each table has a +pk_id+ field that is used to match rows between
-	# different levels.
-	class DomainObject
-		@@subclassHash = {}
-		@@class_fields = {}
-		@@pk_fields =
-			Hash.new { |hash, key|
-				pk_field = PrimaryKeyField.new( key )
-				pk_field.db_field_name = @@sql_primary_keys[key]
-				hash[key] = pk_field
-			}
-		@@sql_primary_keys = Hash.new( 'pk_id' )
-
-		COMMIT_ADD = 1
-		COMMIT_EDIT = 2
-		COMMIT_DELETE = 3
-
-		include DomainComparable
-		
-		def self.abstract_subclasses #:nodoc:
-			require 'lafcadio/domain'
-			[ MapObject ]
-		end
-
-		# Returns an array of all fields defined for this class and all concrete
-		# superclasses.
-		def self.all_fields
-			all_fields = []
-			self_and_concrete_superclasses.each { |aClass|
-				aClass.class_fields.each { |field| all_fields << field }
-			}
-			all_fields
-		end
-
-		def self.class_fields #:nodoc:
-			class_fields = @@class_fields[self]
-			unless class_fields
-				@@class_fields[self] = self.get_class_fields
-				class_fields = @@class_fields[self]
-			end
-			class_fields
-		end
-
-		def self.create_field( field_class, name, att_hash )
-			class_fields = @@class_fields[self]
-			if class_fields.nil?
-				class_fields = [ @@pk_fields[self] ]
-				@@class_fields[self] = class_fields
-			end
-			att_hash['name'] = name
-			field = field_class.instantiate_with_parameters( self, att_hash )
-			att_hash.each { |field_name, value|
-				setter = field_name + '='
-				field.send( setter, value ) if field.respond_to?( setter )
-			}
-			class_fields << field
-		end
-		
-		def self.dependent_classes #:nodoc:
-			dependent_classes = {}
-			DomainObject.subclasses.each { |aClass|
-				if aClass != DomainObjectProxy &&
-						(!DomainObject.abstract_subclasses.index(aClass))
-					aClass.class_fields.each { |field|
-						if ( field.is_a?( LinkField ) &&
-						     field.linked_type == self.domain_class )
-							dependent_classes[aClass] = field
-						end
-					}
-				end
-			}
-			dependent_classes
-		end
-
-		def self.get_class_field(fieldName) #:nodoc:
-			field = nil
-			self.class_fields.each { |aField|
-				field = aField if aField.name == fieldName
-			}
-			field
-		end
-		
-		def DomainObject.get_class_field_by_db_name( fieldName ) #:nodoc:
-			self.class_fields.find { |field| field.db_field_name == fieldName }
-		end
-
-		# Returns an Array of ObjectField instances for this domain class, parsing
-		# them from XML if necessary.
-		def self.get_class_fields
-			if self.methods( false ).include?( 'get_class_fields' )
-				[ @@pk_fields[ self ] ]
-			else
-				xmlParser = try_load_xml_parser
-				if xmlParser
-					xmlParser.get_class_fields
-				else
-					error_msg = "Couldn't find either an XML class description file " +
-											"or get_class_fields method for " + self.name
-					raise MissingError, error_msg, caller
-				end
-			end
-		end
-
-		def self.get_domain_dirs #:nodoc:
-			config = LafcadioConfig.new
-			classPath = config['classpath']
-			domainDirStr = config['domainDirs']
-			if domainDirStr
-				domainDirs = domainDirStr.split(',')
-			else
-				domainDirs = [ classPath + 'domain/' ]
-			end
-		end
-		
-		def self.get_field( fieldName ) #:nodoc:
-			aDomainClass = self
-			field = nil
-			while aDomainClass < DomainObject && !field
-				field = aDomainClass.get_class_field( fieldName )
-				aDomainClass = aDomainClass.superclass
-			end
-			if field
-				field
-			else
-				errStr = "Couldn't find field \"#{ field }\" in " +
-								 "#{ self } domain class"
-				raise( MissingError, errStr, caller )
-			end
-		end
-
-		def self.get_domain_class_from_string(typeString) #:nodoc:
-			domain_class = nil
-			require_domain_file( typeString )
-			subclasses.each { |subclass|
-				domain_class = subclass if subclass.to_s == typeString
-			}
-			if domain_class
-				domain_class
-			else
-				raise CouldntMatchDomainClassError,
-						"couldn't match domain_class #{typeString}", caller
-			end
-		end
-		
-		def self.inherited(subclass) #:nodoc:
-			@@subclassHash[subclass] = true
-		end
-		
-		def self.is_based_on? #:nodoc:
-		  self.superclass.is_concrete?
-		end
-
-		def self.is_concrete? #:nodoc:
-		  (self != DomainObject && abstract_subclasses.index(self).nil?)
-		end
-		
-		def self.method_missing( methodId, *args ) #:nodoc:
-			method_name = methodId.id2name
-			maybe_field_class_name = ( method_name.gsub( /^(.)/ ) { $&.upcase } ) +
-			                         'Field'
-			field_class = Lafcadio.const_get( maybe_field_class_name )
-			create_field( field_class, args[0], args[1] || {} )
-		end
-
-		def self.domain_class #:nodoc:
-			self
-		end
-
-		def self.require_domain_file( typeString )
-			typeString =~ /([^\:]*)$/
-			fileName = $1
-			get_domain_dirs.each { |domainDir|
-				if Dir.entries(domainDir).index("#{fileName}.rb")
-					require "#{ domainDir }#{ fileName }"
-				end
-			}
-			if (domainFilesStr = LafcadioConfig.new['domainFiles'])
-				domainFilesStr.split(',').each { |domainFile|
-					require domainFile
-				}
-			end
-		end
-
-		def self.self_and_concrete_superclasses # :nodoc:
-			classes = [ ]
-			a_domain_class = self
-			until( a_domain_class == DomainObject ||
-					   abstract_subclasses.index( a_domain_class ) != nil )
-				classes << a_domain_class
-				a_domain_class = a_domain_class.superclass
-			end
-			classes
-		end
-
-		def self.singleton_method_added( symbol )
-			if symbol.id2name == 'sql_primary_key_name' && self < DomainObject
-				begin
-					get_field( 'pk_id' ).db_field_name = self.send( symbol )
-				rescue NameError
-					@@sql_primary_keys[self] = self.send( symbol )
-				end
-			end
-		end
-		
-		# Returns the name of the primary key in the database, retrieving it from
-		# the class definition XML if necessary.
-		def self.sql_primary_key_name( set_sql_primary_key_name = nil )
-			if set_sql_primary_key_name
-				get_field( 'pk_id' ).db_field_name = set_sql_primary_key_name
-			end
-			get_field( 'pk_id' ).db_field_name
-		end
-
-		def self.subclasses #:nodoc:
-			@@subclassHash.keys
-		end
-
-		# Returns the table name, which is assumed to be the domain class name 
-		# pluralized, and with the first letter lowercase. A User class is
-		# assumed to be stored in a "users" table, while a ProductCategory class is
-		# assumed to be stored in a "productCategories" table.
-		def self.table_name( set_table_name = nil )
-			if set_table_name
-				@table_name = set_table_name
-			elsif @table_name
-				@table_name
-			else
-				xmlParser = try_load_xml_parser
-				if (!xmlParser.nil? && table_name = xmlParser.table_name)
-					table_name
-				else
-					table_name = self.basename
-					table_name[0] = table_name[0..0].downcase
-					English.plural table_name
-				end
-			end
-		end
-
-		def self.try_load_xml_parser
-			require 'lafcadio/domain'
-			dirName = LafcadioConfig.new['classDefinitionDir']
-			xmlFileName = self.basename + '.xml'
-			xmlPath = File.join( dirName, xmlFileName )
-			xml = ''
-			begin
-				File.open( xmlPath ) { |file| xml = file.readlines.join }
-				ClassDefinitionXmlParser.new( self, xml )
-			rescue Errno::ENOENT
-				# no xml file, so no @xmlParser
-			end
-		end
-		
-		attr_accessor :error_messages, :last_commit, :fields, :fields_set
-		attr_reader :delete
-		protected :fields, :fields_set
-
-		# fieldHash should contain key-value associations for the different
-		# fields of this domain class. For example, instantiating a User class 
-		# might look like:
-		#
-		#   User.new( 'firstNames' => 'John', 'lastName' => 'Doe',
-		#             'email' => 'john.doe@email.com', 'password' => 'l33t' )
-		#
-		# In normal usage any code you write that creates a domain object will not
-		# define the +pk_id+ field. The system assumes that a domain object with an
-		# undefined +pk_id+ has yet to be inserted into the database, and when you
-		# commit the domain object a +pk_id+ will automatically be assigned.
-		#
-		# If you're creating mock objects for unit tests, you can explicitly set 
-		# the +pk_id+ to represent objects that already exist in the database.
-		def initialize(fieldHash)
-			@fieldHash = fieldHash
-			@error_messages = []
-			@fields = {}
-			@fields_set = []
-			check_fields = LafcadioConfig.new()['checkFields']
-			verify if %w( onInstantiate onAllStates ).include?( check_fields )
-		end
-		
-		# Returns a clone, with all of the fields copied.
-		def clone
-			copy = super
-			copy.fields = @fields.clone
-			copy.fields_set = @fields_set.clone
-			copy
-		end
-		
-		# Commits this domain object to the database.
-		def commit
-			ObjectStore.get_object_store.commit self
-		end
-
-		# Set the delete value to true if you want this domain object to be deleted
-		# from the database during its next commit.
-		def delete=(value)
-			if value && !pk_id
-				raise "No point deleting an object that's not already in the DB"
-			end
-			@delete = value
-		end
-
-		def get_field( field ) #:nodoc:
-			unless @fields_set.include?( field )
-				set_field( field, @fieldHash[field.name] )
-			end
-			@fields[field.name]
-		end
-		
-		def get_getter_field( methId ) #:nodoc:
-			begin
-				self.class.get_field( methId.id2name )
-			rescue MissingError
-				nil
-			end
-		end
-
-		def get_setter_field( methId ) #:nodoc:
-			if methId.id2name =~ /(.*)=$/
-				begin
-					self.class.get_field( $1 )
-				rescue MissingError
-					nil
-				end
-			else
-				nil
-			end
-		end
-		
-		def method_missing( methId, *args ) #:nodoc:
-			if ( field = get_setter_field( methId ) )
-				set_field( field, args.first )
-			elsif ( field = get_getter_field( methId ) )
-				get_field( field )
-			elsif ( methId.to_s =~ /^get_/ and
-			        ObjectStore.get_object_store.respond_to?( methId ) )
-				args = [ self ].concat( args )
-				ObjectStore.get_object_store.send( methId, *args )
-			else
-				super( methId, *args )
-			end
-		end
-
-		# Returns the subclass of DomainObject that this instance represents.
-		# Because of the way that proxying works, clients should call this method
-		# instead of Object.class.
-		def domain_class
-			self.class.domain_class
-		end
-
-		# This template method is called before every commit. Subclasses can 
-		# override it to ensure code is executed before a commit.
-		def pre_commit_trigger
-			nil
-		end
-
-		# This template method is called after every commit. Subclasses can 
-		# override it to ensure code is executed after a commit.
-		def post_commit_trigger
-			nil
-		end
-
-		def set_field( field, value ) #:nodoc:
-			if field.class <= LinkField
-				if value.class != DomainObjectProxy && value
-					value = DomainObjectProxy.new(value)
-				end
-			end
-			if ( LafcadioConfig.new()['checkFields'] == 'onAllStates' &&
-			     !field.instance_of?( PrimaryKeyField ) )
-				field.verify( value, pk_id )
-			end
-			@fields[field.name] = value
-			@fields_set << field
-		end
-		
-		def verify
-			self.class.get_class_fields.each { |field|
-				field.verify( self.send( field.name ), self.pk_id )
-			}
-		end
-	end
-
-	# Any domain class that is used mostly to map between two other domain 
-	# classes should be a subclass of MapObject. Subclasses of MapObject should 
-	# override MapObject.mappedTypes, returning a two-element array containing 
-	# the domain classes that the map object maps between.
-	class MapObject < DomainObject
-		def self.other_mapped_type(firstType) #:nodoc:
-			types = mappedTypes
-			if types.index(firstType) == 0
-				types[1]
-			else
-				types[0]
-			end
-		end
-
-		def self.subsidiary_map #:nodoc:
-			nil
-		end
-	end
-end

data/lib/lafcadio/test/testconfig.dat~

@@ -1,13 +0,0 @@
-dbuser:test
-dbpassword:password
-dbname:test
-dbhost:localhost
-adminEmail:john.doe@email.com
-siteName:Site Name
-url:http://test.url
-classpath:lafcadio/
-logdir:../test/testOutput/
-domainDirs:../test/mock/domain/
-domainFiles:../test/mock/domain.rb
-logSql:n
-classDefinitionDir:../test/testData

data/lib/lafcadio/util.rb~

@@ -1,379 +0,0 @@
-require 'delegate'
-require 'singleton'
-
-module Lafcadio
-	# The Context is a singleton object that manages ContextualServices. Each 
-	# ContextualService is a service that connects in some way to external 
-	# resources: ObjectStore connects to the database; Emailer connects to SMTP, 
-	# etc.
-	#
-	# Context makes it easy to ensure that each ContextualService is only 
-	# instantiated once, which can be quite useful for services with expensive 
-	# creation.
-	#
-	# Furthermore, Context allows you to explicitly set instances for a given 
-	# service, which can be quite useful in testing. For example, once 
-	# LafcadioTestCase#setup has an instance of MockObjectStore, it calls 
-	#   context.setObjectStore @mockObjectStore
-	# which ensures that any future calls to ObjectStore.getObjectStore will 
-	# return @mockObjectStore, instead of an instance of ObjectStore connecting 
-	# test code to a live database.
-	class Context
-		include Singleton
-
-		def initialize
-			@resources = {}
-			@init_procs = {}
-		end
-		
-		def create_instance( service_class ) #:nodoc:
-			if ( proc = @init_procs[service_class] )
-				proc.call
-			else
-				service_class.new
-			end
-		end
-		
-		# Flushes all cached ContextualServices.
-		def flush
-			@resources = {}
-		end
-
-		def get_resource( service_class ) #:nodoc:
-			resource = @resources[service_class]
-			unless resource
-				resource = create_instance( service_class )
-				set_resource service_class, resource
-			end
-			resource
-		end
-		
-		def set_init_proc( service_class, proc )
-			@init_procs[service_class] = proc
-		end
-		
-		def set_resource(service_class, resource) #:nodoc:
-			@resources[service_class] = resource
-		end
-	end
-
-	# A ContextualService is a service that is managed by the Context. 
-	# ContextualServices are not instantiated normally. Instead, the instance of 
-	# such a service may be retrieved by calling the method
-	#   < class name >.get< class name >
-	#
-	# For example: ObjectStore.getObjectStore
-	class ContextualService
-		def self.flush; Context.instance.set_resource( self, nil ); end
-	
-		def self.method_missing( methodId, *args )
-			methodName = methodId.id2name
-			if methodName =~ /^get_(.*)/ || methodName =~ /^set_(.*)/
-				if methodName =~ /^get_(.*)/
-					Context.instance.get_resource( self )
-				else
-					Context.instance.set_resource( self, *args )
-				end
-			else
-				super
-			end
-		end
-
-		def self.set_init_proc
-			proc = proc { yield }
-			Context.instance.set_init_proc( self, proc )
-		end
-
-		# ContextualServices can only be initialized through the Context instance.
-		# Note that if you're writing your own initialize method in a child class,
-		# you should make sure to call super() or you'll overwrite this behavior.
-		def initialize
-			regexp = %r{lafcadio/util\.rb.*create_instance}
-			unless caller.any? { |line| line =~ regexp }
-				raise ArgumentError,
-				"#{ self.class.name.to_s } should be instantiated by calling " +
-				    self.class.name.to_s + ".get_" + self.class.name.camel_case_to_underscore,
-				caller
-			end
-		end
-	end
-
-	# A collection of English-language specific utility methods.
-	class English
-		# Turns a camel-case string ("camel_case_to_english") to plain English ("camel 
-		# case to english"). Each word is decapitalized.
-		def self.camel_case_to_english(camelCaseStr)
-			words = []
-			nextCapIndex =(camelCaseStr =~ /[A-Z]/)
-			while nextCapIndex != nil
-				words << $` if $`.size > 0
-				camelCaseStr = $& + $'
-				camelCaseStr[0] = camelCaseStr[0..0].downcase
-				nextCapIndex =(camelCaseStr =~ /[A-Z]/)
-			end
-			words << camelCaseStr
-			words.join ' '
-		end
-
-		# Turns an English language string into camel case.
-		def self.english_to_camel_case(englishStr)
-			cc = ""
-			englishStr.split.each { |word|
-				word = word.capitalize unless cc == ''
-				cc = cc += word
-			}
-			cc
-		end
-
-		# Given a singular noun, returns the plural form.
-		def self.plural(singular)
-			consonantYPattern = Regexp.new("([^aeiou])y$", Regexp::IGNORECASE)
-			if singular =~ consonantYPattern
-				singular.gsub consonantYPattern, '\1ies'
-			elsif singular =~ /[xs]$/
-				singular + "es"
-			else
-				singular + "s"
-			end
-		end
-
-		# Returns the proper noun form of a string by capitalizing most of the 
-		# words.
-		#
-		# Examples:
-		#   English.proper_noun("bosnia and herzegovina") ->
-		#     "Bosnia and Herzegovina"
-		#   English.proper_noun("macedonia, the former yugoslav republic of") ->
-		#     "Macedonia, the Former Yugoslav Republic of"
-		#   English.proper_noun("virgin islands, u.s.") ->
-		#     "Virgin Islands, U.S."
-		def self.proper_noun(string)
-			proper_noun = ""
-			while(matchIndex = string =~ /[\. ]/)
-				word = string[0..matchIndex-1]
-				word = word.capitalize unless [ 'and', 'the', 'of' ].index(word) != nil
-				proper_noun += word + $&
-				string = string[matchIndex+1..string.length]
-			end
-			word = string
-			word = word.capitalize unless [ 'and', 'the', 'of' ].index(word) != nil
-			proper_noun += word
-			proper_noun
-		end
-
-		# Given a format for a template sentence, generates the sentence while 
-		# accounting for details such as pluralization and whether to use "a" or 
-		# "an".
-		# [format] The format string. Format codes are:
-		#          * %num: Number
-		#          * %is: Transitive verb. This will be turned into "is" or "are", 
-		#            depending on <tt>number</tt>.
-		#          * %nam: Name. This will be rendered as either singular or 
-		#            plural, depending on <tt>number</tt>.
-		#          * %a: Indefinite article. This will be turned into "a" or "an", 
-		#            depending on <tt>name</tt>.
-		# [name] The name of the object being described.
-		# [number] The number of the objects being describes.
-		#
-		# Examples:
-		#   English.sentence("There %is currently %num %nam", "product category",
-		#                        0) -> "There are currently 0 product categories"
-		#   English.sentence("There %is currently %num %nam", "product category",
-		#                        1) -> "There is currently 1 product category"
-		#   English.sentence("Add %a %nam", "invoice") -> "Add an invoice"	
-		def self.sentence(format, name, number = 1)
-			sentence = format
-			sentence.gsub!( /%num/, number.to_s )
-			isVerb = number == 1 ? "is" : "are"
-			sentence.gsub!( /%is/, isVerb )
-			name = English.plural name if number != 1
-			sentence.gsub!( /%nam/, name )
-			article = starts_with_vowel_sound(name) ? 'an' : 'a'
-			sentence.gsub!( /%a/, article )
-			sentence
-		end
-		
-		def self.singular(plural)
-			if plural =~ /(.*)ies/
-				$1 + 'y'
-			elsif plural =~ /(.*s)es/
-				$1
-			else
-				plural =~ /(.*)s/
-				$1
-			end
-		end
-		
-		# Does this word start with a vowel sound? "User" and "usury" don't, but 
-		# "ugly" does.
-		def self.starts_with_vowel_sound(word)
-			uSomethingUMatch = word =~ /^u[^aeiuo][aeiou]/
-			# 'user' and 'usury' don't start with a vowel sound
-			word =~ /^[aeiou]/ && !uSomethingUMatch
-		end
-	end
-
-	# LafcadioConfig is a Hash that takes its data from the config file. You'll 
-	# have to set the location of that file before using it: Use 
-	# LafcadioConfig.set_filename.
-	#
-	# LafcadioConfig expects its data to be colon-delimited, one key-value pair 
-	# to a line. For example:
-	#   dbuser:user
-	#   dbpassword:password
-	#   dbname:lafcadio_test
-	#   dbhost:localhost
-	class LafcadioConfig < Hash
-		@@value_hash = nil
-	
-		def self.set_filename(filename); @@filename = filename; end
-		
-		def self.set_values( value_hash ); @@value_hash = value_hash; end
-
-		def initialize
-			if @@value_hash
-				@@value_hash.each { |key, value| self[key] = value }
-			else
-				File.new( @@filename ).each_line { |line|
-					line.chomp =~ /^(.*?):(.*)$/
-					self[$1] = $2
-				}
-			end
-		end
-	end
-
-	class MissingError < RuntimeError
-	end
-
-	# An ordered hash: Keys are ordered according to when they were inserted.
-	class QueueHash < DelegateClass( Array )
-		# Creates a QueueHash with all the elements in <tt>array</tt> as keys, and 
-		# each value initially set to be the same as the corresponding key.
-		def self.new_from_array(array)
-			new( *( ( array.map { |elt| [ elt, elt ] } ).flatten ) )
-		end
-
-		# Takes an even number of arguments, and sets each odd-numbered argument to 
-		# correspond to the argument immediately afterward. For example:
-		#   queueHash = QueueHash.new (1, 2, 3, 4)
-		#   queueHash[1] => 2
-		#   queueHash[3] => 4
-		def initialize(*values)
-			@pairs = []
-			0.step(values.size-1, 2) { |i| @pairs << [ values[i], values[i+1] ] }
-			super( @pairs )
-		end
-		
-		def ==( otherObj )
-			if otherObj.class == QueueHash && otherObj.size == size
-				( 0..size ).all? { |i|
-					keys[i] == otherObj.keys[i] && values[i] == otherObj.values[i]
-				}
-			else
-				false
-			end
-		end
-
-		def [](key)
-			( pair = @pairs.find { |pair| pair[0] == key } ) ? pair.last : nil
-		end
-
-		def []=(key, value); @pairs << [key, value]; end
-
-		def each; @pairs.each { |pair| yield pair[0], pair[1] }; end
-
-		def keys; @pairs.map { |pair| pair[0] }; end
-
-		def values; @pairs.map { |pair| pair[1] }; end
-	end
-
-	class UsStates
-		# Returns a QueueHash of states, with two-letter postal codes as keys and 
-		# state names as values.
-		def self.states
-			QueueHash.new( 'AL', 'Alabama', 'AK', 'Alaska', 'AZ', 'Arizona',
-			               'AR', 'Arkansas', 'CA', 'California', 'CO', 'Colorado',
-			               'CT', 'Connecticut', 'DE', 'Delaware',
-			               'DC', 'District of Columbia', 'FL', 'Florida',
-			               'GA', 'Georgia', 'HI', 'Hawaii', 'ID', 'Idaho',
-			               'IL', 'Illinois', 'IN', 'Indiana', 'IA', 'Iowa',
-			               'KS', 'Kansas', 'KY', 'Kentucky', 'LA', 'Louisiana',
-			               'ME', 'Maine', 'MD', 'Maryland', 'MA', 'Massachusetts',
-			               'MI', 'Michigan', 'MN', 'Minnesota', 'MS', 'Mississippi',
-			               'MO', 'Missouri', 'MT', 'Montana', 'NE', 'Nebraska',
-			               'NV', 'Nevada', 'NH', 'New Hampshire', 'NJ', 'New Jersey',
-			               'NM', 'New Mexico', 'NY', 'New York',
-			               'NC', 'North Carolina', 'ND', 'North Dakota', 'OH', 'Ohio',
-			               'OK', 'Oklahoma', 'OR', 'Oregon', 'PA', 'Pennsylvania',
-			               'PR', 'Puerto Rico', 'RI', 'Rhode Island',
-			               'SC', 'South Carolina', 'SD', 'South Dakota',
-			               'TN', 'Tennessee', 'TX', 'Texas', 'UT', 'Utah',
-			               'VT', 'Vermont', 'VA', 'Virginia', 'WA', 'Washington',
-			               'WV', 'West Virginia', 'WI', 'Wisconsin', 'WY', 'Wyoming' )
-		end
-	end
-end
-
-class String
-	# Returns the underscored version of a camel-case string.
-	def camel_case_to_underscore
-		( gsub( /(.)([A-Z])/ ) { $1 + '_' + $2.downcase } ).downcase
-	end
-
-	# Returns the number of times that <tt>regexp</tt> occurs in the string.
-	def count_occurrences(regexp)
-		count = 0
-		str = self.clone
-		while str =~ regexp
-			count += 1
-			str = $'
-		end
-		count
-	end
-	
-	# Decapitalizes the first letter of the string, or decapitalizes the 
-	# entire string if it's all capitals.
-	#
-	#   'InternalClient'.decapitalize -> "internalClient"
-	#   'SKU'.decapitalize            -> "sku"
-	def decapitalize
-		string = clone
-		firstLetter = string[0..0].downcase
-		string = firstLetter + string[1..string.length]
-		newString = ""
-		while string =~ /([A-Z])([^a-z]|$)/
-			newString += $`
-			newString += $1.downcase
-			string = $2 + $'
-		end
-		newString += string
-		newString
-	end
-
-	# Turns a numeric string into U.S. format if it's not already formatted that
-	# way.
-	#
-	#   "10,00".numeric_string_to_us_format -> "10.00"
-	#   "10.00".numeric_string_to_us_format -> "10.00"
-	def numeric_string_to_us_format
-		numericString = clone
-		numericString.gsub!(/,/, '.') if numericString =~ /,\d{2}$/
-		numericString
-	end
-
-	# Left-pads a string with +fillChar+ up to +size+ size.
-	#
-	#   "a".pad( 10, "+") -> "+++++++++a"
-	def pad(size, fillChar)
-		string = clone
-		while string.length < size
-			string = fillChar + string
-		end
-		string
-	end
-	
-	# Returns the camel-case equivalent of an underscore-style string.
-	def underscore_to_camel_case
-		capitalize.gsub( /_([a-zA-Z0-9]+)/ ) { |s| s[1,s.size - 1].capitalize }
-	end
-end