lafcadio 0.9.0 → 0.9.1

data/lib/lafcadio/query.rb~

@@ -110,11 +110,11 @@ module Lafcadio
 			@domain_class, @opts = domain_class, opts
 			( @condition, @order_by, @limit ) = [ nil, nil, nil ]
 			if pk_id_or_condition
-				if pk_id_or_condition.class <= Condition
+				if pk_id_or_condition.is_a?( Condition )
 					@condition = pk_id_or_condition
 				else
 					@condition = Query::Equals.new(
-						'pk_id', pk_id_or_condition, domain_class
+						:pk_id, pk_id_or_condition, domain_class
 					)
 				end
 			end
@@ -133,52 +133,50 @@ module Lafcadio
 			
 		def compound( comp_type, action )
 			rquery = Query.infer( @domain_class ) { |dobj| action.call( dobj ) }
-			comp_cond = Query::CompoundCondition.new( @condition, rquery.condition,
-			                                          comp_type )
-			comp_cond.query
+			Query::CompoundCondition.new(
+				@condition, rquery.condition, comp_type
+			).query
 		end
 		
-		def eql?( other ); other.class <= Query && other.to_sql == to_sql; end
+		def dobj_satisfies?( dobj )
+			@condition.nil? or @condition.dobj_satisfies?( dobj )
+		end
+
+		def eql?( other ); other.is_a?( Query ) && other.to_sql == to_sql; end
 
 		def fields; @opts[:group_functions] == [:count] ? 'count(*)' : '*'; end
 
 		def hash; to_sql.hash; end
 		
+		def implies?( other_query )
+			if other_query == self
+				true
+			elsif @domain_class == other_query.domain_class
+				if other_query.condition.nil? and !self.condition.nil?
+					true
+				else
+					self.condition and self.condition.implies?( other_query.condition )
+				end
+			end
+		end
+		
 		def limit_clause
 			"limit #{ @limit.begin }, #{ @limit.end - @limit.begin + 1 }" if @limit
 		end
 		
-		def object_meets( dobj ); @condition.object_meets( dobj ); end
-
 		def or( &action ); compound( CompoundCondition::OR, action ); end
 		
 		def order_clause
 			if @order_by
-				if @order_by.is_a? Array
-					field_str = @order_by.map { |f_name|
-						@domain_class.get_field( f_name.to_s ).db_field_name
-					}.join( ', ' )
-				else
-					field_str = @domain_class.get_field( @order_by ).db_field_name
-				end
+				field_str = @order_by.map { |f_name|
+					@domain_class.field( f_name.to_s ).db_field_name
+				}.join( ', ' )
 				clause = "order by #{ field_str } "
 				clause += @order_by_order == ASC ? 'asc' : 'desc'
 				clause
 			end
 		end
 		
-		def implies?( other_query )
-			if other_query == self
-				true
-			elsif @domain_class == other_query.domain_class
-				if other_query.condition.nil? and !self.condition.nil?
-					true
-				else
-					self.condition and self.condition.implies?( other_query.condition )
-				end
-			end
-		end
-		
 		def result_row( row )
 			if @opts[:group_functions] == [:count]
 				{ :count => row.first }
@@ -219,7 +217,7 @@ module Lafcadio
 					where_clauses << @condition.to_sql if @condition
 				end
 			}
-			where_clauses.size > 0 ? 'where ' + where_clauses.join( ' and ' ) : nil
+			!where_clauses.empty? ? 'where ' + where_clauses.join( ' and ' ) : nil
 		end
 
 		class Condition #:nodoc:
@@ -230,19 +228,20 @@ module Lafcadio
 			attr_reader :domain_class
 
 			def initialize(fieldName, searchTerm, domain_class)
-				@fieldName = fieldName
-				@searchTerm = searchTerm
-				unless @searchTerm.class <= self.class.search_term_type
+				@fieldName, @searchTerm, @domain_class =
+						fieldName, searchTerm, domain_class
+				unless @searchTerm.is_a?( self.class.search_term_type )
 					raise "Incorrect searchTerm type #{ searchTerm.class }"
 				end
-				@domain_class = domain_class
-				if @domain_class
-					unless @domain_class <= DomainObject
-						raise "Incorrect object type #{ @domain_class.to_s }"
-					end
+				if @domain_class and !( @domain_class < DomainObject )
+					raise "Incorrect object type #{ @domain_class.to_s }"
 				end
 			end
 			
+			def |( other_cond ); Query.Or( self, other_cond ); end
+			
+			def &( other_cond ); Query.And( self, other_cond ); end
+			
 			def implies?( other_condition )
 				self.eql?( other_condition ) or (
 					other_condition.respond_to?( :implied_by? ) and 
@@ -250,22 +249,28 @@ module Lafcadio
 				)
 			end
 			
-			def db_field_name; get_field.db_table_and_field_name; end
+			def db_field_name; field.db_column; end
 			
 			def eql?( other_cond )
 				other_cond.is_a?( Condition ) and other_cond.to_sql == to_sql
 			end
 			
