lafcadio 0.4.3

data/lib/lafcadio/objectField/EnumField.rb

@@ -0,0 +1,62 @@
+require 'lafcadio/objectField/TextField'
+
+module Lafcadio
+	# 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 EnumField.instantiationParameters( fieldElt ) #:nodoc:
+			parameters = super( fieldElt )
+			if fieldElt.elements['enums'][1].attributes['key']
+				enumValues = []
+				fieldElt.elements.each( 'enums/enum' ) { |enumElt|
+					enumValues << enumElt.attributes['key']
+					enumValues << enumElt.text.to_s
+				}
+				parameters['enums'] = QueueHash.new( *enumValues )
+			else
+				parameters['enums'] = []
+				fieldElt.elements.each( 'enums/enum' ) { |enumElt|
+					parameters['enums'] << enumElt.text.to_s
+				}
+			end
+			parameters
+		end
+		
+		def EnumField.instantiateWithParameters( domainClass, parameters ) #:nodoc:
+			self.new( domainClass, parameters['name'], parameters['enums'],
+								parameters['englishName'] )
+		end
+
+		attr_reader :enums
+
+		# [objectType]  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.
+		# [englishName] The English name of this field. (Deprecated)
+		def initialize(objectType, name, enums, englishName = nil)
+			require 'lafcadio/util/QueueHash'
+			super objectType, name, englishName
+			if enums.class == Array 
+				@enums = QueueHash.newFromArray enums
+			else
+				@enums = enums
+			end
+		end
+		
+		def valueForSQL(value) #:nodoc:
+			value != '' ?(super(value)) : 'null'
+		end
+	end
+end

data/lib/lafcadio/objectField/FieldValueError.rb

@@ -0,0 +1,4 @@
+module Lafcadio
+	class FieldValueError < RuntimeError #:nodoc:
+	end
+end

data/lib/lafcadio/objectField/IntegerField.rb

@@ -0,0 +1,15 @@
+require 'lafcadio/objectField/ObjectField'
+
+module Lafcadio
+	# IntegerField represents an integer.
+	class IntegerField < ObjectField
+		def textBoxSize #:nodoc:
+			5
+		end
+
+		def valueFromSQL(string) #:nodoc:
+			value = super
+			value ? value.to_i : nil
+		end
+	end
+end

data/lib/lafcadio/objectField/LinkField.rb

