lafcadio 0.9.2 → 0.9.3

data/lib/lafcadio/mock.rb~

@@ -9,6 +9,7 @@ module Lafcadio
 			@objects = {}
 			@next_pk_ids = {}
 			@queries = []
+			@transaction = nil
 		end
 
 		def all( domain_class )
@@ -22,21 +23,23 @@ module Lafcadio
 			all( domain_class ).each { |dbObj|
 				objects << dbObj if query.dobj_satisfies?( dbObj )
 			}
-			objects = order_collection( objects, query )
-			if (range = query.limit); objects = objects[range]; end
-			objects
+			query.order_and_limit_collection objects
 		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 = objects_by_domain_class db_object.domain_class
-			if db_object.delete
-				objects_by_domain_class.delete( db_object.pk_id )
+			if @transaction
+				@transaction << db_object
 			else
-				object_pk_id = pre_commit_pk_id( db_object )
-				objects_by_domain_class[object_pk_id] = db_object
+				objects_by_domain_class = objects_by_domain_class db_object.domain_class
+				if db_object.delete
+					objects_by_domain_class.delete( db_object.pk_id )
+				else
+					object_pk_id = pre_commit_pk_id( db_object )
+					objects_by_domain_class[object_pk_id] = db_object
+				end
 			end
 		end
 				
@@ -44,40 +47,33 @@ module Lafcadio
 			query.collect objects_by_domain_class( query.domain_class ).values
 		end
 		
+		def next_pk_id( domain_class )
+			dobjs = objects_by_domain_class( domain_class ).values
+			dobjs.inject( 0 ) { |memo, obj| memo > obj.pk_id ? memo : obj.pk_id } + 1
+		end
+
 		def objects_by_domain_class( domain_class )
 			@objects[domain_class] = {} unless @objects[domain_class]
 			@objects[domain_class]
 		end
 
-		def order_collection( objects, query )
-			objects = objects.sort_by { |dobj|
-				if ( order_by = query.order_by ).nil?
-					dobj.pk_id
-				elsif order_by.is_a?( Array )
-					order_by.map { |field_name| dobj.send( field_name ) }
-				else
-					dobj.send order_by
-				end
-			}
-			objects.reverse! if query.order_by_order == Query::DESC
-			objects
-		end
-		
-		def pre_commit_pk_id( db_object )
-			if db_object.pk_id
-				db_object.pk_id
+		def pre_commit_pk_id( domain_object )
+			@next_pk_ids = {} unless @next_pk_ids
+			if (next_pk_id = @next_pk_ids[domain_object.domain_class])
+				@next_pk_ids[domain_object.domain_class] = nil
+				@last_pk_id_inserted = next_pk_id
+			elsif domain_object.pk_id
+				domain_object.pk_id
+			elsif ( next_pk_id = @next_pk_ids[domain_object.domain_class] )
+				@last_pk_id_inserted = next_pk_id
+				@next_pk_ids[domain_object.domain_class] = nil
+				next_pk_id
 			else
-				if ( next_pk_id = @next_pk_ids[db_object.domain_class] )
-					@last_pk_id_inserted = next_pk_id
-					@next_pk_ids[db_object.domain_class] = nil
-					next_pk_id
-				else
-					pk_ids = objects_by_domain_class( db_object.domain_class ).keys
-					@last_pk_id_inserted = pk_ids.max ? pk_ids.max + 1 : 1
-				end
+				pk_ids = objects_by_domain_class( domain_object.domain_class ).keys
+				@last_pk_id_inserted = pk_ids.max ? pk_ids.max + 1 : 1
 			end
 		end
