lafcadio 0.8.3 → 0.9.0

data/lib/lafcadio.rb

@@ -16,7 +16,7 @@
 # http://lafcadio.rubyforge.org/tutorial.html.
 
 module Lafcadio
-	Version = "0.8.3"
+	Version = "0.9.0"
 
 	require 'lafcadio/depend'
 	require 'lafcadio/domain'

data/lib/lafcadio.rb~

@@ -16,7 +16,7 @@
 # http://lafcadio.rubyforge.org/tutorial.html.
 
 module Lafcadio
-	Version = "0.8.2"
+	Version = "0.8.0"
 
 	require 'lafcadio/depend'
 	require 'lafcadio/domain'

data/lib/lafcadio/dateTime.rb~

@@ -0,0 +1,93 @@
+module Lafcadio
+	# Represents a specific month in time. With the exception of
+	# Month.month_names (which returns a zero-based array), every usage of the
+	# month value assumes that 1 equals January and 12 equals December.
+	class Month
+		# Returns an array of the full names of months (in English). Note that
+		# "January" is the 0th element, and "December" is the 11th element.
+		def Month.month_names
+			[ "January", "February", "March", "April", "May", "June", "July",
+			  "August", "September", "October", "November", "December" ]
+		end
+
+		include Comparable
+
+		attr_reader :month, :year
+
+		# A new month can be set to a specific +month+ and +year+, or you can call 
+		# Month.new with no arguments to receive the current month.
+		def initialize( year = nil, month = nil )
+			require 'date'
+			if month.nil? || year.nil?
+				date = Date.today
+				month = date.mon unless month
+				year = date.year unless year
+			end
+			fail "invalid month" if month < 1 || month > 12
+			@month = month
+			@year = year
+		end
+
+		# Returns a new Month that is +amountToAdd+ months later.
+		def +( amountToAdd )
+			( fullYears, remainingMonths ) = amountToAdd.divmod( 12 )
+			resultYear = @year + fullYears
+			resultMonth = @month + remainingMonths
+			if resultMonth > 12
+				resultMonth -= 12
+				resultYear += 1
+			end
+			Month.new( resultYear, resultMonth )
+		end
+		
+		# Returns a new Month that is +amountToSubtract+ months earlier.
+		def -(amountToSubtract)
+			self + (-amountToSubtract)
+		end
+		
+		# Compare this Month to another Month.
+		def <=>(anOther)
+			if @year == anOther.year
+				@month <=> anOther.month
+			else
+				@year <=> anOther.year
+			end
+		end
+
+		# Returns the last Date of the month.
+		def end_date
+			self.next.start_date - 1
+		end
+
+		# Is this Month equal to +anOther+? +anOther+ must be another Month of the
+		# same value.
+		def eql?(anOther)
+			self == anOther
+		end
+		
+		# Calculate a hash value for this Month.
+		def hash
+			"#{@year}#{@month}".to_i
+		end
+
+		# Returns the next Month.
+		def next
+			self + 1
+		end
+		
+		# Returns the previous Month.
+		def prev
+			self - 1
+		end
+		
+		# Returns the first Date of the month.
+		def start_date
+			Date.new( @year, @month, 1 )
+		end
+		
+		# Returns a string of the format "January 2001".
+		def to_s
+			Month.month_names[@month-1][0..2] + " " + @year.to_s
+		end
+	end
+end

data/lib/lafcadio/depend.rb~

@@ -0,0 +1,8 @@
+require 'dbi'
+require 'englishext'
+require 'extensions/all'
+require 'extensions/module'
+require 'log4r'
+require 'month'
+require 'queuehash'
+require 'uscommerce'

data/lib/lafcadio/domain.rb

@@ -137,9 +137,7 @@ module Lafcadio
 			end
 		end
 		
-		def eql?(otherObj)
-			self == otherObj
-		end
+		def eql?( otherObj ); self == otherObj; end
 
 		def hash; "#{ self.class.name } #{ pk_id }".hash; end
 	end
@@ -242,18 +240,7 @@ module Lafcadio
 	# that each table has a +pk_id+ field that is used to match rows between
 	# different levels.
 	class DomainObject