@@ -0,0 +1,92 @@
+require 'lafcadio/util'
+require 'lafcadio/objectField/ObjectField'
+
+module Lafcadio
+	# A LinkField is used to link from one domain class to another.
+	class LinkField < ObjectField
+		def LinkField.instantiationParameters( fieldElt ) #:nodoc:
+			parameters = super( fieldElt )
+			linkedTypeStr = fieldElt.attributes['linkedType']
+			linkedType = DomainObject.getObjectTypeFromString( linkedTypeStr )
+			parameters['linkedType'] = linkedType
+			parameters['deleteCascade'] = fieldElt.attributes['deleteCascade'] == 'y'
+			parameters
+		end
+
+		def LinkField.instantiateWithParameters( domainClass, parameters ) #:nodoc:
+			instance = self.new(
+				domainClass, parameters['linkedType'], parameters['name'],
+				parameters['englishName'], parameters['deleteCascade']
+			)
+			if parameters['dbFieldName']
+				instance.dbFieldName = parameters['dbFieldName']
+			end
+			instance
+		end
+
+		attr_reader :linkedType
+		attr_accessor :listener, :objectStore, :newDuringEdit, :sortField,
+		              :deleteCascade
+
+		# [objectType]    The domain class that this field belongs to.
+		# [linkedType]    The domain class that this field points to.
+		# [name]          The name of this field.
+		# [englishName]   The English name of this field. (Deprecated)
+		# [deleteCascade] If this is true, deleting the domain object that is linked
+		#                 to will cause this domain object to be deleted as well.
+		def initialize( objectType, linkedType, name = nil, englishName = nil,
+		                deleteCascade = false )
+			unless name
+				linkedType.name =~ /::/
+				name = $' || linkedType.name
+				name = name.decapitalize
+			end
+			super(objectType, name, englishName)
+			( @linkedType, @deleteCascade ) = linkedType, deleteCascade
+			@listener = nil
+			@newDuringEdit = true
+		end
+
+		def valueForSQL(value) #:nodoc:
+			require 'lafcadio/objectStore/DomainObjectInitError'
+			if !value
+				"null"
+			elsif value.pkId
+				value.pkId
+			else
+				raise( DomainObjectInitError, "Can't commit #{name} without pkId", 
+				       caller )
+			end
+		end
+
+		def valueFromSQL(string) #:nodoc:
+			require 'lafcadio/objectStore/DomainObjectProxy'
+			string != nil ? DomainObjectProxy.new(@linkedType, string.to_i) : nil
+		end
+
+		def verify(value, pkId) #:nodoc:
+			super
+			if @linkedType != @objectType && pkId
+				subsetLinkField = nil
+				@linkedType.classFields.each { |field|
+					if field.class == SubsetLinkField && field.subsetField == @name
+						subsetLinkField = field
+					end
+				}
+				if subsetLinkField
+					begin
+						prevObj = ObjectStore.getObjectStore.get(objectType, pkId)
+						prevObjLinkedTo = prevObj.send(name)
+						possiblyMyObj = prevObjLinkedTo.send(subsetLinkField.name)
+						if possiblyMyObj && possiblyMyObj.pkId == pkId
+							cantChangeMsg = "You can't change that."
+							raise FieldValueError, cantChangeMsg, caller
+						end
+					rescue DomainObjectNotFoundError
+						# no previous value, so nothing to check for
+					end
+				end
+			end
+		end
+	end
+end

data/lib/lafcadio/objectField/LinkField.rb~

@@ -0,0 +1,86 @@
+require 'lafcadio/util'
+require 'lafcadio/objectField/ObjectField'
+
+module Lafcadio
+	# A LinkField is used to link from one domain class to another.
+	class LinkField < ObjectField
+		def LinkField.instantiationParameters( fieldElt ) #:nodoc:
+			parameters = super( fieldElt )
+			linkedTypeStr = fieldElt.attributes['linkedType']
+			linkedType = DomainObject.getObjectTypeFromString( linkedTypeStr )
+			parameters['linkedType'] = linkedType
+			parameters['deleteCascade'] = fieldElt.attributes['deleteCascade'] == 'y'
+			parameters
+		end
+
+		def LinkField.instantiateWithParameters( domainClass, parameters ) #:nodoc:
+			self.new( domainClass, parameters['linkedType'], parameters['name'],
+								parameters['englishName'], parameters['deleteCascade'] )
+		end
+
+		attr_reader :linkedType
+		attr_accessor :listener, :objectStore, :newDuringEdit, :sortField,
+		              :deleteCascade
+
+		# [objectType]    The domain class that this field belongs to.
+		# [linkedType]    The domain class that this field points to.
+		# [name]          The name of this field.
+		# [englishName]   The English name of this field. (Deprecated)
+		# [deleteCascade] If this is true, deleting the domain object that is linked
+		#                 to will cause this domain object to be deleted as well.
+		def initialize( objectType, linkedType, name = nil, englishName = nil,
+		                deleteCascade = false )
+			unless name
+				linkedType.name =~ /::/
+				name = $' || linkedType.name
+				name = name.decapitalize
+			end
+			super(objectType, name, englishName)
+			( @linkedType, @deleteCascade ) = linkedType, deleteCascade
+			@listener = nil
+			@newDuringEdit = true
+		end
+
+		def valueForSQL(value) #:nodoc:
+			require 'lafcadio/objectStore/DomainObjectInitError'
+			if !value
+				"null"
+			elsif value.pkId
+				value.pkId
+			else
+				raise( DomainObjectInitError, "Can't commit #{name} without pkId", 
+				       caller )
+			end
+		end
+
+		def valueFromSQL(string) #:nodoc:
+			require 'lafcadio/objectStore/DomainObjectProxy'
+			string != nil ? DomainObjectProxy.new(@linkedType, string.to_i) : nil
+		end
+
+		def verify(value, pkId) #:nodoc:
+			super
+			if @linkedType != @objectType && pkId
+				subsetLinkField = nil
+				@linkedType.classFields.each { |field|
+					if field.class == SubsetLinkField && field.subsetField == @name
+						subsetLinkField = field
+					end
+				}
+				if subsetLinkField
+					begin
+						prevObj = ObjectStore.getObjectStore.get(objectType, pkId)
+						prevObjLinkedTo = prevObj.send(name)
+						possiblyMyObj = prevObjLinkedTo.send(subsetLinkField.name)
+						if possiblyMyObj && possiblyMyObj.pkId == pkId
+							cantChangeMsg = "You can't change that."
+							raise FieldValueError, cantChangeMsg, caller
+						end
+					rescue DomainObjectNotFoundError
+						# no previous value, so nothing to check for
+					end
+				end
+			end
+		end
+	end
+end

