lafcadio 0.6.2 → 0.6.3

data/lib/lafcadio.rb

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

data/lib/lafcadio.rb~

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

data/lib/lafcadio/domain.rb

@@ -330,6 +330,8 @@ module Lafcadio
 		def self.get_class_fields
 			if self.methods( false ).include?( 'get_class_fields' )
 				[ @@pk_fields[ self ] ]
+			elsif abstract_subclasses.include?( self )
+				[]
 			else
 				xmlParser = try_load_xml_parser
 				if xmlParser

data/lib/lafcadio/domain.rb~

@@ -394,8 +394,7 @@ module Lafcadio
 		
 		def self.method_missing( methodId, *args ) #:nodoc:
 			method_name = methodId.id2name
-			maybe_field_class_name = ( method_name.gsub( /^(.)/ ) { $&.upcase } ) +
-			                         'Field'
+			maybe_field_class_name = method_name.underscore_to_camel_case + 'Field'
 			field_class = Lafcadio.const_get( maybe_field_class_name )
 			create_field( field_class, args[0], args[1] || {} )
 		end

data/lib/lafcadio/mock.rb

@@ -37,12 +37,14 @@ module Lafcadio
 					objects << dbObj
 				end
 			}
-			if (range = query.limit)
-				objects = objects[0..(range.last - range.first)]
-			end
 			if ( order_by = query.order_by )
 				objects = objects.sort_by { |dobj| dobj.send( order_by ) }
 				objects.reverse! if query.order_by_order == Query::DESC
+			else
+				objects = objects.sort_by { |dobj| dobj.pk_id }
+			end
+			if (range = query.limit)
+				objects = objects[0..(range.last - range.first)]
 			end
 			objects
 		end

data/lib/lafcadio/mock.rb~

@@ -0,0 +1,95 @@
+require 'lafcadio/objectStore'
+
+module Lafcadio
+	class MockDbBridge #:nodoc:
+		attr_reader :last_pk_id_inserted, :retrievals_by_type, :query_count
+
+		def initialize
+			@objects = {}
+			@retrievals_by_type = Hash.new 0
+			@query_count = Hash.new( 0 )
+		end
+
+		def commit(db_object)
+			objects_by_domain_class = get_objects_by_domain_class(
+				db_object.domain_class
+			)
+			if db_object.delete
+				objects_by_domain_class.delete( db_object.pk_id )
+			else
+				object_pk_id = get_pk_id_before_committing( db_object )
+				objects_by_domain_class[object_pk_id] = db_object
+			end
+		end
+		
+		def _get_all( domain_class )
+			@retrievals_by_type[domain_class] = @retrievals_by_type[domain_class] + 1
+			@objects[domain_class] ? @objects[domain_class].values : []
+		end
+		
+		def get_collection_by_query(query)
+			@query_count[query] += 1
+			objects = []
+			_get_all( query.domain_class ).each { |dbObj|
+				if query.condition
+					objects << dbObj if query.condition.object_meets(dbObj)
+				else
+					objects << dbObj
+				end
+			}
+			if ( order_by = query.order_by )
+				objects = objects.sort_by { |dobj| dobj.send( order_by ) }
+				objects.reverse! if query.order_by_order == Query::DESC
+			end
+			if (range = query.limit)
+				objects = objects[0..(range.last - range.first)]
+			end
+			objects
+		end
+		
+		def get_pk_id_before_committing( db_object )
+			object_pk_id = db_object.pk_id
+			unless object_pk_id
+				maxpk_id = 0
+				pk_ids = get_objects_by_domain_class( db_object.domain_class ).keys
+				pk_ids.each { |pk_id|
+					maxpk_id = pk_id if pk_id > maxpk_id
+				}
+				@last_pk_id_inserted = maxpk_id + 1
+				object_pk_id = @last_pk_id_inserted
+			end
+			object_pk_id
+		end
+		
+		def get_objects_by_domain_class( domain_class )
+			objects_by_domain_class = @objects[domain_class]
+			unless objects_by_domain_class
+				objects_by_domain_class = {}
+				@objects[domain_class] = objects_by_domain_class
+			end
+			objects_by_domain_class
+		end
+
+		def group_query( query )
+			if query.class == Query::Max
+				if ( query.field_name == 'pk_id' || query.field_name == 'rate' )
+					query.collect( @objects[query.domain_class].values )
+				else
+					raise "Can't handle query with sql '#{ query.to_sql }'"
+				end
+			end
+		end
+	end
+
+	# Externally, the MockObjectStore looks and acts exactly like the ObjectStore,
+	# but stores all its data in memory. This makes it very useful for unit
+	# testing, and in fact LafcadioTestCase#setup creates a new instance of
+	# MockObjectStore for each test case.
+	class MockObjectStore < ObjectStore
+		public_class_method :new
+
+		def initialize # :nodoc:
+			super( MockDbBridge.new )
+		end
+	end
+end

