lafcadio 0.4.3 → 0.5.2

data/lib/lafcadio/query/Max.rb~

@@ -1,25 +0,0 @@
-module Lafcadio
-	class Query
-		class Max < Query #:nodoc:
-			attr_reader :field_name
-		
-			def initialize( objectType, field_name = 'pkId' )
-				super( objectType )
-				@field_name = field_name
-			end
-		
-			def collect( coll )
-				max = nil
-				coll.each { |d_obj|
-					a_value = d_obj.send( @field_name )
-					max = a_value if max.nil? || a_value > max
-				}
-				[ max ]
-			end
-		
-			def fields
-				"max(#{ @field_name })"
-			end
-		end
-	end
-end

data/lib/lafcadio/query/Not.rb

@@ -1,21 +0,0 @@
-require 'lafcadio/query/Condition'
-
-module Lafcadio
-	class Query
-		class Not < Condition #:nodoc:
-			def initialize(unCondition)
-				@unCondition = unCondition
-			end
-
-			def toSql
-				"!(#{ @unCondition.toSql })"
-			end
-
-			def objectMeets(obj)
-				!@unCondition.objectMeets(obj)
-			end
-			
-			def objectType; @unCondition.objectType; end
-		end
-	end
-end

data/lib/lafcadio/query/Query.rb

@@ -1,92 +0,0 @@
-module Lafcadio
-	class Query #:nodoc:
-		ASC		= 1
-		DESC 	= 2
-
-		attr_reader :objectType, :condition
-		attr_accessor :orderBy, :orderByOrder, :limit
-
-		def initialize(objectType, pkIdOrCondition = nil)
-			@objectType = objectType
-			( @condition, @orderBy, @limit ) = [ nil, nil, nil ]
-			if pkIdOrCondition
-				if pkIdOrCondition.class <= Condition
-					@condition = pkIdOrCondition
-				else
-					@condition = Query::Equals.new(objectType.sqlPrimaryKeyName,
-							pkIdOrCondition, objectType)
-				end
-			end
-			@orderByOrder = ASC
-		end
-		
-		def hash; toSql.hash; end
-		
-		def eql?( other )
-			other.class <= Query && other.toSql == toSql
-		end
-
-		def tables
-			tableNames = []
-			anObjectType = objectType
-			until(DomainObject.abstractSubclasses.index(anObjectType) != nil ||
-					anObjectType == DomainObject)
-				tableNames.unshift anObjectType.tableName
-				anObjectType = anObjectType.superclass
-			end
-			tableNames.join ', '
-		end
-
-		def whereClause
-			whereClauses = []
-			anObjectType = objectType
-			superclass = anObjectType.superclass
-			until(DomainObject.abstractSubclasses.index(superclass) != nil ||
-					superclass == DomainObject)
-				joinClause = "#{ sqlPrimaryKeyField(superclass) } = " +
-						"#{ sqlPrimaryKeyField(anObjectType) }"
-				whereClauses.unshift joinClause
-				anObjectType = superclass
-				superclass = superclass.superclass
-			end
-			whereClauses << @condition.toSql if @condition
-			if whereClauses.size > 0
-				"where #{ whereClauses.join(' and ') }"
-			else
-				nil
-			end
-		end
-
-		def sqlPrimaryKeyField(objectType)
-			"#{ objectType.tableName }.#{ objectType.sqlPrimaryKeyName }"
-		end
-
-		def fields
-			'*'
-		end
-
-		def orderClause
-			if @orderBy
-				clause = "order by #{ @orderBy } "
-				if @orderByOrder == ASC
-					clause += 'asc'
-				else
-					clause += 'desc'
-				end
-				clause
-			end
-		end
-
-		def limitClause
-			"limit #{ @limit.begin }, #{ @limit.end - @limit.begin + 1 }" if @limit
-		end
-
-		def toSql
-			clauses = [ "select #{ fields }", "from #{ tables }" ]
-			clauses << whereClause if whereClause
-			clauses << orderClause if orderClause
-			clauses << limitClause if limitClause
-			clauses.join ' '
-		end
-	end
-end

