lafcadio 0.5.2 → 0.6.0

data/lib/lafcadio/query.rb

@@ -105,18 +105,18 @@ module Lafcadio
 		ASC		= 1
 		DESC 	= 2
 
-		attr_reader :object_type, :condition
+		attr_reader :domain_class, :condition
 		attr_accessor :order_by, :order_by_order, :limit
 
-		def initialize(object_type, pk_idOrCondition = nil)
-			@object_type = object_type
+		def initialize(domain_class, pk_idOrCondition = nil)
+			@domain_class = domain_class
 			( @condition, @order_by, @limit ) = [ nil, nil, nil ]
 			if pk_idOrCondition
 				if pk_idOrCondition.class <= Condition
 					@condition = pk_idOrCondition
 				else
-					@condition = Query::Equals.new( object_type.sql_primary_key_name,
-					                                pk_idOrCondition, object_type )
+					@condition = Query::Equals.new( 'pk_id', pk_idOrCondition,
+					                                domain_class )
 				end
 			end
 			@order_by_order = ASC
@@ -125,7 +125,7 @@ module Lafcadio
 		def and( &action ); compound( CompoundCondition::AND, action ); end
 		
 		def compound( comp_type, action )
-			rquery = Query.infer( @object_type ) { |dobj| action.call( dobj ) }
+			rquery = Query.infer( @domain_class ) { |dobj| action.call( dobj ) }
 			comp_cond = Query::CompoundCondition.new( @condition, rquery.condition,
 			                                          comp_type )
 			comp_cond.query
@@ -151,12 +151,12 @@ module Lafcadio
 			end
 		end
 
-		def sql_primary_key_field(object_type)
-			"#{ object_type.table_name }.#{ object_type.sql_primary_key_name }"
+		def sql_primary_key_field(domain_class)
+			"#{ domain_class.table_name }.#{ domain_class.sql_primary_key_name }"
 		end
 
 		def tables
-			concrete_classes = object_type.self_and_concrete_superclasses.reverse
+			concrete_classes = domain_class.self_and_concrete_superclasses.reverse
 			table_names = concrete_classes.collect { |domain_class|
 				domain_class.table_name
 			}
@@ -172,7 +172,7 @@ module Lafcadio
 		end
 
 		def where_clause
-			concrete_classes = object_type.self_and_concrete_superclasses.reverse
+			concrete_classes = domain_class.self_and_concrete_superclasses.reverse
 			where_clauses = []
 			concrete_classes.each_with_index { |domain_class, i|
 				if i < concrete_classes.size - 1
@@ -191,18 +191,18 @@ module Lafcadio
 				Object
 			end
 
-			attr_reader :object_type
+			attr_reader :domain_class
 
-			def initialize(fieldName, searchTerm, object_type)
+			def initialize(fieldName, searchTerm, domain_class)
 				@fieldName = fieldName
 				@searchTerm = searchTerm
 				unless @searchTerm.class <= self.class.search_term_type
 					raise "Incorrect searchTerm type #{ searchTerm.class }"
 				end
-				@object_type = object_type
-				if @object_type
-					unless @object_type <= DomainObject
-						raise "Incorrect object type #{ @object_type.to_s }"
+				@domain_class = domain_class
+				if @domain_class
+					unless @domain_class <= DomainObject
+						raise "Incorrect object type #{ @domain_class.to_s }"
 					end
 				end
 			end
@@ -210,32 +210,28 @@ module Lafcadio
 			def db_field_name; get_field.db_table_and_field_name; end
 			
 			def get_field
-				anObjectType = @object_type
+				a_domain_class = @domain_class
 				field = nil
-				while (anObjectType < DomainObject || anObjectType < DomainObject) &&
-							!field
-					field = anObjectType.get_class_field( @fieldName ) ||
-					        anObjectType.get_class_field_by_db_name( @fieldName )
-					anObjectType = anObjectType.superclass
+				while ( a_domain_class < DomainObject ) && !field
+					field = a_domain_class.get_class_field( @fieldName )
+					a_domain_class = a_domain_class.superclass
 				end
 				if field
 					field
 				else
 					errStr = "Couldn't find field \"#{ @fieldName }\" in " +
-									 "#{ @object_type } domain class"
+									 "#{ @domain_class } domain class"
 					raise( MissingError, errStr, caller )
 				end
 			end
 			
-			def query; Query.new( @object_type, self ); end
+			def query; Query.new( @domain_class, self ); end
 			
 			def not
 				Query::Not.new( self )
 			end
 
-			def primary_key_field?
-				[ @object_type.sql_primary_key_name, 'pk_id' ].include?( @fieldName )
-			end
+			def primary_key_field?; 'pk_id' == @fieldName; end
 			
 			def to_condition; self; end
 		end
@@ -260,8 +256,8 @@ module Lafcadio
 				GREATER_THAN => Proc.new { |d1, d2| d1 > d2 }
 			}
 