data/lib/lafcadio/query.rb

@@ -273,15 +273,17 @@ module Lafcadio
 			AND = 1
 			OR  = 2
 		
-			def initialize(*conditions)
-				if( [ AND, OR ].index(conditions.last) )
-					@compoundType = conditions.last
-					conditions.pop
+			def initialize( *args )
+				if( [ AND, OR ].index( args.last) )
+					@compoundType = args.last
+					args.pop
 				else
 					@compoundType = AND
 				end
-				@conditions = conditions
-				@domain_class = conditions[0].domain_class
+				@conditions = args.map { |arg|
+					arg.respond_to?( :to_condition ) ? arg.to_condition : arg
+				}
+				@domain_class = @conditions[0].domain_class
 			end
 
 			def object_meets(anObj)

data/lib/lafcadio/util.rb

@@ -1,4 +1,5 @@
 require 'delegate'
+require 'lafcadio/depend'
 require 'singleton'
 
 module Lafcadio
@@ -66,14 +67,16 @@ module Lafcadio
 	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_(.*)/
-				if methodName =~ /^get_(.*)/
-					Context.instance.get_resource( self )
-				else
-					Context.instance.set_resource( self, *args )
-				end
+		def self.method_missing( symbol, *args )
+			method_name = symbol.id2name
+			target = nil
+			if method_name =~ /^get_(.*)/
+				target = :get_resource if $1.underscore_to_camel_case == basename
+			elsif method_name =~ /^set_(.*)/
+				target = :set_resource if $1.underscore_to_camel_case == basename
+			end
+			if target
+				Context.instance.send( target, self, *args )
 			else
 				super
 			end

data/lib/lafcadio/util.rb~

