lafcadio 0.6.6 → 0.7.0

data/lib/lafcadio.rb

@@ -16,7 +16,7 @@
 # http://lafcadio.rubyforge.org/tutorial.html.
 
 module Lafcadio
-	Version = "0.6.6"
+	Version = "0.7.0"
 
 	require 'lafcadio/dateTime'
 	require 'lafcadio/depend'

data/lib/lafcadio.rb~

@@ -16,7 +16,7 @@
 # http://lafcadio.rubyforge.org/tutorial.html.
 
 module Lafcadio
-	Version = "0.6.5"
+	Version = "0.6.0"
 
 	require 'lafcadio/dateTime'
 	require 'lafcadio/depend'

data/lib/lafcadio/domain.rb

@@ -1,4 +1,3 @@
-require 'extensions/module'
 require 'lafcadio/objectField'
 require 'lafcadio/util'
 require 'rexml/document'
@@ -278,13 +277,6 @@ module Lafcadio
 			unless class_fields
 				@@class_fields[self] = self.get_class_fields
 				class_fields = @@class_fields[self]
-				class_fields.each do |class_field|
-					begin
-						undef_method class_field.name.to_sym
-					rescue NameError
-						# not defined globally or in an included Module, skip it
-					end
-				end
 			end
 			class_fields
 		end
@@ -295,15 +287,13 @@ module Lafcadio
 				class_fields = [ @@pk_fields[self] ]
 				@@class_fields[self] = class_fields
 			end
-			unless class_fields.any? { |cf| cf.name == name }
-				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
+			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:
@@ -339,8 +329,6 @@ module Lafcadio
 		def self.get_class_fields
 			if self.methods( false ).include?( 'get_class_fields' )
 				[ @@pk_fields[ self ] ]
-			elsif abstract_subclasses.include?( self )
-				[]
 			else
 				xmlParser = try_load_xml_parser
 				if xmlParser
@@ -360,7 +348,7 @@ module Lafcadio
 				[]
 			end
 		end
-
+		
 		def self.get_field( fieldName ) #:nodoc:
 			aDomainClass = self
 			field = nil
@@ -371,7 +359,7 @@ module Lafcadio
 			if field
 				field
 			else
-				errStr = "Couldn't find field \"#{ fieldName }\" in " +
+				errStr = "Couldn't find field \"#{ field }\" in " +
 								 "#{ self } domain class"
 				raise( MissingError, errStr, caller )
 			end
@@ -405,7 +393,8 @@ module Lafcadio
 		
 		def self.method_missing( methodId, *args ) #:nodoc:
 			method_name = methodId.id2name
-			maybe_field_class_name = method_name.underscore_to_camel_case + 'Field'
+			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

data/lib/lafcadio/domain.rb~

@@ -1,4 +1,3 @@
-require 'extensions/module'
 require 'lafcadio/objectField'
 require 'lafcadio/util'
 require 'rexml/document'
@@ -278,13 +277,6 @@ module Lafcadio
 			unless class_fields
 				@@class_fields[self] = self.get_class_fields
 				class_fields = @@class_fields[self]
-				class_fields.each do |class_field|
-					begin
-						undef_method class_field.name.to_sym
-					rescue NameError
-						# not defined globally or in an included Module, skip it
-					end
-				end
 			end
 			class_fields
 		end
@@ -337,8 +329,6 @@ module Lafcadio
 		def self.get_class_fields
 			if self.methods( false ).include?( 'get_class_fields' )
 				[ @@pk_fields[ self ] ]
-			elsif abstract_subclasses.include?( self )
-				[]
 			else
 				xmlParser = try_load_xml_parser
 				if xmlParser
@@ -352,13 +342,16 @@ module Lafcadio
 		end
 
 		def self.get_domain_dirs #:nodoc:
-			if ( domainDirStr = LafcadioConfig.new['domainDirs'] )
-				domainDirStr.split(',')
+			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
@@ -369,7 +362,7 @@ module Lafcadio
 			if field
 				field
 			else
-				errStr = "Couldn't find field \"#{ fieldName }\" in " +
+				errStr = "Couldn't find field \"#{ field }\" in " +
 								 "#{ self } domain class"
 				raise( MissingError, errStr, caller )
 			end
@@ -403,7 +396,8 @@ module Lafcadio
 		
 		def self.method_missing( methodId, *args ) #:nodoc:
 			method_name = methodId.id2name
-			maybe_field_class_name = method_name.underscore_to_camel_case + 'Field'
+			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

data/lib/lafcadio/mock.rb

