og 0.16.0 → 0.17.0

data/lib/og/collection.rb

@@ -0,0 +1,156 @@
+module Og
+
+# An 'active' collection that reflects a relation.
+# A collection stores entitities that participate in
+# a relation.
+
+class Collection
+
+	# The owner of this collection.
+	
+	attr_accessor :owner
+	
+	# The members of this collection. Keeps the objects
+	# tha belong to this collection.
+	
+	attr_accessor :members
+
+	# A method used to add insert objects in the collection.
+	 
+	attr_accessor :insert_proc
+	
+	# A method used to find the objects that belong to the
+	# collection.
+	
+	attr_accessor :find_proc
+
+	# The default find options.
+	
+	attr_accessor :find_options
+	
+	# Is the collection in build mode?
+	
+	attr_accessor :building
+	
+	# Is the collection loaded?
+	
+	attr_accessor :loaded
+
+	# Initialize the collection.
+		
+	def initialize(owner = nil, insert_proc = nil, find_proc = nil, find_options = {})
+		@owner = owner
+		@insert_proc = insert_proc
+		@find_proc = find_proc
+		@find_options = find_options
+		@members = []
+		@loaded = false
+		@building = false
+	end
+
+	# Load the members of the collection.	
+
+	def load_members
+		unless @loaded
+			@members = @owner.send(@find_proc, @find_options)
+			@loaded = true
+		end
+		@members
+	end
+	
+	# Reload the collection.
+	
+	def reload(options)
+		@find_options = options
+		@members = @owner.send(@find_proc, @find_options)
+	end
+
+	# Convert the collection to an array.
+		
+	def to_ary
+		load_members
+		@members
+	end
+
+	# Defined to avoid the method missing overhead.
+	
+	def each(&block)
+		load_members
+		@members.each(&block)
+	end
+	
+	# Defined to avoid the method missing overhead.
+	
+	def [](idx)
+		load_members
+		@members[idx]
+	end
+	
+	# Add a new member to the collection.
+	
+	def push(obj)
+		@members.push(obj)
+		unless @building or owner.unsaved?
+			@owner.send(@insert_proc, obj)
+		end
+	end
+	alias_method :<<, :push
+	alias_method :add, :push
+
+	# Delete a member from the collection.
+	
+	def delete(*objects)
+		objects = objects.flatten
+
+		objects.reject! { |obj| @members.delete(obj) if obj.unsaved? }
+		return if objects.empty?
+
+		@owner.transaction do
+			objects.each do |obj| 
+				obj.delete
+				@members.delete(obj) 
+			end
+		end
+	end
+
+	# Delete all members of the collection.
+	
+	def clear
+		@owner.transaction do
+			@members.each { |obj| obj.delete }
+		end
+		@members.clear
+	end
+
+	# Redirect all other methods to the members array.
+	
+	def method_missing(symbol, *args, &block)
+		load_members
+		@members.send(symbol, *args, &block)
+	end
+
+private
+
+	def check_type(obj)
+	end
+	
+end
+
+end
+
+__END__
+
+=== Examples
+
+article.comments.to_ary
+
+for article in article.comments
+end
+
+blog = Blog.new
+blog.categories << Category.new
+blog.categories << Category.new
+blog.enties << Entry.new
+blog.save
+
+blog.categories.unlink(1)

data/lib/og/entity.rb