@@ -0,0 +1,379 @@
+require 'delegate'
+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 = {}
+			@init_procs = {}
+		end
+		
+		def create_instance( service_class ) #:nodoc:
+			if ( proc = @init_procs[service_class] )
+				proc.call
+			else
+				service_class.new
+			end
+		end
+		
+		# Flushes all cached ContextualServices.
+		def flush
+			@resources = {}
+		end
+
+		def get_resource( service_class ) #:nodoc:
+			resource = @resources[service_class]
+			unless resource
+				resource = create_instance( service_class )
+				set_resource service_class, resource
+			end
+			resource
+		end
+		
+		def set_init_proc( service_class, proc )
+			@init_procs[service_class] = proc
+		end
+		
+		def set_resource(service_class, resource) #:nodoc:
+			@resources[service_class] = resource
+		end
+	end
+
+	# 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 self.flush; Context.instance.set_resource( self, nil ); end
+	
+		def self.method_missing( methodId, *args )
+			methodName = methodId.id2name
+			if methodName =~ /^get_(.*)/ || methodName =~ /^set_(.*)/
+				if methodName =~ /^get_(.*)/
+					Context.instance.get_resource( self )
+				else
+					Context.instance.set_resource( self, *args )
+				end
+			else
+				super
+			end
+		end
+
+		def self.set_init_proc
+			proc = proc { yield }
+			Context.instance.set_init_proc( self, proc )
+		end
+
+		# ContextualServices can only be initialized through the Context instance.
+		# Note that if you're writing your own initialize method in a child class,
+		# you should make sure to call super() or you'll overwrite this behavior.
+		def initialize
+			regexp = %r{lafcadio/util\.rb.*create_instance}
+			unless caller.any? { |line| line =~ regexp }
+				raise ArgumentError,
+				"#{ self.class.name.to_s } should be instantiated by calling " +
+				    self.class.name.to_s + ".get_" + self.class.name.camel_case_to_underscore,
+				caller
+			end
+		end
+	end
+
+	# A collection of English-language specific utility methods.
+	class English
+		# Turns a camel-case string ("camel_case_to_english") to plain English ("camel 
+		# case to english"). Each word is decapitalized.
+		def self.camel_case_to_english(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
+
+		# Turns an English language string into camel case.
+		def self.english_to_camel_case(englishStr)
+			cc = ""
+			englishStr.split.each { |word|
+				word = word.capitalize unless cc == ''
+				cc = cc += word
+			}
+			cc
+		end
+
+		# Given a singular noun, returns the plural form.
+		def self.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.proper_noun("bosnia and herzegovina") ->
+		#     "Bosnia and Herzegovina"
+		#   English.proper_noun("macedonia, the former yugoslav republic of") ->
+		#     "Macedonia, the Former Yugoslav Republic of"
+		#   English.proper_noun("virgin islands, u.s.") ->
+		#     "Virgin Islands, U.S."
+		def self.proper_noun(string)
+			proper_noun = ""
+			while(matchIndex = string =~ /[\. ]/)
+				word = string[0..matchIndex-1]
+				word = word.capitalize unless [ 'and', 'the', 'of' ].index(word) != nil
+				proper_noun += word + $&
+				string = string[matchIndex+1..string.length]
+			end
+			word = string
+			word = word.capitalize unless [ 'and', 'the', 'of' ].index(word) != nil
+			proper_noun += word
+			proper_noun
+		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 self.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 = starts_with_vowel_sound(name) ? 'an' : 'a'
+			sentence.gsub!( /%a/, article )
+			sentence
+		end
+		
+		def self.singular(plural)
+			if plural =~ /(.*)ies/
+				$1 + 'y'
+			elsif plural =~ /(.*s)es/
+				$1
+			else
+				plural =~ /(.*)s/
+				$1
+			end
+		end
+		
+		# Does this word start with a vowel sound? "User" and "usury" don't, but 
+		# "ugly" does.
+		def self.starts_with_vowel_sound(word)
+			uSomethingUMatch = word =~ /^u[^aeiuo][aeiou]/
+			# 'user' and 'usury' don't start with a vowel sound
+			word =~ /^[aeiou]/ && !uSomethingUMatch
+		end
+	end
+
+	# LafcadioConfig is a Hash that takes its data from the config file. You'll 
+	# have to set the location of that file before using it: Use 
+	# LafcadioConfig.set_filename.
+	#
+	# LafcadioConfig expects its data to be colon-delimited, one key-value pair 
+	# to a line. For example:
+	#   dbuser:user
+	#   dbpassword:password
+	#   dbname:lafcadio_test
+	#   dbhost:localhost
+	class LafcadioConfig < Hash
+		@@value_hash = nil
+	
+		def self.set_filename(filename); @@filename = filename; end
+		
+		def self.set_values( value_hash ); @@value_hash = value_hash; end
+
+		def initialize
+			if @@value_hash
+				@@value_hash.each { |key, value| self[key] = value }
+			else
+				File.new( @@filename ).each_line { |line|
+					line.chomp =~ /^(.*?):(.*)$/
+					self[$1] = $2
+				}
+			end
+		end
+	end
+
+	class MissingError < RuntimeError
+	end
+
+	# An ordered hash: Keys are ordered according to when they were inserted.
+	class QueueHash < DelegateClass( Array )
+		# Creates a QueueHash with all the elements in <tt>array</tt> as keys, and 
+		# each value initially set to be the same as the corresponding key.
+		def self.new_from_array(array)
+			new( *( ( array.map { |elt| [ elt, elt ] } ).flatten ) )
+		end
+
+		# Takes an even number of arguments, and sets each odd-numbered argument to 
+		# correspond to the argument immediately afterward. For example:
+		#   queueHash = QueueHash.new (1, 2, 3, 4)
+		#   queueHash[1] => 2
+		#   queueHash[3] => 4
+		def initialize(*values)
+			@pairs = []
+			0.step(values.size-1, 2) { |i| @pairs << [ values[i], values[i+1] ] }
+			super( @pairs )
+		end
+		
+		def ==( otherObj )
+			if otherObj.class == QueueHash && otherObj.size == size
+				( 0..size ).all? { |i|
+					keys[i] == otherObj.keys[i] && values[i] == otherObj.values[i]
+				}
+			else
+				false
+			end
+		end
+
+		def [](key)
+			( pair = @pairs.find { |pair| pair[0] == key } ) ? pair.last : nil
+		end
+
+		def []=(key, value); @pairs << [key, value]; end
+
+		def each; @pairs.each { |pair| yield pair[0], pair[1] }; end
+
+		def keys; @pairs.map { |pair| pair[0] }; end
+
+		def values; @pairs.map { |pair| pair[1] }; end
+	end
+
+	class UsStates
+		# Returns a QueueHash of states, with two-letter postal codes as keys and 
+		# state names as values.
+		def self.states
+			QueueHash.new( 'AL', 'Alabama', 'AK', 'Alaska', 'AZ', 'Arizona',
+			               'AR', 'Arkansas', 'CA', 'California', 'CO', 'Colorado',
+			               'CT', 'Connecticut', 'DE', 'Delaware',
+			               'DC', 'District of Columbia', 'FL', 'Florida',
+			               'GA', 'Georgia', 'HI', 'Hawaii', 'ID', 'Idaho',
+			               'IL', 'Illinois', 'IN', 'Indiana', 'IA', 'Iowa',
+			               'KS', 'Kansas', 'KY', 'Kentucky', 'LA', 'Louisiana',
+			               'ME', 'Maine', 'MD', 'Maryland', 'MA', 'Massachusetts',
+			               'MI', 'Michigan', 'MN', 'Minnesota', 'MS', 'Mississippi',
+			               'MO', 'Missouri', 'MT', 'Montana', 'NE', 'Nebraska',
+			               'NV', 'Nevada', 'NH', 'New Hampshire', 'NJ', 'New Jersey',
+			               'NM', 'New Mexico', 'NY', 'New York',
+			               'NC', 'North Carolina', 'ND', 'North Dakota', 'OH', 'Ohio',
+			               'OK', 'Oklahoma', 'OR', 'Oregon', 'PA', 'Pennsylvania',
+			               'PR', 'Puerto Rico', 'RI', 'Rhode Island',
+			               'SC', 'South Carolina', 'SD', 'South Dakota',
+			               'TN', 'Tennessee', 'TX', 'Texas', 'UT', 'Utah',
+			               'VT', 'Vermont', 'VA', 'Virginia', 'WA', 'Washington',
+			               'WV', 'West Virginia', 'WI', 'Wisconsin', 'WY', 'Wyoming' )
+		end
+	end
+end
+
+class String
+	# Returns the underscored version of a camel-case string.
+	def camel_case_to_underscore
+		( gsub( /(.)([A-Z])/ ) { $1 + '_' + $2.downcase } ).downcase
+	end
+
+	# Returns the number of times that <tt>regexp</tt> occurs in the string.
+	def count_occurrences(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
+
+	# Turns a numeric string into U.S. format if it's not already formatted that
+	# way.
+	#
+	#   "10,00".numeric_string_to_us_format -> "10.00"
+	#   "10.00".numeric_string_to_us_format -> "10.00"
+	def numeric_string_to_us_format
+		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
+	
+	# 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 }
+	end
+end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.8.1
 specification_version: 1
 name: lafcadio
 version: !ruby/object:Gem::Version 
-  version: 0.6.2
-date: 2005-01-27
+  version: 0.6.3
+date: 2005-02-26
 summary: Lafcadio is an object-relational mapping layer
 require_paths: 
   - lib
@@ -38,6 +38,7 @@ files:
   - lib/lafcadio/domain.rb
   - lib/lafcadio/domain.rb~
   - lib/lafcadio/mock.rb
+  - lib/lafcadio/mock.rb~
   - lib/lafcadio/objectField.rb
   - lib/lafcadio/objectField.rb~
   - lib/lafcadio/objectStore.rb
@@ -48,6 +49,7 @@ files:
   - lib/lafcadio/test
   - lib/lafcadio/test.rb
   - lib/lafcadio/util.rb
+  - lib/lafcadio/util.rb~
   - lib/lafcadio/test/testconfig.dat
 test_files: []
 rdoc_options: []