lafcadio 0.4.3 → 0.5.2

data/lib/lafcadio/includer.rb

@@ -1,18 +0,0 @@
-class Includer # :nodoc:
-	def Includer.include( subdir )
-		dir = nil
-		$:.each { |includeDir|
-			attemptedDir = includeDir + '/lafcadio/' + subdir
-			begin
-				dir = Dir.open( attemptedDir )
-			rescue Errno::ENOENT
-				# wrong include directory, try again
-			end
-		}
-		if dir
-			dir.entries.each { |entry|
-				require "lafcadio/#{ subdir }/#{ $1 }" if entry =~ /(.*)\.rb/
-			}
-		end
-	end
-end

data/lib/lafcadio/mock/MockDbBridge.rb

@@ -1,78 +0,0 @@
-module Lafcadio
-	class MockDbBridge #:nodoc:
-		attr_reader :lastPkIdInserted, :retrievalsByType, :query_count
-
-		def initialize
-			@objects = {}
-			@retrievalsByType = Hash.new 0
-			@query_count = Hash.new( 0 )
-		end
-
-		def addObject(dbObject)
-			commit dbObject
-		end
-
-		def commit(dbObject)
-			objectsByObjectType = @objects[dbObject.objectType]
-			unless objectsByObjectType
-				objectsByObjectType = {}
-				@objects[dbObject.objectType] = objectsByObjectType
-			end
-			if dbObject.delete
-				objectsByObjectType.delete dbObject.pkId
-			else
-				object_pkId = dbObject.pkId
-				unless object_pkId
-					maxpkId = 0
-					objectsByObjectType.keys.each { |pkId|
-						maxpkId = pkId if pkId > maxpkId
-					}
-					@lastPkIdInserted = maxpkId + 1
-					object_pkId = @lastPkIdInserted
-				end
-				objectsByObjectType[object_pkId] = dbObject
-			end
-		end
-		
-		def collection(objectType, objects); objects; end
-
-		def _getAll(objectType)
-			@retrievalsByType[objectType] = @retrievalsByType[objectType] + 1
-			@objects[objectType] ? @objects[objectType].values : []
-		end
-
-		def getCollectionByQuery(query)
-			@query_count[query] += 1
-			objectType = query.objectType
-			condition = query.condition
-			objects = []
-			_getAll( objectType ).each { |dbObj|
-				if condition
-					objects << dbObj if condition.objectMeets(dbObj)
-				else
-					objects << dbObj
-				end
-			}
-			coll = collection( objectType, objects )
-			if (range = query.limit)
-				coll = coll[0..(range.last - range.first)]
-			end
-			if ( order_by = query.orderBy )
-				coll = coll.sort_by { |dobj| dobj.send( order_by ) }
-				coll.reverse! if query.orderByOrder == Query::DESC
-			end
-			coll
-		end
-		
-		def group_query( query )
-			if query.class == Query::Max
-				if ( query.field_name == query.objectType.sqlPrimaryKeyName ||
-				     query.field_name == 'rate' )
-					query.collect( @objects[query.objectType].values )
-				else
-					raise "Can't handle query with sql '#{ query.toSql }'"
-				end
-			end
-		end
-	end
-end

data/lib/lafcadio/mock/MockDbBridge.rb~