data/lib/lafcadio/schema/CreateTableStatement.rb

@@ -1,61 +0,0 @@
-module Lafcadio
-	class CreateTableStatement #:nodoc:
-		def initialize( domainClass )
-			@domainClass = domainClass
-		end
-		
-		def typeClause( field )
-			require 'lafcadio/objectField/TextField'
-			require 'lafcadio/objectField/DecimalField'
-			require 'lafcadio/objectField/LinkField'
-			require 'lafcadio/objectField/IntegerField'
-			require 'lafcadio/objectField/DateField'
-			require 'lafcadio/objectField/EnumField'
-			require 'lafcadio/objectField/TextListField'
-			require 'lafcadio/objectField/BooleanField'
-			require 'lafcadio/objectField/DateTimeField'
-			if ( field.class <= EnumField )
-				singleQuotedValues = field.enums.keys.collect! { |enumValue|
-					"'#{ enumValue }'"
-				}
-				"enum( #{ singleQuotedValues.join( ', ' ) } )"
-			elsif ( field.class <= TextField || field.class <= TextListField )
-				'varchar(255)'
-			elsif field.class <= DecimalField
-				"float(10, #{ field.precision })"
-			elsif ( field.class <= LinkField || field.class <= IntegerField )
-				'int'
-			elsif field.class <= DateField
-				'date'
-			elsif field.class <= BooleanField
-				'bool'
-			elsif field.class <= TimeStampField
-				'timestamp'
-			elsif field.class <= DateTimeField
-				'datetime'
-			elsif field.class <= BlobField
-				'blob'
-			end
-		end
-		
-		def toSql
-			createDefinitions = []
-			createDefinitions << "#{ @domainClass.sqlPrimaryKeyName } " +
-													 "int not null auto_increment"
-			createDefinitions << "primary key (#{ @domainClass.sqlPrimaryKeyName })"
-			@domainClass.classFields.each { |field|
-				definitionTerms = []
-				definitionTerms << field.dbFieldName
-				definitionTerms << typeClause( field )
-				definitionTerms << 'not null' if field.notNull
-				definitionTerms << 'unique' if field.unique
-				createDefinitions << definitionTerms.join(' ')
-			}
-			<<-SQL
-	create table #{ @domainClass.tableName } (
-		#{ createDefinitions.join(",\n  ") }
-	);
-			SQL
-		end
-	end
-end

data/lib/lafcadio/schema/CreateTableStatement.rb~

@@ -1,59 +0,0 @@
-module Lafcadio
-	class CreateTableStatement #:nodoc:
-		def initialize( domainClass )
-			@domainClass = domainClass
-		end
-		
-		def typeClause( field )
-			require 'lafcadio/objectField/TextField'
-			require 'lafcadio/objectField/DecimalField'
-			require 'lafcadio/objectField/LinkField'
-			require 'lafcadio/objectField/IntegerField'
-			require 'lafcadio/objectField/DateField'
-			require 'lafcadio/objectField/EnumField'
-			require 'lafcadio/objectField/TextListField'
-			require 'lafcadio/objectField/BooleanField'
-			require 'lafcadio/objectField/DateTimeField'
-			if ( field.class <= EnumField )
-				singleQuotedValues = field.enums.keys.collect! { |enumValue|
-					"'#{ enumValue }'"
-				}
-				"enum( #{ singleQuotedValues.join( ', ' ) } )"
-			elsif ( field.class <= TextField || field.class <= TextListField )
-				'varchar(255)'
-			elsif field.class <= DecimalField
-				"float(10, #{ field.precision })"
-			elsif ( field.class <= LinkField || field.class <= IntegerField )
-				'int'
-			elsif field.class <= DateField
-				'date'
-			elsif field.class <= BooleanField
-				'bool'
-			elsif field.class <= TimeStampField
-				'timestamp'
-			elsif field.class <= DateTimeField
-				'datetime'
-			end
-		end
-		
-		def toSql
-			createDefinitions = []
-			createDefinitions << "#{ @domainClass.sqlPrimaryKeyName } " +
-													 "int not null auto_increment"
-			createDefinitions << "primary key (#{ @domainClass.sqlPrimaryKeyName })"
-			@domainClass.classFields.each { |field|
-				definitionTerms = []
-				definitionTerms << field.dbFieldName
-				definitionTerms << typeClause( field )
-				definitionTerms << 'not null' if field.notNull
-				definitionTerms << 'unique' if field.unique
-				createDefinitions << definitionTerms.join(' ')
-			}
-			<<-SQL
-	create table #{ @domainClass.tableName } (
-		#{ createDefinitions.join(",\n  ") }
-	);
-			SQL
-		end
-	end
-end