-		@@subclassHash = {}
-		@@class_fields = {}
-		@@pk_fields =
-			Hash.new { |hash, key|
-				pk_field = PrimaryKeyField.new( key )
-				pk_field.db_field_name = @@sql_primary_keys[key]
-				hash[key] = pk_field
-			}
-		@@sql_primary_keys = Hash.new( 'pk_id' )
-		@@default_field_setup_hashes = Hash.new { |hash, key|
-			hash[key] = Hash.new( {} )
-		}
+		@@subclass_records = Hash.new do |h, k| h[k] = SubclassRecord.new( k ); end
 
 		COMMIT_ADD = 1
 		COMMIT_EDIT = 2
@@ -264,7 +251,6 @@ module Lafcadio
 		def self.[]( pk_id ); get( pk_id ); end
 		
 		def self.abstract_subclasses #:nodoc:
-			require 'lafcadio/domain'
 			[ MapObject ]
 		end
 		
@@ -273,19 +259,23 @@ module Lafcadio
 		# Returns an array of all fields defined for this class and all concrete
 		# superclasses.
 		def self.all_fields
-			all_fields = []
-			self_and_concrete_superclasses.each { |aClass|
-				aClass.class_fields.each { |field| all_fields << field }
-			}
-			all_fields
+			self_and_concrete_superclasses.map { |a_class|
+				a_class.class_fields
+			}.flatten
 		end
 
+		def self.class_field(fieldName) #:nodoc:
+			field = nil
+			self.class_fields.each { |aField|
+				field = aField if aField.name == fieldName
+			}
+			field
+		end
+		
 		def self.class_fields #:nodoc:
-			class_fields = @@class_fields[self]
-			unless class_fields
-				@@class_fields[self] = self.get_class_fields
-				class_fields = @@class_fields[self]
-				class_fields.each do |class_field|
+			unless subclass_record.fields
+				subclass_record.fields = self.get_class_fields
+				subclass_record.fields.each do |class_field|
 					begin
 						undef_method class_field.name.to_sym
 					rescue NameError
@@ -293,52 +283,50 @@ module Lafcadio
 					end
 				end
 			end
-			class_fields
+			subclass_record.fields
 		end
 
 		def self.create_field( field_class, *args )
-			class_fields = @@class_fields[self]
-			if args.last.is_a? Hash
-				att_hash = args.last
-			else
-				att_hash = @@default_field_setup_hashes[self][field_class].clone
+			subclass_record.maybe_init_fields
+			att_hash = create_field_att_hash( field_class, *args )
+			field = field_class.create_with_args( self, att_hash )
+			unless class_fields.any? { |cf| cf.name == field.name }
+				att_hash.each { |field_name, value|
+					setter = field_name + '='
+					field.send( setter, value ) if field.respond_to?( setter )
+				}
+				class_fields << field
 			end
-			if class_fields.nil?
-				class_fields = [ @@pk_fields[self] ]
-				@@class_fields[self] = class_fields
+		end
+		
+		def self.create_field_att_hash( field_class, *args ) #:nodoc:
+			att_hash = args.last
+			unless att_hash.is_a? Hash
+				att_hash = subclass_record.default_field_setup_hash[
+					field_class
+				].clone
 			end
 			if field_class == DomainObjectField
 				att_hash['linked_type'] = args.first
 				att_hash['name'] = args[1] if args[1] and !args[1].is_a? Hash
 			else
 				name = args.first
-				att_hash['name'] = name == String ? name : name.to_s
-			end
-			field = field_class.instantiate_with_parameters( self, att_hash )
-			unless class_fields.any? { |cf| cf.name == field.name }
-				att_hash.each { |field_name, value|
-					setter = field_name + '='
-					field.send( setter, value ) if field.respond_to?( setter )
-				}
-				class_fields << field
+				att_hash['name'] = name.is_a?( String ) ? name : name.to_s
 			end
+			att_hash
 		end
 		
 		def self.default_field_setup_hash( field_class, hash )
-			@@default_field_setup_hashes[self][field_class] = hash
+			subclass_record.default_field_setup_hash[field_class] = hash
 		end
 
 		def self.dependent_classes #:nodoc:
 			dependent_classes = {}
 			DomainObject.subclasses.each { |aClass|
-				if aClass != DomainObjectProxy &&
-						(!DomainObject.abstract_subclasses.index(aClass))
-					aClass.class_fields.each { |field|
-						if ( field.is_a?( DomainObjectField ) &&
-						     field.linked_type == self.domain_class )
-							dependent_classes[aClass] = field
-						end
-					}
+				unless DomainObject.abstract_subclasses.include?( aClass )
+					if ( field = aClass.get_link_field( self ) )
+						dependent_classes[aClass] = field
+					end
 				end
 			}
 			dependent_classes