@@ -1,74 +0,0 @@
-module Lafcadio
-	class MockDbBridge #:nodoc:
-		attr_reader :lastPkIdInserted, :retrievalsByType, :query_count
-
-		def initialize
-			@objects = {}
-			@retrievalsByType = Hash.new 0
-			@query_count = Hash.new( 0 )
-		end
-
-		def addObject(dbObject)
-			commit dbObject
-		end
-
-		def commit(dbObject)
-			objectsByObjectType = @objects[dbObject.objectType]
-			unless objectsByObjectType
-				objectsByObjectType = {}
-				@objects[dbObject.objectType] = objectsByObjectType
-			end
-			if dbObject.delete
-				objectsByObjectType.delete dbObject.pkId
-			else
-				object_pkId = dbObject.pkId
-				unless object_pkId
-					maxpkId = 0
-					objectsByObjectType.keys.each { |pkId|
-						maxpkId = pkId if pkId > maxpkId
-					}
-					@lastPkIdInserted = maxpkId + 1
-					object_pkId = @lastPkIdInserted
-				end
-				objectsByObjectType[object_pkId] = dbObject
-			end
-		end
-		
-		def collection(objectType, objects); objects; end
-
-		def _getAll(objectType)
-			@retrievalsByType[objectType] = @retrievalsByType[objectType] + 1
-			@objects[objectType] ? @objects[objectType].values : []
-		end
-
-		def getCollectionByQuery(query)
-			@query_count[query] += 1
-			objectType = query.objectType
-			condition = query.condition
-			objects = []
-			_getAll( objectType ).each { |dbObj|
-				if condition
-					objects << dbObj if condition.objectMeets(dbObj)
-				else
-					objects << dbObj
-				end
-			}
-			coll = collection( objectType, objects )
-			if (range = query.limit)
-				coll = coll[0..(range.last - range.first)]
-			end
-			coll
-		end
-		
-		def group_query( query )
-			if query.class == Query::Max
-				if ( query.field_name == query.objectType.sqlPrimaryKeyName ||
-				     query.field_name == 'rate' )
-					query.collect( @objects[query.objectType].values )
-				else
-					raise "Can't handle query with sql '#{ query.toSql }'"
-				end
-			end
-		end
-	end
-end

data/lib/lafcadio/mock/MockObjectStore.rb

@@ -1,20 +0,0 @@
-require 'lafcadio/objectStore/ObjectStore'
-require 'lafcadio/mock/MockDbBridge'
-
-module Lafcadio
-	# 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.
-	class MockObjectStore < ObjectStore
-		public_class_method :new
-
-		def initialize(context) # :nodoc:
-			super(context, MockDbBridge.new)
-		end
-
-		def addObject(dbObject) # :nodoc:
-			commit dbObject
-		end
-	end
-end

data/lib/lafcadio/objectField/AutoIncrementField.rb

@@ -1,25 +0,0 @@
-require 'lafcadio/objectField/IntegerField'
-
-module Lafcadio
-	class AutoIncrementField < IntegerField # :nodoc:
-		attr_reader :objectType
-
-		def initialize(objectType, name, englishName = nil)
-			super(objectType, name, englishName)
-			@objectType = objectType
-		end
-
-		def HTMLWidgetValueStr(value)
-			if value != nil
-				super value
-			else
-				highestValue = 0
-				ObjectStore.getObjectStore.getAll(objectType).each { |obj|
-					aValue = obj.send(name).to_i
-					highestValue = aValue if aValue > highestValue
-				}
-			 (highestValue + 1).to_s
-			end
-		end
-	end
-end

data/lib/lafcadio/objectField/BooleanField.rb

@@ -1,83 +0,0 @@
-require 'lafcadio/objectField/ObjectField'
-
-module Lafcadio
-	# 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"
-	#          enumType="ENUMS_CAPITAL_YES_NO"/>
-	# If you're defining a field in Ruby, simply set BooleanField#enumType 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 +enumType+.
-	class BooleanField < ObjectField
-		ENUMS_ONE_ZERO = 0
-		ENUMS_CAPITAL_YES_NO = 1
-
-		attr_accessor :enumType, :enums
-
-		def initialize(objectType, name, englishName = nil)
-			super(objectType, name, englishName)
-			@enumType = ENUMS_ONE_ZERO
-			@enums = nil
-		end
-
-		def getEnums( value = nil ) # :nodoc:
-			if @enums
-				@enums
-			elsif @enumType == ENUMS_ONE_ZERO
-				if value.class == String
-					{ true => '1', false => '0' }
-				else
-					{ true => 1, false => 0 }
-				end
-			elsif @enumType == ENUMS_CAPITAL_YES_NO
-				{ true => 'Y', false => 'N' }
-			else
-				raise MissingError
-			end
-		end
-
-		def trueEnum( value = nil ) # :nodoc:
-			getEnums( value )[true]
-		end
-
-		def falseEnum # :nodoc:
-			getEnums[false]
-		end
-
-		def textEnumType # :nodoc:
-			@enums ? @enums[true].class == String : @enumType == ENUMS_CAPITAL_YES_NO
-		end
-
-		def valueForSQL(value) # :nodoc:
-			if value
-				vfs = trueEnum
-			else
-				vfs = falseEnum
-			end
-			textEnumType ? "'#{vfs}'" : vfs
-		end
-
-		def valueFromSQL(value, lookupLink = true) # :nodoc:
-			value == trueEnum( value )
-		end
-	end
-end