@@ -11,6 +11,9 @@ module Lafcadio
 		end
 
 		def commit(db_object)
+			if db_object.pk_id and !db_object.pk_id.is_a?( Integer )
+				raise ArgumentError
+			end
 			objects_by_domain_class = get_objects_by_domain_class(
 				db_object.domain_class
 			)
@@ -28,7 +31,7 @@ module Lafcadio
 		end
 		
 		def get_collection_by_query(query)
-			@query_count[query] += 1
+			@query_count[query.to_sql] += 1
 			objects = []
 			_get_all( query.domain_class ).each { |dbObj|
 				if query.condition
@@ -37,14 +40,12 @@ module Lafcadio
 					objects << dbObj
 				end
 			}
+			if (range = query.limit)
+				objects = objects[0..(range.last - range.first)]
+			end
 			if ( order_by = query.order_by )
 				objects = objects.sort_by { |dobj| dobj.send( order_by ) }
 				objects.reverse! if query.order_by_order == Query::DESC
-			else
-				objects = objects.sort_by { |dobj| dobj.pk_id }
-			end
-			if (range = query.limit)
-				objects = objects[range]
 			end
 			objects
 		end
@@ -74,14 +75,10 @@ module Lafcadio
 
 		def group_query( query )
 			if query.class == Query::Max
-				dobjs_by_pk_id = @objects[query.domain_class]
-				if dobjs_by_pk_id
-					dobjs = dobjs_by_pk_id.values.sort_by { |dobj|
-						dobj.send( query.field_name )
-					}
-					[ dobjs.last.send( query.field_name ) ]
+				if ( query.field_name == 'pk_id' || query.field_name == 'rate' )
+					query.collect( @objects[query.domain_class].values )
 				else
-					[ nil ]
+					raise "Can't handle query with sql '#{ query.to_sql }'"
 				end
 			end
 		end

data/lib/lafcadio/mock.rb~

@@ -11,6 +11,9 @@ module Lafcadio
 		end
 
 		def commit(db_object)
+			if db_object.pk_id and !db_object.pk_id.is_a?( Integer )
+				raise ArgumentError
+			end
 			objects_by_domain_class = get_objects_by_domain_class(
 				db_object.domain_class
 			)
@@ -28,7 +31,7 @@ module Lafcadio
 		end
 		
 		def get_collection_by_query(query)
-			@query_count[query] += 1
+			@query_count[query.to_sql] += 1
 			objects = []
 			_get_all( query.domain_class ).each { |dbObj|
 				if query.condition
@@ -37,14 +40,12 @@ module Lafcadio
 					objects << dbObj
 				end
 			}
+			if (range = query.limit)
+				objects = objects[0..(range.last - range.first)]
+			end
 			if ( order_by = query.order_by )
 				objects = objects.sort_by { |dobj| dobj.send( order_by ) }
 				objects.reverse! if query.order_by_order == Query::DESC
-			else
-				objects = objects.sort_by { |dobj| dobj.pk_id }
-			end
-			if (range = query.limit)
-				objects = objects[range]
 			end
 			objects
 		end

data/lib/lafcadio/objectField.rb

@@ -424,7 +424,7 @@ module Lafcadio
 			unless name
 				linked_type.name =~ /::/
 				name = $' || linked_type.name
-				name = name.camel_case_to_underscore
+				name = name.decapitalize
 			end
 			super( domain_class, name )
 			( @linked_type, @delete_cascade ) = linked_type, delete_cascade

data/lib/lafcadio/objectStore.rb

@@ -11,10 +11,9 @@ module Lafcadio
 
 		attr_reader :commit_type, :db_object
 
-		def initialize(db_object, dbBridge, cache)
+		def initialize(db_object, dbBridge)
 			@db_object = db_object
 			@dbBridge = dbBridge
-			@cache = cache
 			@objectStore = ObjectStore.get_object_store
 			@commit_type = nil
 		end
@@ -29,7 +28,6 @@ module Lafcadio
 			unless @db_object.pk_id
 				@db_object.pk_id = @dbBridge.last_pk_id_inserted
 			end
-			@cache.update_after_commit self
 			@db_object.post_commit_trigger
 		end
 
@@ -131,8 +129,12 @@ module Lafcadio
 		
 		def group_query( query )
 			execute_select( query.to_sql )[0].collect { |val|
-				a_field = query.domain_class.get_field( query.field_name )
-				a_field.value_from_sql( val )
+				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
+				end
 			}
 		end
 
@@ -441,7 +443,7 @@ module Lafcadio
 		def get_db_bridge; @dbBridge; end
 		
 		def get_field_name( domain_object )
