lafcadio 0.9.0 → 0.9.1

data/lib/lafcadio/domain.rb~

@@ -137,9 +137,7 @@ module Lafcadio
 			end
 		end
 		
-		def eql?(otherObj)
-			self == otherObj
-		end
+		def eql?( otherObj ); self == otherObj; end
 
 		def hash; "#{ self.class.name } #{ pk_id }".hash; end
 	end
@@ -242,18 +240,7 @@ module Lafcadio
 	# that each table has a +pk_id+ field that is used to match rows between
 	# different levels.
 	class DomainObject
-		@@subclassHash = {}
-		@@class_fields = {}
-		@@pk_fields =
-			Hash.new { |hash, key|
-				pk_field = PrimaryKeyField.new( key )
-				pk_field.db_field_name = @@sql_primary_keys[key]
-				hash[key] = pk_field
-			}
-		@@sql_primary_keys = Hash.new( 'pk_id' )
-		@@default_field_setup_hashes = Hash.new { |hash, key|
-			hash[key] = Hash.new( {} )
-		}
+		@@subclass_records = Hash.new do |h, k| h[k] = SubclassRecord.new( k ); end
 
 		COMMIT_ADD = 1
 		COMMIT_EDIT = 2
@@ -263,8 +250,11 @@ module Lafcadio
 		
 		def self.[]( pk_id ); get( pk_id ); end
 		
+		def self.abstract_subclass?( a_class ) #:nodoc:
+			abstract_subclasses.include? a_class
+		end
+		
 		def self.abstract_subclasses #:nodoc:
-			require 'lafcadio/domain'
 			[ MapObject ]
 		end
 		
@@ -273,19 +263,19 @@ module Lafcadio
 		# Returns an array of all fields defined for this class and all concrete
 		# superclasses.
 		def self.all_fields
-			all_fields = []
-			self_and_concrete_superclasses.each { |aClass|
-				aClass.class_fields.each { |field| all_fields << field }
-			}
-			all_fields
+			self_and_concrete_superclasses.map { |a_class|
+				a_class.class_fields
+			}.flatten
 		end
 
+		def self.class_field(fieldName) #:nodoc:
+			self.class_fields.find { |field| field.name == fieldName }
+		end
+		
 		def self.class_fields #:nodoc:
-			class_fields = @@class_fields[self]
-			unless class_fields
-				@@class_fields[self] = self.get_class_fields
-				class_fields = @@class_fields[self]
-				class_fields.each do |class_field|
+			unless subclass_record.fields
+				subclass_record.fields = self.get_class_fields
+				subclass_record.fields.each do |class_field|
 					begin
 						undef_method class_field.name.to_sym
 					rescue NameError
@@ -293,57 +283,80 @@ module Lafcadio
 					end
 				end
 			end
-			class_fields
+			subclass_record.fields
 		end
 
 		def self.create_field( field_class, *args )
-			class_fields = @@class_fields[self]
-			if args.last.is_a? Hash
-				att_hash = args.last
-			else
-				att_hash = @@default_field_setup_hashes[self][field_class].clone
+			subclass_record.maybe_init_fields
+			att_hash = create_field_att_hash( field_class, *args )
+			field = field_class.create_with_args( self, att_hash )
+			unless class_field( field.name )
+				att_hash.each { |field_name, value|
+					setter = field_name + '='
+					field.send( setter, value ) if field.respond_to?( setter )
+				}
+				class_fields << field
 			end
-			if class_fields.nil?
-				class_fields = [ @@pk_fields[self] ]
-				@@class_fields[self] = class_fields
+		end
+		
+		def self.create_field_att_hash( field_class, *args ) #:nodoc:
+			att_hash = args.last
+			unless att_hash.is_a? Hash
+				att_hash = subclass_record.default_field_setup_hash[field_class].clone
 			end
 			if field_class == DomainObjectField
 				att_hash['linked_type'] = args.first
 				att_hash['name'] = args[1] if args[1] and !args[1].is_a? Hash
 			else
-				name = args.first
-				att_hash['name'] = name == String ? name : name.to_s
+				att_hash['name'] = args.first.to_s
 			end
