lafcadio 0.5.2 → 0.6.0

data/lib/lafcadio/objectField.rb

@@ -7,8 +7,8 @@ module Lafcadio
 	class ObjectField
 		include Comparable
 
-		attr_reader :name, :object_type
-		attr_accessor :not_null, :unique, :db_field_name
+		attr_reader :name, :domain_class
+		attr_accessor :not_null, :db_field_name
 
 		def self.instantiate_from_xml( domain_class, fieldElt ) #:nodoc:
 			parameters = instantiation_parameters( fieldElt )
@@ -16,8 +16,7 @@ module Lafcadio
 		end
 
 		def self.instantiate_with_parameters( domain_class, parameters ) #:nodoc:
-			instance = self.new( domain_class, parameters['name'],
-			                     parameters['english_name'] )
+			instance = self.new( domain_class, parameters['name'] )
 			if ( db_field_name = parameters['db_field_name'] )
 				instance.db_field_name = db_field_name
 			end
@@ -27,7 +26,6 @@ module Lafcadio
 		def self.instantiation_parameters( fieldElt ) #:nodoc:
 			parameters = {}
 			parameters['name'] = fieldElt.attributes['name']
-			parameters['english_name'] = fieldElt.attributes['english_name']
 			parameters['db_field_name'] = fieldElt.attributes['db_field_name']
 			parameters
 		end
@@ -36,20 +34,17 @@ module Lafcadio
 			Object
 		end
 
-		# [object_type]  The domain class that this object field belongs to.
-		# [name]        The name of this field.
-		# [english_name] The descriptive English name of this field. (Deprecated)
-		def initialize(object_type, name, english_name = nil )
-			@object_type = object_type
+		# [domain_class]  The domain class that this object field belongs to.
+		# [name]          The name of this field.
+		def initialize( domain_class, name )
+			@domain_class = domain_class
 			@name = name
 			@db_field_name = name
 			@not_null = true
-			@unique = false
-			@english_nameOrNil = english_name
 		end
 		
 		def <=>(other)
-			if @object_type == other.object_type && name == other.name
+			if @domain_class == other.domain_class && name == other.name
 				0
 			else
 				object_id <=> other.object_id
@@ -59,17 +54,13 @@ module Lafcadio
 		def bind_write?; false; end #:nodoc:
 		
 		def db_table_and_field_name
-			"#{ object_type.table_name }.#{ db_field_name }"
+			"#{ domain_class.table_name }.#{ db_field_name }"
 		end
 
 		def db_will_automatically_write #:nodoc:
 			false
 		end
 
-		def english_name #:nodoc:
-			@english_nameOrNil || English.camel_case_to_english(name).capitalize
-		end
-
 		# Returns the name that this field is referenced by in the MySQL table. By 
 		# default this is the same as the name; to override it, set 
 		# ObjectField#db_field_name.
@@ -77,12 +68,8 @@ module Lafcadio
 			db_field_name
 		end
 
-		def null_error_msg #:nodoc:
-			"#{ self.object_type.name }##{ name } can not be nil."
-		end
-
 		def prev_value(pk_id) #:nodoc:
-			prevObject = ObjectStore.get_object_store.get(@object_type, pk_id)
+			prevObject = ObjectStore.get_object_store.get( @domain_class, pk_id )
 			prevObject.send(name)
 		end
 
@@ -99,7 +86,11 @@ module Lafcadio
 
 		def verify(value, pk_id) #:nodoc:
 			if value.nil? && not_null
-				raise FieldValueError, null_error_msg, caller
+				raise(
+					FieldValueError,
+					"#{ self.domain_class.name }##{ name } can not be nil.",
+					caller
+				)
 			end
 			verify_non_nil( value, pk_id ) if value
 		end
@@ -107,23 +98,12 @@ module Lafcadio
 		def verify_non_nil( value, pk_id )
 			value_type = self.class.value_type
 			unless value.class <= value_type