-		
+
 		def queries( domain_class = nil )
 			@queries.select { |qry|
 				domain_class ? qry.domain_class == domain_class : true
@@ -89,16 +85,43 @@ module Lafcadio
 		end
 		
 		def set_next_pk_id( domain_class, npi )
+			@next_pk_ids = {} unless @next_pk_ids
 			@next_pk_ids[ domain_class ] = npi
 		end
+		
+		def transaction( action )
+			tr = MockDbBridge::Transaction.new
+			@transaction = tr
+			begin
+				action.call tr
+				@transaction = nil
+				tr.each do |dobj_to_commit| commit( dobj_to_commit ); end
+			rescue RollbackError; end
+		end
+		
+		class Transaction < Array
+			def rollback; raise RollbackError; end
+		end
+		
+		class RollbackError < StandardError #:nodoc:
+		end
 	end
 
 	# Externally, the MockObjectStore looks and acts exactly like the ObjectStore,
 	# but stores all its data in memory. This makes it very useful for unit
 	# testing, and in fact LafcadioTestCase#setup creates a new instance of
-	# MockObjectStore for each test case.
+	# MockObjectStore for each test case. For example:
+	#
+	#   class SomeTestCase < Test::Unit::TestCase
+	#     def setup
+	#       @mock_object_store = Lafcadio::MockObjectStore.new
+	#       Lafcadio::ObjectStore.set_object_store @mock_object_store
+	#     end
+	#   end
 	class MockObjectStore < ObjectStore
-		def self.db_bridge; MockDbBridge.new; end
+		def self.db_bridge #:nodoc:
+			MockDbBridge.new
+		end
 		
 		public_class_method :new
 

data/lib/lafcadio/objectField.rb

@@ -148,9 +148,9 @@ module Lafcadio
 		end
 	end
 
-	# BlobField stores a string value and expects to store its value in a BLOB
-	# field in the database.
-	class BlobField < ObjectField
+	# BinaryField stores a string value and expects to store its value in a
+	# binary field in the database.
+	class BinaryField < ObjectField
 		def self.value_type #:nodoc:
 			String
 		end
@@ -166,12 +166,12 @@ module Lafcadio
 	#
 	# 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')
+	#   * :one_zero (the default, uses integers 1 and 0)
+	#   * :capital_yes_no (uses characters 'Y' and 'N')
+	#   * :raw_true_false (uses unquoted values 'true' and 'false')
 	# In a class definition, this would look like
 	#   class User < Lafcadio::DomainObject
-	#     boolean 'administrator',
-	#             { 'enum_type' => Lafcadio::BooleanField::ENUMS_CAPITAL_YES_NO }
+	#     boolean 'administrator', { 'enum_type' => :capital_yes_no }
 	#   end
 	#
 	# For more fine-grained specification you can pass a hash with the keys
@@ -182,31 +182,42 @@ module Lafcadio
 	#   end
 	# +enums+ takes precedence over +enum_type+.
 	class BooleanField < ObjectField
-		ENUMS_ONE_ZERO = 0
-		ENUMS_CAPITAL_YES_NO = 1
-
 		attr_accessor :enum_type
 		attr_writer   :enums
 
 		def initialize( domain_class, name )
 			super( domain_class, name )
-			@enum_type = ENUMS_ONE_ZERO
 			@enums = nil
 		end
+		
+		def default_enum_type
+			case ObjectStore.db_type
+			when 'Mysql'
+				:one_zero
+			when 'Pg'
+				:raw_true_false
+			end
+		end
 
 		def enums( value = nil ) # :nodoc:
 			if @enums
 				@enums
-			elsif @enum_type == ENUMS_ONE_ZERO
-				if value.is_a?( String )
-					{ true => '1', false => '0' }
+			else
+				enum_type = ( @enum_type or default_enum_type )
+				case enum_type
+				when :one_zero
+					if value.is_a?( String )
+						{ true => '1', false => '0' }
+					else
+						{ true => 1, false => 0 }
+					end
+				when :capital_yes_no
+					{ true => 'Y', false => 'N' }
+				when :raw_true_false
+					{ true => true, false => false }
 				else
-					{ true => 1, false => 0 }
+					raise MissingError
 				end
-			elsif @enum_type == ENUMS_CAPITAL_YES_NO
-				{ true => 'Y', false => 'N' }
-			else
-				raise MissingError
 			end
 		end
 
@@ -215,7 +226,7 @@ module Lafcadio
 		end
 
 		def text_enum_type? # :nodoc:
-			@enums ? @enums[true].class == String : @enum_type == ENUMS_CAPITAL_YES_NO
+			@enums ? @enums[true].class == String : @enum_type == :capital_yes_no
 		end
 
 		def true_enum( value = nil ) # :nodoc:

data/lib/lafcadio/objectField.rb~

@@ -4,14 +4,28 @@ require 'lafcadio/util'
 
 module Lafcadio
 	# ObjectField is the abstract base class of any field for domain objects.
+	# Fields can be added to a domain class using DomainObject.string,
+	# DomainObject.integer, etc.
+	#
+	#   class User < Lafcadio::DomainObject
+	#     string 'fname'
+	#     date   'birthday'
+	#   end
+	#
+	# All fields accept the following arguments in hashes:
+	# [not_nil]        This is +true+ by default. Set it to +false+ to avoid
+	#                  checking for nil values in tests.
+	# [db_field_name]  By default, fields are assumed to have the same name in
+	#                  the database, but you can override this assumption using
+	#                  +db_field_name+.
+	#
+	#   class User < Lafcadio::DomainObject
+	#     string 'fname', { 'not_nil' => false }
+	#     date   'birthday', { 'db_field_name' => 'bday' }
+	#   end
 	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 )