-			def initialize(fieldName, searchTerm, object_type, compareType)
-				super fieldName, searchTerm, object_type
+			def initialize(fieldName, searchTerm, domain_class, compareType)
+				super fieldName, searchTerm, domain_class
 				@compareType = compareType
 			end
 
@@ -298,7 +294,7 @@ module Lafcadio
 					@compoundType = AND
 				end
 				@conditions = conditions
-				@object_type = conditions[0].object_type
+				@domain_class = conditions[0].domain_class
 			end
 
 			def object_meets(anObj)
@@ -344,7 +340,16 @@ module Lafcadio
 				if @searchTerm.class <= ObjectField
 					@searchTerm.db_table_and_field_name
 				else
-					field.value_for_sql(@searchTerm).to_s
+					begin
+						field.value_for_sql( @searchTerm ).to_s
+					rescue DomainObjectInitError
+						raise(
+							ArgumentError,
+							"Can't query using an uncommitted domain object as a search " +
+									"term.",
+							caller
+						)
+					end
 				end
 			end
 
@@ -382,6 +387,19 @@ module Lafcadio
 				"#{ db_field_name } in (#{ @searchTerm.join(', ') })"
 			end
 		end
+		
+		class Include < CompoundCondition
+			def initialize( field_name, search_term, domain_class )
+				begin_cond = Like.new( field_name, search_term + ',', domain_class,
+				                       Like::POST_ONLY )
+				mid_cond = Like.new( field_name, ',' + search_term + ',',
+				                     domain_class )
+				end_cond = Like.new( field_name, ',' + search_term, domain_class,
+				                     Like::PRE_ONLY )
+				only_cond = Equals.new( field_name, search_term, domain_class )
+				super( begin_cond, mid_cond, end_cond, only_cond, OR )
+			end
+		end
 
 		class Inferrer #:nodoc:
 			def initialize( domain_class, &action )
@@ -401,8 +419,8 @@ module Lafcadio
 			POST_ONLY			= 3
 
 			def initialize(
-					fieldName, searchTerm, object_type, matchType = PRE_AND_POST)
-				super fieldName, searchTerm, object_type
+					fieldName, searchTerm, domain_class, matchType = PRE_AND_POST)
+				super fieldName, searchTerm, domain_class
 				@matchType = matchType
 			end
 			
@@ -441,36 +459,11 @@ module Lafcadio
 			end
 		end
 
-		class Link < Condition #:nodoc:
-			def initialize( fieldName, searchTerm, object_type )
-				if searchTerm.pk_id.nil?
-					raise ArgumentError,
-					      "Can't query using an uncommitted domain object as a search term",
-								caller
-				else
-					super( fieldName, searchTerm, object_type )
-				end
-			end
-		
-			def self.search_term_type
-				DomainObject
-			end
-
-			def object_meets(anObj)
-				value = anObj.send @fieldName
-				value ? value.pk_id == @searchTerm.pk_id : false
-			end
-
-			def to_sql
-				"#{ db_field_name } = #{ @searchTerm.pk_id }"
-			end
-		end
-
 		class Max < Query #:nodoc:
 			attr_reader :field_name
 		
