og 0.6.0 → 0.7.0

data/lib/glue/property.rb.old

@@ -0,0 +1,307 @@
+# code:
+# * George Moschovitis  <gm@navel.gr>
+# design:
+# * Anastastios Koutoumanos  <ak@navel.gr>
+# * Elias Karakoulakis  <ekarak@ktismata.com>
+#
+# (c) 2004 Navel, all rights reserved.
+# $Id: property.rb 185 2004-12-10 13:29:09Z gmosx $
+
+require "glue/array"
+require "glue/hash"
+
+module G
+
+# = Property
+#
+# Ruby attributes are typeless and generally this is good. Some times
+# we need extra metadata though, for example in relational mapping,
+# or web form population.
+#
+# Only Fixnums, Strings, Floats, Times, Booleans are converted.
+#
+# The default = methods do not force the  types. A special 
+# __force_set method should be used instead.
+#
+#--
+# TODO:
+# Inject only the really needd methods into Module.
+# Perhaps a sync is needed in evals (!!!!)
+#++
+#
+class Property
+	# the symbol of the property
+	attr_accessor :symbol
+	# the string representation of the symbol
+	attr_accessor :name
+	# the class of the property
+	attr_accessor :klass
+	# additional metadata (like sql declaratio, sql index, etc)
+	attr_accessor :meta
+	
+	def initialize(symbol, klass, meta = {})
+		@symbol, @klass = symbol, klass
+		@meta = meta
+		@name = @symbol.to_s()
+	end
+	
+	def ==(other)
+		return @symbol == other.symbol
+	end
+	
+	def to_s
+		return name
+	end
+end
+
+end # module
+
+class Module
+
+	# Define a property (== typed attribute)
+	# This works like Ruby's standard attr method, ie creates
+	# only one property. 
+	#
+	# Use the prop_reader, prop_writer, prop_accessor methods 
+	# for multiple properties.
+	#
+	# Examples:
+	#	prop String, :name, :sql => "char(32), :sql_index => "name(32)"
+	# --> creates only writer.
+	# prop Fixnum, :oid, writer = true, :sql => "integer PRIMARY KEY"
+	#	--> creates reader and writer.
+	# 
+	def prop(*params)
+		meta = {}
+		klass = Object
+		
+		for param in params
+			if param.is_a?(Class)
+				klass = param
+			elsif param.is_a?(Symbol)
+				symbol = param
+			elsif param.is_a?(TrueClass) or param.is_a?(TrueClass) 
+				writer = param
+			elsif param.is_a?(Hash)
+				# the meta hash.
+				meta = param
+			else
+				raise "Error when defining property!"
+			end
+		end
+
+		unless self.methods.include?(:__props)
+			eval %{
+				# Properties
+				# An array is used to enforce order.
+				def __props
+					@__props
+				end
+
+				def __props=(props)
+					@__props = props
+				end
+				
+				def __meta
+					@__meta
+				end
+
+				def __meta=(meta)
+					@__meta = meta
+				end				
+			}
+		end
+
+		@__props = G::SafeArray.new() unless @__props
+				
+		property = G::Property.new(symbol, klass, meta)
+		
+		reader = meta[:reader] || true
+		writer = writer || meta[:writer] || false
+		
+		__add_prop(property, reader, writer)
+	end
+
+	# Helper method. Accepts a collection of symbols and generates
+	# properties. Only generates reader.
+	#
+	# Example:
+	#	prop_reader String, :name, :title, :body, :sql => "char(32)"
+	#
+	def prop_reader(*params)
+		meta = {}
+		klass = Object
+		symbols = []
+
+		for param in params
+			if param.is_a?(Class)
+				klass = param
+			elsif param.is_a?(Symbol)
+				symbols << param
+			elsif param.is_a?(Hash)
+				# the meta hash.
+				meta = param
+			else
+				raise "Error when defining property!"
+			end
+		end
+		
+		meta[:reader] = true
+		meta[:writer] = false
+		
+		for symbol in symbols
+			prop(klass, symbol, meta)
+		end
+	end
+
+	# Helper method. Accepts a collection of symbols and generates
+	# properties. Only generates writer.
+	#
+	# Example:
+	#	prop_writer String, :name, :title, :body, :sql => "char(32)"
+	#
+	def prop_writer(*params)
+		meta = {}
+		klass = Object
+		symbols = []
+
+		for param in params
+			if param.is_a?(Class)
+				klass = param
+			elsif param.is_a?(Symbol)
+				symbols << param
+			elsif param.is_a?(Hash)
+				# the meta hash.
+				meta = param
+			else
+				raise "Error when defining property!"
+			end
+		end
+		
+		meta[:reader] = false
+		meta[:writer] = true
+		
+		for symbol in symbols
+			prop(klass, symbol, meta)
+		end
+	end
+
+	# Helper method. Accepts a collection of symbols and generates
+	# properties. Generates reader and writer.
+	#
+	# Example:
+	#	prop_accessor String, :name, :title, :body, :sql => "char(32)"
+	#
+	def prop_accessor(*params)
+		meta = {}
+		klass = Object
+		symbols = []
+
+		for param in params
+			if param.is_a?(Class)
+				klass = param
+			elsif param.is_a?(Symbol)
+				symbols << param
+			elsif param.is_a?(Hash)
+				# the meta hash.
+				meta = param
+			else
+				raise "Error when defining property!"
+			end
+		end
+		
+		meta[:reader] = true
+		meta[:writer] = true
+		
+		for symbol in symbols
+			prop(klass, symbol, meta)
+		end
+	end
+	
+	# Add the property
+	#
+	def __add_prop(prop, reader = true, writer = true)
+		if idx = @__props.index(prop)
+			# override in case of duplicates. Keep the order of the props.
+			@__props[idx] = prop
+		else
+			@__props << prop
+		end
+		
+		# Precompile the property read/write methods
+
+		s, klass = prop.symbol, prop.klass 
+
+		if reader		
+			module_eval %{
+				def #{s}
+					return @#{s}
+				end
+			}
+		end
+			
+		# gmosx: __force_xxx reuses xxx= to allow for easier
+		# overrides.
+		if writer 
+			module_eval %{
+				def #{s}=(val)
+					@#{s} = val
+				end
+				
+				def __force_#{s}(val)
+						self.#{s}=(} + case klass.name
+													when Fixnum.name
+														"val.to_i()"
+													when String.name
+														"val.to_s()"
+													when Float.name
+														"val.to_f()"
+													when Time.name
+														"Time.parse(val.to_s())"
+													when TrueClass.name, FalseClass.name
+														"val.to_i() > 0"
+													else
+														"val"
+												end + %{) 
+				end
+			}
+		end
+	end
+	
+	# Attach metadata 
+	#
+	def meta(key, val)
+		@__meta = G::SafeHash.new unless @__meta
+
+		@__meta[key] = [] unless @__meta[key]
+
+		# guard against duplicates, no need to keep order.
+		@__meta[key].delete_if { |v| val == v }
+		@__meta[key] << val			
+	end
+	
+	# This method is typically called before including other
+	# modules to preserve properties order. 
+	#
+	def inherit_meta(mod = superclass)
+		# concat props.
+		if mod.__props
+			@__props = G::SafeArray.new unless @__props
+			
+			mod.__props.each { |p|
+				__add_prop(p)
+			} 
+		end
+
+		# concat metadata
+		if mod.__meta
+			mod.__meta.each { |k, val|
+				val.each { |v|
+					meta(k, v)
+				} if val
+			}
+		end
+	end
+	
+end
+