-				raise( FieldValueError, 
-				       "#{ object_type.name }##{ name } needs a " + value_type.name +
+				raise(
+					FieldValueError, 
+					"#{ domain_class.name }##{ name } needs a " + value_type.name +
 				           " value.",
-				       caller )
-			end
-			verify_uniqueness(value, pk_id) if unique
-		end
-
-		def verify_uniqueness(value, pk_id) #:nodoc:
-			inferrer = Query::Inferrer.new( @object_type ) { |domain_obj|
-				Query.And( domain_obj.send( self.name ).equals( value ),
-									 domain_obj.pk_id.equals( pk_id ).not )
-			}
-			collisions = ObjectStore.get_object_store.get_subset( inferrer.execute )
-			if collisions.size > 0
-				notUniqueMsg = "That #{english_name.downcase} already exists."
-				raise FieldValueError, notUniqueMsg, caller
+					caller
+				)
 			end
 		end
 
@@ -154,28 +134,6 @@ module Lafcadio
 		end
 	end
 
-	class AutoIncrementField < IntegerField # :nodoc:
-		attr_reader :object_type
-
-		def initialize(object_type, name, english_name = nil)
-			super(object_type, name, english_name)
-			@object_type = object_type
-		end
-
-		def html_widget_value_str(value)
-			if value != nil
-				super value
-			else
-				highestValue = 0
-				ObjectStore.get_object_store.get_all(object_type).each { |obj|
-					aValue = obj.send(name).to_i
-					highestValue = aValue if aValue > highestValue
-				}
-			 (highestValue + 1).to_s
-			end
-		end
-	end
-
 	# BlobField stores a string value and expects to store its value in a BLOB
 	# field in the database.
 	class BlobField < ObjectField
@@ -220,8 +178,8 @@ module Lafcadio
 
 		attr_accessor :enum_type, :enums
 
-		def initialize(object_type, name, english_name = nil)
-			super(object_type, name, english_name)
+		def initialize( domain_class, name )
+			super( domain_class, name )
 			@enum_type = ENUMS_ONE_ZERO
 			@enums = nil
 		end
@@ -270,18 +228,12 @@ module Lafcadio
 
 	# DateField represents a Date.
 	class DateField < ObjectField
-		RANGE_NEAR_FUTURE = 0
-		RANGE_PAST = 1
-
 		def self.value_type # :nodoc:
 			Date
 		end
 
-		attr_accessor :range
-
-		def initialize(object_type, name = "date", english_name = nil)
-			super(object_type, name, english_name)
-			@range = RANGE_NEAR_FUTURE
+		def initialize( domain_class, name = "date" )
+			super( domain_class, name )
 		end
 
 		def value_for_sql(value) # :nodoc:
@@ -321,7 +273,7 @@ module Lafcadio
 	# DecimalField represents a decimal value.
 	class DecimalField < ObjectField
 		def self.instantiate_with_parameters( domain_class, parameters ) #:nodoc:
-			self.new( domain_class, parameters['name'], parameters['english_name'] )
+			self.new( domain_class, parameters['name'] )
 		end
 
 		def self.value_type #:nodoc:
@@ -346,20 +298,18 @@ module Lafcadio
 			address =~ /^[^ @]+@[^ \.]+\.[^ ,]+$/
 		end
 
-		def initialize(object_type, name = "email", english_name = nil)
-			super(object_type, name, english_name)
-		end
-
-		def null_error_msg #:nodoc:
-			"Please enter an email address."
+		def initialize( domain_class, name = "email" )
+			super( domain_class, name )
 		end
 
 		def verify_non_nil(value, pk_id) #:nodoc:
 			super(value, pk_id)
 			if !EmailField.valid_address(value)
-				raise( FieldValueError,
-				       "#{ object_type.name }##{ name } needs a valid email address.",
-				       caller )
+				raise(
+					FieldValueError,
+				  "#{ domain_class.name }##{ name } needs a valid email address.",
+				  caller
+				)
 			end
 		end
 	end
@@ -379,8 +329,7 @@ module Lafcadio
 	#
 	class EnumField < TextField
 		def self.instantiate_with_parameters( domain_class, parameters ) #:nodoc:
-			self.new( domain_class, parameters['name'], parameters['enums'],
-								parameters['english_name'] )
+			self.new( domain_class, parameters['name'], parameters['enums'] )
 		end
 
 		def self.enum_queue_hash( fieldElt )
@@ -407,13 +356,12 @@ module Lafcadio
 		
 		attr_reader :enums
 