-			def get_field; @domain_class.get_field( @fieldName ); end
-			
-			def query; Query.new( @domain_class, self ); end
-			
-			def not
-				Query::Not.new( self )
+			def field
+				f = @domain_class.field @fieldName.to_s
+				f or raise(
+					MissingError,
+					"Couldn't find field \"#{ @fieldName }\" in " + @domain_class.name +
+							" domain class",
+					caller
+				)
 			end
+			
+			def not; Query::Not.new( self ); end
 
 			def primary_key_field?; 'pk_id' == @fieldName; end
 			
+			def query; Query.new( @domain_class, self ); end
+			
 			def to_condition; self; end
 		end
 
@@ -294,17 +299,7 @@ module Lafcadio
 				@compareType = compareType
 			end
 
-			def to_sql
-				if ( get_field.kind_of?( DomainObjectField ) &&
-				     !@searchTerm.respond_to?( :pk_id ) )
-					search_val = @searchTerm.to_s
-				else
-					search_val = get_field.value_for_sql( @searchTerm ).to_s
-				end
-				"#{ db_field_name } #{ @@comparators[@compareType] } " + search_val
-			end
-
-			def object_meets(anObj)
+			def dobj_satisfies?(anObj)
 				value = anObj.send @fieldName
 				value = value.pk_id if value.class <= DomainObject
 				if value
@@ -313,6 +308,16 @@ module Lafcadio
 					false
 				end
 			end
+
+			def to_sql
+				if ( field.kind_of?( DomainObjectField ) &&
+				     !@searchTerm.respond_to?( :pk_id ) )
+					search_val = @searchTerm.to_s
+				else
+					search_val = field.value_for_sql( @searchTerm ).to_s
+				end
+				"#{ db_field_name } #{ @@comparators[@compareType] } #{ search_val }"
+			end
 		end
 
 		class CompoundCondition < Condition #:nodoc:
@@ -320,7 +325,7 @@ module Lafcadio
 			OR  = 2
 			
 			def initialize( *args )
-				if( [ AND, OR ].index( args.last) )
+				if( [ AND, OR ].include?( args.last ) )
 					@compound_type = args.last
 					args.pop
 				else
@@ -332,6 +337,18 @@ module Lafcadio
 				@domain_class = @conditions[0].domain_class
 			end
 
+			def dobj_satisfies?(anObj)
+				if @compound_type == AND
+					@conditions.inject( true ) { |result, cond|
+						result && cond.dobj_satisfies?( anObj )
+					}
+				else
+					@conditions.inject( false ) { |result, cond|
+						result || cond.dobj_satisfies?( anObj )
+					}
+				end
+			end
+
 			def implied_by?( other_condition )
 				@compound_type == OR && @conditions.any? { |cond|
 					cond.implies?( other_condition )
@@ -341,27 +358,15 @@ module Lafcadio
 			def implies?( other_condition )
 				super( other_condition ) or (
 					@compound_type == AND and @conditions.any? { |cond|
-						cond.implies?( other_condition )
+						cond.implies? other_condition
 					}
 				) or (
 					@compound_type == OR and @conditions.all? { |cond|
-						cond.implies?( other_condition )
+						cond.implies? other_condition
 					}
 				)
 			end
 
-			def object_meets(anObj)
-				if @compound_type == AND
-					@conditions.inject( true ) { |result, cond|
-						result && cond.object_meets( anObj )
-					}
-				else
-					@conditions.inject( false ) { |result, cond|
-						result || cond.object_meets( anObj )
-					}
-				end
-			end
-
 			def to_sql
 				booleanString = @compound_type == AND ? 'and' : 'or'
 				subSqlStrings = @conditions.collect { |cond| cond.to_sql }
@@ -382,10 +387,9 @@ module Lafcadio
 						
 						def method_missing( methId, *args )
 							fieldName = methId.id2name
-							begin
-								classField = self.domain_class.get_field( fieldName )
+							if ( classField = self.domain_class.field( fieldName ) )
 								ObjectFieldImpostor.new( self, classField )
-							rescue MissingError
+							else
 								super( methId, *args )
 							end
 						end
@@ -406,10 +410,18 @@ module Lafcadio
 		end
 		
 		class Equals < Condition #:nodoc:
+			def dobj_satisfies?(anObj)
+				if @searchTerm.is_a?( ObjectField )
+					compare_value = anObj.send @searchTerm.name
+				else
+					compare_value = @searchTerm
+				end
+				compare_value == anObj.send( @fieldName )
+			end
+
 			def r_val_string
-				field = get_field
-				if @searchTerm.class <= ObjectField
-					@searchTerm.db_table_and_field_name
+				if @searchTerm.is_a?( ObjectField )
+					@searchTerm.db_column
 				else
 					begin
 						field.value_for_sql( @searchTerm ).to_s
@@ -424,38 +436,22 @@ module Lafcadio
 				end
 			end
 
-			def object_meets(anObj)
-				if @searchTerm.class <= ObjectField
-					compare_value = anObj.send( @searchTerm.name )
-				else
-					compare_value = @searchTerm
-				end
-				compare_value == anObj.send( @fieldName )
-			end
-
 			def to_sql
 				sql = "#{ db_field_name } "
-				unless @searchTerm.nil?
-					sql += "= " + r_val_string
-				else
-					sql += "is null"
-				end
+				sql += ( !@searchTerm.nil? ? "= #{ r_val_string }" : "is null" )
 				sql
 			end
 		end
 
 		class In < Condition #:nodoc:
-			def self.search_term_type
-				Array
-			end
+			def self.search_term_type; Array; end
 
-			def object_meets(anObj)
-				value = anObj.send @fieldName
-				@searchTerm.index(value) != nil
+			def dobj_satisfies?(anObj)
+				@searchTerm.include?( anObj.send( @fieldName ) )
 			end
 
 			def to_sql
-				if get_field.is_a?( StringField )
+				if field.is_a?( StringField )
 					quoted = @searchTerm.map do |str| "'#{ str }'"; end
 					end_clause = quoted.join ', '
 				else
@@ -467,12 +463,15 @@ module Lafcadio
 		
 		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 )