-			field = field_class.instantiate_with_parameters( self, att_hash )
-			unless class_fields.any? { |cf| cf.name == field.name }
-				att_hash.each { |field_name, value|
-					setter = field_name + '='
-					field.send( setter, value ) if field.respond_to?( setter )
-				}
-				class_fields << field
+			att_hash
+		end
+
+		def self.create_fields( field_class, *args ) #:nodoc:
+			arg = args.shift
+			until args.empty?
+				next_arg = args.shift
+				if next_arg.is_a? String or next_arg.is_a? Symbol
+					create_field( field_class, arg )
+					arg = next_arg
+				else
+					create_field( field_class, arg, next_arg )
+					arg = args.shift
+				end
 			end
+			create_field( field_class, arg ) unless arg.nil?
 		end
 		
 		def self.default_field_setup_hash( field_class, hash )
-			@@default_field_setup_hashes[self][field_class] = hash
+			subclass_record.default_field_setup_hash[field_class] = hash
 		end
 
 		def self.dependent_classes #:nodoc:
 			dependent_classes = {}
 			DomainObject.subclasses.each { |aClass|
-				if aClass != DomainObjectProxy &&
-						(!DomainObject.abstract_subclasses.index(aClass))
-					aClass.class_fields.each { |field|
-						if ( field.is_a?( DomainObjectField ) &&
-						     field.linked_type == self.domain_class )
-							dependent_classes[aClass] = field
-						end
-					}
+				if (
+					!abstract_subclass?( aClass ) and
+					( field = aClass.link_field( self ) )
+				)
+					dependent_classes[aClass] = field
 				end
 			}
 			dependent_classes
 		end
 		
