lafcadio 0.9.0 → 0.9.1

data/lib/lafcadio/schema.rb

@@ -3,8 +3,11 @@ require 'lafcadio/objectField'
 module Lafcadio
 	class CreateTableStatement #:nodoc:
 		@@simple_field_clauses = {
-			FloatField => 'float', DateField => 'date', BooleanField => 'bool',
-			TimeStampField => 'timestamp', DateTimeField => 'datetime'
+			BooleanField => 'bool', BlobField => 'blob', DateField => 'date', 
+			DomainObjectField => 'int', FloatField => 'float',
+			DateTimeField => 'datetime', IntegerField => 'int',
+			StringField => 'varchar(255)', TextListField => 'varchar(255)',
+			TimeStampField => 'timestamp'
 		}
 	
 		def initialize( domain_class )
@@ -15,15 +18,16 @@ module Lafcadio
 			definitionTerms = []
 			definitionTerms << field.db_field_name
 			definitionTerms << type_clause( field )
-			definitionTerms << 'not null' if field.not_null
+			definitionTerms << 'not null' if field.not_nil
 			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 })"
+			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 )
 			}
@@ -42,14 +46,6 @@ module Lafcadio
 					"'#{ 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

data/lib/lafcadio/schema.rb~

@@ -4,7 +4,7 @@ module Lafcadio
 	class CreateTableStatement #:nodoc:
 		@@simple_field_clauses = {
 			FloatField => 'float', DateField => 'date', BooleanField => 'bool',
-			TimeStampField => 'timestamp', TimeField => 'datetime'
+			TimeStampField => 'timestamp', DateTimeField => 'datetime'
 		}
 	
 		def initialize( domain_class )

data/lib/lafcadio/test.rb

@@ -21,28 +21,37 @@ class LafcadioTestCase < Test::Unit::TestCase
 		)
   end
 	
-	def default_test; end
+	# Asserts that for each key-value pair in +att_values+, sending the key to
+	# +object+ will return the value.
+	#   u = User.new( 'fname' => 'Francis', 'lname' => 'Hwang' )
+	#   assert_attributes( u, { 'fname' => 'Francis', 'lname' => 'Hwang' } )
+	def assert_attributes( object, att_values )
+		att_values.each { |method, expected|
+			assert_equal( expected, object.send( method ), method.to_s )
+		}
+	end
+	
+	def default_test #:nodoc:
+	end
 end
 
 module Lafcadio
-	def BooleanField.mock_value; true; end
+	def BooleanField.mock_value #:nodoc:
+		true
+	end
 	
-	def DateField.mock_value; Date.today; end
+	def DateField.mock_value #:nodoc:
+		Date.today
+	end
 
-	def DateTimeField.mock_value; Time.now; end
+	def DateTimeField.mock_value #:nodoc:
+		Time.now
+	end
 	
-	module DomainMock
+	module DomainMock #:nodoc:
 		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|
@@ -58,6 +67,15 @@ module Lafcadio
 					setup_procs << proc
 				}
 			end
+
+			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
 		end
 	
 		def commit_domain_object( domain_class, non_default_values = {} )
@@ -82,7 +100,7 @@ module Lafcadio
 			self.class.setup_procs.each { |proc| proc.call( self ) }
 		end
 	
-		class DomainClassSymbolMapper < Hash
+		class DomainClassSymbolMapper < Hash #:nodoc:
 			def initialize; @last_domain_class = nil; end
 		
 			def default_symbol_name( domain_class )
@@ -119,26 +137,73 @@ module Lafcadio
 			hash[a_class] = default_args
 		}
 	
-		def self.commit_mock( args, caller = nil )
+		def self.commit_mock( args, caller = nil ) #:nodoc:
 			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
+				maybe_call_default_mock( field, caller ) if ( val and val.pk_id == 1 )
 			end
 			dobj.commit
 			dobj
 		end
 	
+		# Commits and returns a custom mock object of the given domain class. All
+		# the field values are set to defaults, except for the fields passed in
+		# through +custom_args+. This mock object will have a +pk_id+ greater than
+		# 1, and each successive call to DomainObject.custom_mock will return an
+		# object with a unique +pk_id+.
+		#
+		# This class method is only visible if you include
+		# <tt>lafcadio/test.rb</tt>.
+		#
+		#   class User < Lafcadio::DomainObject
+		#     string :fname, :lname, :email
+		#   end
+		#   u1 = User.custom_mock
+		#   u1.fname # => 'test text'
+		#   u1.lname # => 'test text'
+		#   u1.email # => 'test text'
+		#   u1.pk_id # => probably 2, guaranteed to be greater than 1
+		#   u2 = User.custom_mock( 'fname' => 'Francis', 'lname' => 'Hwang' )
+		#   u2.fname # => 'Francis'
+		#   u2.lname # => 'Hwang'
+		#   u2.email # => 'test text'
+		#   u2.pk_id # => probably 3, guaranteed to not be u1.pk_id and to be
+		#            #    greater than 1 
+		def self.custom_mock( custom_args = nil )
+			dobj_args = default_args
+			object_store = ObjectStore.get_object_store
+			dbb = object_store.db_bridge
+			dbb.set_next_pk_id( self, 2 ) if dbb.next_pk_id( self ) == 1
+			dobj_args['pk_id'] = nil
+			if custom_args.is_a? Hash
+				custom_args.each do |k, v| dobj_args[k.to_s] = v; end
+			end
+			commit_mock( dobj_args )
+		end
+		
+		# Returns a hash of default arguments for mock instances of this domain
+		# class. DomainObject.default_mock uses exactly these arguments to create
+		# the default mock for a given domain class, and DomainObject.custom_mock
+		# overrides some of the field arguments based on its custom arguments.
+		#
+		# By default this will retrieve simple values based on the field type:
+		# * BooleanField:      +true+
+		# * DateField:         Date.today
+		# * DateTimeField:     Time.now
+		# * DomainObjectField: The instance of the domain class with +pk_id+ 1
+		# * EmailField:        "john.doe@email.com"
+		# * FloatField:        0.0
+		# * IntegerField:      1
+		# * StringField:       "test text"
+		# * TextListField:     [ 'a', 'b', 'c' ]
+		#
+		# You can override this method, if you like. However, it will probably be
+		# simpler just to call DomainObject.mock_value.
+		#
+		# This class method is only visible if you include
+		# <tt>lafcadio/test.rb</tt>.
 		def self.default_args
 			default_args = {}
 			@@default_arg_directives[self].each do |name, value_or_proc|
