lafcadio 0.4.3 → 0.5.2

data/lib/lafcadio/schema.rb

@@ -1,2 +1,57 @@
-require 'lafcadio/includer'
-Includer.include( 'schema' )
+require 'lafcadio/objectField'
+
+module Lafcadio
+	class CreateTableStatement #:nodoc:
+		@@simple_field_clauses = {
+			DecimalField => 'float', DateField => 'date', BooleanField => 'bool',
+			TimeStampField => 'timestamp', DateTimeField => 'datetime'
+		}
+	
+		def initialize( domain_class )
+			@domain_class = domain_class
+		end
+		
+		def definition_terms( field )
+			definitionTerms = []
+			definitionTerms << field.db_field_name
+			definitionTerms << type_clause( field )
+			definitionTerms << 'not null' if field.not_null
+			definitionTerms << 'unique' if field.unique
+			definitionTerms.join( ' ' )
+		end
+
+		def to_sql
+			createDefinitions = []
+			createDefinitions << "#{ @domain_class.sql_primary_key_name } " +
+													 "int not null auto_increment"
+			createDefinitions << "primary key (#{ @domain_class.sql_primary_key_name })"
+			@domain_class.class_fields.each { |field|
+				createDefinitions << definition_terms( field )
+			}
+			<<-SQL
+	create table #{ @domain_class.table_name } (
+		#{ createDefinitions.join(",\n  ") }
+	);
+			SQL
+		end
+		
+		def type_clause( field )
+			if ( type_clause = @@simple_field_clauses[field.class] )
+				type_clause
+			elsif ( 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 <= LinkField || field.class <= IntegerField )
+				'int'
+			elsif ( field.class <= DecimalField )
+				'float(10, 2)'
+			elsif ( field.class <= BlobField )
+				'blob'
+			end
+		end
+	end
+end

data/lib/lafcadio/test.rb

@@ -1,2 +1,17 @@
-require 'lafcadio/includer'
-Includer.include( 'test' )
+require 'lafcadio/depend'
+require 'lafcadio/mock'
+require 'lafcadio/util'
+
+# 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
+		ObjectStore.set_object_store @mockObjectStore
+		LafcadioConfig.set_filename 'lafcadio/test/testConfig.dat'
+  end
+end

data/lib/lafcadio/{test/LafcadioTestCase.rb → test.rb~}

@@ -1,6 +1,6 @@
 require 'runit/testcase'
-require 'lafcadio/mock/MockObjectStore'
-require 'lafcadio/util/LafcadioConfig'
+require 'lafcadio/mock'
+require 'lafcadio/util'
 
 # 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.
@@ -10,8 +10,8 @@ class LafcadioTestCase < RUNIT::TestCase
   def setup
   	context = Context.instance
   	context.flush
-    @mockObjectStore = MockObjectStore.new context
-		context.setObjectStore @mockObjectStore
-		LafcadioConfig.setFilename 'lafcadio/test/testConfig.dat'
+    @mockObjectStore = MockObjectStore.new
+		ObjectStore.set_object_store @mockObjectStore
+		LafcadioConfig.set_filename 'lafcadio/test/testConfig.dat'
   end
 end

data/lib/lafcadio/test/testconfig.dat

@@ -7,7 +7,7 @@ siteName:Site Name
 url:http://test.url
 classpath:lafcadio/
 logdir:../test/testOutput/
-domainDirs:lafcadio/domain/,../test/mock/domain/
+domainDirs:../test/mock/domain/
 domainFiles:../test/mock/domain.rb
 logSql:n
 classDefinitionDir:../test/testData

data/lib/lafcadio/util.rb

@@ -1,5 +1,5 @@
-require 'lafcadio/includer'
-Includer.include( 'util' )
+require 'delegate'
+require 'singleton'
 
 class Array
 	# If this array has one element, returns that element; otherwise, raises an
@@ -15,7 +15,7 @@ end
 
 class Class < Module
 	# Given a String, returns a class object by the same name.
-	def self.getClass(className)
+	def self.get_class(className)
 		theClass = nil
 		ObjectSpace.each_object(Class) { |aClass|
 			theClass = aClass if aClass.name == className
@@ -30,15 +30,322 @@ class Class < Module
 	
 	# Returns the name of <tt>aClass</tt> itself, stripping off the names of any 
 	# containing modules or outer classes.
-	def bareName
+	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, 
+	# 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.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 Numeric
@@ -47,10 +354,10 @@ class Numeric
 	# <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)
+	#   (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
@@ -68,8 +375,13 @@ class Numeric
 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 countOccurrences(regexp)
+	def count_occurrences(regexp)
 		count = 0
 		str = self.clone
 		while str =~ regexp
@@ -102,10 +414,10 @@ class String
 	# 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
+	#   "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!(/\..*$/, '')
@@ -121,9 +433,9 @@ class String
 
 	# Breaks a string into lines no longer than <tt>lineLength</tt>.
 	#
-	#   'the quick brown fox jumped over the lazy dog.'.lineWrap( 10 ) ->
+	#   'the quick brown fox jumped over the lazy dog.'.line_wrape( 10 ) ->
 	#     "the quick\nbrown fox\njumped\nover the\nlazy dog."
-	def lineWrap(lineLength)
+	def line_wrape(lineLength)
 		words = split ' '
 		line = ''
 		lines = []
@@ -141,9 +453,9 @@ class String
 	# 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
+	#   "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
@@ -164,9 +476,9 @@ class String
 	# delimiter, and returns an array containing both the substrings and the 
 	# portions that matched <tt>regexp</tt>.
 	#
-	#   'theZquickZZbrownZfox'.splitKeepInBetweens(/Z+/) ->
+	#   'theZquickZZbrownZfox'.split_keep_in_betweens(/Z+/) ->
 	#     ['the', 'Z', 'quick', 'ZZ', 'brown', 'Z', 'fox' ]
-	def splitKeepInBetweens(regexp)
+	def split_keep_in_betweens(regexp)
 		result = []
 		string = clone
 		while string =~ regexp
@@ -177,4 +489,9 @@ class String
 		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 }
+	end
 end