data/lib/lafcadio/util/Context.rb

@@ -1,61 +0,0 @@
-require 'singleton'
-
-module Lafcadio
-	# The Context is a singleton object that manages ContextualServices. Each 
-	# ContextualService is a service that connects in some way to external 
-	# resources: ObjectStore connects to the database; Emailer connects to SMTP, 
-	# etc.
-	#
-	# Context makes it easy to ensure that each ContextualService is only 
-	# instantiated once, which can be quite useful for services with expensive 
-	# creation.
-	#
-	# Furthermore, Context allows you to explicitly set instances for a given 
-	# service, which can be quite useful in testing. For example, once 
-	# LafcadioTestCase#setup has an instance of MockObjectStore, it calls 
-	#   context.setObjectStore @mockObjectStore
-	# which ensures that any future calls to ObjectStore.getObjectStore will 
-	# return @mockObjectStore, instead of an instance of ObjectStore connecting 
-	# test code to a live database.
-	class Context
-		include Singleton
-
-		def initialize
-			@resources = {}
-		end
-		
-		# Flushes all cached ContextualServices.
-		def flush
-			@resources = {}
-		end
-		
-		def createInstance(resourceName) #:nodoc:
-			resourceClass = eval resourceName
-			resourceClass.new self
-		end
-
-		def getResource(resourceName) #:nodoc:
-			resource = @resources[resourceName]
-			unless resource
-				resource = createInstance resourceName
-				setResource resourceName, resource
-			end
-			resource
-		end
-		
-		def setResource(resourceName, resource) #:nodoc:
-			@resources[resourceName] = resource
-		end
-
-		def method_missing(methId, *args) #:nodoc:
-			methodName = methId.id2name
-			if methodName =~ /^get(.*)$/
-				getResource $1
-			elsif methodName =~ /^set(.*)$/
-				setResource $1, args[0]
-			else
-				super
-			end
-		end	
-	end
-end

data/lib/lafcadio/util/ContextualService.rb

@@ -1,33 +0,0 @@
-require 'lafcadio/util/Context'
-
-module Lafcadio
-	# A ContextualService is a service that is managed by the Context. 
-	# ContextualServices are not instantiated normally. Instead, the instance of 
-	# such a service may be retrieved by calling the method
-	#   < class name >.get< class name >
-	#
-	# For example: ObjectStore.getObjectStore
-	class ContextualService
-		def ContextualService.method_missing(methodId)
-			methodName = methodId.id2name
-			if methodName =~ /^get.*/
-				Context.instance.send(methodName)
-			else
-				super methodId
-			end
-		end
-
-		# The +passKey+ needs to be the Context instance, or else this method fails. 
-		# Note that this isn't hard security of any kind; it's simply a gentle 
-		# reminder to users of a ContextualService that the class should not be 
-		# instantiated directly.
-		def initialize(passKey)
-			if passKey.class != Context
-				raise ArgumentError,
-						  "#{ self.class.name.to_s } should only be instantiated by a " +
-							  "Context",
-						  caller
-			end
-		end
-	end
-end

data/lib/lafcadio/util/English.rb