+		def self.create_from_xml( domain_class, fieldElt ) #:nodoc:
+			parameters = creation_parameters( fieldElt )
 			create_with_args( domain_class, parameters )
 		end
 
@@ -23,7 +37,7 @@ module Lafcadio
 			instance
 		end
 
-		def self.instantiation_parameters( fieldElt ) #:nodoc:
+		def self.creation_parameters( fieldElt ) #:nodoc:
 			parameters = {}
 			parameters['name'] = fieldElt.attributes['name']
 			parameters['db_field_name'] = fieldElt.attributes['db_field_name']
@@ -34,13 +48,18 @@ module Lafcadio
 			Object
 		end
 
-		# [domain_class]  The domain class that this object field belongs to.
+		include Comparable
+
+		attr_reader :domain_class, :name
+		attr_accessor :db_field_name, :not_nil
+
+		# [domain_class]  The domain class that this 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
+			@not_nil = true
 		end
 		
 		def <=>(other)
@@ -51,23 +70,18 @@ module Lafcadio
 			end
 		end
 
-		def bind_write?; false; end #:nodoc:
+		def bind_write? #:nodoc:
+			false
+		end
 		
-		def db_table_and_field_name
+		def db_column #:nodoc:
 			"#{ domain_class.table_name }.#{ db_field_name }"
 		end
 
-		def db_will_automatically_write #:nodoc:
+		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)
@@ -85,17 +99,17 @@ module Lafcadio
 		end
 
 		def verify(value, pk_id) #:nodoc:
-			if value.nil? && not_null
+			if value.nil? && not_nil
 				raise(
 					FieldValueError,
 					"#{ self.domain_class.name }##{ name } can not be nil.",
 					caller
 				)
 			end
-			verify_non_nil( value, pk_id ) if value
+			verify_non_nil_value( value, pk_id ) if value
 		end
 