+		def self.domain_class #:nodoc:
+			self
+		end
+
+		def self.domain_dirs #:nodoc:
+			if ( domainDirStr = LafcadioConfig.new['domainDirs'] )
+				domainDirStr.split(',')
+			else
+				[]
+			end
+		end
+		
 		def self.exist?( search_term, field_name = :pk_id )
 			query = Query.infer( self ) { |dobj|
 				dobj.send( field_name ).equals( search_term )
@@ -351,6 +364,16 @@ module Lafcadio
 			!ObjectStore.get_object_store.get_subset( query ).empty?
 		end
 		
+		def self.field( fieldName ) #:nodoc:
+			aDomainClass = self
+			field = nil
+			while aDomainClass < DomainObject && !field
+				field = aDomainClass.class_field( fieldName )
+				aDomainClass = aDomainClass.superclass
+			end
+			field
+		end
+
 		def self.first; all.first; end
 			
 		def self.get( *args )
@@ -370,29 +393,17 @@ module Lafcadio
 			end
 		end
 
-		def self.get_class_field(fieldName) #:nodoc:
-			field = nil
-			self.class_fields.each { |aField|
-				field = aField if aField.name == fieldName
-			}
-			field
-		end
-		
-		def DomainObject.get_class_field_by_db_name( fieldName ) #:nodoc:
-			self.class_fields.find { |field| field.db_field_name == fieldName }
-		end
-
 		# Returns an Array of ObjectField instances for this domain class, parsing
 		# them from XML if necessary.
 		def self.get_class_fields
 			if self.methods( false ).include?( 'get_class_fields' )
-				[ @@pk_fields[ self ] ]
-			elsif abstract_subclasses.include?( self )
+				[ subclass_record.pk_field ]
+			elsif abstract_subclass?( self )
 				[]
 			else
 				xmlParser = try_load_xml_parser
 				if xmlParser
-					xmlParser.get_class_fields
+					xmlParser.get_class_fields     
 				else
 					error_msg = "Couldn't find either an XML class description file " +
 											"or get_class_fields method for " + self.name
@@ -401,107 +412,57 @@ module Lafcadio
 			end
 		end
 
-		def self.get_domain_dirs #:nodoc:
-			if ( domainDirStr = LafcadioConfig.new['domainDirs'] )
-				domainDirStr.split(',')
-			else
-				[]
-			end
-		end
-		
-		def self.get_field( fieldName ) #:nodoc:
-			aDomainClass = self
-			field = nil
-			while aDomainClass < DomainObject && !field
-				field = aDomainClass.get_class_field( fieldName )
-				aDomainClass = aDomainClass.superclass
-			end
-			if field
-				field
-			else
-				errStr = "Couldn't find field \"#{ fieldName }\" in " +
-								 "#{ self } domain class"
-				raise( MissingError, errStr, caller )
-			end
+		def self.is_child_domain_class? #:nodoc:
+			superclass != DomainObject and !abstract_subclass?( superclass )
 		end
 
-		def self.get_domain_class_from_string(typeString) #:nodoc:
-			domain_class = nil
-			require_domain_file( typeString )
-			subclasses.each { |subclass|
-				domain_class = subclass if subclass.to_s == typeString
-			}
-			if domain_class
-				domain_class
-			else
-				raise CouldntMatchDomainClassError,
-						"couldn't match domain_class #{typeString}", caller
-			end
-		end
+		def self.last; all.last; end
 		
-		def self.get_link_field( linked_domain_class ) # :nodoc:
+		def self.link_field( linked_domain_class ) # :nodoc:
 			class_fields.find { |field|
-				field.is_a? DomainObjectField and field.linked_type == linked_domain_class
+				field.is_a? DomainObjectField and
+				field.linked_type == linked_domain_class
 			}
 		end
 		
-		def self.inherited(subclass) #:nodoc:
-			@@subclassHash[subclass] = true
-		end
-		
-		def self.is_based_on? #:nodoc:
-		  self.superclass.is_concrete?
-		end
-
-		def self.is_concrete? #:nodoc:
-		  (self != DomainObject && abstract_subclasses.index(self).nil?)
-		end
-		
-		def self.last; all.last; end
-		
 		def self.method_missing( methodId, *args ) #:nodoc:
+			dispatched = false
 			method_name = methodId.id2name
-			maybe_field_class_name = method_name.underscore_to_camel_case + 'Field'
 			begin
-				field_class = Lafcadio.const_get( maybe_field_class_name )
-				create_field( field_class, *args )
+				method_missing_try_create_field( method_name, *args )
+				dispatched = true
 			rescue NameError
-				singular = method_name.singular
-				if singular
-					maybe_field_class_name = singular.underscore_to_camel_case + 'Field'
-					begin
-						field_class = Lafcadio.const_get( maybe_field_class_name )
-						arg = args.shift
-						until args.empty?
-							next_arg = args.shift
-							if next_arg.is_a? String or next_arg.is_a? Symbol
-								create_field( field_class, arg )
-								arg = next_arg
-							else
-								create_field( field_class, arg, next_arg )
-								arg = args.shift
-							end
-						end
-						create_field( field_class, arg ) unless arg.nil?
-					rescue NameError
-						super
-					end
-				else
-					super
-				end
+				begin
+					method_missing_try_create_fields( method_name, *args )
+					dispatched = true
+				rescue NameError; end
 			end
+			super unless dispatched
 		end
 		
-		def self.only; all.only; end
-
-		def self.domain_class #:nodoc:
-			self
+		def self.method_missing_try_create_field( method_name, *args ) # :nodoc:
+			maybe_field_class_name = method_name.underscore_to_camel_case + 'Field'
+			field_class = Lafcadio.const_get( maybe_field_class_name )
+			create_field( field_class, *args )
 		end
+		
+		def self.method_missing_try_create_fields( method_name, *args ) # :nodoc:
+			singular = method_name.singular
+			if singular
+				maybe_field_class_name = singular.underscore_to_camel_case + 'Field'
+				field_class = Lafcadio.const_get( maybe_field_class_name )
+				create_fields( field_class, *args )
+			else
+				raise NameError
+			end
+		end
+
+		def self.only; all.only; end
 
 		def self.require_domain_file( typeString )
 			typeString =~ /([^\:]*)$/
 			fileName = $1
-			get_domain_dirs.each { |domainDir|
+			domain_dirs.each { |domainDir|
 				if Dir.entries(domainDir).index("#{fileName}.rb")
 					require "#{ domainDir }#{ fileName }"
 				end
@@ -515,8 +476,9 @@ module Lafcadio
 		def self.self_and_concrete_superclasses # :nodoc:
 			classes = [ ]
 			a_domain_class = self
-			until( a_domain_class == DomainObject ||
-					   abstract_subclasses.index( a_domain_class ) != nil )
+			until(
+				a_domain_class == DomainObject || abstract_subclass?( a_domain_class )
+			)
 				classes << a_domain_class
 				a_domain_class = a_domain_class.superclass
 			end
@@ -526,24 +488,24 @@ module Lafcadio
 		def self.singleton_method_added( symbol )
 			if symbol.id2name == 'sql_primary_key_name' && self < DomainObject
 				begin
-					get_field( 'pk_id' ).db_field_name = self.send( symbol )
+					field( 'pk_id' ).db_field_name = self.send( symbol )
 				rescue NameError
-					@@sql_primary_keys[self] = self.send( symbol )
+					subclass_record.sql_primary_key = self.send( symbol )
 				end
 			end
 		end
 		
 		# Returns the name of the primary key in the database, retrieving it from
 		# the class definition XML if necessary.
-		def self.sql_primary_key_name( set_sql_primary_key_name = nil )
-			if set_sql_primary_key_name
-				get_field( 'pk_id' ).db_field_name = set_sql_primary_key_name
-			end
-			get_field( 'pk_id' ).db_field_name
+		def self.sql_primary_key_name( set_db_field_name = nil )
+			field( 'pk_id' ).db_field_name = set_db_field_name if set_db_field_name
+			field( 'pk_id' ).db_field_name
 		end
+		
+		def self.subclass_record; @@subclass_records[self]; end
 
 		def self.subclasses #:nodoc:
-			@@subclassHash.keys
+			@@subclass_records.keys
 		end
 
 		# Returns the table name, which is assumed to be the domain class name 
@@ -570,18 +532,17 @@ module Lafcadio
 			dirName = LafcadioConfig.new['classDefinitionDir']
 			xmlFileName = self.basename + '.xml'
 			xmlPath = File.join( dirName, xmlFileName )
-			xml = ''
 			begin
-				File.open( xmlPath ) { |file| xml = file.readlines.join }
+				xml = File.open( xmlPath ) do |f| f.gets( nil ); end
 				ClassDefinitionXmlParser.new( self, xml )
 			rescue Errno::ENOENT
 				# no xml file, so no @xmlParser
 			end
 		end
 		
-		attr_accessor :error_messages, :last_commit, :fields, :fields_set
+		attr_accessor :fields_set, :field_values, :last_commit_type
 		attr_reader :delete
-		protected :fields, :fields_set
+		protected :fields_set, :field_values
 
 		# fieldHash should contain key-value associations for the different
 		# fields of this domain class. For example, instantiating a User class 
@@ -598,26 +559,10 @@ module Lafcadio
 		# If you're creating mock objects for unit tests, you can explicitly set 
 		# the +pk_id+ to represent objects that already exist in the database.
 		def initialize(fieldHash)
-			if fieldHash.respond_to? :keys
-				fieldHash.keys.each { |key|
-					key = key.to_s
-					begin
-						self.class.get_field( key )
-					rescue MissingError
-						raise ArgumentError, "Invalid field name #{ key }"
-					end
-				}
-			end
-			if fieldHash.is_a? Hash
-				@fieldHash = {}
-				fieldHash.each do |k, v| @fieldHash[k.to_s] = v; end
-			else
-				@fieldHash = fieldHash
-			end
-			@error_messages = []
-			@fields = {}
+			fieldHash = preprocess_field_hash fieldHash
+			@field_values = {}
 			@fields_set = []
-			@original_values = OriginalValuesHash.new( @fieldHash )
+			@original_values = ReadOnlyHash.new @fieldHash
 			check_fields = LafcadioConfig.new()['checkFields']
 			verify if %w( onInstantiate onAllStates ).include?( check_fields )
 		end
@@ -625,7 +570,7 @@ module Lafcadio
 		# Returns a clone, with all of the fields copied.
 		def clone
 			copy = super
-			copy.fields = @fields.clone
+			copy.field_values = @field_values.clone
 			copy.fields_set = @fields_set.clone
 			copy
 		end
@@ -649,38 +594,29 @@ module Lafcadio
 			commit
 		end
 
-		def get_field( field ) #:nodoc:
+		# Returns the subclass of DomainObject that this instance represents.
+		# Because of the way that proxying works, clients should call this method
+		# instead of Object.class.
+		def domain_class
+			self.class.domain_class
+		end
+
+		def field_value( field ) #:nodoc:
 			unless @fields_set.include?( field )
-				set_field( field, @fieldHash[field.name] )
+				set_field_value( field, @fieldHash[field.name] )
 			end
-			@fields[field.name]
+			@field_values[field.name]
 		end
 		
-		def get_getter_field( methId ) #:nodoc:
-			begin
-				self.class.get_field( methId.id2name )
-			rescue MissingError
-				nil
-			end
+		def getter_field( methId ) #:nodoc:
+			self.class.field methId.id2name
 		end
 
-		def get_setter_field( methId ) #:nodoc:
-			if methId.id2name =~ /(.*)=$/
-				begin
-					self.class.get_field( $1 )
-				rescue MissingError
-					nil
-				end
-			else
-				nil
-			end
-		end
-		
 		def method_missing( methId, *args ) #:nodoc:
-			if ( field = get_setter_field( methId ) )
-				set_field( field, args.first )
-			elsif ( field = get_getter_field( methId ) )
-				get_field( field )
+			if ( field = setter_field( methId ) )
+				set_field_value( field, args.first )
+			elsif ( field = getter_field( methId ) )
+				field_value( field )
 			else
 				new_symbol = ( 'get_' + methId.id2name ).to_sym
 				object_store = ObjectStore.get_object_store
@@ -693,55 +629,93 @@ module Lafcadio
 			end
 		end
 
-		# Returns the subclass of DomainObject that this instance represents.
-		# Because of the way that proxying works, clients should call this method
-		# instead of Object.class.
-		def domain_class
-			self.class.domain_class
-		end
-
 		# This template method is called before every commit. Subclasses can 
 		# override it to ensure code is executed before a commit.
 		def pre_commit_trigger
 			nil
 		end
 
+		def preprocess_field_hash( fieldHash )
+			if fieldHash.is_a? Hash
+				fieldHash.keys.each { |key|
+					if self.class.field( key.to_s ).nil?
+						raise ArgumentError, "Invalid field name #{ key.to_s }"
+					end
+				}
+				@fieldHash = {}
+				fieldHash.each do |k, v| @fieldHash[k.to_s] = v; end
+			else
+				@fieldHash = fieldHash
+			end
+		end
+		
 		# This template method is called after every commit. Subclasses can 
 		# override it to ensure code is executed after a commit.
 		def post_commit_trigger
 			nil
 		end
 
-		def set_field( field, value ) #:nodoc:
-			if field.class <= DomainObjectField
-				if value.class != DomainObjectProxy && value
-					value = DomainObjectProxy.new(value)
-				end
+		def set_field_value( field, value ) #:nodoc:
+			if (
+				field.is_a?( DomainObjectField ) and
+				!value.is_a?( DomainObjectProxy ) and value
+			)
+				value = DomainObjectProxy.new(value)
 			end
 			if ( LafcadioConfig.new()['checkFields'] == 'onAllStates' &&
 			     !field.instance_of?( PrimaryKeyField ) )
 				field.verify( value, pk_id )
 			end
-			@fields[field.name] = value
+			@field_values[field.name] = value
 			@fields_set << field
 		end
 		
+		def setter_field( methId ) #:nodoc:
+			if methId.id2name =~ /(.*)=$/
+				self.class.field $1
+			else
+				nil
+			end
+		end
+		
 		def update!( changes )
 			changes.each do |sym, value| self.send( sym.to_s + '=', value ); end
 			commit
 		end
 		
 		def verify
-			if ObjectStore.get_object_store.mock?
+			if ObjectStore.mock?
 				self.class.get_class_fields.each { |field|
 					field.verify( self.send( field.name ), self.pk_id )
 				}
 			end
 		end
 		
-		class OriginalValuesHash < DelegateClass( Hash )
+		class ReadOnlyHash < DelegateClass( Hash )
 			def []=( key, val ); raise NoMethodError; end
 		end
+		
+		class SubclassRecord
+			attr_accessor :default_field_setup_hash, :fields, :sql_primary_key
+			
+			def initialize( subclass )
+				@subclass = subclass
+				@default_field_setup_hash = Hash.new( {} )
+				@sql_primary_key = 'pk_id'
+			end
+			
+			def maybe_init_fields
+				self.fields = [ pk_field ] if self.fields.nil?
+			end
+			
+			def pk_field
+				if @pk_field.nil?
+					@pk_field = PrimaryKeyField.new @subclass
+					@pk_field.db_field_name = sql_primary_key
+				end
+				@pk_field
+			end
+		end
 	end
 
 	# Any domain class that is used mostly to map between two other domain 
@@ -750,12 +724,9 @@ module Lafcadio
 	# the domain classes that the map object maps between.
 	class MapObject < DomainObject
 		def self.other_mapped_type(firstType) #:nodoc:
-			types = mappedTypes
-			if types.index(firstType) == 0
-				types[1]
-			else
-				types[0]
-			end
+			mt = mappedTypes.clone
+			mt.delete firstType
+			mt.only
 		end
 
 		def self.subsidiary_map #:nodoc: