lafcadio 0.4.3

data/lib/lafcadio/objectField/StateField.rb

@@ -0,0 +1,13 @@
+require 'lafcadio/util/UsStates'
+require 'lafcadio/objectField/EnumField'
+
+module Lafcadio
+	# 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(objectType, name = "state", englishName = nil)
+			super objectType, name, UsStates.states, englishName
+		end
+	end
+end

data/lib/lafcadio/objectField/SubsetLinkField.rb

@@ -0,0 +1,25 @@
+require 'lafcadio/objectField/LinkField'
+
+module Lafcadio
+	class SubsetLinkField < LinkField #:nodoc:
+		def SubsetLinkField.instantiationParameters( fieldElt )
+			parameters = super( fieldElt )
+			parameters['subsetField'] = fieldElt.attributes['subsetField']
+			parameters
+		end
+		
+		def SubsetLinkField.instantiateWithParameters( domainClass, parameters )
+			self.new( domainClass, parameters['linkedType'],
+			          parameters['subsetField'], parameters['name'],
+								parameters['englishName'] )
+		end
+
+		attr_accessor :subsetField
+
+		def initialize(objectType, linkedType, subsetField,
+				name = linkedType.name.downcase, englishName = nil)
+			super(objectType, linkedType, name, englishName)
+			@subsetField = subsetField
+		end
+	end
+end

data/lib/lafcadio/objectField/TextField.rb

@@ -0,0 +1,23 @@
+require 'lafcadio/objectField/ObjectField'
+
+module Lafcadio
+	# A TextField is expected to contain a string value.
+	class TextField < ObjectField
+		attr_accessor :large, :size
+
+		def initialize(objectType, name, englishName = nil)
+			super objectType, name, englishName
+			@large = false
+		end
+
+		def valueForSQL(value) #:nodoc:
+			if value
+				value = value.gsub(/(\\?')/) { |m| m.length == 1 ? "''" : m }
+				value = value.gsub(/\\/) { '\\\\' }
+				"'#{value}'"
+			else
+				"null"
+			end
+		end
+	end
+end

data/lib/lafcadio/objectField/TextListField.rb

@@ -0,0 +1,21 @@
+require 'lafcadio/objectField/ObjectField'
+
+module Lafcadio
+	# 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 valueFromSQL(sqlString, lookupLink = true) #:nodoc:
+			if sqlString
+				sqlString.split ','
+			else
+				[]
+			end
+		end
+
+		def valueForSQL(objectValue) #:nodoc:
+			"'" + objectValue.join(',') + "'"
+		end
+	end
+end

data/lib/lafcadio/objectField/TimeStampField.rb

@@ -0,0 +1,15 @@
+require 'lafcadio/objectField/DateTimeField'
+
+module Lafcadio
+	class TimeStampField < DateTimeField #:nodoc:
+		def initialize(objectType, name = 'timeStamp', englishName = nil)
+			super( objectType, name, englishName )
+			@hideDisplay = true
+			@notNull = false
+		end
+
+		def dbWillAutomaticallyWrite
+			true
+		end
+	end
+end

data/lib/lafcadio/objectStore.rb

@@ -0,0 +1,100 @@
+require 'lafcadio/includer'
+Includer.include( 'objectStore' )
+require 'lafcadio/util/English'
+
+module Lafcadio
+	class FieldMatchError < StandardError; end
+
+	class ObjectStore
+		class MethodDispatch #:nodoc:
+			attr_reader :symbol, :args
+		
+			def initialize( orig_method, maybe_proc, *orig_args )
+				@orig_method = orig_method
+				@maybe_proc = maybe_proc
+				@orig_args = orig_args
+				@methodName = orig_method.id2name
+				if @methodName =~ /^get(.*)$/
+					dispatch_get_method
+				else
+					raise_no_method_error
+				end
+			end
+			
+			def dispatch_get_plural
+				if @orig_args.size == 0 && @maybe_proc.nil?
+					@symbol = :getAll
+					@args = [ @domain_class ]
+				else
+					searchTerm = @orig_args[0]
+					fieldName = @orig_args[1]
+					if searchTerm.nil? && @maybe_proc.nil? && fieldName.nil?
+						msg = "ObjectStore\##{ @orig_method } needs a field name as its " +
+						      "second argument if its first argument is nil"
+						raise( ArgumentError, msg, caller )
+					end
+					dispatch_get_plural_by_query_block_or_search_term( searchTerm,
+					                                                   fieldName )
+				end
+			end
+			
+			def dispatch_get_plural_by_query_block
+				inferrer = Query::Inferrer.new( @domain_class ) { |obj|
+					@maybe_proc.call( obj )
+				}
+				@symbol = :getSubset
+				@args = [ inferrer.execute ]
+			end
+
+			def dispatch_get_plural_by_query_block_or_search_term( searchTerm,
+					                                                   fieldName )
+				if !@maybe_proc.nil? && searchTerm.nil?
+					dispatch_get_plural_by_query_block
+				elsif @maybe_proc.nil? && ( !( searchTerm.nil? && fieldName.nil? ) )
+					@symbol = :getFiltered
+					@args = [ @domain_class.name, searchTerm, fieldName ]
+				else
+					raise( ArgumentError,
+					 	     "Shouldn't send both a query block and a search term",
+					       caller )
+				end
+			end
+			
+			def dispatch_get_method
+				begin
+					dispatch_get_singular
+				rescue CouldntMatchObjectTypeError
+					objectTypeName = English.singular( method_name_after_get )
+					begin
+						@domain_class = DomainObject.
+						                getObjectTypeFromString( objectTypeName )
+						dispatch_get_plural
+					rescue CouldntMatchObjectTypeError
+						raise_no_method_error
+					end
+				end
+			end
+			
+			def dispatch_get_singular
+				objectType = DomainObject.
+				             getObjectTypeFromString( method_name_after_get )
+				if @orig_args[0].class <= Integer
+					@symbol = :get
+					@args = [ objectType, @orig_args[0] ]
+				elsif @orig_args[0].class <= DomainObject
+					@symbol = :getMapObject
+					@args = [ objectType, @orig_args[0], @orig_args[1] ]
+				end
+			end
+			
+			def method_name_after_get
+				@orig_method.id2name =~ /^get(.*)$/
+				$1
+			end
+			
+			def raise_no_method_error
+				raise( NoMethodError, "undefined method '#{ @methodName }'", caller )
+			end
+		end
+	end
+end

data/lib/lafcadio/objectStore/Cache.rb

@@ -0,0 +1,81 @@
+require 'lafcadio/util/ContextualService'
+
+module Lafcadio
+	class ObjectStore < ContextualService
+		class Cache #:nodoc:
+			def initialize( dbBridge )
+				@dbBridge = dbBridge
+				@objects = {}
+				@collections_by_query = {}
+				@commit_times = {}
+			end
+
+			def hashByObjectType(objectType)
+				unless @objects[objectType]
+					@objects[objectType] = {}
+				end
+				@objects[objectType]
+			end
+
+			# Returns a cached domain object, or nil if none is found.
+			def get(objectType, pkId)
+				hashByObjectType(objectType)[pkId].clone
+			end
+
+			# Saves a domain object.
+			def save(dbObject)
+				hashByObjectType(dbObject.objectType)[dbObject.pkId] = dbObject
+				flush_collection_cache( dbObject.objectType )
+			end
+			
+			def getByQuery( query )
+				unless @collections_by_query[query]
+					newObjects = @dbBridge.getCollectionByQuery(query)
+					newObjects.each { |dbObj| save dbObj }
+					@collections_by_query[query] = newObjects.collect { |dobj|
+						dobj.pkId
+					}
+				end
+				collection = []
+				@collections_by_query[query].each { |pkId|
+					dobj = get( query.objectType, pkId )
+					collection << dobj if dobj
+				}
+				collection
+			end
+
+			# Returns an array of all domain objects of a given type.
+			def getAll(objectType)
+				hashByObjectType(objectType).values.collect { |d_obj| d_obj.clone }
+			end
+
+			# Flushes a domain object.
+			def flush(dbObject)
+				hashByObjectType(dbObject.objectType).delete dbObject.pkId
+				flush_collection_cache( dbObject.objectType )
+			end
+			
+			def flush_collection_cache( objectType )
+				@collections_by_query.keys.each { |query|
+					if query.objectType == objectType
+						@collections_by_query.delete( query )
+					end
+				}
+			end
+
+			def last_commit_time( domain_class, pkId )
+				by_domain_class = @commit_times[domain_class]
+				by_domain_class ? by_domain_class[pkId] : nil
+			end
+			
+			def set_commit_time( d_obj )
+				by_domain_class = @commit_times[d_obj.objectType]
+				if by_domain_class.nil?
+					by_domain_class = {}
+					@commit_times[d_obj.objectType] = by_domain_class
+				end
+				by_domain_class[d_obj.pkId] = Time.now
+			end
+		end
+	end
+end

data/lib/lafcadio/objectStore/Committer.rb

@@ -0,0 +1,65 @@
+require 'lafcadio/objectStore/ObjectStore'
+
+module Lafcadio
+	class Committer #:nodoc:
+		INSERT 	= 1
+		UPDATE 	= 2
+		DELETE  = 3
+
+		attr_reader :commitType, :dbObject
+
+		def initialize(dbObject, dbBridge)
+			@dbObject = dbObject
+			@dbBridge = dbBridge
+			@objectStore = Context.instance.getObjectStore
+			@commitType = nil
+		end
+		
+		def setCommitType
+			if @dbObject.delete
+				@commitType = DELETE
+			elsif @dbObject.pkId
+				@commitType = UPDATE
+			else
+				@commitType = INSERT
+			end
+		end
+
+		def execute
+			setCommitType
+			@dbObject.lastCommit = getLastCommit
+			@dbObject.preCommitTrigger
+			if @dbObject.delete
+				dependentClasses = @dbObject.objectType.dependentClasses
+				dependentClasses.keys.each { |aClass|
+					field = dependentClasses[aClass]
+					collection = @objectStore.getFiltered( aClass.name, @dbObject,
+																								 field.name )
+					collection.each { |dependentObject|
+						if field.deleteCascade
+							dependentObject.delete = true
+						else
+							dependentObject.send( field.name + '=', nil )
+						end
+						@objectStore.commit(dependentObject)
+					}
+				}
+			end
+			@dbBridge.commit @dbObject
+			unless @dbObject.pkId
+				@dbObject.pkId = @dbBridge.lastPkIdInserted
+			end
+			@dbObject.postCommitTrigger
+		end
+		
+		def getLastCommit
+			if @dbObject.delete
+				DomainObject::COMMIT_DELETE
+			elsif @dbObject.pkId
+				DomainObject::COMMIT_EDIT
+			else
+				DomainObject::COMMIT_ADD
+			end
+		end
+	end
+end

data/lib/lafcadio/objectStore/CouldntMatchObjectTypeError.rb

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

data/lib/lafcadio/objectStore/DbBridge.rb

@@ -0,0 +1,140 @@
+require 'rubygems'
+
+require 'dbi'
+require_gem 'log4r'
+require 'lafcadio/util/LafcadioConfig'
+
+module Lafcadio
+	class DbBridge #:nodoc:
+		@@dbh = nil
+		@@lastPkIdInserted = nil
+		@@dbName = nil
+		@@connectionClass = DBI
+		
+		def DbBridge.setDbName(dbName)
+			@@dbName = dbName
+		end
+		
+		def DbBridge._load(aString)
+			aString =~ /dbh:/
+			dbString = $'
+			begin
+				dbh = Marshal.load(dbString)
+			rescue TypeError
+				dbh = nil
+			end
+			new dbh
+		end
+		
+		def DbBridge.flushConnection
+			@@dbh = nil
+		end
+		
+		def DbBridge.setConnectionClass( aClass )
+			@@connectionClass = aClass
+		end
+		
+		def DbBridge.disconnect
+			@@dbh.disconnect if @@dbh
+		end
+		
+		def initialize(dbh = nil)
+			if dbh == nil
+				if @@dbh == nil
+					config = LafcadioConfig.new
+					dbName = @@dbName || config['dbname']
+					dbAndHost = nil
+					if dbName && config['dbhost']
+						dbAndHost = "dbi:Mysql:#{ dbName }:#{ config['dbhost'] }"
+					else
+						dbAndHost = "dbi:#{config['dbconn']}"
+					end
+					@@dbh = @@connectionClass.connect( dbAndHost, config['dbuser'],
+																						 config['dbpassword'] )
+				end
+			else
+				@@dbh = dbh
+			end
+			@dbh = @@dbh
+			ObjectSpace.define_finalizer( self, proc { |id| DbBridge.disconnect } )
+		end
+		
+		def maybeLog(sql)
+			config = LafcadioConfig.new
+			if config['logSql'] == 'y'
+				sqllog = Log4r::Logger['sql'] || Log4r::Logger.new( 'sql' )
+				filename = File.join( config['logdir'], config['sqlLogFile'] || 'sql' )
+				outputter = Log4r::FileOutputter.new( 'outputter',
+																							{ :filename => filename } )
+				sqllog.outputters = outputter
+				sqllog.info sql
+			end
+		end
+		
+		def commit(dbObject)
+			require 'lafcadio/objectStore/DomainObjectSqlMaker'
+			sqlMaker = DomainObjectSqlMaker.new(dbObject)
+			sqlMaker.sqlStatements.each { |sql, binds| executeCommit( sql, binds ) }
+			if sqlMaker.sqlStatements[0].first =~ /insert/
+				sql = 'select last_insert_id()'
+				result = executeSelect( sql )
+				@@lastPkIdInserted = result[0]['last_insert_id()'].to_i
+			end
+		end
+		
+		def executeCommit( sql, binds )
+			@dbh.do( sql, *binds )
+		end
+		
+		def getCollectionByQuery(query)
+			require 'lafcadio/objectStore/SqlValueConverter'
+			objectType = query.objectType
+			coll = []
+			objects = []
+			result = executeSelect query.toSql
+			result.each { |row_hash|
+				converter = SqlValueConverter.new(objectType, row_hash)
+				obj = objectType.new converter
+				objects << obj
+			}
+			coll = coll.concat objects
+			coll
+		end
+		
+		def executeSelect(sql)
+			maybeLog sql
+			begin
+				@dbh.select_all( sql )
+			rescue DBI::DatabaseError => e
+				raise $!.to_s + ": #{ e.errstr }"
+			end	
+		end
+		
+		def _dump(aDepth)
+			if @db.respond_to? '_dump'
+				dbDump = @db._dump
+			else
+				dbDump = @db.class.to_s
+			end
+			"dbh:#{dbDump}"
+		end
+		
+		def lastPkIdInserted
+			@@lastPkIdInserted
+		end
+		
+		def group_query( query )
+			row = executeSelect( query.toSql )[0]
+			result = []
+			row.each { |val|
+				if query.field_name != query.objectType.sqlPrimaryKeyName
+					a_field = query.objectType.getField( query.field_name )
+					result << a_field.valueFromSQL( val )
+				else
+					result << val.to_i
+				end
+			}
+			result
+		end
+	end
+end