data/lib/og.rb

@@ -2,7 +2,7 @@
 # * George Moschovitis  <gm@navel.gr>
 #
 # (c) 2004 Navel, all rights reserved.
-# $Id: og.rb 185 2004-12-10 13:29:09Z gmosx $
+# $Id: og.rb 197 2004-12-21 13:50:17Z gmosx $
 
 require "glue/property"
 require "glue/array"
@@ -28,6 +28,11 @@ $og_auto_manage_classes = true
 # If true, automatically include the Og meta-language into Module. 
 $og_include_meta_language = true
 
+# Attach the following prefix to all generated SQL table names.
+# Usefull on hosting scenarios where you have to run multiple
+# web applications/sites on a single database.
+$og_table_prefix = nil
+
 require "og/meta"
 
 # = Og
@@ -169,7 +174,10 @@ class Database
 		@config[:connection_count].times do
 			@connection_pool << Og::Connection.new(self)
 		end
-		
+	
+		# gmosx, FIXME: this automanage code is not elegant and slow
+		# should probably recode this, along with glue/property.rb
+		#
 		if $og_auto_manage_classes
 			# automatically manage classes with properties and metadata.
 			# gmosx: Any idea how to optimize this?
@@ -286,8 +294,6 @@ class Database
 		Og::Utils.eval_og_oid(klass) unless klass.instance_methods.include?(:oid)
 		
 		klass.class_eval %{
-			inherit_meta(superclass) if superclass
-			
 			DBTABLE = "#{Og::Utils.table(klass)}"
 			DBSEQ = "#{Og::Utils.table(klass)}_oids_seq" 
 			
@@ -311,7 +317,12 @@ class Database
 	# class and its instances. 
 	#
 	def enchant(klass)
-		klass.class_eval %{
+		klass.module_eval <<-"end_eval", __FILE__, __LINE__
+			def self.create(*params)
+				obj = #{klass}.new(*params)
+				obj.save!
+			end
+				
 			def self.save(obj)
 				$og << obj
 			end
@@ -362,7 +373,7 @@ class Database
 			def delete!
 				$og.delete(@oid, #{klass})
 			end
-		}
+		end_eval
 	end
 	
 	# Automatically wrap connection methods.

data/lib/og/backend.rb

@@ -2,7 +2,7 @@
 # * George Moschovitis  <gm@navel.gr>
 #
 # (c) 2004 Navel, all rights reserved.
-# $Id: backend.rb 185 2004-12-10 13:29:09Z gmosx $
+# $Id: backend.rb 197 2004-12-21 13:50:17Z gmosx $
 
 require "yaml"
 
@@ -28,13 +28,13 @@ module Utils
 	# The name of the SQL table where objects of this class are stored.
 	#
 	def self.table(klass)
-		"_#{encode(klass)}"
+		"_#{$og_table_prefix}#{encode(klass)}"
 	end
 
 	# The name of the join table for the two given classes.
 	#
 	def self.join_table(klass1, klass2)
-		"_j_#{Og::Utils.encode(klass1)}_#{Og::Utils.encode(klass2)}"
+		"_#{$og_table_prefix}j_#{Og::Utils.encode(klass1)}_#{Og::Utils.encode(klass2)}"
 	end
 	
 	# Returns the props that will be included in the insert query.
@@ -232,7 +232,37 @@ class Backend
 	def rollback
 		exec "ROLLBACK"
 	end	
-	
+
+	# Create the fields that correpsond to the klass properties.
+	# The generated fields array is used in create_table.
+	# If the property has an :sql metadata this overrides the default mapping.
+	# If the property has an :extra_sql metadata the extra sql is appended
+	# after the default mapping.
+	#
+	def create_fields(klass, typemap)
+		fields = []
+		
+		klass.__props.each do |p|
+			klass.sql_index(p.symbol) if p.meta[:sql_index]
+				
+			field = "#{p.symbol}"
+			
+			if p.meta and p.meta[:sql]
+				field << " #{p.meta[:sql]}"
+			else
+				field << " #{typemap[p.klass]}"
+				# attach extra sql
+				if p.meta and extra_sql = p.meta[:extra_sql]
+					field << " #{extra_sql}"
+				end
+			end
+			
+			fields << field 
+		end
+
+		return fields
+	end
+
 	# Create the managed object table. The properties of the
 	# object are mapped to the table columns. Additional sql relations
 	# and constrains are created (indicices, sequences, etc).

data/lib/og/backends/mysql.rb

@@ -3,7 +3,7 @@
 # * Elias Athanasopoulos  <elathan@navel.gr>
 #
 # (c) 2004 Navel, all rights reserved.
-# $Id: mysql.rb 185 2004-12-10 13:29:09Z gmosx $
+# $Id: mysql.rb 194 2004-12-20 20:23:57Z gmosx $
 
 require "mysql"
 
@@ -263,21 +263,7 @@ class MysqlBackend < Og::Backend
 	# and constrains are created (indicices, sequences, etc).
 	#
 	def create_table(klass)
-		fields = []
-		
-		klass.__props.each do |p|
-			klass.sql_index(p.symbol) if p.meta[:sql_index]
-			
-			field = "#{p.symbol}"
-			
-			if p.meta and p.meta[:sql]
-				field << " #{p.meta[:sql]}"
-			else
-				field << " #{TYPEMAP[p.klass]}"
-			end
-			
-			fields << field 
-		end
+		fields = create_fields(klass, TYPEMAP)
 
 		sql = "CREATE TABLE #{klass::DBTABLE} (#{fields.join(', ')}"
 		
@@ -326,7 +312,7 @@ class MysqlBackend < Og::Backend
 				join_src = "#{Og::Utils.encode(klass)}_oid"
 				join_dst = "#{Og::Utils.encode(join_class)}_oid"
 				begin
-					exec "CREATE TABLE #{join_table} ( key1 integer, key2 integer )"
+					exec "CREATE TABLE #{join_table} ( key1 integer NOT NULL, key2 integer NOT NULL )"
 					exec "CREATE INDEX #{join_table}_key1_idx ON #{join_table} (key1)"
 					exec "CREATE INDEX #{join_table}_key2_idx ON #{join_table} (key2)"
 				rescue => ex