@@ -352,30 +340,35 @@ module Lafcadio
 		end
 		
 		def self.first; all.first; end
-
-		def self.get_class_field(fieldName) #:nodoc:
-			field = nil
-			self.class_fields.each { |aField|
-				field = aField if aField.name == fieldName
-			}
-			field
-		end
-		
-		def DomainObject.get_class_field_by_db_name( fieldName ) #:nodoc:
-			self.class_fields.find { |field| field.db_field_name == fieldName }
+			
+		def self.get( *args )
+			if block_given?
+				query = Query.infer( self ) { |dobj| yield( dobj ) }
+				ObjectStore.get_object_store.get_subset( query )
+			elsif args.size == 1
+				arg = args.first
+				if arg.is_a? Fixnum
+					ObjectStore.get_object_store.get( self, *args )
+				else
+					qry = Query.new( self, nil, { :group_functions => [ :count ] } )
+					ObjectStore.get_object_store.query qry
+				end
+			else
+				ObjectStore.get_object_store.get_filtered( self.name, *args )
+			end
 		end
 
 		# Returns an Array of ObjectField instances for this domain class, parsing
 		# them from XML if necessary.
 		def self.get_class_fields
 			if self.methods( false ).include?( 'get_class_fields' )
-				[ @@pk_fields[ self ] ]
+				[ subclass_record.pk_field ]
 			elsif abstract_subclasses.include?( self )
 				[]
 			else
 				xmlParser = try_load_xml_parser
 				if xmlParser
-					xmlParser.get_class_fields
+					xmlParser.get_class_fields     
 				else
 					error_msg = "Couldn't find either an XML class description file " +
 											"or get_class_fields method for " + self.name
@@ -396,7 +389,7 @@ module Lafcadio
 			aDomainClass = self
 			field = nil
 			while aDomainClass < DomainObject && !field
-				field = aDomainClass.get_class_field( fieldName )
+				field = aDomainClass.class_field( fieldName )
 				aDomainClass = aDomainClass.superclass
 			end
 			if field
@@ -429,7 +422,7 @@ module Lafcadio
 		end
 		
 		def self.inherited(subclass) #:nodoc:
-			@@subclassHash[subclass] = true
+			@@subclass_records[subclass]
 		end
 		
 		def self.is_based_on? #:nodoc:
@@ -444,44 +437,33 @@ module Lafcadio
 		
 		def self.method_missing( methodId, *args ) #:nodoc:
 			method_name = methodId.id2name
-			if method_name == 'get'
-				if block_given?
-					query = Query.infer( self ) { |dobj| yield( dobj ) }
-					ObjectStore.get_object_store.get_subset( query )
-				elsif args.size == 1
-					ObjectStore.get_object_store.get( self, *args )
-				else
-					ObjectStore.get_object_store.get_filtered( self.name, *args )
-				end
-			else
-				maybe_field_class_name = method_name.underscore_to_camel_case + 'Field'
-				begin
-					field_class = Lafcadio.const_get( maybe_field_class_name )
-					create_field( field_class, *args )
-				rescue NameError
-					singular = method_name.singular
-					if singular
-						maybe_field_class_name = singular.underscore_to_camel_case + 'Field'
-						begin
-							field_class = Lafcadio.const_get( maybe_field_class_name )
-							arg = args.shift
-							until args.empty?
-								next_arg = args.shift
-								if next_arg.is_a? String or next_arg.is_a? Symbol
-									create_field( field_class, arg )
-									arg = next_arg
-								else
-									create_field( field_class, arg, next_arg )
-									arg = args.shift
-								end
+			maybe_field_class_name = method_name.underscore_to_camel_case + 'Field'
+			begin
+				field_class = Lafcadio.const_get( maybe_field_class_name )
+				create_field( field_class, *args )
+			rescue NameError
+				singular = method_name.singular
+				if singular
+					maybe_field_class_name = singular.underscore_to_camel_case + 'Field'
+					begin
+						field_class = Lafcadio.const_get( maybe_field_class_name )
+						arg = args.shift
+						until args.empty?
+							next_arg = args.shift
+							if next_arg.is_a? String or next_arg.is_a? Symbol
+								create_field( field_class, arg )
+								arg = next_arg
+							else
+								create_field( field_class, arg, next_arg )
+								arg = args.shift
 							end