@@ -0,0 +1,131 @@
+require 'og/relation'
+
+module Og
+
+# Include this module to classes to make them  managable by Og.
+
+module EntityMixin
+
+	def self.append_features(base)
+		super
+
+		base.extend(ClassMethods)
+
+		base.module_eval <<-end_eval, __FILE__, __LINE__ 
+			def save
+				self.class.ogmanager.store.save(self)
+				return self
+			end
+			alias_method :save!, :save
+
+			def insert
+				self.class.ogmanager.store.insert(self)
+				return self
+			end
+						
+			def update(*properties)
+				properties = nil if properties.empty?
+				self.class.ogmanager.store.update(self, properties)
+			end
+			
+			def update_properties(set)
+				self.class.ogmanager.store.update_properties(self, set)
+			end
+			
+			def reload
+				self.class.ogmanager.store.reload(self, self.pk)
+			end
+			alias_method :reload!, :reload
+
+			def delete
+				self.class.ogmanager.store.delete(self)
+			end
+			alias_method :delete!, :delete
+
+			def transaction(&block)
+				self.class.ogmanager.store.transaction(&block)
+			end
+		end_eval
+
+		base.send(:include, RelationMacros)
+	end
+
+	module ClassMethods
+		def create(*args)
+			obj = self.new(*args)
+			yield(obj) if block_given?
+			ogmanager.store.save(obj)
+			return obj
+		end
+				
+		def load(pk)
+			ogmanager.store.load(pk, self)
+		end
+		alias_method :[], :load
+
+		def update_properties(set, options = nil)
+			ogmanager.store.update_properties(self, set, options)
+		end
+		alias_method :pupdate, :update_properties
+		alias_method :update_property, :update_properties
+		alias_method :batch_update, :update_properties
+		
+		def find(options = {})
+			options[:class] = self
+			ogmanager.store.find(options)
+		end
+		alias_method :all, :find
+
+		def find_one(options = {})
+			options[:class] = self
+			ogmanager.store.find_one(options)
+		end
+		alias_method :one, :find_one
+		alias_method :first, :find_one
+
+		def count(options = {})
+			options[:class] = self
+			ogmanager.store.count(options)
+		end
+
+		def delete(obj_or_pk)
+			ogmanager.store.delete(obj_or_pk, self)
+		end
+		alias_method :delete!, :delete
+
+		def transaction(&block)
+			ogmanager.store.transaction(&block)
+		end
+		
+		def primary_key
+			unless @__meta and @__meta[:primary_key]
+				self.meta :primary_key, Entity.resolve_primary_key(self)
+			end
+			@__meta[:primary_key].flatten
+		end
+		
+		def const_missing(sym)
+			return sym
+		end
+	end
+
+end
+
+# A helper class.
+
+class Entity 
+	class << self
+		def resolve_primary_key(klass)
+			for p in klass.properties
+				if p.meta[:primary_key]
+					return p.symbol, p.klass
+				end
+			end
+			return :oid, Fixnum
+		end
+	end
+	
+	include EntityMixin
+end
+
+end

data/lib/og/errors.rb

@@ -1,21 +1,16 @@
-# * George Moschovitis  <gm@navel.gr>
-# (c) 2004-2005 Navel, all rights reserved.
-# $Id: errors.rb 1 2005-04-11 11:04:30Z gmosx $
+# $Id$
 
 module Og
+	
+# This exception is thrown when a low level error happens 
+# in the store. 
 
-# This exception is thrown when a low level error
-# happens in the store implementation.
-#--
-# TODO: rename adapter_exception to store_exception.
-#++
-
-class SqlException < Exception
-	attr_accessor :adapter_exception, :sql
+class StoreException < Exception
+	attr_accessor :original_exception, :info
 
-	def initialize(adapter_exception, sql = nil)
-		@adapter_exception, @sql = adapter_exception, sql
+	def initialize(original_exception, info = nil)
+		@original_exception, @info = original_exception, info
 	end
 end
-	
-end 
+
+end

data/lib/og/manager.rb

