nitro 0.8.0 → 0.9.3

data/lib/og/connection.rb

@@ -1,17 +1,15 @@
-# code: 
-# * George Moschovitis  <gm@navel.gr>
-#
-# (c) 2004 Navel, all rights reserved.
-# $Id: connection.rb 167 2004-11-23 14:03:10Z gmosx $
+#-- 
+# George Moschovitis  <gm@navel.gr>
+# (c) 2004-2005 Navel, all rights reserved.
+# $Id: connection.rb 248 2005-01-31 13:38:34Z gmosx $
+#++
 
 class Og; 
 
-require "glue/property"
-require "glue/array"
-require "glue/time"
+require 'glue/property'
+require 'glue/array'
+require 'glue/time'
 
-# = Connection
-#
 # A Connection to the Database. This file defines the skeleton 
 # functionality. A backend specific implementation file (driver) 
 # implements all methods.
@@ -20,20 +18,23 @@ require "glue/time"
 #
 # - support caching.
 # - support prepared statements.
-#
+
 class Connection
 	# The frontend (Og) contains useful strucutres.
+	
 	attr_reader :og
 	
 	# The backend
+	
 	attr_reader :db
 
 	# If set to true, the select methods deserialize the 
 	# resultset to create entities.
+
 	attr_accessor :deserialize 
 		
 	# Initialize a connection to the database
-	#
+	
 	def initialize(og)
 		@og = og
 		@db = @og.config[:backend].new(@og.config)
@@ -189,9 +190,8 @@ class Connection
 		# TODO: implement this as stored procedure? naaah.
 		transaction do |tx|
 			tx.exec "DELETE FROM #{klass::DBTABLE} WHERE oid=#{oid}"
-			
-			if cascade and klass.respond_to?(:og_descendants)
-				klass.og_descendants.each do |dclass, linkback|
+			if cascade and klass.__meta.include?(:has)
+				klass.__meta[:has].each do |dclass, linkback|
 					tx.exec "DELETE FROM #{dclass::DBTABLE} WHERE #{linkback}=#{oid}"
 				end
 			end

data/lib/og/enchant.rb

@@ -1,20 +1,18 @@
-# code: 
 # * George Moschovitis  <gm@navel.gr>
-#
-# (c) 2004 Navel, all rights reserved.
+# (c) 2004-2005 Navel, all rights reserved.
 # $Id: meta.rb 198 2004-12-22 11:26:59Z gmosx $
 
 class Og
 
 module Enchant
 
-	# Enchant a managed class. Add useful DB related methods to the 
-	# class and its instances. 
-	#
+	# Enchant a managed class. Add useful DB related methods 
+	# to the class and its instances. 
+	
 	def enchant(klass)
 		klass.module_eval <<-"end_eval", __FILE__, __LINE__
-			def self.create(*params)
-				obj = #{klass}.new(*params)
+			def self.create(*params, &block)
+				obj = #{klass}.new(*params, &block)
 				obj.save!
 			end
 				