+				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
@@ -489,7 +488,7 @@ module Lafcadio
 			end
 			
 			def execute
-				impostor = DomainObjectImpostor.impostor( @domain_class )
+				impostor = DomainObjectImpostor.impostor @domain_class
 				condition = @action.call( impostor ).to_condition
 				query = Query.new( @domain_class, condition )
 				query.order_by = @order_by
@@ -504,12 +503,23 @@ module Lafcadio
 			POST_ONLY			= 3
 
 			def initialize(
-					fieldName, searchTerm, domain_class, matchType = PRE_AND_POST)
+				fieldName, searchTerm, domain_class, matchType = PRE_AND_POST
+			)
 				super fieldName, searchTerm, domain_class
 				@matchType = matchType
 			end
 			
-			def get_regexp
+			def dobj_satisfies?(anObj)
+				value = anObj.send @fieldName
+				value = value.pk_id.to_s if value.respond_to?( :pk_id )
+				if value.is_a?( Array )
+					value.include? @searchTerm
+				else
+					!regexp.match( value ).nil?
+				end
+			end
+
+			def regexp
 				if @matchType == PRE_AND_POST
 					Regexp.new( @searchTerm, Regexp::IGNORECASE )
 				elsif @matchType == PRE_ONLY
@@ -519,18 +529,6 @@ module Lafcadio
 				end
 			end
 
-			def object_meets(anObj)
-				value = anObj.send @fieldName
-				if value.class <= DomainObject || value.class == DomainObjectProxy
-					value = value.pk_id.to_s
-				end
-				if value.class <= Array
-					(value.index(@searchTerm) != nil)
-				else
-					get_regexp.match(value) != nil
-				end
-			end
-
 			def to_sql
 				withWildcards = @searchTerm
 				if @matchType == PRE_AND_POST
@@ -553,15 +551,15 @@ module Lafcadio
 			end
 		
 			def collect( coll )
-				max = coll.inject( nil ) { |max, d_obj|
-					a_value = d_obj.send( @field_name )
-					( max.nil? || a_value > max ) ? a_value : max
+				max = coll.inject( coll.first ) { |max, d_obj|
+					a_value = d_obj.send @field_name
+					( a_value > max ) ? a_value : max
 				}
 				[ result_row( [max] ) ]
 			end
 		
 			def fields
-				"max(#{ @domain_class.get_field( @field_name ).db_field_name })"
+				"max(#{ @domain_class.field( @field_name ).db_field_name })"
 			end
 			
 			def result_row( row ); { :max => row.first }; end
@@ -572,8 +570,8 @@ module Lafcadio
 				@unCondition = unCondition
 			end
 
-			def object_meets(obj)
-				!@unCondition.object_meets(obj)
+			def dobj_satisfies?(obj)
+				!@unCondition.dobj_satisfies?(obj)
 			end
 			
 			def domain_class; @unCondition.domain_class; end
@@ -594,25 +592,25 @@ module Lafcadio
 			
 			attr_reader :class_field
 		
-			def initialize( domainObjectImpostor, class_field_or_name )
+			def initialize( domainObjectImpostor, class_field )
 				@domainObjectImpostor = domainObjectImpostor
-				if class_field_or_name == 'pk_id'
-					@field_name = 'pk_id'
-				else
-					@class_field = class_field_or_name
-					@field_name = class_field_or_name.name
-				end
+				@class_field = class_field
+				@field_name = class_field.name
 			end
 			
 			def method_missing( methId, *args )
 				methodName = methId.id2name
-				if !ObjectFieldImpostor.comparators.keys.index( methodName ).nil?
+				if self.class.comparators.keys.include?( methodName )
 					register_compare_condition( methodName, *args )
 				else
 					super( methId, *args )
 				end
 			end
 			
+			def |( condition ); Query.Or( to_condition, condition ); end
+			
+			def &( condition ); Query.And( to_condition, condition ); end
+
 			def register_compare_condition( compareStr, searchTerm)
 				compareVal = ObjectFieldImpostor.comparators[compareStr]
 				Compare.new( @field_name, searchTerm,