lafcadio 0.4.3

data/lib/lafcadio/query/Query.rb

@@ -0,0 +1,92 @@
+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.rb

@@ -0,0 +1,2 @@
+require 'lafcadio/includer'
+Includer.include( 'schema' )

data/lib/lafcadio/schema/CreateTableStatement.rb

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

@@ -0,0 +1,59 @@
+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/test.rb

@@ -0,0 +1,2 @@
+require 'lafcadio/includer'
+Includer.include( 'test' )

data/lib/lafcadio/test/LafcadioTestCase.rb

@@ -0,0 +1,17 @@
+require 'runit/testcase'
+require 'lafcadio/mock/MockObjectStore'
+require 'lafcadio/util/LafcadioConfig'
+
+# A test case that sets up a number of mock services. In writing an application 
+# that uses Lafcadio you may find it convenient to inherit from this class.
+class LafcadioTestCase < RUNIT::TestCase
+	include Lafcadio
+
+  def setup
+  	context = Context.instance
+  	context.flush
+    @mockObjectStore = MockObjectStore.new context
+		context.setObjectStore @mockObjectStore
+		LafcadioConfig.setFilename 'lafcadio/test/testConfig.dat'
+  end
+end

data/lib/lafcadio/test/testconfig.dat

@@ -0,0 +1,13 @@
+dbuser:test
+dbpassword:password
+dbname:test
+dbhost:localhost
+adminEmail:john.doe@email.com
+siteName:Site Name
+url:http://test.url
+classpath:lafcadio/
+logdir:../test/testOutput/
+domainDirs:lafcadio/domain/,../test/mock/domain/
+domainFiles:../test/mock/domain.rb
+logSql:n
+classDefinitionDir:../test/testData

data/lib/lafcadio/util.rb

@@ -0,0 +1,180 @@
+require 'lafcadio/includer'
+Includer.include( 'util' )
+
+class Array
+	# If this array has one element, returns that element; otherwise, raises an
+	# error.
+	def only
+		if size != 1
+			raise "Expected single-value Array but Array has #{ size } members"
+		else
+			first
+		end
+	end
+end
+
+class Class < Module
+	# Given a String, returns a class object by the same name.
+	def self.getClass(className)
+		theClass = nil
+		ObjectSpace.each_object(Class) { |aClass|
+			theClass = aClass if aClass.name == className
+		}
+		if theClass
+			theClass
+		else
+			raise( Lafcadio::MissingError, "Couldn't find class \"#{ className }\"",
+			       caller )
+		end
+	end
+	
+	# Returns the name of <tt>aClass</tt> itself, stripping off the names of any 
+	# containing modules or outer classes.
+	def bareName
+		name =~ /::/
+		$' || name
+	end
+end
+
+module Lafcadio
+	class MissingError < RuntimeError
+	end
+end
+
+class Numeric
+	# Returns a string that represents the numbeer to <tt>precision</tt> decimal 
+	# places, rounding down if necessary. If <tt>padDecimals</tt> is set to 
+	# <tt>false</tt> and the number rounds to a whole number, there will be no 
+	# decimals shown.
+	#
+	#   (24.55).precisionFormat( 3 )    -> "24.550"
+	#   (24.55).precisionFormat( 0 )    -> "24"
+	#   100.precisionFormat( 2, false ) -> "100"
+  def precisionFormat(precision, padDecimals = true)
+    str = floor.to_s
+    if precision > 0
+      decimal = self - self.floor
+      decimalStr =(decimal * 10 ** precision).floor.to_s
+      if decimalStr.size < precision
+        decimalStr += "0" *(precision - decimalStr.size)
+      end
+      if padDecimals || decimalStr =~ /[123456789]/
+	      str += "."
+  	    str += decimalStr
+  	  end
+    end
+    str
+  end
+end
+
+class String
+	# Returns the number of times that <tt>regexp</tt> occurs in the string.
+	def countOccurrences(regexp)
+		count = 0
+		str = self.clone
+		while str =~ regexp
+			count += 1
+			str = $'
+		end
+		count
+	end
+	
+	# Decapitalizes the first letter of the string, or decapitalizes the 
+	# entire string if it's all capitals.
+	#
+	#   'InternalClient'.decapitalize -> "internalClient"
+	#   'SKU'.decapitalize            -> "sku"
+	def decapitalize
+		string = clone
+		firstLetter = string[0..0].downcase
+		string = firstLetter + string[1..string.length]
+		newString = ""
+		while string =~ /([A-Z])([^a-z]|$)/
+			newString += $`
+			newString += $1.downcase
+			string = $2 + $'
+		end
+		newString += string
+		newString
+	end
+
+	# Increments a filename. If the filename ends with a number, it increments 
+	# that number; otherwise it appends a "_1" after the filename but before the 
+	# file extension.
+	#
+	#   "john.jpg".incrementFilename   -> "john_1.jpg"
+	#   "john_1.jpg".incrementFilename -> "john_2.jpg"
+	#   "john_2.jpg".incrementFilename -> "john_3.jpg"
+  def incrementFilename
+		filename = self.clone
+    extension = filename.split(/\./).last
+    filename.sub!(/\..*$/, '')
+    if filename =~ /_(\d*)$/
+      newSuffix = $1.to_i + 1
+      filename = $` + "_#{newSuffix}"
+    else
+      filename += "_1"
+    end
+    filename += ".#{extension}"
+    filename
+  end
+
+	# Breaks a string into lines no longer than <tt>lineLength</tt>.
+	#
+	#   'the quick brown fox jumped over the lazy dog.'.lineWrap( 10 ) ->
+	#     "the quick\nbrown fox\njumped\nover the\nlazy dog."
+	def lineWrap(lineLength)
+		words = split ' '
+		line = ''
+		lines = []
+		words.each { |word|
+			if line.length + word.length + 1 > lineLength
+				lines << line
+				line = ''
+			end
+			line = line != '' ? "#{ line } #{ word }" : word
+		}
+		lines << line
+		lines.join "\n"
+	end
+	
+	# Turns a numeric string into U.S. format if it's not already formatted that
+	# way.
+	#
+	#   "10,00".numericStringToUsFormat -> "10.00"
+	#   "10.00".numericStringToUsFormat -> "10.00"
+	def numericStringToUsFormat
+		numericString = clone
+		numericString.gsub!(/,/, '.') if numericString =~ /,\d{2}$/
+		numericString
+	end
+
+	# Left-pads a string with +fillChar+ up to +size+ size.
+	#
+	#   "a".pad( 10, "+") -> "+++++++++a"
+	def pad(size, fillChar)
+		string = clone
+		while string.length < size
+			string = fillChar + string
+		end
+		string
+	end
+	
+	# Divides a string into substrings using <tt>regexp</tt> as a 
+	# delimiter, and returns an array containing both the substrings and the 
+	# portions that matched <tt>regexp</tt>.
+	#
+	#   'theZquickZZbrownZfox'.splitKeepInBetweens(/Z+/) ->
+	#     ['the', 'Z', 'quick', 'ZZ', 'brown', 'Z', 'fox' ]
+	def splitKeepInBetweens(regexp)
+		result = []
+		string = clone
+		while string =~ regexp
+			result << $`
+			result << $&
+			string = $'
+		end
+		result << string unless string == ''
+		result
+	end
+end

data/lib/lafcadio/util/Context.rb

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