@@ -151,23 +216,29 @@ module Lafcadio
 			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
-		
+		# Commits and returns a mock object of the given domain class. All
+		# the field values are set to defaults. This mock object will have a
+		# +pk_id+ of 1. Successive calls to DomainObject.default_mock will always 
+		# return the same mock object.
+		#
+		# This class method is only visible if you include
+		# <tt>lafcadio/test.rb</tt>.
+		#
+		#   class User < Lafcadio::DomainObject
+		#     string :fname, :lname, :email
+		#   end
+		#   u1 = User.default_mock
+		#   u1.fname # => 'test text'
+		#   u1.lname # => 'test text'
+		#   u1.email # => 'test text'
+		#   u1.pk_id # => 1
 		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 = ObjectStore.get_object_store.db_bridge
 					dbb.set_next_pk_id( self, 1 ) if dbb.next_pk_id( self ) > 1
 					commit_mock( default_args, calling_class )
 				end
@@ -176,68 +247,96 @@ module Lafcadio
 			end
 		end
 
-		def self.default_mock_available( is_avail )
+		def self.default_mock_available( is_avail ) #:nodoc:
 			@@default_mock_available[self] = is_avail
 		end
+		
+		def self.maybe_call_default_mock( field, caller ) #:nodoc:
+			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
 
+		# Sets the mock value for the given field. These mock values are used in
+		# DomainObject.default_mock and DomainObject.custom_mock
+		#
+		# This class method is only visible if you include
+		# <tt>lafcadio/test.rb</tt>.
+		#
+		#   class User < Lafcadio::DomainObject
+		#     string :fname, :lname, :email
+		#   end
+		#   User.mock_value :fname, 'Bill'
+		#   User.mock_value :lname, 'Smith'
+		#   u1 = User.default_mock
+		#   u1.fname # => 'Bill'
+		#   u1.lname # => 'Smith'
+		#   u1.email # => 'test text'
+		#   u1.pk_id # => 1
 		def self.mock_value( field_sym, value )
 			@@default_arg_directives[self][field_sym.id2name] = value
 		end
 		
+		# Sets the mock value for the fields in +hash+. These mock values are used
+		# in DomainObject.default_mock and DomainObject.custom_mock
+		#
+		# This class method is only visible if you include
+		# <tt>lafcadio/test.rb</tt>.
+		#
+		#   class User < Lafcadio::DomainObject
+		#     string :fname, :lname, :email
+		#   end
+		#   User.mock_values { :fname => 'Bill', :lname => 'Smith' }
+		#   u1 = User.default_mock
+		#   u1.fname # => 'Bill'
+		#   u1.lname # => 'Smith'
+		#   u1.email # => 'test text'
+		#   u1.pk_id # => 1
 		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
+		def default_mock_value #:nodoc:
+			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
+	def EmailField.mock_value #:nodoc:
+		'john.doe@email.com'
+	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 FloatField.mock_value #:nodoc:
+		0.0
+	end
 
-		def set_next_pk_id( domain_class, npi )
-			@next_pk_ids = {} unless @next_pk_ids
-			@next_pk_ids[ domain_class ] = npi
-		end
+	def IntegerField.mock_value #:nodoc:
+		1
 	end
-	
+
 	class ObjectField
 		attr_writer :mock_value
 	
-		def default_mock_value; self.class.mock_value; end
+		def default_mock_value #:nodoc:
+			self.class.mock_value
+		end
 	end
 
-	def PrimaryKeyField.mock_value; nil; end
+	def PrimaryKeyField.mock_value #:nodoc:
+		nil
+	end
 
-	def StringField.mock_value; 'test text'; end
+	def StringField.mock_value #:nodoc:
+		'test text'
+	end
 	
-	def TextListField.mock_value; %w( a b c ); end
+	def TextListField.mock_value #:nodoc:
+		%w( a b c )
+	end
 end

data/lib/lafcadio/test.rb~

@@ -23,3 +23,194 @@ 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_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
+
+			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
+		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 )
+				maybe_call_default_mock( field, caller ) if ( val and val.pk_id == 1 )
+			end
+			dobj.commit
+			dobj
+		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_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.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.maybe_call_default_mock( field, caller )
+			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
+
+		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 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