@@ -0,0 +1,115 @@
+require 'og/entity'
+require 'og/store'
+
+module Og
+
+# A Manager defines the relations between entities, ie Objects
+# managed by Og.
+
+class Manager
+
+	# Information about an Entity class
+
+	class EntityInfo
+		attr_accessor :klass
+		attr_accessor :enchanted
+		attr_accessor :options
+		
+
+		def initialize(klass = nil)
+			@klass = klass
+			@enchanted = false
+			@options = {}
+		end
+	end
+
+	# The configuration options.
+
+	attr_accessor :options
+
+	# The store used for persistence.
+
+	attr_accessor :store
+
+	# The collection of Entities managed by this manager.
+
+	attr_accessor :entities
+
+	def initialize(options)
+		@options = options
+		@entities = {}
+	end
+
+	# Manage a class. Converts the class to an Entity.
+
+	def manage(klass)
+		return if managed?(klass) or klass.ancestors.include?(Unmanageable)
+		
+		info = EntityInfo.new(klass)
+
+		klass.module_eval %{
+			def ==(other)
+				@#{klass.primary_key.first} == other.#{klass.primary_key.first}
+			end
+		}
+
+		klass.instance_variable_set '@ogmanager', self
+		klass.class.send(:attr_accessor, :ogmanager)
+
+		Relation.enchant(klass)		
+		@store.enchant(klass, self)
+		
+		@entities[klass] = info
+	end
+
+	# Is the class managed by Og? 
+
+	def managed?(klass)
+		@entities.include?(klass)
+	end
+	alias_method :entity?, :managed?
+
+	# Use Ruby's advanced reflection features to find
+	# all manageable classes. Managable are all classes that 
+	# define Properties.
+
+	def manageable_classes
+		classes = []
+
+		ObjectSpace.each_object(Class) do |c|
+			if c.respond_to?(:__props) and (!c.__props.empty?)
+				classes << c
+			end
+		end
+		
+		Logger.debug "Og manageable classes: #{classes.inspect}" if $DBG
+
+		return classes
+	end
+
+	# Manage a collection of classes.
+	
+	def manage_classes(*classes)
+		classes = manageable_classes if classes.empty?
+		classes.flatten.each { |c| manage(c) }
+	end
+
+end
+
+class << self
+	
+# Helper method, useful to initialize Og.
+
+def setup(options = {})
+	m = Manager.new(options)
+	store = Store.for_name(options[:store])
+	store.destroy(options) if options[:destroy]
+	m.store = store.new(options)
+	m.manage_classes
+	return m
+end
+alias_method :connect, :setup
+
+end
+
+end

data/lib/og/{mixins → mixin}/hierarchical.rb

@@ -1,6 +1,7 @@
-# * George Moschovitis  <gm@navel.gr>
-# (c) 2004-2005 Navel, all rights reserved.
-# $Id: hierarchical.rb 1 2005-04-11 11:04:30Z gmosx $
+require 'facet/string/plural'
+require 'facet/string/singular'
+require 'facet/string/demodulize'
+require 'facet/string/underscore'
 
 require 'glue/dynamic_include'
 
@@ -8,6 +9,9 @@ module Og
 
 # Implements the Nested Sets pattern for hierarchical 
 # SQL queries.
+#--
+# TODO: use actice collections.
+#++
 
 module NestedSets
 
@@ -16,9 +20,8 @@ module NestedSets
 			:left => 'lft', 
 			:right => 'rgt', 
 			:type => Fixnum, 
-			:scope => '"1 = 1"',
-			:parent => Inflector.name(base),
-			:children => Inflector.plural_name(base)  
+			:parent => base.to_s.demodulize.underscore.downcase,
+			:children => base.to_s.demodulize.underscore.downcase.plural  
 		}
 		c.update(options) if options
 
@@ -26,16 +29,26 @@ module NestedSets
 		left = c[:left]
 		right = c[:right]
 		children = c[:children]
-		child = Inflector.singularize(children)
+		child = children.singular
 
 	 	if c[:scope].is_a?(Symbol) && c[:scope].to_s !~ /_oid$/
 			c[:scope] = "#{c[:scope]}_oid".intern
 		end
+
 		scope = c[:scope]