-		# [object_type]  The domain class that this field belongs to.
-		# [name]        The name of this domain class.
-		# [enums]       An array of Strings representing the possible choices for
-		#               this field.
-		# [english_name] The English name of this field. (Deprecated)
-		def initialize(object_type, name, enums, english_name = nil)
-			super object_type, name, english_name
+		# [domain_class]  The domain class that this field belongs to.
+		# [name]          The name of this domain class.
+		# [enums]         An array of Strings representing the possible choices for
+		#                 this field.
+		def initialize( domain_class, name, enums )
+			super( domain_class, name )
 			if enums.class == Array 
 				@enums = QueueHash.new_from_array enums
 			else
@@ -430,7 +378,7 @@ module Lafcadio
 			if @enums[value].nil?
 				key_str = '[ ' +
 				          ( @enums.keys.map { |key| "\"#{ key }\"" } ).join(', ') + ' ]'
-				err_str = "#{ @object_type.name }##{ name } needs a value that is " +
+				err_str = "#{ @domain_class.name }##{ name } needs a value that is " +
 				          "one of #{ key_str }"
 				raise( FieldValueError, err_str, caller )
 			end
@@ -445,7 +393,7 @@ module Lafcadio
 		def self.instantiate_with_parameters( domain_class, parameters ) #:nodoc:
 			instance = self.new(
 				domain_class, parameters['linked_type'], parameters['name'],
-				parameters['english_name'], parameters['delete_cascade']
+				parameters['delete_cascade']
 			)
 			if parameters['db_field_name']
 				instance.db_field_name = parameters['db_field_name']
@@ -456,7 +404,7 @@ module Lafcadio
 		def self.instantiation_parameters( fieldElt ) #:nodoc:
 			parameters = super( fieldElt )
 			linked_typeStr = fieldElt.attributes['linked_type']
-			linked_type = DomainObject.get_object_type_from_string( linked_typeStr )
+			linked_type = DomainObject.get_domain_class_from_string( linked_typeStr )
 			parameters['linked_type'] = linked_type
 			parameters['delete_cascade'] = fieldElt.attributes['delete_cascade'] == 'y'
 			parameters
@@ -465,20 +413,20 @@ module Lafcadio
 		attr_reader :linked_type
 		attr_accessor :delete_cascade
 