-			domain_object.domain_class.basename.camel_case_to_underscore
+			domain_object.domain_class.basename.decapitalize
 		end
 
 		def get_filtered(domain_class_name, searchTerm, fieldName = nil) #:nodoc:
@@ -538,8 +540,9 @@ module Lafcadio
 			end
 
 			def commit( db_object )
-				committer = Committer.new db_object, @dbBridge, self
+				committer = Committer.new db_object, @dbBridge
 				committer.execute
+				update_after_commit( committer )
 			end
 
 			# Flushes a domain object.
@@ -570,11 +573,23 @@ module Lafcadio
 
 			def get_by_query( query )
 				unless @collections_by_query[query]
-					newObjects = @dbBridge.get_collection_by_query(query)
-					newObjects.each { |dbObj| save dbObj }
-					@collections_by_query[query] = newObjects.collect { |dobj|
-						dobj.pk_id
-					}
+					superset_query, pk_ids =
+						@collections_by_query.find { |other_query, pk_ids|
+							query.implies?( other_query )
+						}
+					if pk_ids
+						@collections_by_query[query] = ( pk_ids.collect { |pk_id|
+							get( query.domain_class, pk_id )
+						} ).select { |dobj| query.object_meets( dobj ) }.collect { |dobj|
+							dobj.pk_id
+						}
+					elsif @collections_by_query.values
+						newObjects = @dbBridge.get_collection_by_query(query)
+						newObjects.each { |dbObj| save dbObj }
+						@collections_by_query[query] = newObjects.collect { |dobj|
+							dobj.pk_id
+						}
+					end
 				end
 				collection = []
 				@collections_by_query[query].each { |pk_id|

data/lib/lafcadio/objectStore.rb~

@@ -129,8 +129,12 @@ module Lafcadio
 		
 		def group_query( query )
 			execute_select( query.to_sql )[0].collect { |val|
-				a_field = query.domain_class.get_field( query.field_name )
-				a_field.value_from_sql( val )
+				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
+				end
 			}
 		end
 
@@ -439,7 +443,7 @@ module Lafcadio
 		def get_db_bridge; @dbBridge; end
 		
 		def get_field_name( domain_object )
-			domain_object.domain_class.basename.camel_case_to_underscore
+			domain_object.domain_class.basename.decapitalize
 		end
 
 		def get_filtered(domain_class_name, searchTerm, fieldName = nil) #:nodoc:

data/lib/lafcadio/query.rb

@@ -140,17 +140,30 @@ module Lafcadio
 		def limit_clause
 			"limit #{ @limit.begin }, #{ @limit.end - @limit.begin + 1 }" if @limit
 		end
+		
+		def object_meets( dobj ); @condition.object_meets( dobj ); end
 
 		def or( &action ); compound( CompoundCondition::OR, action ); end
 		
 		def order_clause
 			if @order_by
-				order_by_field = @domain_class.get_field( @order_by )
-				clause = "order by #{ order_by_field.db_field_name } "
+				clause = "order by #{ @order_by } "
 				clause += @order_by_order == ASC ? 'asc' : 'desc'
 				clause
 			end
 		end
+		
+		def implies?( other_query )
+			if other_query == self
+				true
+			elsif @domain_class == other_query.domain_class
+				if other_query.condition.nil? and !self.condition.nil?
+					true
+				else
+					self.condition and self.condition.implies?( other_query.condition )
+				end
+			end
+		end
 
 		def sql_primary_key_field(domain_class)
 			"#{ domain_class.table_name }.#{ domain_class.sql_primary_key_name }"
@@ -208,9 +221,34 @@ module Lafcadio
 				end
 			end
 			
+			def implies?( other_condition )
+				self.eql?( other_condition ) or (
+					other_condition.respond_to?( :implied_by? ) and 
+							other_condition.implied_by?( self )
+				)
+			end
+			
 			def db_field_name; get_field.db_table_and_field_name; end
 			
-			def get_field; @domain_class.get_field( @fieldName ); end
+			def eql?( other_cond )
+				other_cond.is_a?( Condition ) and other_cond.to_sql == to_sql
+			end
+			
+			def get_field
+				a_domain_class = @domain_class
+				field = nil
+				while ( a_domain_class < DomainObject ) && !field
+					field = a_domain_class.get_class_field( @fieldName )
+					a_domain_class = a_domain_class.superclass
+				end
+				if field
+					field
+				else
+					errStr = "Couldn't find field \"#{ @fieldName }\" in " +
+									 "#{ @domain_class } domain class"
+					raise( MissingError, errStr, caller )
+				end
+			end
 			
 			def query; Query.new( @domain_class, self ); end
 			
@@ -272,22 +310,38 @@ module Lafcadio
 		class CompoundCondition < Condition #:nodoc:
 			AND = 1
 			OR  = 2
-		
-			def initialize( *args )
-				if( [ AND, OR ].index( args.last) )
-					@compoundType = args.last
-					args.pop
+			
+			def initialize(*conditions)
+				if( [ AND, OR ].index(conditions.last) )
+					@compound_type = conditions.last
+					conditions.pop
 				else
-					@compoundType = AND
+					@compound_type = AND
 				end
-				@conditions = args.map { |arg|
-					arg.respond_to?( :to_condition ) ? arg.to_condition : arg
+				@conditions = conditions
+				@domain_class = conditions[0].domain_class
+			end
+			
+			def implied_by?( other_condition )
+				@compound_type == OR && @conditions.any? { |cond|
+					cond.implies?( other_condition )
 				}
-				@domain_class = @conditions[0].domain_class
+			end
+			
+			def implies?( other_condition )
+				super( other_condition ) or (
+					@compound_type == AND and @conditions.any? { |cond|
+						cond.implies?( other_condition )
+					}
+				) or (
+					@compound_type == OR and @conditions.all? { |cond|
+						cond.implies?( other_condition )
+					}
+				)
 			end
 
 			def object_meets(anObj)
-				if @compoundType == AND
+				if @compound_type == AND
 					@conditions.inject( true ) { |result, cond|
 						result && cond.object_meets( anObj )
 					}
@@ -299,7 +353,7 @@ module Lafcadio
 			end
 
 			def to_sql
-				booleanString = @compoundType == AND ? 'and' : 'or'
+				booleanString = @compound_type == AND ? 'and' : 'or'
 				subSqlStrings = @conditions.collect { |cond| cond.to_sql }
 				"(#{ subSqlStrings.join(" #{ booleanString } ") })"
 			end
@@ -415,11 +469,11 @@ module Lafcadio
 			
 			def get_regexp
 				if @matchType == PRE_AND_POST
-					Regexp.new( @searchTerm, Regexp::IGNORECASE )
+					Regexp.new(@searchTerm)
 				elsif @matchType == PRE_ONLY
-					Regexp.new( @searchTerm.to_s + "$", Regexp::IGNORECASE )
+					Regexp.new(@searchTerm.to_s + "$")
 				elsif @matchType == POST_ONLY
-					Regexp.new( "^" + @searchTerm, Regexp::IGNORECASE )
+					Regexp.new("^" + @searchTerm)
 				end
 			end
 

data/lib/lafcadio/query.rb~

@@ -145,8 +145,7 @@ module Lafcadio
 		
 		def order_clause
 			if @order_by
-				order_by_field = @domain_class.get_field( @order_by )
-				clause = "order by #{ order_by_field.db_field_name } "
+				clause = "order by #{ @order_by } "
 				clause += @order_by_order == ASC ? 'asc' : 'desc'
 				clause
 			end
@@ -210,7 +209,21 @@ module Lafcadio
 			
 			def db_field_name; get_field.db_table_and_field_name; end
 			
-			def get_field; @domain_class.get_field( @fieldName ); end
+			def get_field
+				a_domain_class = @domain_class
+				field = nil
+				while ( a_domain_class < DomainObject ) && !field
+					field = a_domain_class.get_class_field( @fieldName )
+					a_domain_class = a_domain_class.superclass
+				end
+				if field
+					field
+				else
+					errStr = "Couldn't find field \"#{ @fieldName }\" in " +
+									 "#{ @domain_class } domain class"
+					raise( MissingError, errStr, caller )
+				end
+			end
 			
 			def query; Query.new( @domain_class, self ); end
 			
@@ -273,17 +286,15 @@ module Lafcadio
 			AND = 1
 			OR  = 2
 		
-			def initialize( *args )
-				if( [ AND, OR ].index( args.last) )
-					@compoundType = args.last
-					args.pop
+			def initialize(*conditions)
+				if( [ AND, OR ].index(conditions.last) )
+					@compoundType = conditions.last
+					conditions.pop
 				else
 					@compoundType = AND
 				end
-				@conditions = args.map { |arg|
-					arg.respond_to?( :to_condition ) ? arg.to_condition : arg
-				}
-				@domain_class = @conditions[0].domain_class
+				@conditions = conditions
+				@domain_class = conditions[0].domain_class
 			end
 
 			def object_meets(anObj)

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

@@ -0,0 +1,13 @@
+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,5 +1,4 @@
 require 'delegate'
-require 'lafcadio/depend'
 require 'singleton'
 
 module Lafcadio
@@ -67,16 +66,14 @@ module Lafcadio
 	class ContextualService
 		def self.flush; Context.instance.set_resource( self, nil ); end
 	
-		def self.method_missing( symbol, *args )
-			method_name = symbol.id2name
-			target = nil
-			if method_name =~ /^get_(.*)/
-				target = :get_resource if $1.underscore_to_camel_case == basename
-			elsif method_name =~ /^set_(.*)/
-				target = :set_resource if $1.underscore_to_camel_case == basename
-			end
-			if target
-				Context.instance.send( target, self, *args )
+		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
@@ -133,12 +130,8 @@ module Lafcadio
 			consonantYPattern = Regexp.new("([^aeiou])y$", Regexp::IGNORECASE)
 			if singular =~ consonantYPattern
 				singular.gsub consonantYPattern, '\1ies'
-			elsif singular =~ /^(.*)xis$/
-				$1 + 'xes'
 			elsif singular =~ /[xs]$/
 				singular + "es"
-			elsif singular =~ /(.*)tum$/
-				$1 + 'ta'
 			else
 				singular + "s"
 			end

data/lib/lafcadio/util.rb~

@@ -1,5 +1,4 @@
 require 'delegate'
-require 'lafcadio/depend'
 require 'singleton'
 
 module Lafcadio
@@ -67,16 +66,14 @@ module Lafcadio
 	class ContextualService
 		def self.flush; Context.instance.set_resource( self, nil ); end
 	
-		def self.method_missing( symbol, *args )
-			method_name = symbol.id2name
-			target = nil
-			if method_name =~ /^get_(.*)/
-				target = :get_resource if $1.underscore_to_camel_case == basename
-			elsif method_name =~ /^set_(.*)/
-				target = :set_resource if $1.underscore_to_camel_case == basename
-			end
-			if target
-				Context.instance.send( target, self, *args )
+		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

metadata

@@ -1,13 +1,14 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.8.6
+rubygems_version: 0.8.1
 specification_version: 1
 name: lafcadio
 version: !ruby/object:Gem::Version 
-  version: 0.6.6
-date: 2005-08-14
+  version: 0.7.0
+date: 2005-01-20
 summary: Lafcadio is an object-relational mapping layer
 require_paths: 
   - lib
+author: Francis Hwang
 email: sera@fhwang.net
 homepage: http://lafcadio.rubyforge.org/
 rubyforge_project: 
@@ -28,8 +29,6 @@ required_ruby_version: !ruby/object:Gem::Version::Requirement
         version: 0.0.0
   version: 
 platform: ruby
-authors: 
-  - Francis Hwang
 files: 
   - lib/lafcadio
   - lib/lafcadio.rb
@@ -41,7 +40,6 @@ files:
   - lib/lafcadio/mock.rb
   - lib/lafcadio/mock.rb~
   - lib/lafcadio/objectField.rb
-  - lib/lafcadio/objectField.rb~
   - lib/lafcadio/objectStore.rb
   - lib/lafcadio/objectStore.rb~
   - lib/lafcadio/query.rb
@@ -52,6 +50,7 @@ files:
   - 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/objectField.rb~

@@ -1,561 +0,0 @@
-require 'date'
-require 'lafcadio/dateTime'
-require 'lafcadio/util'
-
-module Lafcadio
-	# ObjectField is the abstract base class of any field for domain objects.
-	class ObjectField
-		include Comparable
-
-		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 )
-			instantiate_with_parameters( domain_class, parameters )
-		end
-
-		def self.instantiate_with_parameters( domain_class, parameters ) #:nodoc:
-			instance = self.new( domain_class, parameters['name'] )
-			if ( db_field_name = parameters['db_field_name'] )
-				instance.db_field_name = db_field_name
-			end
-			instance
-		end
-
-		def self.instantiation_parameters( fieldElt ) #:nodoc:
-			parameters = {}
-			parameters['name'] = fieldElt.attributes['name']
-			parameters['db_field_name'] = fieldElt.attributes['db_field_name']
-			parameters
-		end
-		
-		def self.value_type #:nodoc:
-			Object
-		end
-
-		# [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
-		end
-		
-		def <=>(other)
-			if @domain_class == other.domain_class && name == other.name
-				0
-			else
-				object_id <=> other.object_id
-			end
-		end
-
-		def bind_write?; false; end #:nodoc:
-		
-		def db_table_and_field_name
-			"#{ domain_class.table_name }.#{ db_field_name }"
-		end
-
-		def db_will_automatically_write #:nodoc:
-			false
-		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.
-		def name_for_sql
-			db_field_name
-		end
-
-		def prev_value(pk_id) #:nodoc:
-			prevObject = ObjectStore.get_object_store.get( @domain_class, pk_id )
-			prevObject.send(name)
-		end
-
-		def process_before_verify(value) #:nodoc:
-			value = @default if value == nil
-			value
-		end
-
-		# Returns a string value suitable for committing this field's value to 
-		# MySQL.
-		def value_for_sql(value)
-			value || 'null'
-		end
-
-		def verify(value, pk_id) #:nodoc:
-			if value.nil? && not_null
-				raise(
-					FieldValueError,
-					"#{ self.domain_class.name }##{ name } can not be nil.",
-					caller
-				)
-			end
-			verify_non_nil( value, pk_id ) if value
-		end
-
-		def verify_non_nil( value, pk_id )
-			value_type = self.class.value_type
-			unless value.class <= value_type
-				raise(
-					FieldValueError, 
-					"#{ domain_class.name }##{ name } needs a " + value_type.name +
-				           " value.",
-					caller
-				)
-			end
-		end
-
-		# Given the SQL value string, returns a Ruby-native value.
-		def value_from_sql(string)
-			string
-		end
-	end
-
-	# IntegerField represents an integer.
-	class IntegerField < ObjectField
-		def value_from_sql(string) #:nodoc:
-			value = super
-			value ? value.to_i : nil
-		end
-	end
-
-	# A TextField is expected to contain a string value.
-	class TextField < ObjectField
-		def value_for_sql(value) #:nodoc:
-			if value
-				value = value.gsub(/(\\?')/) { |m| m.length == 1 ? "''" : m }
-				value = value.gsub(/\\/) { '\\\\' }
-				"'#{value}'"
-			else
-				"null"
-			end
-		end
-	end
-
-	# BlobField stores a string value and expects to store its value in a BLOB
-	# field in the database.
-	class BlobField < ObjectField
-		attr_accessor :size
-		
-		def self.value_type; String; end
-
-		def bind_write?; true; end #:nodoc:
-
-		def value_for_sql(value); "?"; end #:nodoc:
-	end
-
-	# BooleanField represents a boolean value. By default, it assumes that the
-	# table field represents True and False with the integers 1 and 0. There are
-	# two different ways to change this default.
-	#
-	# First, BooleanField includes a few enumerated defaults. Currently there are
-	# only
-	#   * BooleanField::ENUMS_ONE_ZERO (the default, uses integers 1 and 0)
-	#   * BooleanField::ENUMS_CAPITAL_YES_NO (uses characters 'Y' and 'N')
-	# In the XML class definition, this field would look like
-	#   <field name="field_name" class="BooleanField"
-	#          enum_type="ENUMS_CAPITAL_YES_NO"/>
-	# If you're defining a field in Ruby, simply set BooleanField#enum_type to one
-	# of the values.
-	#
-	# For more fine-grained specification you can pass specific values in. Use
-	# this format for the XML class definition:
-	#   <field name="field_name" class="BooleanField">
-	#     <enums>
-	#       <enum key="true">yin</enum>
-	#       <enum key="false">tang</enum>
-	#     </enums>
-	#   </field>
-	# If you're defining the field in Ruby, set BooleanField#enums to a hash.
-	#   myBooleanField.enums = { true => 'yin', false => 'yang' }
-	#
-	# +enums+ takes precedence over +enum_type+.
-	class BooleanField < ObjectField
-		ENUMS_ONE_ZERO = 0
-		ENUMS_CAPITAL_YES_NO = 1
-
-		attr_accessor :enum_type, :enums
-
-		def initialize( domain_class, name )
-			super( domain_class, name )
-			@enum_type = ENUMS_ONE_ZERO
-			@enums = nil
-		end
-
-		def false_enum # :nodoc:
-			get_enums[false]
-		end
-
-		def get_enums( value = nil ) # :nodoc:
-			if @enums
-				@enums
-			elsif @enum_type == ENUMS_ONE_ZERO
-				if value.class == String
-					{ true => '1', false => '0' }
-				else
-					{ true => 1, false => 0 }
-				end
-			elsif @enum_type == ENUMS_CAPITAL_YES_NO
-				{ true => 'Y', false => 'N' }
-			else
-				raise MissingError
-			end
-		end
-
-		def text_enum_type # :nodoc:
-			@enums ? @enums[true].class == String : @enum_type == ENUMS_CAPITAL_YES_NO
-		end
-
-		def true_enum( value = nil ) # :nodoc:
-			get_enums( value )[true]
-		end
-
-		def value_for_sql(value) # :nodoc:
-			if value
-				vfs = true_enum
-			else
-				vfs = false_enum
-			end
-			text_enum_type ? "'#{vfs}'" : vfs
-		end
-
-		def value_from_sql(value, lookupLink = true) # :nodoc:
-			value == true_enum( value )
-		end
-	end
-
-	# DateField represents a Date.
-	class DateField < ObjectField
-		def self.value_type # :nodoc:
-			Date
-		end
-
-		def initialize( domain_class, name = "date" )
-			super( domain_class, name )
-		end
-
-		def value_for_sql(value) # :nodoc:
-			value ? "'#{value.to_s}'" : 'null'
-		end
-
-		def value_from_sql(dbiDate, lookupLink = true) # :nodoc:
-			begin
-				dbiDate ? dbiDate.to_date : nil
-			rescue ArgumentError
-				nil
-			end
-		end
-	end
-	
-	# DateTimeField represents a DateTime.
-	class DateTimeField < ObjectField
-		def value_for_sql(value) # :nodoc:
-			if value
-				year = value.year
-				month = value.mon.to_s.pad( 2, "0" )
-				day = value.day.to_s.pad( 2, "0" )
-				hour = value.hour.to_s.pad( 2, "0" )
-				minute = value.min.to_s.pad( 2, "0" )
-				second = value.sec.to_s.pad( 2, "0" )
-				"'#{year}-#{month}-#{day} #{hour}:#{minute}:#{second}'"
-			else
-				"null"
-			end
-		end
-
-		def value_from_sql(dbi_value, lookupLink = true) # :nodoc:
-			dbi_value ? dbi_value.to_time : nil
-		end
-	end
-	
-	# DecimalField represents a decimal value.
-	class DecimalField < ObjectField
-		def self.instantiate_with_parameters( domain_class, parameters ) #:nodoc:
-			self.new( domain_class, parameters['name'] )
-		end
-
-		def self.value_type #:nodoc:
-			Numeric
-		end
-
-		def process_before_verify(value) #:nodoc:
-			value = super value
-			value != nil && value != '' ? value.to_f : nil
-		end
-
-		def value_from_sql(string, lookupLink = true) #:nodoc:
-			string != nil ? string.to_f : nil
-		end
-	end
-
-	# EmailField takes a text value that is expected to be formatted as a single
-	# valid email address.
-	class EmailField < TextField
-		# Is +address+ a valid email address?
-		def self.valid_address(address)
-			address =~ /^[^ @]+@[^ \.]+\.[^ ,]+$/
-		end
-
-		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,
-				  "#{ domain_class.name }##{ name } needs a valid email address.",
-				  caller
-				)
-			end
-		end
-	end
-
-	# EnumField represents an enumerated field that can only be set to one of a
-	# set range of string values. To set the enumeration in the class definition
-	# XML, use the following format:
-	#   <field name="flavor" class="EnumField">
-	#     <enums>
-	#       <enum>Vanilla</enum>
-	#       <enum>Chocolate</enum>
-	#       <enum>Lychee</enum>
-	#     </enums>
-	#   </field>
-	# If you're defining the field in Ruby, you can simply pass in an array of
-	# enums as the +enums+ argument.
-	#
-	class EnumField < TextField
-		def self.instantiate_with_parameters( domain_class, parameters ) #:nodoc:
-			self.new( domain_class, parameters['name'], parameters['enums'] )
-		end
-
-		def self.enum_queue_hash( fieldElt )
-			enumValues = []
-			fieldElt.elements.each( 'enums/enum' ) { |enumElt|
-				enumValues << enumElt.attributes['key']
-				enumValues << enumElt.text.to_s
-			}
-			QueueHash.new( *enumValues )
-		end
-
-		def self.instantiation_parameters( fieldElt ) #:nodoc:
-			parameters = super( fieldElt )
-			if fieldElt.elements['enums'][1].attributes['key']
-				parameters['enums'] = enum_queue_hash( fieldElt )
-			else
-				parameters['enums'] = []
-				fieldElt.elements.each( 'enums/enum' ) { |enumElt|
-					parameters['enums'] << enumElt.text.to_s
-				}
-			end
-			parameters
-		end
-		
-		attr_reader :enums
-
-		# [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
-				@enums = enums
-			end
-		end
-		
-		def value_for_sql(value) #:nodoc:
-			value != '' ?(super(value)) : 'null'
-		end
-		
-		def verify_non_nil( value, pk_id ) #:nodoc:
-			super
-			if @enums[value].nil?
-				key_str = '[ ' +
-				          ( @enums.keys.map { |key| "\"#{ key }\"" } ).join(', ') + ' ]'
-				err_str = "#{ @domain_class.name }##{ name } needs a value that is " +
-				          "one of #{ key_str }"
-				raise( FieldValueError, err_str, caller )
-			end
-		end
-	end
-	
-	class FieldValueError < RuntimeError #:nodoc:
-	end
-
-	# A LinkField is used to link from one domain class to another.
-	class LinkField < ObjectField
-		def self.instantiate_with_parameters( domain_class, parameters ) #:nodoc:
-			instance = self.new(
-				domain_class, parameters['linked_type'], parameters['name'],
-				parameters['delete_cascade']
-			)
-			if parameters['db_field_name']
-				instance.db_field_name = parameters['db_field_name']
-			end
-			instance
-		end
-
-		def self.instantiation_parameters( fieldElt ) #:nodoc:
-			parameters = super( fieldElt )
-			linked_typeStr = fieldElt.attributes['linked_type']
-			linked_type = DomainObject.get_domain_class_from_string( linked_typeStr )
-			parameters['linked_type'] = linked_type
-			parameters['delete_cascade'] = fieldElt.attributes['delete_cascade'] == 'y'
-			parameters
-		end
-
-		attr_reader :linked_type
-		attr_accessor :delete_cascade
-
-		# [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( domain_class, name )
-			( @linked_type, @delete_cascade ) = linked_type, delete_cascade
-		end
-
-		def value_from_sql(string) #:nodoc:
-			string != nil ? DomainObjectProxy.new(@linked_type, string.to_i) : nil
-		end
-
-		def value_for_sql(value) #:nodoc:
-			if !value
-				"null"
-			elsif value.pk_id
-				value.pk_id
-			else
-				raise( DomainObjectInitError, "Can't commit #{name} without pk_id", 
-				       caller )
-			end
-		end
-
-		def verify_non_nil(value, pk_id) #:nodoc:
-			super
-			if @linked_type != @domain_class && pk_id
-				subsetLinkField = @linked_type.class_fields.find { |field|
-					field.class == SubsetLinkField && field.subset_field == @name
-				}
-				if subsetLinkField
-					verify_subset_link_field( subsetLinkField, pk_id )
-				end
-			end
-		end
-
-		def verify_subset_link_field( subsetLinkField, pk_id )
-			begin
-				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
-					cantChangeMsg = "You can't change that."
-					raise FieldValueError, cantChangeMsg, caller
-				end
-			rescue DomainObjectNotFoundError
-				# no previous value, so nothing to check for
-			end
-		end
-	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
-		def self.value_type #:nodoc:
-			Month
-		end
-
-		def value_for_sql(value) #:nodoc:
-			"'#{value.year}-#{value.month}-01'"
-		end
-	end
-
-	class PrimaryKeyField < IntegerField
-		def initialize( domain_class )
-			super( domain_class, 'pk_id' )
-			@not_null = false
-		end
-	end
-
-	# A StateField is a specialized subclass of EnumField; its possible values are
-	# any of the 50 states of the United States, stored as each state's two-letter
-	# postal code.
-	class StateField < EnumField
-		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'] )
-		end
-
-		def self.instantiation_parameters( fieldElt )
-			parameters = super( fieldElt )
-			parameters['subset_field'] = fieldElt.attributes['subset_field']
-			parameters
-		end
-		
-		attr_accessor :subset_field
-
-		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
-
-	# TextListField maps to any String SQL field that tries to represent a 
-	# quick-and-dirty list with a comma-separated string. It returns an Array. 
-	# For example, a SQL field with the value "john,bill,dave", then the Ruby 
-	# field will have the value <tt>[ "john", "bill", "dave" ]</tt>.
-	class TextListField < ObjectField
-		def self.value_type #:nodoc:
-			Array
-		end
-
-		def value_for_sql(objectValue) #:nodoc:
-			if objectValue.is_a?( Array )
-				str = objectValue.join(',')
-			else
-				str = objectValue
-			end
-			"'" + str + "'"
-		end
-
-		def value_from_sql(sqlString, lookupLink = true) #:nodoc:
-			if sqlString
-				sqlString.split ','
-			else
-				[]
-			end
-		end
-	end
-
-	class TimeStampField < DateTimeField #:nodoc:
-		def initialize( domain_class, name = 'timeStamp' )
-			super( domain_class, name )
-			@not_null = false
-		end
-
-		def db_will_automatically_write
-			true
-		end
-	end
-end