-			def initialize( object_type, field_name = 'pk_id' )
-				super( object_type )
+			def initialize( domain_class, field_name = 'pk_id' )
+				super( domain_class )
 				@field_name = field_name
 			end
 		
@@ -483,7 +476,7 @@ module Lafcadio
 			end
 		
 			def fields
-				"max(#{ @object_type.get_field( @field_name ).db_field_name })"
+				"max(#{ @domain_class.get_field( @field_name ).db_field_name })"
 			end
 		end
 
@@ -496,7 +489,7 @@ module Lafcadio
 				!@unCondition.object_meets(obj)
 			end
 			
-			def object_type; @unCondition.object_type; end
+			def domain_class; @unCondition.domain_class; end
 
 			def to_sql
 				"!(#{ @unCondition.to_sql })"
@@ -517,10 +510,10 @@ module Lafcadio
 			def initialize( domainObjectImpostor, class_field_or_name )
 				@domainObjectImpostor = domainObjectImpostor
 				if class_field_or_name == 'pk_id'
-					@db_field_name = 'pk_id'
+					@field_name = 'pk_id'
 				else
 					@class_field = class_field_or_name
-					@db_field_name = class_field_or_name.db_field_name
+					@field_name = class_field_or_name.name
 				end
 			end
 			
@@ -535,12 +528,12 @@ module Lafcadio
 			
 			def register_compare_condition( compareStr, searchTerm)
 				compareVal = ObjectFieldImpostor.comparators[compareStr]