data/lib/lafcadio/objectField/DateField.rb

@@ -1,33 +0,0 @@
-require 'lafcadio/objectField/ObjectField'
-require 'date'
-
-module Lafcadio
-	# DateField represents a Date.
-	class DateField < ObjectField
-		RANGE_NEAR_FUTURE = 0
-		RANGE_PAST = 1
-
-		def DateField.valueType # :nodoc:
-			Date
-		end
-
-		attr_accessor :range
-
-		def initialize(objectType, name = "date", englishName = nil)
-			super(objectType, name, englishName)
-			@range = RANGE_NEAR_FUTURE
-		end
-
-		def valueForSQL(value) # :nodoc:
-			value ? "'#{value.to_s}'" : 'null'
-		end
-
-		def valueFromSQL(dbiDate, lookupLink = true) # :nodoc:
-			begin
-				dbiDate ? dbiDate.to_date : nil
-			rescue ArgumentError
-				nil
-			end
-		end
-	end
-end

data/lib/lafcadio/objectField/DateTimeField.rb

@@ -1,25 +0,0 @@
-require 'lafcadio/util'
-require 'lafcadio/objectField/ObjectField'
-
-module Lafcadio
-	# DateTimeField represents a DateTime.
-	class DateTimeField < ObjectField
-		def valueFromSQL(dbi_value, lookupLink = true) # :nodoc:
-			dbi_value ? dbi_value.to_time : nil
-		end
-
-		def valueForSQL(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
-	end
-end

data/lib/lafcadio/objectField/DecimalField.rb

@@ -1,41 +0,0 @@
-require 'lafcadio/objectField/ObjectField'
-
-module Lafcadio
-	# DecimalField represents a decimal value.
-	class DecimalField < ObjectField
-		attr_reader :precision
-
-		def DecimalField.valueType #:nodoc:
-			Numeric
-		end
-
-		def DecimalField.instantiationParameters( fieldElt ) #:nodoc:
-			parameters = super( fieldElt )
-			parameters['precision'] = fieldElt.attributes['precision'].to_i
-			parameters
-		end
-		
-		def self.instantiateWithParameters( domainClass, parameters ) #:nodoc:
-			self.new( domainClass, parameters['name'], parameters['precision'],
-								parameters['englishName'] )
-		end
-
-		# [objectType]  The domain class that this field belongs to.
-		# [name]        The name of this field.
-		# [precision]   The expected field precision. (Deprecated)
-		# [englishName] The English name of this field. (Deprecated)
-		def initialize(objectType, name, precision, englishName = nil)
-			super(objectType, name, englishName)
-			@precision = precision
-		end
-
-		def valueFromSQL(string, lookupLink = true) #:nodoc:
-			string != nil ? string.to_f : nil
-		end
-
-		def processBeforeVerify(value) #:nodoc:
-			value = super value
-			value != nil && value != '' ? value.to_f : nil
-		end
-	end
-end

data/lib/lafcadio/objectField/EmailField.rb

@@ -1,28 +0,0 @@
-require 'lafcadio/objectField/TextField'
-require 'lafcadio/objectField/FieldValueError'
-
-module Lafcadio
-	# 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 EmailField.validAddress(address)
-			address =~ /^[^ @]+@[^ \.]+\.[^ ,]+$/
-		end
-
-		def initialize(objectType, name = "email", englishName = nil)
-			super(objectType, name, englishName)
-		end
-
-		def nullErrorMsg #:nodoc:
-			"Please enter an email address."
-		end
-
-		def verify(value, pkId) #:nodoc:
-			super(value, pkId)
-			if !EmailField.validAddress(value)
-				raise FieldValueError, "Please enter a valid email address.", caller
-			end
-		end
-	end
-end

data/lib/lafcadio/objectField/EnumField.rb

@@ -1,62 +0,0 @@
-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