-		def verify_non_nil( value, pk_id )
+		def verify_non_nil_value( value, pk_id ) #:nodoc:
 			value_type = self.class.value_type
 			unless value.class <= value_type
 				raise(
@@ -115,7 +129,7 @@ module Lafcadio
 
 	# A StringField is expected to contain a string value.
 	class StringField < ObjectField
-		def value_for_sql(value) #:nodoc:
+		def value_for_sql(value)
 			if value
 				value = value.gsub(/(\\?')/) { |m| m.length == 1 ? "''" : m }
 				value = value.gsub(/\\/) { '\\\\' }
@@ -128,100 +142,103 @@ module Lafcadio
 
 	# IntegerField represents an integer.
 	class IntegerField < ObjectField
-		def value_from_sql(string) #:nodoc:
+		def value_from_sql(string)
 			value = super
 			value ? value.to_i : nil
 		end
 	end
 
-	# BlobField stores a string value and expects to store its value in a BLOB
+	# BinaryField 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
+	class BinaryField < ObjectField
+		def self.value_type #:nodoc:
+			String
+		end
 
 		def bind_write?; true; end #:nodoc:
 
-		def value_for_sql(value); "?"; end #:nodoc:
+		def value_for_sql(value); "?"; end
 	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.
+	# 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' }
+	#   * :one_zero (the default, uses integers 1 and 0)
+	#   * :capital_yes_no (uses characters 'Y' and 'N')
+	#   * :raw_true_false (uses unquoted values 'true' and 'false')
+	# In a class definition, this would look like
+	#   class User < Lafcadio::DomainObject
+	#     boolean 'administrator', { 'enum_type' => :capital_yes_no }
+	#   end
 	#
+	# For more fine-grained specification you can pass a hash with the keys
+	# +true+ and +false+ using the argument +enums+.
+	#   class User < Lafcadio::DomainObject
+	#     boolean 'administrator',
+	#             { 'enums' => { true => 'yin', false => 'yang' } }
+	#   end
 	# +enums+ takes precedence over +enum_type+.
 	class BooleanField < ObjectField
-		ENUMS_ONE_ZERO = 0
-		ENUMS_CAPITAL_YES_NO = 1
-
-		attr_accessor :enum_type, :enums
+		attr_accessor :enum_type
+		attr_writer   :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]
+		
+		def default_enum_type
+			case ObjectStore.db_type
+			when 'Mysql'
+				:one_zero
+			when 'Pg'
+				:raw_true_false
+			end
 		end
 
-		def get_enums( value = nil ) # :nodoc:
+		def enums( value = nil ) # :nodoc:
 			if @enums
 				@enums
-			elsif @enum_type == ENUMS_ONE_ZERO
-				if value.class == String
-					{ true => '1', false => '0' }
+			else
+				enum_type = ( @enum_type or default_enum_type )
+				case enum_type
+				when :one_zero
+					if value.is_a?( String )
+						{ true => '1', false => '0' }
+					else
+						{ true => 1, false => 0 }
+					end
+				when :capital_yes_no
+					{ true => 'Y', false => 'N' }
+				when :raw_true_false
+					{ true => true, false => false }
 				else
-					{ true => 1, false => 0 }
+					raise MissingError
 				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
+		def false_enum # :nodoc:
+			enums[false]
+		end
+
+		def text_enum_type? # :nodoc:
+			@enums ? @enums[true].class == String : @enum_type == :capital_yes_no
 		end
 
 		def true_enum( value = nil ) # :nodoc:
-			get_enums( value )[true]
+			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
+			vfs = value ? true_enum : false_enum
+			text_enum_type? ? "'#{ vfs }'" : vfs
 		end
 
-		def value_from_sql(value, lookupLink = true) # :nodoc:
+		def value_from_sql( value ) # :nodoc:
 			value == true_enum( value )
 		end
 	end
@@ -240,7 +257,7 @@ module Lafcadio
 			value ? "'#{value.to_s}'" : 'null'
 		end
 
-		def value_from_sql(dbiDate, lookupLink = true) # :nodoc:
+		def value_from_sql( dbiDate ) # :nodoc:
 			begin
 				dbiDate ? dbiDate.to_date : nil
 			rescue ArgumentError
@@ -265,16 +282,41 @@ module Lafcadio
 			end
 		end
 
-		def value_from_sql(dbi_value, lookupLink = true) # :nodoc:
+		def value_from_sql( dbi_value ) # :nodoc:
 			dbi_value ? dbi_value.to_time : nil
 		end
 	end
 
-	# A DomainObjectField is used to link from one domain class to another.
+	# A DomainObjectField is used to link from one domain class to another. To
+	# add such an association in a class definition, call
+	# DomainObject.domain_object:
+	#   class Invoice < Lafcadio::DomainObject
+	#     domain_object Client
+	#   end
+	# By default, the field name is assumed to be the same as the class name,
+	# only lower-cased and camel-case.
+	#   class LineItem < Lafcadio::DomainObject
+	#     domain_object Product         # field name 'product'
+	#     domain_object CatalogOrder    # field name 'catalog_order'
+	#   end
+	# The field name can be explicitly set as the 2nd argument of
+	# DomainObject.domain_object.
+	#   class Message < Lafcadio::DomainObject
+	#     domain_object User, 'sender'
+	#     domain_object User, 'recipient'
+	#   end
+	# Setting +delete_cascade+ to true means that if the domain object being
+	# associated to is deleted, this domain object will also be deleted.
+	#   class Invoice < Lafcadio::DomainObject
+	#     domain_object Client, 'client', { 'delete_cascade' => true }
+	#   end
+	#   cli = Client.new( 'name' => 'big company' ).commit
+	#   inv = Invoice.new( 'client' => cli ).commit
+	#   cli.delete!
+	#   inv_prime = Invoice[inv.pk_id] # => will raise DomainObjectNotFoundError
 	class DomainObjectField < ObjectField
-		def self.auto_name( linked_type )
-			linked_type.name =~ /::/
-			( $' || linked_type.name ).camel_case_to_underscore
+		def self.auto_name( linked_type ) #:nodoc:
+			linked_type.basename.camel_case_to_underscore
 		end
 
 		def self.create_with_args( domain_class, parameters ) #:nodoc:
@@ -290,51 +332,46 @@ module Lafcadio
 			instance
 		end
 
-		def self.instantiation_parameters( fieldElt ) #:nodoc:
+		def self.creation_parameters( fieldElt ) #:nodoc:
 			parameters = super( fieldElt )
 			linked_typeStr = fieldElt.attributes['linked_type']
-			linked_type = Class.by_name linked_typeStr
-			parameters['linked_type'] = linked_type
-			parameters['delete_cascade'] = fieldElt.attributes['delete_cascade'] == 'y'
+			parameters['linked_type'] = Class.by_name linked_typeStr
+			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 )
+		                delete_cascade = false ) #:nodoc:
 			name = self.class.auto_name( linked_type ) unless name
 			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
+			if value.nil?
 				"null"
 			elsif value.pk_id
 				value.pk_id
 			else
-				raise( DomainObjectInitError, "Can't commit #{name} without pk_id", 
-				       caller )
+				raise(
+					DomainObjectInitError, "Can't commit #{name} without pk_id", caller
+				)
 			end
 		end
 
-		def verify_non_nil(value, pk_id) #:nodoc:
+		def value_from_sql(string) #:nodoc:
+			string ? DomainObjectProxy.new(@linked_type, string.to_i) : nil
+		end
+
+		def verify_non_nil_value(value, pk_id) #:nodoc:
 			super
 			if @linked_type != @domain_class && pk_id
 				subsetDomainObjectField = @linked_type.class_fields.find { |field|
-					field.class == SubsetDomainObjectField && field.subset_field == @name
+					field.is_a?( SubsetDomainObjectField ) && field.subset_field == @name
 				}
 				if subsetDomainObjectField
 					verify_subset_link_field( subsetDomainObjectField, pk_id )
@@ -342,11 +379,10 @@ module Lafcadio
 			end
 		end
 
-		def verify_subset_link_field( subsetDomainObjectField, pk_id )
+		def verify_subset_link_field( subsetDomainObjectField, pk_id ) #:nodoc:
 			begin
-				prevObj = ObjectStore.get_object_store.get( domain_class, pk_id )
-				prevObjLinkedTo = prevObj.send(name)
-				possiblyMyObj = prevObjLinkedTo.send(subsetDomainObjectField.name)
+				prevObjLinkedTo = domain_class[pk_id].send(name)
+				possiblyMyObj = prevObjLinkedTo.send subsetDomainObjectField.name
 				if possiblyMyObj && possiblyMyObj.pk_id == pk_id
 					cantChangeMsg = "You can't change that."
 					raise FieldValueError, cantChangeMsg, caller
@@ -369,7 +405,7 @@ module Lafcadio
 			super( domain_class, name )
 		end
 
-		def verify_non_nil(value, pk_id) #:nodoc:
+		def verify_non_nil_value(value, pk_id) #:nodoc:
 			super(value, pk_id)
 			if !EmailField.valid_address(value)
 				raise(
@@ -382,24 +418,17 @@ module Lafcadio
 	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.
-	#
+	# set range of string values. To set the enumeration in the class definition,
+	# pass in an Array of values as +enums+.
+	#   class IceCream < Lafcadio::DomainObject
+	#     enum 'flavor', { 'enums' => %w( Vanilla Chocolate Lychee ) }
+	#   end
 	class EnumField < StringField
 		def self.create_with_args( domain_class, parameters ) #:nodoc:
 			self.new( domain_class, parameters['name'], parameters['enums'] )
 		end
 
-		def self.enum_queue_hash( fieldElt )
+		def self.enum_queue_hash( fieldElt ) #:nodoc:
 			enumValues = []
 			fieldElt.elements.each( 'enums/enum' ) { |enumElt|
 				enumValues << enumElt.attributes['key']
@@ -408,7 +437,7 @@ module Lafcadio
 			QueueHash.new( *enumValues )
 		end
 
-		def self.instantiation_parameters( fieldElt ) #:nodoc:
+		def self.creation_parameters( fieldElt ) #:nodoc:
 			parameters = super( fieldElt )
 			if fieldElt.elements['enums'][1].attributes['key']
 				parameters['enums'] = enum_queue_hash( fieldElt )
@@ -423,11 +452,7 @@ module Lafcadio
 		
 		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 )
+		def initialize( domain_class, name, enums ) #:nodoc:
 			super( domain_class, name )
 			if enums.class == Array 
 				@enums = QueueHash.new_from_array enums
@@ -437,10 +462,10 @@ module Lafcadio
 		end
 		
 		def value_for_sql(value) #:nodoc:
-			value != '' ?(super(value)) : 'null'
+			value != '' ? (super(value)) : 'null'
 		end
 		
-		def verify_non_nil( value, pk_id ) #:nodoc:
+		def verify_non_nil_value( value, pk_id ) #:nodoc:
 			super
 			if @enums[value].nil?
 				key_str = '[ ' +
@@ -457,10 +482,6 @@ module Lafcadio
 
 	# FloatField represents a decimal value.
 	class FloatField < ObjectField
-		def self.create_with_args( domain_class, parameters ) #:nodoc:
-			self.new( domain_class, parameters['name'] )
-		end
-
 		def self.value_type #:nodoc:
 			Numeric
 		end
@@ -487,16 +508,16 @@ module Lafcadio
 		end
 	end
 
-	class PrimaryKeyField < IntegerField
+	class PrimaryKeyField < IntegerField #:nodoc:
 		def initialize( domain_class )
 			super( domain_class, 'pk_id' )
-			@not_null = false
+			@not_nil = 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.
+	# A StateField is a specialized subclass of EnumField; its possible value
+	# 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, USCommerce::UsStates.states )
@@ -509,7 +530,7 @@ module Lafcadio
 			          parameters['subset_field'], parameters['name'] )
 		end
 
-		def self.instantiation_parameters( fieldElt )
+		def self.creation_parameters( fieldElt )
 			parameters = super( fieldElt )
 			parameters['subset_field'] = fieldElt.attributes['subset_field']
 			parameters
@@ -554,10 +575,10 @@ module Lafcadio
 	class TimeStampField < DateTimeField #:nodoc:
 		def initialize( domain_class, name = 'timeStamp' )
 			super( domain_class, name )
-			@not_null = false
+			@not_nil = false
 		end
 
-		def db_will_automatically_write
+		def db_will_automatically_write?
 			true
 		end
 	end