@@ -26,6 +24,10 @@ module Enchant
 				Og.db.load(oid_or_name, #{klass})
 			end
 
+			def self.get(oid_or_name)
+				Og.db.load(oid_or_name, #{klass})
+			end
+			
 			def self.[](oid_or_name)
 				Og.db.load(oid_or_name, #{klass})
 			end
@@ -57,6 +59,11 @@ module Enchant
 			def self.delete(obj_or_oid)
 				Og.db.delete(obj_or_oid, #{klass})
 			end
+
+			def each(&block)
+				all.each(&block)
+			end
+			include Enumerable
 			
 			def save
 				Og.db << self
@@ -77,4 +84,4 @@ module Enchant
 
 end
 	
-end # namespace
+end

data/lib/og/meta.rb

@@ -1,8 +1,6 @@
-# code: 
 # * George Moschovitis  <gm@navel.gr>
-#
-# (c) 2004 Navel, all rights reserved.
-# $Id: meta.rb 198 2004-12-22 11:26:59Z gmosx $
+# (c) 2004-2005 Navel, all rights reserved.
+# $Id: meta.rb 248 2005-01-31 13:38:34Z gmosx $
 
 require 'og/backend'
 require 'glue/inflector'
@@ -12,18 +10,42 @@ class Og
 # = MetaUtils
 #
 # Some useful meta-language utilities.
-#
+
 module MetaUtils # :nodoc: all
 
-	# Conver the klass to a string representation
+	# Convert the klass to a string representation
 	# The leading module if available is removed.
 	#--
 	# gmosx, FIXME: unify with the ogutils.encode method?
 	#++
+	
 	def self.expand(klass)
 		return klass.name.gsub(/^.*::/, '').gsub(/::/, '_').downcase
 	end
 
+	# Infer the target klass for a relation. When defining
+	# relations, tha target class is typically given. Some times
+	# in order to avoid forward declarations a symbol is given instead
+	# of a class. Other times on class is given at all, and 
+	# the inflection mechanism is used to infer the class name.
+
+	def self.resolve_class(name, klass)
+		klass ||= N::Inflector.camelize(name)
+		
+		return klass if klass.is_a?(Class)
+		
+		unless klass.is_a?(String) or klass.is_a?(Symbol)
+			raise 'Invalid class definition' 
+		end
+	
+		unless Object.const_get(klass.intern)
+			# Forward declaration.
+			Object.class_eval("class #{klass}; end")
+		end
+
+		return Object.const_get(klass)
+	end
+
 end
 
 # = MetaLanguage
@@ -33,11 +55,12 @@ end
 # from the excellent ActiveRecord library.
 #
 # Many more useful relations will be available soon.
-#
+
 module MetaLanguage
 
-	# Defines an SQL index.
-	#
+	# Defines an SQL index. Useful for defining indiced
+	# over multiple columns.
+	
 	def sql_index(index, options = {})
 		meta :sql_index, [index, options]
 	end
@@ -56,12 +79,14 @@ module MetaLanguage
 	# prop_accessor Fixnum, :parent_oid
 	# def parent; ... end
 	# def parent=(obj_or_oid); ... end
-	#
+	
 	def belongs_to(name, klass, options = {})
 		prop_eval = "prop_accessor Fixnum, :#{name}_oid"
 		prop_eval << ", :sql => '#{options[:sql]}'" if options[:sql]
 		prop_eval << ", :extra_sql => '#{options[:extra_sql]}'" if options[:extra_sql]
 
+		meta :belongs_to, klass
+		
 		module_eval %{
 			#{prop_eval}
 			
@@ -81,31 +106,31 @@ module MetaLanguage
 	# Example:
 	#
 	# class MyObject
-	#		has_one AnotherObject
+	#		has_one :child, TheClass
+	#		has_one :article
 	# end
 	#
 	# creates the code:
 	#
 	# ...
-	#
-	def has_one(name, klass, options = {})
+	
+	def has_one(name, klass = nil, options = {})
+
 		# linkback is the property of the child object that 'links back' 
 		# to this object. 
+
 		linkback = options[:linkback] || "#{MetaUtils.expand(self)}_oid"
 		
+		meta :has, [klass, linkback]
+		
 		module_eval %{
-			@@og_descendants ||= {}
-			@@og_descendants[#{klass}] = :#{linkback} 
-	
-			unless defined?(og_descendants)
-				def self.og_descendants
-					@@og_descendants
-				end
-			end
-			
 			def #{name}(extrasql = nil)
-				Og.db.select_one("SELECT * FROM #{Og::Backend.table(klass)} WHERE #{linkback}=\#\@oid \#\{extrasql\}", #{klass})
+				Og.db.select_one("SELECT * FROM #{Backend.table(klass)} WHERE #{linkback}=\#\@oid \#\{extrasql\}", #{klass})
 			end
+
+			def delete_#{name}(extrasql = nil)
+				Og.db.exec("DELETE FROM #{Backend.table(klass)} WHERE #{linkback}=\#\@oid \#\{extrasql\}") 
+			end			
 		}
 	end	
 	
@@ -121,36 +146,37 @@ module MetaLanguage
 	# creates the code:
 	#
 	# def children; ... end
-	#
+	
 	def has_many(name, klass, options = {})
 		name_s = N::Inflector.singularize(name.to_s)
 		
 		# linkback is the property of the child object that 'links back' 
 		# to this object. 
+
 		linkback = options[:linkback] || "#{MetaUtils.expand(self)}_oid"
 		
+		# keep belongs to metadata, useful for 
+		# reflection/scaffolding.
+
+		meta :has, [klass, linkback]
+
 		module_eval %{
-			@@og_descendants ||= {}
-			@@og_descendants[#{klass}] = :#{linkback} 
-	
-			unless defined?(og_descendants)
-				def self.og_descendants
-					@@og_descendants
-				end
-			end
-			
 			def #{name}(extrasql = nil)
-				Og.db.select("SELECT * FROM #{Og::Backend.table(klass)} WHERE #{linkback}=\#\@oid \#\{extrasql\}", #{klass})
+				Og.db.select("SELECT * FROM #{Backend.table(klass)} WHERE #{linkback}=\#\@oid \#\{extrasql\}", #{klass})
 			end
 
 			def #{name}_count(extrasql = nil)
-				Og.db.count("SELECT COUNT(*) FROM #{Og::Backend.table(klass)} WHERE #{linkback}=\#\@oid \#\{extrasql\}")
+				Og.db.count("SELECT COUNT(*) FROM #{Backend.table(klass)} WHERE #{linkback}=\#\@oid \#\{extrasql\}")
 			end			
 
 			def add_#{name_s}(obj, extra = nil)
 				obj.#{linkback} = @oid
 				obj.save!
 			end
+			
+			def delete_all_#{name}(extrasql = nil)
+				Og.db.exec("DELETE FROM #{Backend.table(klass)} WHERE #{linkback}=\#\@oid \#\{extrasql\}") 
+			end			
 		}
 	end
 	
@@ -173,10 +199,10 @@ module MetaLanguage
 	#
 	# category.articles
 	# ...
-	#
 	#--
 	# FIXME: make more compatible with other enchant methods.
 	#++
+	
 	def many_to_many(name, klass, options = {})
 		list_o = name.to_s
 		prop_o = N::Inflector.singularize(list_o)
@@ -185,36 +211,38 @@ module MetaLanguage
 	
 		# exit if the class is allready indirectly 'enchanted' from the
 		# other class of the many_to_many relation.
+
 		return if self.respond_to?(prop_m)
 	
 		# Add some metadata to the class to allow for automatic join table
 		# calculation.
+
 		meta :sql_join, [klass, options]
 
-		# gmosx, FIXME: should I update descendants here ?
+		meta :many_to_many, klass
+		klass.meta :many_to_many, self 
 
 		# enchant this class
 		
 		module_eval %{
 			def #{list_o}(extrasql = nil)
-				Og.db.select("SELECT d.* FROM #{Og::Backend.table(klass)} AS d, #{Og::Backend.join_table(self, klass)} AS j WHERE j.key1=\#\@oid AND j.key2=d.oid \#\{extrasql\}", #{klass})
+				Og.db.select("SELECT d.* FROM #{Backend.table(klass)} AS d, #{Backend.join_table(self, klass)} AS j WHERE j.key1=\#\@oid AND j.key2=d.oid \#\{extrasql\}", #{klass})
 			end
 
 			def #{list_o}_count(extrasql = nil)
-				Og.db.select("SELECT COUNT(*) FROM #{Og::Backend.table(klass)} AS d, #{Og::Backend.join_table(self, klass)} AS j WHERE j.key1=\#\@oid AND j.key2=d.oid \#\{extrasql\}", #{klass})
+				Og.db.select("SELECT COUNT(*) FROM #{Backend.table(klass)} AS d, #{Backend.join_table(self, klass)} AS j WHERE j.key1=\#\@oid AND j.key2=d.oid \#\{extrasql\}", #{klass})
 			end						
 			
 			def add_#{prop_o}(obj, extra = nil)
-				Og.db.exec("INSERT INTO #{Og::Backend.join_table(self, klass)} (key1, key2) VALUES (\#\@oid, \#\{obj.oid\})") 
+				Og.db.exec("INSERT INTO #{Backend.join_table(self, klass)} (key1, key2) VALUES (\#\@oid, \#\{obj.oid\})") 
 			end
 			
-			def del_#{prop_o}(obj_or_oid, extra = nil)
-				Og.db.exec("DELETE FROM #{Og::Backend.join_table(self, klass)} WHERE key2=\#\{obj_or_oid.to_i\}") 
+			def delete_#{prop_o}(obj_or_oid, extra = nil)
+				Og.db.exec("DELETE FROM #{Backend.join_table(self, klass)} WHERE key2=\#\{obj_or_oid.to_i\}") 
 			end
-			alias_method :delete_#{prop_o}, :del_#{prop_o}
 
 			def clear_#{list_o}
-				Og.db.exec("DELETE FROM #{Og::Backend.join_table(self, klass)} WHERE key1=\#\@oid") 
+				Og.db.exec("DELETE FROM #{Backend.join_table(self, klass)} WHERE key1=\#\@oid") 
 			end			
 		}
 		
@@ -222,40 +250,85 @@ module MetaLanguage
 		
 		klass.module_eval %{
 			def #{list_m}(extrasql = nil)
-				Og.db.select("SELECT s.* FROM #{Og::Backend.table(self)} AS s, #{Og::Backend.join_table(self, klass)} AS j WHERE j.key2=\#\@oid AND j.key1=s.oid \#\{extrasql\}", #{self})
+				Og.db.select("SELECT s.* FROM #{Backend.table(self)} AS s, #{Backend.join_table(self, klass)} AS j WHERE j.key2=\#\@oid AND j.key1=s.oid \#\{extrasql\}", #{self})
 			end
 
 			def #{list_m}_count(extrasql = nil)
-				Og.db.select("SELECT COUNT(*) FROM #{Og::Backend.table(self)} AS s, #{Og::Backend.join_table(self, klass)} AS j WHERE j.key2=\#\@oid AND j.key1=s.oid \#\{extrasql\}", #{self})
+				Og.db.select("SELECT COUNT(*) FROM #{Backend.table(self)} AS s, #{Backend.join_table(self, klass)} AS j WHERE j.key2=\#\@oid AND j.key1=s.oid \#\{extrasql\}", #{self})
 			end
 			
 			def add_#{prop_m}(obj, extra = nil)
-				Og.db.exec("INSERT INTO #{Og::Backend.join_table(self, klass)} (key1, key2) VALUES (\#\{obj.oid\}, \#\@oid)") 
+				Og.db.exec("INSERT INTO #{Backend.join_table(self, klass)} (key1, key2) VALUES (\#\{obj.oid\}, \#\@oid)") 
 			end
 			
-			def del_#{prop_m}(obj_or_oid, extra = nil)
-				Og.db.exec("DELETE FROM #{Og::Backend.join_table(self, klass)} WHERE key1=\#\{obj_or_oid.to_i\}") 
+			def delete_#{prop_m}(obj_or_oid, extra = nil)
+				Og.db.exec("DELETE FROM #{Backend.join_table(self, klass)} WHERE key1=\#\{obj_or_oid.to_i\}") 
 			end
-			alias_method :delete_#{prop_m}, :del_#{prop_m}						
 
 			def clear_#{list_m}
-				Og.db.exec("DELETE FROM #{Og::Backend.join_table(self, klass)} WHERE key2=\#\@oid") 
+				Og.db.exec("DELETE FROM #{Backend.join_table(self, klass)} WHERE key2=\#\@oid") 
 			end			
 		}
 	end
 	alias :has_and_belongs_to_many :many_to_many 
 
+	# Implements a 'refers_to' relation.
+	# This is a one-way version of the 'has_one'/'belongs_to' 
+	# relations. The target object cannot link back to the source
+	# object.
+	# This is in fact EXACTLY the same as belongs_to with a 
+	# different name (!!!!)
+	#
+	# Automatically enchants the calling class with helper methods.
+	# 
+	# 
+	# Example:
+	#
+	# class MyObject
+	#		refers_to article, Article
+	# end
+	#
+	# creates the code:
+	#
+	# prop_accessor Fixnum, :article_oid
+	# def article; ... end
+	# def article=(obj_or_oid); ... end
+
+	def refers_to(name, klass, options = {})
+		prop_eval = "prop_accessor Fixnum, :#{name}_oid"
+		prop_eval << ", :sql => '#{options[:sql]}'" if options[:sql]
+		prop_eval << ", :extra_sql => '#{options[:extra_sql]}'" if options[:extra_sql]
+
+		meta :refers_to, klass
+		klass.meta :has, [self, "#{name}_oid"]
+		
+		module_eval %{
+			#{prop_eval}
+			
+			def #{name}
+				Og.db.load_by_oid(@#{name}_oid, #{klass})
+			end
+			
+			def #{name}=(obj_or_oid)
+				@#{name}_oid = obj_or_oid.to_i
+			end
+		}
+	end
+
 end
 
-end # namespace
+end
 
 # Include the meta-language extensions into Module. If the flag is
 # false the developer is responsible for including the MetaLanguage
 # module where needed.
-#
+# 
+# By default this is FALSE, to avoid polution of the Module object.
+# However if you include a prop_accessor or a managed Mixin in your
+# object MetaLanguage gets automatically extended in the class.
+
 if Og.include_meta_language
 	class Module # :nodoc: all
 		include Og::MetaLanguage
 	end
 end
-