-		if scope.is_a?(Symbol)
-			scope = %{(#{scope} ? "#{scope} = \#{@#{scope}}" : "#{scope} IS NULL")}
-		end
 		
+		if scope
+			if scope.is_a?(Symbol)
+				scope = %{(#{scope} ? "#{scope} = \#{@#{scope}}" : "#{scope} IS NULL")}
+			end
+		
+			cond = 'condition => ' + scope
+			cond_and = ':condition => ' + scope + ' + " AND " +'
+		else
+			cond = ':condition => nil'
+			cond_and = ':condition => '
+		end		
+
 		base.module_eval <<-EOE, __FILE__, __LINE__		
 			property :#{parent}, Fixnum, :sql_index => true
 			property :#{left}, :#{right}, #{c[:type]}
@@ -52,52 +65,43 @@ module NestedSets
 				return (@#{right} - @#{left} - 1)/2
 			end
 
-			def full_#{children}(extrasql = nil)
-				#{base}.all("WHERE " + #{scope} + " AND (#{left} BETWEEN \#\{@#{left}\} AND \#{@#{right}}) \#{extrasql}")
+			def full_#{children}(options = {})
+				options.update(#{cond_and}"(#{left} BETWEEN \#\{@#{left}\} AND \#{@#{right}})")
+				#{base}.all(options)
 			end
 
-			def #{children}(extrasql = nil)
-				#{base}.all("WHERE " + #{scope} + " AND (#{left} > \#\{@#{left}\}) AND (#{right} < \#{@#{right}}) \#{extrasql}")
+			def #{children}(options = {})
+				options.update(#{cond_and}"(#{left} > \#\{@#{left}\}) AND (#{right} < \#{@#{right}})")
+				#{base}.all(options)
 			end
 														
-			def direct_#{children}(extrasql = nil)
-				#{base}.all("WHERE " + #{scope} + " AND #{parent} = \#{@oid} \#{extrasql}")
+			def direct_#{children}(options = {})
+				options.update(#{cond_and}"#{parent} = \#{pk}")
+				#{base}.all(options)
 			end
 
 			def add_#{child}(child)
-				self.reload if @oid
-				child.reload if child.oid
+				self.reload if pk
+				child.reload if child.pk
 				
 				if @#{left}.nil? || @#{left} == 0 || @#{right}.nil? || @#{right} == 0
 					@#{left} = 1
 					@#{right} = 2 
 				end
 			
-				child.#{parent} = @oid
+				child.#{parent} = pk
 				child.#{left} = pivot = @#{right}
 				child.#{right} = pivot + 1
 				@#{right} = pivot + 2
 
-				self.class.transaction do
-					self.class.update("#{left} = (#{left} + 2)",  "WHERE " + #{scope} + " AND #{left} >= \#{pivot}")
-					self.class.update("#{right} = (#{right} + 2)",  "WHERE " + #{scope} + " AND #{right} >= \#{pivot}")
+				#{base}.transaction do
+					#{base}.update_property("#{left} = (#{left} + 2)",  #{cond_and}"#{left} >= \#{pivot}")
+					#{base}.update_property("#{right} = (#{right} + 2)", #{cond_and}"#{right} >= \#{pivot}")
 				end
 			
 				self.save
 				child.save
 			end
-			
-			def self.og_pre_delete(conn, obj)
-				return unless (obj.#{left} and obj.#{right})
-
-				span = obj.#{right} - obj.#{left} + 1
-				
-				(klass = obj.class).transaction do 
-					klass.delete(#{scope} + " AND #{left} > \#{obj.#{left}} AND (#{right} < \#{obj.#{right}})")
-					klass.update("#{left} = (#{left} - \#{span})",  "WHERE " + #{scope} + " AND #{left} >= \#{obj.#{right}}")
-					klass.update("#{right} = (#{right} - \#{span})",  "WHERE " + #{scope} + " AND #{right} >= \#{obj.#{right}}")
-				end
-			end
 		EOE
 	end
 
@@ -121,14 +125,16 @@ end
 module Hierarchical
 
 	def self.append_dynamic_features(base, options)
-		c = { 
+		o = { 
 			:method => :nested_sets, 
 		}
-		c.update(options) if options
+		o.update(options) if options
 
-		base.include(NestedSets)
+		base.include(NestedSets, o)
 	end
 
 end
 
 end 
+
+__END__