lafcadio 0.8.3 → 0.9.0

data/lib/lafcadio/schema.rb~

@@ -0,0 +1,56 @@
+require 'lafcadio/objectField'
+
+module Lafcadio
+	class CreateTableStatement #:nodoc:
+		@@simple_field_clauses = {
+			FloatField => 'float', DateField => 'date', BooleanField => 'bool',
+			TimeStampField => 'timestamp', TimeField => '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.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 <= StringField || field.class <= TextListField )
+				'varchar(255)'
+			elsif ( field.class <= DomainObjectField || field.class <= IntegerField )
+				'int'
+			elsif ( field.class <= FloatField )
+				'float(10, 2)'
+			elsif ( field.class <= BlobField )
+				'blob'
+			end
+		end
+	end
+end

data/lib/lafcadio/test.rb

@@ -23,3 +23,221 @@ class LafcadioTestCase < Test::Unit::TestCase
 	
 	def default_test; end
 end
+
+module Lafcadio
+	def BooleanField.mock_value; true; end
+	
+	def DateField.mock_value; Date.today; end
+
+	def DateTimeField.mock_value; Time.now; end
+	
+	module DomainMock
+		Version = '0.1.0'
+		
+		def self.included( includer )
+			def includer.setup_procs
+				unless defined? @@all_setup_procs
+					@@all_setup_procs = Hash.new { |hash, domain_class|
+						hash[domain_class] = []
+					}
+				end
+				@@all_setup_procs[self]
+			end
+			def includer.setup_mock_dobjs( *domain_classes_or_symbol_names )
+				domain_classes = DomainClassSymbolMapper.new
+				domain_classes_or_symbol_names.each { |domain_class_or_symbol_name|
+					domain_classes.process( domain_class_or_symbol_name )
+				}
+				domain_classes.finish
+				domain_classes.each { |my_domain_class, my_symbol_name|
+					proc = Proc.new { |test_case|
+						test_case.instance_variable_set(
+							my_symbol_name, my_domain_class.default_mock
+						)
+					}
+					setup_procs << proc
+				}
+			end
+		end
+	
+		def commit_domain_object( domain_class, non_default_values = {} )
+			self.class.mock_domain_files.each do |file| require file; end
+			dobj = domain_class.send( :custom_mock, non_default_values )
+			dobj.commit
+		end
+	
+		def method_missing( sym, *args )
+			method_name = sym.id2name
+			if method_name =~ /^custom_mock_(.*)/
+				domain_class = Module.by_name( $1.underscore_to_camel_case )
+				commit_domain_object( domain_class, *args )
+			elsif method_name =~ /^default_mock_(.*)/
+				Module.by_name( $1.underscore_to_camel_case ).default_mock
+			else
+				super
+			end
+		end
+		
+		def setup
+			self.class.setup_procs.each { |proc| proc.call( self ) }
+		end
+	
+		class DomainClassSymbolMapper < Hash
+			def initialize; @last_domain_class = nil; end
+		
+			def default_symbol_name( domain_class )
+				"@#{ domain_class.name.camel_case_to_underscore }"
+			end
+			
+			def finish
+				if @last_domain_class
+					self[@last_domain_class] = default_symbol_name( @last_domain_class )
+				end
+			end
+		
+			def process( domain_class_or_symbol_name )
+				if domain_class_or_symbol_name.class == Class
+					if @last_domain_class
+						self[@last_domain_class] = default_symbol_name( @last_domain_class )
+					end
+					@last_domain_class = domain_class_or_symbol_name
+				else
+					self[@last_domain_class] = domain_class_or_symbol_name
+					@last_domain_class = nil
+				end
+			end
+		end
+	end
+
+	class DomainObject
+		@@default_mock_available = Hash.new true
+		@@default_arg_directives = Hash.new { |hash, a_class|
+			default_args = {}
+			a_class.all_fields.each do |field|
+				default_args[field.name] = field.default_mock_value
+			end
+			hash[a_class] = default_args
+		}
+	
+		def self.commit_mock( args, caller = nil )
+			dobj = self.new( args )
+			link_fields = all_fields.select { |field| field.is_a? DomainObjectField }
+			link_fields.each do |field|
+				val = dobj.send( field.name )
+				if val and val.pk_id == 1
+					linked_type = field.linked_type
+					begin
+						ObjectStore.get_object_store.get( linked_type, 1 )
+					rescue DomainObjectNotFoundError
+						unless linked_type == caller
+							linked_type.send( 'default_mock', self )
+						end
+					end
+				end
+			end
+			dobj.commit
+			dobj
+		end
+	
+		def self.default_args
+			default_args = {}
+			@@default_arg_directives[self].each do |name, value_or_proc|
+				if value_or_proc.is_a? Proc
+					default_args[name] = value_or_proc.call
+				else
+					default_args[name] = value_or_proc
+				end
+			end
+			default_args
+		end
+		
+		def self.custom_mock( custom_args = nil )
+			dobj_args = default_args
+			object_store = ObjectStore.get_object_store
+			dbb = object_store.get_db_bridge
+			dbb.set_next_pk_id( self, 2 ) if dbb.next_pk_id( self ) == 1
+			dobj_args['pk_id'] = nil
+			dobj_args = dobj_args.merge( custom_args ) if custom_args.is_a?( Hash )
+			commit_mock( dobj_args )
+		end
+		
+		def self.default_mock( calling_class = nil )
+			if @@default_mock_available[self]
+				begin
+					dobj = ObjectStore.get_object_store.get( self, 1 )
+					dobj
+				rescue DomainObjectNotFoundError
+					dbb = ObjectStore.get_object_store.get_db_bridge
+					dbb.set_next_pk_id( self, 1 ) if dbb.next_pk_id( self ) > 1
+					commit_mock( default_args, calling_class )
+				end
+			else
+				raise( TypeError, self.name + ".default_mock not allowed", caller )
+			end
+		end
+
+		def self.default_mock_available( is_avail )
+			@@default_mock_available[self] = is_avail
+		end
+
+		def self.mock_value( field_sym, value )
+			@@default_arg_directives[self][field_sym.id2name] = value
+		end
+		
+		def self.mock_values( hash )
+			hash.each do |field_sym, value| mock_value( field_sym, value ); end
+		end
+	end
+	
+	class DomainObjectField < ObjectField
+		def default_mock_value; DomainObjectProxy.new( linked_type, 1 ); end
+	end
+	
+	def EmailField.mock_value; 'john.doe@email.com'; end
+
+	def FloatField.mock_value; 0.0; end
+
+	def IntegerField.mock_value; 1; end
+
+	class MockDbBridge
+		unless instance_methods.include?( 'orig_get_pk_id_before_committing' )
+			alias_method(
+				:orig_get_pk_id_before_committing, :get_pk_id_before_committing
+			)
+			
+			def get_pk_id_before_committing( domain_object )
+				@next_pk_ids = {} unless @next_pk_ids
+				orig_pk_id = orig_get_pk_id_before_committing domain_object
+				if (next_pk_id = @next_pk_ids[domain_object.domain_class])
+					@last_pk_id_inserted = next_pk_id
+					@next_pk_ids[domain_object.domain_class] = nil
+					next_pk_id
+				else
+					orig_pk_id
+				end
+			end
+		end
+		
+		def next_pk_id( domain_class )
+			dobjs = get_objects_by_domain_class( domain_class ).values
+			dobjs.inject( 0 ) { |memo, obj| memo > obj.pk_id ? memo : obj.pk_id } + 1
+		end
+
+		def set_next_pk_id( domain_class, npi )
+			@next_pk_ids = {} unless @next_pk_ids
+			@next_pk_ids[ domain_class ] = npi
+		end
+	end
+	
+	class ObjectField
+		attr_writer :mock_value
+	
+		def default_mock_value; self.class.mock_value; end
+	end
+
+	def PrimaryKeyField.mock_value; nil; end
+
+	def StringField.mock_value; 'test text'; end
+	
+	def TextListField.mock_value; %w( a b c ); end
+end

data/lib/lafcadio/test.rb~

@@ -0,0 +1,25 @@
+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 < Test::Unit::TestCase
+	include Lafcadio
+
+  def setup
+  	context = ContextualService::Context.instance
+  	context.flush
+    @mockObjectStore = MockObjectStore.new
+		ObjectStore.set_object_store @mockObjectStore
+		LafcadioConfig.set_values(
+			'classDefinitionDir' => '../test/testData', 'dbhost' => 'localhost',
+			'dbname' => 'test', 'dbpassword' => 'password', 'dbuser' => 'test',
+			'domainFiles' => %w( ../test/mock/domain ),
+			'logdir' => '../test/testOutput/', 'logSql' => 'n'
+		)
+  end
+	
+	def default_test; end
+end

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

@@ -2,7 +2,7 @@ require 'delegate'
 require 'lafcadio/depend'
 require 'singleton'
 
-module Lafcadio
+module Lafcadio	
 	# 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.
@@ -14,6 +14,7 @@ module Lafcadio
 	#   dbname:lafcadio_test
 	#   dbhost:localhost
 	class LafcadioConfig < Hash
+		@@filename = nil
 		@@value_hash = nil
 	
 		def self.set_filename(filename); @@filename = filename; end
@@ -23,7 +24,7 @@ module Lafcadio
 		def initialize
 			if @@value_hash
 				@@value_hash.each { |key, value| self[key] = value }
-			else
+			elsif @@filename
 				File.new( @@filename ).each_line { |line|
 					line.chomp =~ /^(.*?):(.*)$/
 					self[$1] = $2

data/lib/lafcadio/util.rb~

@@ -0,0 +1,104 @@
+require 'delegate'
+require 'lafcadio/depend'
+require 'singleton'
+
+module Lafcadio	
+	# 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
+		@@filename = nil
+		@@value_hash = nil
+	
+		def self.set_filename(filename); @@filename = filename; end
+		
+		def self.set_values( value_hash ); @@value_hash = value_hash; end
+
+		def initialize
+#puts "initialize " + @@filename.inspect
+			if @@value_hash
+				@@value_hash.each { |key, value| self[key] = value }
+#			elsif @@filename
+			else
+#puts caller.inspect
+				File.new( @@filename ).each_line { |line|
+					line.chomp =~ /^(.*?):(.*)$/
+					self[$1] = $2
+				}
+#			else
+#				raise
+			end
+		end
+	end
+
+	class MissingError < RuntimeError
+	end
+end
+
+class String
+	unless method_defined?( :camel_case_to_underscore )
+
+		# Returns the underscored version of a camel-case string.
+		def camel_case_to_underscore
+			( gsub( /(.)([A-Z])/ ) { $1 + '_' + $2.downcase } ).downcase
+		end
+		
+	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
+
+	# 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
+	
+	unless method_defined?( :underscore_to_camel_case )
+
+		# 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
+end