-		# [object_type]    The domain class that this field belongs to.
-		# [linked_type]    The domain class that this field points to.
-		# [name]          The name of this field.
-		# [english_name]   The English name of this field. (Deprecated)
-		# [delete_cascade] If this is true, deleting the domain object that is linked
-		#                 to will cause this domain object to be deleted as well.
-		def initialize( object_type, linked_type, name = nil, english_name = nil,
+		# [domain_class]    The domain class that this field belongs to.
+		# [linked_type]     The domain class that this field points to.
+		# [name]            The name of this field.
+		# [delete_cascade]  If this is true, deleting the domain object that is
+		#                   linked to will cause this domain object to be deleted
+		#                   as well.
+		def initialize( domain_class, linked_type, name = nil,
 		                delete_cascade = false )
 			unless name
 				linked_type.name =~ /::/
 				name = $' || linked_type.name
 				name = name.decapitalize
 			end
-			super(object_type, name, english_name)
+			super( domain_class, name )
 			( @linked_type, @delete_cascade ) = linked_type, delete_cascade
 		end
 
@@ -499,7 +447,7 @@ module Lafcadio
 
 		def verify_non_nil(value, pk_id) #:nodoc:
 			super
-			if @linked_type != @object_type && pk_id
+			if @linked_type != @domain_class && pk_id
 				subsetLinkField = @linked_type.class_fields.find { |field|
 					field.class == SubsetLinkField && field.subset_field == @name
 				}
@@ -511,7 +459,7 @@ module Lafcadio
 
 		def verify_subset_link_field( subsetLinkField, pk_id )
 			begin
-				prevObj = ObjectStore.get_object_store.get(object_type, pk_id)
+				prevObj = ObjectStore.get_object_store.get( domain_class, pk_id )
 				prevObjLinkedTo = prevObj.send(name)
 				possiblyMyObj = prevObjLinkedTo.send(subsetLinkField.name)
 				if possiblyMyObj && possiblyMyObj.pk_id == pk_id
@@ -524,9 +472,6 @@ module Lafcadio
 		end
 	end
 
-	class MoneyField < DecimalField #:nodoc:
-	end
-
 	# Accepts a Month as a value. This field automatically saves in MySQL as a 
 	# date corresponding to the first day of the month.
 	class MonthField < DateField
@@ -539,19 +484,6 @@ module Lafcadio
 		end
 	end
 
-	# A PasswordField is simply a TextField that is expected to contain a password
-	# value. It can be set to auto-generate a password at random.
-	class PasswordField < TextField
-		# Returns a random 8-letter alphanumeric password.
-		def self.random_password
-			chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789".
-					split(//)
-			value = ""
-			0.upto(8) { |i| value += chars[rand(chars.size)] }
-			value
-		end
-	end
-	
 	class PrimaryKeyField < IntegerField
 		def initialize( domain_class )
 			super( domain_class, 'pk_id' )
@@ -563,16 +495,15 @@ module Lafcadio
 	# any of the 50 states of the United States, stored as each state's two-letter
 	# postal code.
 	class StateField < EnumField
-		def initialize(object_type, name = "state", english_name = nil)
-			super object_type, name, UsStates.states, english_name
+		def initialize( domain_class, name = "state" )
+			super( domain_class, name, UsStates.states )
 		end
 	end
 
 	class SubsetLinkField < LinkField #:nodoc:
 		def self.instantiate_with_parameters( domain_class, parameters )
 			self.new( domain_class, parameters['linked_type'],
-			          parameters['subset_field'], parameters['name'],
-								parameters['english_name'] )
+			          parameters['subset_field'], parameters['name'] )
 		end
 
 		def self.instantiation_parameters( fieldElt )
@@ -583,9 +514,9 @@ module Lafcadio
 		
 		attr_accessor :subset_field
 
-		def initialize(object_type, linked_type, subset_field,
-				name = linked_type.name.downcase, english_name = nil)
-			super(object_type, linked_type, name, english_name)
+		def initialize( domain_class, linked_type, subset_field,
+		                name = linked_type.name.downcase )
+			super( domain_class, linked_type, name )
 			@subset_field = subset_field
 		end
 	end
@@ -600,7 +531,12 @@ module Lafcadio
 		end
 
 		def value_for_sql(objectValue) #:nodoc:
-			"'" + objectValue.join(',') + "'"
+			if objectValue.is_a?( Array )
+				str = objectValue.join(',')
+			else
+				str = objectValue
+			end
+			"'" + str + "'"
 		end
 
 		def value_from_sql(sqlString, lookupLink = true) #:nodoc:
@@ -613,8 +549,8 @@ module Lafcadio
 	end
 
 	class TimeStampField < DateTimeField #:nodoc:
-		def initialize(object_type, name = 'timeStamp', english_name = nil)
-			super( object_type, name, english_name )
+		def initialize( domain_class, name = 'timeStamp' )
+			super( domain_class, name )
 			@not_null = false
 		end
 

data/lib/lafcadio/objectStore.rb

@@ -1,3 +1,4 @@
+require 'dbi'
 require 'lafcadio/domain'
 require 'lafcadio/query'
 require 'lafcadio/util'
@@ -51,7 +52,7 @@ module Lafcadio
 		end
 
 		def update_dependent_domain_objects
-			dependent_classes = @db_object.object_type.dependent_classes
+			dependent_classes = @db_object.domain_class.dependent_classes
 			dependent_classes.keys.each { |aClass|
 				field = dependent_classes[aClass]
 				collection = @objectStore.get_filtered( aClass.name, @db_object,
@@ -68,7 +69,7 @@ module Lafcadio
 		end
 	end
 
-	class CouldntMatchObjectTypeError < RuntimeError #:nodoc:
+	class CouldntMatchDomainClassError < RuntimeError #:nodoc:
 	end
 
 	class DbBridge #:nodoc:
@@ -120,16 +121,16 @@ module Lafcadio
 		end
 		
 		def get_collection_by_query(query)
-			object_type = query.object_type
+			domain_class = query.domain_class
 			execute_select( query.to_sql ).collect { |row_hash|
-				object_type.new( SqlValueConverter.new( object_type, row_hash ) )
+				domain_class.new( SqlValueConverter.new( domain_class, row_hash ) )
 			}
 		end
 		
 		def group_query( query )
 			execute_select( query.to_sql )[0].collect { |val|
-				if query.field_name != query.object_type.sql_primary_key_name
-					a_field = query.object_type.get_field( query.field_name )
+				if query.field_name != query.domain_class.sql_primary_key_name
+					a_field = query.domain_class.get_field( query.field_name )
 					a_field.value_from_sql( val )
 				else
 					val.to_i
@@ -205,7 +206,8 @@ module Lafcadio
 	end
 
 	# The DomainObjectProxy is used when retrieving domain objects that are 
-	# linked to other domain objects with LinkFields. In terms of +object_type+ and 
+	# linked to other domain objects with LinkFields. In terms of +domain_class+
+	# and 
 	# +pk_id+, a DomainObjectProxy instance looks to the outside world like the 
 	# domain object it's supposed to represent. It only retrieves its domain 
 	# object from the database when member data is requested.
@@ -213,20 +215,20 @@ module Lafcadio
 	# In normal usage you will probably never manipulate a DomainObjectProxy
 	# directly, but you may discover it by accident by calling
 	# DomainObjectProxy#class (or DomainObject#class) instead of
-	# DomainObjectProxy#object_type (or DomainObjectProxy#object_type).
+	# DomainObjectProxy#domain_class (or DomainObjectProxy#domain_class).
 	class DomainObjectProxy
 		include DomainComparable
 
-		attr_accessor :object_type, :pk_id
+		attr_accessor :domain_class, :pk_id
 
-		def initialize(object_typeOrDbObject, pk_id = nil)
+		def initialize(domain_classOrDbObject, pk_id = nil)
 			if pk_id
-				@object_type = object_typeOrDbObject
+				@domain_class = domain_classOrDbObject
 				@pk_id = pk_id
-			elsif object_typeOrDbObject.class < DomainObject
-				@db_object = object_typeOrDbObject
+			elsif domain_classOrDbObject.class < DomainObject
+				@db_object = domain_classOrDbObject
 				@d_obj_retrieve_time = Time.now
-				@object_type = @db_object.class
+				@domain_class = @db_object.class
 				@pk_id = @db_object.pk_id
 			else
 				raise ArgumentError
@@ -237,9 +239,8 @@ module Lafcadio
 		def get_db_object
 			object_store = ObjectStore.get_object_store
 			if @db_object.nil? || needs_refresh?
-				@db_object = object_store.get(@object_type, @pk_id)
-								@d_obj_retrieve_time = Time.now
-
+				@db_object = object_store.get( @domain_class, @pk_id )
+				@d_obj_retrieve_time = Time.now
 			end
 			@db_object
 		end
@@ -254,7 +255,7 @@ module Lafcadio
 
 		def needs_refresh?
 			object_store = ObjectStore.get_object_store
-			last_commit_time = object_store.last_commit_time( @object_type, @pk_id )
+			last_commit_time = object_store.last_commit_time( @domain_class, @pk_id )
 			!last_commit_time.nil? && last_commit_time > @d_obj_retrieve_time
 		end
 		
@@ -268,14 +269,14 @@ module Lafcadio
 
 		def initialize(obj); @obj = obj; end
 
-		def delete_sql(object_type)
-			"delete from #{ object_type.table_name} " +
-					"where #{ object_type.sql_primary_key_name }=#{ @obj.pk_id }"
+		def delete_sql( domain_class )
+			"delete from #{ domain_class.table_name} " +
+					"where #{ domain_class.sql_primary_key_name }=#{ @obj.pk_id }"
 		end
 
-		def get_name_value_pairs(object_type)
+		def get_name_value_pairs( domain_class )
 			nameValues = []
-			object_type.class_fields.each { |field|
+			domain_class.class_fields.each { |field|
 				unless field.instance_of?( PrimaryKeyField )
 					value = @obj.send(field.name)
 					unless field.db_will_automatically_write
@@ -290,15 +291,15 @@ module Lafcadio
 			QueueHash.new( *nameValues )
 		end
 
-		def insert_sql(object_type)
-			fields = object_type.class_fields
-			nameValuePairs = get_name_value_pairs(object_type)
-			if object_type.is_based_on?
-				nameValuePairs[object_type.sql_primary_key_name] = 'LAST_INSERT_ID()'
+		def insert_sql( domain_class )
+			fields = domain_class.class_fields
+			nameValuePairs = get_name_value_pairs( domain_class )
+			if domain_class.is_based_on?
+				nameValuePairs[domain_class.sql_primary_key_name] = 'LAST_INSERT_ID()'
 			end
 			fieldNameStr = nameValuePairs.keys.join ", "
 			fieldValueStr = nameValuePairs.values.join ", "
-			"insert into #{ object_type.table_name}(#{fieldNameStr}) " +
+			"insert into #{ domain_class.table_name}(#{fieldNameStr}) " +
 					"values(#{fieldValueStr})"
 		end
 
@@ -307,35 +308,35 @@ module Lafcadio
 			if @obj.error_messages.size > 0
 				raise DomainObjectInitError, @obj.error_messages, caller
 			end
-			@obj.class.self_and_concrete_superclasses.each { |object_type|
-				statements << statement_bind_value_pair( object_type )
+			@obj.class.self_and_concrete_superclasses.each { |domain_class|
+				statements << statement_bind_value_pair( domain_class )
  			}
 			statements.reverse
 		end
 
-		def statement_bind_value_pair( object_type )
+		def statement_bind_value_pair( domain_class )
 			@bind_values = []
 			if @obj.pk_id == nil
-				statement = insert_sql(object_type)
+				statement = insert_sql( domain_class )
 			else
 				if @obj.delete
-					statement = delete_sql(object_type)
+					statement = delete_sql( domain_class )
 				else
-					statement = update_sql(object_type)
+					statement = update_sql( domain_class)
 				end
 			end
 			[statement, @bind_values]
 		end
 
-		def update_sql(object_type)
+		def update_sql( domain_class )
 			nameValueStrings = []
-			nameValuePairs = get_name_value_pairs(object_type)
+			nameValuePairs = get_name_value_pairs( domain_class )
 			nameValuePairs.each { |key, value|
 				nameValueStrings << "#{key}=#{ value }"
 			}
 			allNameValues = nameValueStrings.join ', '
-			"update #{ object_type.table_name} set #{allNameValues} " +
-					"where #{ object_type.sql_primary_key_name}=#{@obj.pk_id}"
+			"update #{ domain_class.table_name} set #{allNameValues} " +
+					"where #{ domain_class.sql_primary_key_name}=#{@obj.pk_id}"
 		end
 	end
 
@@ -427,54 +428,51 @@ module Lafcadio
 		end
 
 		# Returns the domain object corresponding to the domain class and pk_id.
-		def get(object_type, pk_id)
-			query = Query.new object_type, pk_id
+		def get( domain_class, pk_id )
+			query = Query.new domain_class, pk_id
 			@cache.get_by_query( query )[0] ||
 			    ( raise( DomainObjectNotFoundError,
-					         "Can't find #{object_type} #{pk_id}", caller ) )
+					         "Can't find #{domain_class} #{pk_id}", caller ) )
 		end
 
 		# Returns all domain objects for the given domain class.
-		def get_all(object_type); @cache.get_by_query( Query.new( object_type ) ); end
+		def get_all(domain_class); @cache.get_by_query( Query.new( domain_class ) ); end
 
 		# Returns the DbBridge; this is useful in case you need to use raw SQL for a
 		# specific query.
 		def get_db_bridge; @dbBridge; end
 		
 		def get_field_name( domain_object )
-			domain_object.object_type.bare_name.decapitalize
+			domain_object.domain_class.basename.decapitalize
 		end
 
-		def get_filtered(object_typeName, searchTerm, fieldName = nil) #:nodoc:
-			object_type = DomainObject.get_object_type_from_string object_typeName
+		def get_filtered(domain_class_name, searchTerm, fieldName = nil) #:nodoc:
+			domain_class = DomainObject.get_domain_class_from_string(
+				domain_class_name
+			)
 			fieldName = get_field_name( searchTerm ) unless fieldName
-			if searchTerm.class <= DomainObject
-				cond_class = Query::Link
-			else
-				cond_class = Query::Equals
-			end
-			get_subset( cond_class.new( fieldName, searchTerm, object_type ) )
+			get_subset( Query::Equals.new( fieldName, searchTerm, domain_class ) )
 		end
 
-		def get_map_match(object_type, mapped) #:nodoc:
-			Query::Equals.new( get_field_name( mapped ), mapped, object_type )
+		def get_map_match( domain_class, mapped ) #:nodoc:
+			Query::Equals.new( get_field_name( mapped ), mapped, domain_class )
 		end
 
-		def get_map_object(object_type, map1, map2) #:nodoc:
+		def get_map_object( domain_class, map1, map2 ) #:nodoc:
 			unless map1 && map2
 				raise ArgumentError,
 						"ObjectStore#get_map_object needs two non-nil keys", caller
 			end
-			mapMatch1 = get_map_match object_type, map1
-			mapMatch2 = get_map_match object_type, map2
+			mapMatch1 = get_map_match domain_class, map1
+			mapMatch2 = get_map_match domain_class, map2
 			condition = Query::CompoundCondition.new mapMatch1, mapMatch2
 			get_subset(condition)[0]
 		end
 
 		def get_mapped(searchTerm, resultTypeName) #:nodoc:
-			resultType = DomainObject.get_object_type_from_string resultTypeName
-			firstTypeName = searchTerm.class.bare_name
-			secondTypeName = resultType.bare_name
+			resultType = DomainObject.get_domain_class_from_string resultTypeName
+			firstTypeName = searchTerm.class.basename
+			secondTypeName = resultType.basename
 			mapTypeName = firstTypeName + secondTypeName
 			get_filtered( mapTypeName, searchTerm ).collect { |mapObj|
 				mapObj.send( resultType.name.decapitalize )
@@ -492,14 +490,23 @@ module Lafcadio
 
 		# Retrieves a collection of domain objects by +pk_id+.
 		#   ObjectStore#get_objects( Clients, [ 1, 2, 3 ] )
-		def get_objects(object_type, pk_ids)
-			get_subset Query::In.new('pk_id', pk_ids, object_type)
+		def get_objects( domain_class, pk_ids )
+			if pk_ids.is_a?( Array ) && pk_ids.all? { |elt| elt.is_a?( Integer ) }
+				get_subset Query::In.new( 'pk_id', pk_ids, domain_class )
+			else
+				raise(
+					ArgumentError, 
+					"ObjectStore#get_objects( domain_class, pk_ids ): pk_ids needs to " +
+							"be an array of integers",
+					caller
+				)
+			end
 		end
 
 		def get_subset(conditionOrQuery) #:nodoc:
 			if conditionOrQuery.class <= Query::Condition
 				condition = conditionOrQuery
-				query = Query.new condition.object_type, condition
+				query = Query.new condition.domain_class, condition
 			else
 				query = conditionOrQuery
 			end
@@ -540,26 +547,28 @@ module Lafcadio
 
 			# Flushes a domain object.
 			def flush(db_object)
-				hash_by_object_type(db_object.object_type).delete db_object.pk_id
-				flush_collection_cache( db_object.object_type )
+				hash_by_domain_class( db_object.domain_class ).delete db_object.pk_id
+				flush_collection_cache( db_object.domain_class )
 			end
 			
-			def flush_collection_cache( object_type )
+			def flush_collection_cache( domain_class )
 				@collections_by_query.keys.each { |query|
-					if query.object_type == object_type
+					if query.domain_class == domain_class
 						@collections_by_query.delete( query )
 					end
 				}
 			end
 
 			# Returns a cached domain object, or nil if none is found.
-			def get(object_type, pk_id)
-				hash_by_object_type(object_type)[pk_id].clone
+			def get( domain_class, pk_id )
+				hash_by_domain_class( domain_class )[pk_id].clone
 			end
 
 			# Returns an array of all domain objects of a given type.
-			def get_all(object_type)
-				hash_by_object_type(object_type).values.collect { |d_obj| d_obj.clone }
+			def get_all( domain_class )
+				hash_by_domain_class( domain_class ).values.collect { |d_obj|
+					d_obj.clone
+				}
 			end
 
 			def get_by_query( query )
@@ -572,17 +581,17 @@ module Lafcadio
 				end
 				collection = []
 				@collections_by_query[query].each { |pk_id|
-					dobj = get( query.object_type, pk_id )
+					dobj = get( query.domain_class, pk_id )
 					collection << dobj if dobj
 				}
 				collection
 			end
 
-			def hash_by_object_type(object_type)
-				unless @objects[object_type]
-					@objects[object_type] = {}
+			def hash_by_domain_class( domain_class )
+				unless @objects[domain_class]
+					@objects[domain_class] = {}
 				end
-				@objects[object_type]
+				@objects[domain_class]
 			end
 
 			def last_commit_time( domain_class, pk_id )
@@ -591,18 +600,19 @@ module Lafcadio
 			end
 			
 			def set_commit_time( d_obj )
-				by_domain_class = @commit_times[d_obj.object_type]
+				by_domain_class = @commit_times[d_obj.domain_class]
 				if by_domain_class.nil?
 					by_domain_class = {}
-					@commit_times[d_obj.object_type] = by_domain_class
+					@commit_times[d_obj.domain_class] = by_domain_class
 				end
 				by_domain_class[d_obj.pk_id] = Time.now
 			end
 
 			# Saves a domain object.
 			def save(db_object)
-				hash_by_object_type(db_object.object_type)[db_object.pk_id] = db_object
-				flush_collection_cache( db_object.object_type )
+				hash = hash_by_domain_class( db_object.domain_class )
+				hash[db_object.pk_id] = db_object
+				flush_collection_cache( db_object.domain_class )
 			end
 			
 			def update_after_commit( committer ) #:nodoc:
@@ -675,29 +685,30 @@ module Lafcadio
 			def dispatch_get_method
 				begin
 					dispatch_get_singular
-				rescue CouldntMatchObjectTypeError
-					object_typeName = English.singular( camel_case_method_name_after_get
-					                                  )
+				rescue CouldntMatchDomainClassError
+					domain_class_name = English.singular(
+						camel_case_method_name_after_get
+					)
 					begin
-						@domain_class = DomainObject.
-						                get_object_type_from_string( object_typeName )
+						@domain_class =
+								DomainObject.get_domain_class_from_string( domain_class_name )
 						dispatch_get_plural
-					rescue CouldntMatchObjectTypeError
+					rescue CouldntMatchDomainClassError
 						raise_no_method_error
 					end
 				end
 			end
 			
 			def dispatch_get_singular
-				object_type = DomainObject.get_object_type_from_string(
+				domain_class = DomainObject.get_domain_class_from_string(
 					camel_case_method_name_after_get
 				)
 				if @orig_args[0].class <= Integer
 					@symbol = :get
-					@args = [ object_type, @orig_args[0] ]
+					@args = [ domain_class, @orig_args[0] ]
 				elsif @orig_args[0].class <= DomainObject
 					@symbol = :get_map_object
-					@args = [ object_type, @orig_args[0], @orig_args[1] ]
+					@args = [ domain_class, @orig_args[0], @orig_args[1] ]
 				end
 			end
 			
@@ -713,16 +724,16 @@ module Lafcadio
 	end
 
 	class SqlValueConverter #:nodoc:
-		attr_reader :object_type, :row_hash
+		attr_reader :domain_class, :row_hash
 
-		def initialize(object_type, row_hash)
-			@object_type = object_type
+		def initialize( domain_class, row_hash )
+			@domain_class = domain_class
 			@row_hash = row_hash
 		end
 
 		def []( key )
 			begin
-				field = @object_type.get_field( key )
+				field = @domain_class.get_field( key )
 				val = field.value_from_sql( @row_hash[ field.db_field_name ] )
 				if field.instance_of?( PrimaryKeyField ) && val.nil?
 					raise FieldMatchError, error_msg, caller
@@ -735,9 +746,9 @@ module Lafcadio
 		end
 
 		def error_msg
-			"The field \"" + @object_type.sql_primary_key_name +
+			"The field \"" + @domain_class.sql_primary_key_name +
 					"\" can\'t be found in the table \"" + 
-					@object_type.table_name + "\"."
+					@domain_class.table_name + "\"."
 		end
 	end
 end