-				Compare.new( @db_field_name, searchTerm,
+				Compare.new( @field_name, searchTerm,
 				             @domainObjectImpostor.domain_class, compareVal )
 			end
 			
 			def equals( searchTerm )
-				Equals.new( @db_field_name, field_or_field_name( searchTerm ),
+				Equals.new( @field_name, field_or_field_name( searchTerm ),
 					          @domainObjectImpostor.domain_class )
 			end
 			
@@ -552,29 +545,45 @@ module Lafcadio
 				end
 			end
 			
+			def include?( search_term )
+				if @class_field.instance_of?( TextListField )
+					Include.new( @field_name, search_term,
+					             @domainObjectImpostor.domain_class )
+				else
+					raise ArgumentError
+				end
+			end
+			
 			def like( regexp )
-				if regexp.source =~ /^\^(.*)/
-					searchTerm = $1
-					matchType = Query::Like::POST_ONLY
-				elsif regexp.source =~ /(.*)\$$/
-					searchTerm = $1
-					matchType = Query::Like::PRE_ONLY
+				if regexp.is_a?( Regexp )
+					if regexp.source =~ /^\^(.*)/
+						searchTerm = $1
+						matchType = Query::Like::POST_ONLY
+					elsif regexp.source =~ /(.*)\$$/
+						searchTerm = $1
+						matchType = Query::Like::PRE_ONLY
+					else
+						searchTerm = regexp.source
+						matchType = Query::Like::PRE_AND_POST
+					end
+					Query::Like.new( @field_name, searchTerm,
+													 @domainObjectImpostor.domain_class, matchType )
 				else
-					searchTerm = regexp.source
-					matchType = Query::Like::PRE_AND_POST
+					raise(
+						ArgumentError, "#{ @field_name }#like needs to receive a Regexp",
+						caller
+					)
 				end
-				Query::Like.new( @db_field_name, searchTerm,
-												 @domainObjectImpostor.domain_class, matchType )
 			end
 			
 			def in( *searchTerms )
-				Query::In.new( @db_field_name, searchTerms,
+				Query::In.new( @field_name, searchTerms,
 											 @domainObjectImpostor.domain_class )
 			end
 			
 			def to_condition
 				if @class_field.instance_of?( BooleanField )
-					Query::Equals.new( @db_field_name, true,
+					Query::Equals.new( @field_name, true,
 					                   @domainObjectImpostor.domain_class )
 				else
 					raise

data/lib/lafcadio/schema.rb

@@ -16,7 +16,6 @@ module Lafcadio
 			definitionTerms << field.db_field_name
 			definitionTerms << type_clause( field )
 			definitionTerms << 'not null' if field.not_null
-			definitionTerms << 'unique' if field.unique
 			definitionTerms.join( ' ' )
 		end
 

data/lib/lafcadio/test.rb

@@ -1,10 +1,11 @@
 require 'lafcadio/depend'
 require 'lafcadio/mock'
 require 'lafcadio/util'
+require 'test/unit'
 
 # 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
+class LafcadioTestCase < Test::Unit::TestCase
 	include Lafcadio
 
   def setup
@@ -14,4 +15,6 @@ class LafcadioTestCase < RUNIT::TestCase
 		ObjectStore.set_object_store @mockObjectStore
 		LafcadioConfig.set_filename 'lafcadio/test/testConfig.dat'
   end
+	
+	def default_test; end
 end

data/lib/lafcadio/test/testconfig.dat

@@ -5,9 +5,7 @@ dbhost:localhost
 adminEmail:john.doe@email.com
 siteName:Site Name
 url:http://test.url
-classpath:lafcadio/
 logdir:../test/testOutput/
-domainDirs:../test/mock/domain/
 domainFiles:../test/mock/domain.rb
 logSql:n
 classDefinitionDir:../test/testData

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:../test/mock/domain/
+domainFiles:../test/mock/domain.rb
+logSql:n
+classDefinitionDir:../test/testData

data/lib/lafcadio/util.rb

@@ -1,43 +1,7 @@
 require 'delegate'
 require 'singleton'
 
-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.get_class(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 bare_name
-		name =~ /::/
-		$' || name
-	end
-end
-
 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, 
@@ -100,6 +64,8 @@ module Lafcadio
 	#
 	# For example: ObjectStore.getObjectStore
 	class ContextualService
+		def self.flush; Context.instance.set_resource( self, nil ); end
+	
 		def self.method_missing( methodId, *args )
 			methodName = methodId.id2name
 			if methodName =~ /^get_(.*)/ || methodName =~ /^set_(.*)/
@@ -348,32 +314,6 @@ module Lafcadio
 	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).precision_format( 3 )    -> "24.550"
-	#   (24.55).precision_format( 0 )    -> "24"
-	#   100.precision_format( 2, false ) -> "100"
-  def precision_format(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 underscored version of a camel-case string.
 	def camel_case_to_underscore
@@ -410,46 +350,6 @@ class 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".increment_filename   -> "john_1.jpg"
-	#   "john_1.jpg".increment_filename -> "john_2.jpg"
-	#   "john_2.jpg".increment_filename -> "john_3.jpg"
-  def increment_filename
-		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.'.line_wrape( 10 ) ->
-	#     "the quick\nbrown fox\njumped\nover the\nlazy dog."
-	def line_wrape(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.
 	#
@@ -472,24 +372,6 @@ class String
 		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'.split_keep_in_betweens(/Z+/) ->
-	#     ['the', 'Z', 'quick', 'ZZ', 'brown', 'Z', 'fox' ]
-	def split_keep_in_betweens(regexp)
-		result = []
-		string = clone
-		while string =~ regexp
-			result << $`
-			result << $&
-			string = $'
-		end
-		result << string unless string == ''
-		result
-	end
-
 	# Returns the camel-case equivalent of an underscore-style string.
 	def underscore_to_camel_case
 		capitalize.gsub( /_([a-zA-Z0-9]+)/ ) { |s| s[1,s.size - 1].capitalize }