lafcadio 0.8.0 → 0.8.1

data/lib/lafcadio/schema.rb~

@@ -1,56 +0,0 @@
-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~

@@ -1,25 +0,0 @@
-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 = 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~

@@ -1,13 +0,0 @@
-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~

@@ -1,196 +0,0 @@
-require 'delegate'
-require 'lafcadio/depend'
-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
-			flush
-			@init_procs = {}
-		end
-		
-		def create_instance( service_class, *init_args ) #:nodoc:
-			if ( proc = @init_procs[service_class] )
-				proc.call( *init_args )
-			else
-				service_class.new( *init_args )
-			end
-		end
-		
-		# Flushes all cached ContextualServices.
-		def flush
-			@resources_by_class = Hash.new { |hash, key| hash[key] = {} }
-		end
-
-		def get_resource( service_class, *init_args ) #:nodoc:
-			resource = @resources_by_class[service_class][init_args]
-			unless resource
-				resource = create_instance( service_class, *init_args )
-				set_resource( service_class, resource, *init_args )
-			end
-			resource
-		end
-		
-		def set_init_proc( service_class, proc )
-			@init_procs[service_class] = proc
-		end
-		
-		def set_resource( service_class, resource, *init_args ) #:nodoc:
-			@resources_by_class[service_class][init_args] = 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( 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
-		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
-
-	# 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
-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