data/lib/lafcadio/objectField/MoneyField.rb

@@ -0,0 +1,13 @@
+require 'lafcadio/objectField/DecimalField'
+
+module Lafcadio
+	class MoneyField < DecimalField #:nodoc:
+		def MoneyField.instantiateWithParameters( domainClass, parameters )
+			self.new( domainClass, parameters['name'], parameters['englishName'] )
+		end
+
+		def initialize(objectType, name, englishName = nil)
+			super(objectType, name, 2, englishName)
+		end
+	end
+end

data/lib/lafcadio/objectField/MonthField.rb

@@ -0,0 +1,16 @@
+require 'lafcadio/objectField/DateField'
+require 'lafcadio/dateTime/Month'
+
+module Lafcadio
+	# 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 MonthField.valueType #:nodoc:
+			Month
+		end
+
+		def valueForSQL(value) #:nodoc:
+			"'#{value.year}-#{value.month}-01'"
+		end
+	end
+end

data/lib/lafcadio/objectField/ObjectField.rb

@@ -0,0 +1,142 @@
+require 'lafcadio/util/English'
+require 'lafcadio/objectField/FieldValueError'
+
+module Lafcadio
+	# ObjectField is the abstract base class of any field for domain objects.
+	class ObjectField
+		include Comparable
+
+		attr_reader :name, :defaultFieldName, :objectType
+		attr_accessor :notNull, :hideLabel, :writeOnce, :unique, :hideDisplay,
+				:default, :dbFieldName, :notUniqueMsg
+
+		def ObjectField.valueType #:nodoc:
+			Object
+		end
+
+		def ObjectField.instantiationParameters( fieldElt ) #:nodoc:
+			parameters = {}
+			parameters['name'] = fieldElt.attributes['name']
+			parameters['englishName'] = fieldElt.attributes['englishName']
+			parameters['dbFieldName'] = fieldElt.attributes['dbFieldName']
+			parameters
+		end
+		
+		def ObjectField.instantiateFromXml( domainClass, fieldElt ) #:nodoc:
+			parameters = instantiationParameters( fieldElt )
+			instantiateWithParameters( domainClass, parameters )
+		end
+
+		def self.instantiateWithParameters( domainClass, parameters ) #:nodoc:
+			instance = self.new( domainClass, parameters['name'],
+			                     parameters['englishName'] )
+			if ( dbFieldName = parameters['dbFieldName'] )
+				instance.dbFieldName = dbFieldName
+			end
+			instance
+		end
+
+		# [objectType]  The domain class that this object field belongs to.
+		# [name]        The name of this field.
+		# [englishName] The descriptive English name of this field. (Deprecated)
+		def initialize(objectType, name, englishName = nil )
+			@objectType = objectType
+			@name = name
+			@dbFieldName = name
+			@notNull = true
+			@unique = false
+			( @default, @notUniqueMsg ) = [ nil, nil ]
+			@englishNameOrNil = englishName
+		end
+		
+		def bind_write?; false; end #:nodoc:
+		
+		def db_table_and_field_name
+			"#{ objectType.tableName }.#{ dbFieldName }"
+		end
+
+		def englishName #:nodoc:
+			@englishNameOrNil || English.camelCaseToEnglish(name).capitalize
+		end
+
+		def nullErrorMsg #:nodoc:
+			English.sentence "Please enter %a %nam.", englishName.downcase
+		end
+
+		def verify(value, pkId) #:nodoc:
+			if value.nil? && notNull
+				raise FieldValueError, nullErrorMsg, caller
+			end
+			if value
+				valueType = self.class.valueType
+				unless value.class <= valueType
+					raise FieldValueError, 
+							"#{name} needs an object of type #{valueType.name}", caller
+				end
+				verifyUniqueness(value, pkId) if unique
+			end
+		end
+
+		def verifyUniqueness(value, pkId) #:nodoc:
+			inferrer = Query::Inferrer.new( @objectType ) { |domain_obj|
+				Query.And( domain_obj.send( self.name ).equals( value ),
+									 domain_obj.pkId.equals( pkId ).not )
+			}
+			collisions = ObjectStore.getObjectStore.getSubset( inferrer.execute )
+			if collisions.size > 0
+				if @notUniqueMsg
+					notUniqueMsg = @notUniqueMsg
+				else
+					notUniqueMsg = "That #{englishName.downcase} is already taken. " +
+							"Please choose another."
+				end
+				raise FieldValueError, notUniqueMsg, caller
+			end
+		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#dbFieldName.
+		def nameForSQL
+			dbFieldName
+		end
+
+		# Returns a string value suitable for committing this field's value to 
+		# MySQL.
+		def valueForSQL(value)
+			value || 'null'
+		end
+
+		def firstTime(fieldManager) #:nodoc:
+			pkId = fieldManager.getpkId
+			pkId == nil
+		end
+
+		def prevValue(pkId) #:nodoc:
+			prevObject = ObjectStore.getObjectStore.get(@objectType, pkId)
+			prevObject.send(name)
+		end
+
+		def processBeforeVerify(value) #:nodoc:
+			value = @default if value == nil
+			value
+		end
+
+		# Given the SQL value string, returns a Ruby-native value.
+		def valueFromSQL(string)
+			string
+		end
+
+		def <=>(other)
+			if @objectType == other.objectType && name == other.name
+				0
+			else
+				object_id <=> other.object_id
+			end
+		end
+
+		def dbWillAutomaticallyWrite #:nodoc:
+			false
+		end
+	end
+end

data/lib/lafcadio/objectField/PasswordField.rb

@@ -0,0 +1,29 @@
+require 'lafcadio/objectField/TextField'
+
+module Lafcadio
+	# 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 PasswordField.randomPassword
+			chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789".
+					split(//)
+			value = ""
+			0.upto(8) { |i| value += chars[rand(chars.size)] }
+			value
+		end
+
+		attr_reader :maxLength
+		attr_accessor :autoGenerate
+
+		# [objectType]  The domain class that this object field belongs to.
+		# [name]        The name of this field.
+		# [maxLength]   The maximum length of the password. (Deprecated)
+		# [englishName] The descriptive English name of this field. (Deprecated)
+		def initialize(objectType, maxLength, name = "password", englishName = nil)
+			super(objectType, name, englishName)
+			@maxLength = maxLength
+			@autoGenerate = true
+		end
+	end
+end