lafcadio 0.9.2 → 0.9.3

data/lib/lafcadio/schema.rb

@@ -3,7 +3,7 @@ require 'lafcadio/objectField'
 module Lafcadio
 	class CreateTableStatement #:nodoc:
 		@@simple_field_clauses = {
-			BooleanField => 'bool', BlobField => 'blob', DateField => 'date', 
+			BooleanField => 'bool', BinaryField => 'blob', DateField => 'date', 
 			DomainObjectField => 'int', FloatField => 'float',
 			DateTimeField => 'datetime', IntegerField => 'int',
 			StringField => 'varchar(255)', TextListField => 'varchar(255)',
@@ -32,9 +32,9 @@ module Lafcadio
 				createDefinitions << definition_terms( field )
 			}
 			<<-SQL
-	create table #{ @domain_class.table_name } (
-		#{ createDefinitions.join(",\n  ") }
-	);
+create table #{ @domain_class.table_name } (
+#{ createDefinitions.join(",\n  ") }
+);
 			SQL
 		end
 		

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,22 +18,23 @@ 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 )
 			}
 			<<-SQL
-	create table #{ @domain_class.table_name } (
-		#{ createDefinitions.join(",\n  ") }
-	);
+create table #{ @domain_class.table_name } (
+#{ createDefinitions.join(",\n  ") }
+);
 			SQL
 		end
 		
@@ -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/test.rb

@@ -48,9 +48,35 @@ module Lafcadio
 		Time.now
 	end
 	
-	module DomainMock #:nodoc:
-		Version = '0.1.0'
-		
+	# A convenience module for test-cases of Lafcadio-dependent applications.
+	# Include this module in a test-case, and you automatically get the
+	# class-level method <tt>setup_mock_dobjs</tt>. This calls
+	# DomainObject.default_mock, and assigns the result to an instance variable 
+	# named after the domain class. Note that if your test case also defines a 
+	# <tt>setup</tt>, you should make sure to call <tt>super</tt> in that setup 
+	# method to make <tt>setup_mock_dobjs</tt> work.
+	#
+	#   class User < Lafcadio::DomainObject
+	#     strings :fname, :lname, :email
+	#   end
+	#
+	#   class TestSendMessage < Test::Unit::TestCase
+	#     include Lafcadio::DomainMock
+	#     setup_mock_dobjs User
+	#     def test_send_to_self
+	#       SendMessage.new( 'sender' => @user, 'recipient' => @user )
+	#       assert_equal( 1, Message.all.size )
+	#     end
+	#   end
+	#
+	# <tt>setup_mock_dobjs</tt> can handle plural domain classes:
+	#
+	#   setup_mock_dobjs User, Message
+	#
+	# It can also handle assignments to different instance variables:
+	#
+	#   setup_mock_dobjs User, '@sender'
+	module DomainMock
 		def self.included( includer )
 			def includer.setup_mock_dobjs( *domain_classes_or_symbol_names )
 				domain_classes = DomainClassSymbolMapper.new
@@ -158,7 +184,7 @@ module Lafcadio
 		# <tt>lafcadio/test.rb</tt>.
 		#
 		#   class User < Lafcadio::DomainObject
-		#     string :fname, :lname, :email
+		#     strings :fname, :lname, :email
 		#   end
 		#   u1 = User.custom_mock
 		#   u1.fname # => 'test text'
@@ -225,7 +251,7 @@ module Lafcadio
 		# <tt>lafcadio/test.rb</tt>.
 		#
 		#   class User < Lafcadio::DomainObject
-		#     string :fname, :lname, :email
+		#     strings :fname, :lname, :email
 		#   end
 		#   u1 = User.default_mock
 		#   u1.fname # => 'test text'
@@ -269,7 +295,7 @@ module Lafcadio
 		# <tt>lafcadio/test.rb</tt>.
 		#
 		#   class User < Lafcadio::DomainObject
-		#     string :fname, :lname, :email
+		#     strings :fname, :lname, :email
 		#   end
 		#   User.mock_value :fname, 'Bill'
 		#   User.mock_value :lname, 'Smith'
@@ -289,7 +315,7 @@ module Lafcadio
 		# <tt>lafcadio/test.rb</tt>.
 		#
 		#   class User < Lafcadio::DomainObject
-		#     string :fname, :lname, :email
+		#     strings :fname, :lname, :email
 		#   end
 		#   User.mock_values { :fname => 'Bill', :lname => 'Smith' }
 		#   u1 = User.default_mock

data/lib/lafcadio/test.rb~

@@ -21,17 +21,34 @@ 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 )
@@ -83,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 )
@@ -120,7 +137,7 @@ 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|
@@ -131,16 +148,62 @@ module Lafcadio
 			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.get_db_bridge
+			dbb = object_store.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 )
+			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|
@@ -153,13 +216,29 @@ module Lafcadio
 			default_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
@@ -168,11 +247,11 @@ 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 )
+		def self.maybe_call_default_mock( field, caller ) #:nodoc:
 			linked_type = field.linked_type
 			begin
 				ObjectStore.get_object_store.get( linked_type, 1 )
@@ -183,34 +262,81 @@ module Lafcadio
 			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 EmailField.mock_value #:nodoc:
+		'john.doe@email.com'
+	end
 
-	def FloatField.mock_value; 0.0; end
+	def FloatField.mock_value #:nodoc:
+		0.0
+	end
 
-	def IntegerField.mock_value; 1; 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/util.rb

@@ -13,24 +13,40 @@ module Lafcadio
 	#   dbpassword:password
 	#   dbname:lafcadio_test
 	#   dbhost:localhost
+	#   dbtype:Mysql ("Mysql" is the default; select "Pg" for Postgres)
 	class LafcadioConfig < Hash
-		@@filename = nil
-		@@value_hash = nil
-	
-		def self.set_filename(filename); @@filename = filename; end
+		@@value_hash = {}
+		@@instances = []
 		
-		def self.set_values( value_hash ); @@value_hash = value_hash; end
-
-		def initialize
-			if @@value_hash
-				@@value_hash.each { |key, value| self[key] = value }
-			elsif @@filename
-				File.new( @@filename ).each_line { |line|
+		def self.[]=( k, v )
+			@@value_hash[k] = v
+			@@instances.each do |instance| instance[k] = v; end
+		end
+		
+		def self.new
+			inst = super
+			@@instances << inst
+			inst
+		end
+	
+		def self.set_filename(filename)
+			@@value_hash = {}
+			if filename
+				File.new( filename ).each_line { |line|
 					line.chomp =~ /^(.*?):(.*)$/
 					self[$1] = $2
 				}
 			end
 		end
+		
+		def self.set_values( value_hash )
+			@@value_hash = ( value_hash.nil? ? {} : value_hash )
+			ObjectStore.db_type = @@value_hash['dbtype'] if @@value_hash['dbtype']
+		end
+
+		def initialize
+			@@value_hash.each { |key, value| self[key] = value }
+		end
 	end
 
 	class MissingError < RuntimeError; end