-							create_field( field_class, arg ) unless arg.nil?
-						rescue NameError
-							super
 						end
-					else
+						create_field( field_class, arg ) unless arg.nil?
+					rescue NameError
 						super
 					end
+				else
+					super
 				end
 			end
 		end
@@ -522,7 +504,7 @@ module Lafcadio
 				begin
 					get_field( 'pk_id' ).db_field_name = self.send( symbol )
 				rescue NameError
-					@@sql_primary_keys[self] = self.send( symbol )
+					subclass_record.sql_primary_key = self.send( symbol )
 				end
 			end
 		end
@@ -535,9 +517,11 @@ module Lafcadio
 			end
 			get_field( 'pk_id' ).db_field_name
 		end
+		
+		def self.subclass_record; @@subclass_records[self]; end
 
 		def self.subclasses #:nodoc:
-			@@subclassHash.keys
+			@@subclass_records.keys
 		end
 
 		# Returns the table name, which is assumed to be the domain class name 
@@ -561,16 +545,15 @@ module Lafcadio
 
 		def self.try_load_xml_parser
 			require 'lafcadio/domain'
-			if ( dirName = LafcadioConfig.new['classDefinitionDir'] )
-				xmlFileName = self.basename + '.xml'
-				xmlPath = File.join( dirName, xmlFileName )
-				xml = ''
-				begin
-					File.open( xmlPath ) { |file| xml = file.readlines.join }
-					ClassDefinitionXmlParser.new( self, xml )
-				rescue Errno::ENOENT
-					# no xml file, so no @xmlParser
-				end
+			dirName = LafcadioConfig.new['classDefinitionDir']
+			xmlFileName = self.basename + '.xml'
+			xmlPath = File.join( dirName, xmlFileName )
+			xml = ''
+			begin
+				File.open( xmlPath ) { |file| xml = file.readlines.join }
+				ClassDefinitionXmlParser.new( self, xml )
+			rescue Errno::ENOENT
+				# no xml file, so no @xmlParser
 			end
 		end
 		
@@ -595,6 +578,7 @@ module Lafcadio
 		def initialize(fieldHash)
 			if fieldHash.respond_to? :keys
 				fieldHash.keys.each { |key|
+					key = key.to_s
 					begin
 						self.class.get_field( key )
 					rescue MissingError
@@ -602,11 +586,16 @@ module Lafcadio
 					end
 				}
 			end
-			@fieldHash = fieldHash
+			if fieldHash.is_a? Hash
+				@fieldHash = {}
+				fieldHash.each do |k, v| @fieldHash[k.to_s] = v; end
+			else
+				@fieldHash = fieldHash
+			end
 			@error_messages = []
 			@fields = {}
 			@fields_set = []
-			reset_original_values_hash @fieldHash
+			@original_values = OriginalValuesHash.new( @fieldHash )
 			check_fields = LafcadioConfig.new()['checkFields']
 			verify if %w( onInstantiate onAllStates ).include?( check_fields )
 		end
@@ -700,10 +689,6 @@ module Lafcadio
 		def post_commit_trigger
 			nil
 		end
-		
-		def reset_original_values_hash( f = @fields ) #:nodoc:
-			@original_values = OriginalValuesHash.new( f.clone )
-		end
 
 		def set_field( field, value ) #:nodoc:
 			if field.class <= DomainObjectField
@@ -735,6 +720,28 @@ module Lafcadio
 		class OriginalValuesHash < DelegateClass( Hash )
 			def []=( key, val ); raise NoMethodError; end
 		end
+		
+		class SubclassRecord
+			attr_accessor :default_field_setup_hash, :fields, :sql_primary_key
+			
+			def initialize( subclass )
+				@subclass = subclass
+				@default_field_setup_hash = Hash.new( {} )
+				@sql_primary_key = 'pk_id'
+			end
+			
+			def maybe_init_fields
+				self.fields = [ pk_field ] if self.fields.nil?
+			end
+			
+			def pk_field
+				if @pk_field.nil?
+					@pk_field = PrimaryKeyField.new @subclass
+					@pk_field.db_field_name = sql_primary_key
+				end
+				@pk_field
+			end
+		end
 	end
 
 	# Any domain class that is used mostly to map between two other domain