@@ -1,117 +0,0 @@
-module Lafcadio
-	# A collection of English-language specific utility methods.
-	class English
-		# Turns a camel-case string ("camelCaseToEnglish") to plain English ("camel 
-		# case to english"). Each word is decapitalized.
-		def English.camelCaseToEnglish(camelCaseStr)
-			words = []
-			nextCapIndex =(camelCaseStr =~ /[A-Z]/)
-			while nextCapIndex != nil
-				words << $` if $`.size > 0
-				camelCaseStr = $& + $'
-				camelCaseStr[0] = camelCaseStr[0..0].downcase
-				nextCapIndex =(camelCaseStr =~ /[A-Z]/)
-			end
-			words << camelCaseStr
-			words.join ' '
-		end
-
-		# Given a format for a template sentence, generates the sentence while 
-		# accounting for details such as pluralization and whether to use "a" or 
-		# "an".
-		# [format] The format string. Format codes are:
-		#          * %num: Number
-		#          * %is: Transitive verb. This will be turned into "is" or "are", 
-		#            depending on <tt>number</tt>.
-		#          * %nam: Name. This will be rendered as either singular or 
-		#            plural, depending on <tt>number</tt>.
-		#          * %a: Indefinite article. This will be turned into "a" or "an", 
-		#            depending on <tt>name</tt>.
-		# [name] The name of the object being described.
-		# [number] The number of the objects being describes.
-		#
-		# Examples:
-		#   English.sentence("There %is currently %num %nam", "product category",
-		#                        0) -> "There are currently 0 product categories"
-		#   English.sentence("There %is currently %num %nam", "product category",
-		#                        1) -> "There is currently 1 product category"
-		#   English.sentence("Add %a %nam", "invoice") -> "Add an invoice"	
-		def English.sentence(format, name, number = 1)
-			sentence = format
-			sentence.gsub!( /%num/, number.to_s )
-			isVerb = number == 1 ? "is" : "are"
-			sentence.gsub!( /%is/, isVerb )
-			name = English.plural name if number != 1
-			sentence.gsub!( /%nam/, name )
-			article = startsWithVowelSound(name) ? 'an' : 'a'
-			sentence.gsub!( /%a/, article )
-			sentence
-		end
-
-		# Does this word start with a vowel sound? "User" and "usury" don't, but 
-		# "ugly" does.
-		def English.startsWithVowelSound(word)
-			uSomethingUMatch = word =~ /^u[^aeiuo][aeiou]/
-					# 'user' and 'usury' don't start with a vowel sound
-			word =~ /^[aeiou]/ && !uSomethingUMatch
-		end
-
-		# Given a singular noun, returns the plural form.
-		def English.plural(singular)
-			consonantYPattern = Regexp.new("([^aeiou])y$", Regexp::IGNORECASE)
-			if singular =~ consonantYPattern
-				singular.gsub consonantYPattern, '\1ies'
-			elsif singular =~ /[xs]$/
-				singular + "es"
-			else
-				singular + "s"
-			end
-		end
-
-		# Returns the proper noun form of a string by capitalizing most of the 
-		# words.
-		#
-		# Examples:
-		#   English.properNoun("bosnia and herzegovina") ->
-		#     "Bosnia and Herzegovina"
-		#   English.properNoun("macedonia, the former yugoslav republic of") ->
-		#     "Macedonia, the Former Yugoslav Republic of"
-		#   English.properNoun("virgin islands, u.s.") ->
-		#     "Virgin Islands, U.S."
-		def English.properNoun(string)
-			properNoun = ""
-			while(matchIndex = string =~ /[\. ]/)
-				word = string[0..matchIndex-1]
-				word = word.capitalize unless [ 'and', 'the', 'of' ].index(word) != nil
-				properNoun += word + $&
-				string = string[matchIndex+1..string.length]
-			end
-			word = string
-			word = word.capitalize unless [ 'and', 'the', 'of' ].index(word) != nil
-			properNoun += word
-			properNoun
-		end
-
-		# Given a noun in plural form, returns its singular version.
-		def English.singular(plural)
-			if plural =~ /(.*)ies/
-				$1 + 'y'
-			elsif plural =~ /(.*s)es/
-				$1
-			else
-				plural =~ /(.*)s/
-				$1
-			end
-		end
-
-		# Turns an English language string into camel case.
-		def English.englishToCamelCase(englishStr)
-			cc = ""
-			englishStr.split.each { |word|
-				word = word.capitalize unless cc == ''
-				cc = cc += word
-			}
-			cc
-		end
-	end
-end