og 0.16.0 → 0.17.0

data/lib/og/relation/many_to_many.rb

@@ -0,0 +1,17 @@
+require 'og/relation/joins_many'
+
+module Og
+
+# A 'many_to_many' relation.
+# This objects is associated with an other using an intermediate 
+# join table. Just an alias for 'joins_many'.
+#
+# === Examples
+#
+# many_to_many Category
+# many_to_many :categories, Category
+
+class ManyToMany < JoinsMany
+end
+
+end

data/lib/og/relation/refers_to.rb

@@ -0,0 +1,31 @@
+require 'og/relation'
+
+module Og
+
+class RefersTo < Relation
+
+	def enchant
+		self[:foreign_key] = "#{foreign_name || target_singular_name}_#{target_pk}"
+
+		owner_class.module_eval %{
+			attr_accessor :#{target_singular_name}
+			prop_accessor :#{foreign_key}, #{target_pkclass}
+
+			def #{target_singular_name}(reload = false)
+				unless reload
+					@#{target_singular_name} = #{target_class}[@#{foreign_key}] unless @#{target_singular_name}
+					return @#{target_singular_name}
+				else
+					return #{target_class}[@#{foreign_key}]
+				end
+			end
+
+			def #{target_singular_name}=(obj)
+				@#{foreign_key} = obj.#{target_pk}
+			end
+		}
+	end
+
+end
+
+end

data/lib/og/store.rb

@@ -0,0 +1,223 @@
+module Og
+
+# A Store is responsible for the peristance of the ObjectGraph.
+
+class Store
+	
+	# Options.
+	
+	attr_accessor :options
+	
+	# Transaction nesting.
+	
+	attr_accessor :transaction_nesting
+
+	# :section: Store methods.
+
+	# Return the store for the given name.
+
+	def self.for_name(name)
+		# gmosx: to keep RDoc happy.
+    eval %{ 
+			require 'og/store/#{name}'
+			return  #{name.to_s.capitalize}Store
+		}
+	end
+											
+	# Creates a store.
+
+	def self.create(options)
+	end
+
+	# Destroys a store.
+
+	def self.destroy(options)
+	end
+
+	# :section: Misc methods.
+
+	# Create a session to the store.
+
+	def initialize(options)
+		@options = options
+		@transaction_nesting = 0
+	end
+
+	# Close the session to the store.
+	
+	def close
+	end
+
+	# Enchants a class. 
+
+	def enchant(klass, manager)
+		klass.class.send(:define_method, :index) do |arg|
+			meta :index, arg 
+		end
+
+		pk = klass.primary_key.first
+
+		klass.module_eval %{
+			def saved?
+				return @#{klass.primary_key.first}
+			end
+
+			def unsaved?
+				return !@#{klass.primary_key.first}
+			end
+
+			# Evaluate an alias for the primary key.
+	
+			alias_method :pk, :#{pk}
+			alias_method :pk=, :#{pk}=
+			
+			def self.pk_symbol
+				:#{klass.primary_key.first}
+			end
+		}
+		
+		# Generate finder methods.
+	
+		code = ''
+		
+		for p in klass.properties
+			finder = p.meta[:unique] ? 'find_one' : 'find'
+			
+			code << %{
+				def self.find_by_#{p.symbol}(val, operator = '=', options = {})
+					options.update(
+						:class => #{klass},
+						:condition => "#{p.symbol}\#{operator}\#{ogmanager.store.quote(val)}"
+					)
+					ogmanager.store.#{finder}(options)
+				end; 
+			}
+		end
+	
+		klass.module_eval(code)
+	end
+
+	# :section: Lifecycle methods.
+
+	# Loads an object from the store using the primary key.
+
+	def load(pk, klass)
+	end
+
+	# Reloads an object from the store.
+
+	def reload(obj)
+	end
+
+	# Save an object to store. Insert if this is a new object or
+	# update if this is already inserted in the database.
+		 
+	def save(obj)
+		if obj.saved?
+			obj.og_update(self)
+		else
+			obj.og_insert(self)
+		end
+	end
+	alias_method :<<, :save
+
+	# Insert an object in the store.
+
+	def insert(obj)
+		obj.og_insert(self)
+	end
+
+	# Update an object in the store.
+
+	def update(obj, properties = nil)
+		obj.og_update(self)
+	end
+
+	# Update selected properties of an object or class of
+	# objects.
+	
+	def update_properties(obj_or_class, props, options = nil)
+	end
+	alias_method :pupdate, :update_properties
+	alias_method :update_property, :update_properties
+		
+	# Permanently delete an object from the store.
+	
+	def delete(obj_or_pk, klass = nil, cascade = true)
+		unless obj_or_pk.is_a?(EntityMixin)
+			# create a dummy instance to keep the og_delete
+			# method as an instance method like the other lifecycle
+			# methods.
+			klass.allocate.og_delete(self, obj_or_pk, cascade)
+		else
+			obj_or_pk.og_delete(self, nil, cascade)
+		end
+	end
+
+	# Perform a query.
+	
+	def find(klass, options)
+	end
+
+	# Count the results returned by the query.
+	
+	def count(options)
+	end
+	
+	# :section: Transaction methods.
+	
+	# Start a new transaction.
+	
+	def start
+		raise 'Not implemented'
+		true if @transaction_nesting < 1
+		@transaction_nesting += 1
+	end
+	
+	# Commit a transaction.
+	
+	def commit
+		raise 'Not implemented'
+		@transaction_nesting -= 1
+		true if @transaction_nesting < 1
+	end
+	
+	# Rollback a transaction.
+	
+	def rollback
+		@transaction_nesting -= 1
+		true if @transaction_nesting < 1
+	end
+
+	# Transaction helper. In the transaction block use
+	# the db pointer to the backend.
+	
+	def transaction(&block)
+		begin
+			start
+			yield(self) 
+			commit
+		rescue => ex
+			Logger.error 'Error in transaction'
+			Logger.error ex
+			Logger.error ex.backtrace
+			rollback
+		end
+	end
+
+private
+
+	def eval_og_insert(klass)
+	end
+
+	def eval_og_update(klass)
+	end
+
+	def eval_og_read(klass)
+	end
+
+	def eval_og_delete(klass)
+	end
+end
+
+end

data/lib/og/store/filesys.rb

@@ -0,0 +1,113 @@
+require 'yaml'
+require 'fileutils'
+
+require 'og/store'
+
+module Og
+
+# A Store that saves the object on the Filesystem.
+# You can create multiple instances that point to the same store.
+
+class FilesysStore < Store
+
+	# :section: Store methods.
+
+	def self.dir(name)
+		"#{name}_db"
+	end
+
+	def self.create(options)
+		name = dir(options[:name])
+		FileUtils.mkdir_p(name)
+	rescue 
+		Logger.error "Cannot create '#{name}'"
+	end
+	
+	def self.destroy(options)
+		name = dir(options[:name])
+		FileUtils.rm_rf(name)
+	rescue 
+		Logger.error "Cannot destroy '#{name}'"
+	end
+
+	# :section: Misc methods.
+	
+	# Initialize a connection to this store.
+
+  def initialize(options)
+		super
+
+		@base_dir = self.class.dir(options[:name])
+	
+		unless File.directory?(@base_dir)
+			Logger.info "Database '#{options[:name]}' not found!"
+			self.class.create(options)
+		end
+	end
+																																								
+	def enchant(klass, manager)		
+		super 
+
+		klass.const_set 'OGNAME', klass.to_s.gsub(/::/, "/").downcase
+		klass.property :oid, Fixnum
+ 
+		FileUtils.mkdir_p(path(klass))
+		File.open(spath(klass), 'w') { |f| f << '1' }
+	rescue => ex
+		p ex
+	  Logger.error "Cannot create directory to store '#{klass}' classes!"											
+	end
+
+	# :section: Lifecycle methods.
+
+	def load(oid, klass)
+    obj = nil
+		File.open(path(klass, oid), 'r') { |f| obj = YAML::load(f.read) }
+		return obj						
+	rescue
+		return nil
+	end
+
+	def reload(obj)
+	end
+
+	def save(obj)
+    seq = nil
+		File.open(spath(obj.class), 'r') { |f| seq = f.read.to_i }
+		obj.oid = seq
+		File.open(path(obj.class, obj.oid), 'w') { |f| f << obj.to_yaml }
+		seq += 1
+		File.open(spath(obj.class), 'w') { |f| f << seq }												
+	end
+
+	def delete(obj_or_pk, klass = nil, cascade = true)
+		pk = obj_or_pk.is_a?(Fixnum) ? obj_or_pk : obj_or_pk.oid
+		klass ||= obj_or_pk.class
+		FileUtils.rm(path(klass, pk))
+	end
+
+	def find
+	end
+
+	def count
+	end
+
+private
+
+	# Path helper.
+
+	def path(klass, pk = nil)
+		class_dir = File.join(@base_dir, klass::OGNAME)
+		pk ? File.join(class_dir, "#{pk}.yml") : class_dir
+	end
+
+	# Path to sequence helper.
+	
+	def spath(klass)
+		File.join(path(klass), 'seq')
+	end
+
+end
+
+end
+

data/lib/og/store/madeleine.rb

@@ -0,0 +1,4 @@
+# $Id$
+
+module Og
+end

data/lib/og/store/memory.rb

@@ -0,0 +1,291 @@
+require 'yaml'
+require 'fileutils'
+
+module Og
+
+# A collection of utilities. Mainly to stay compatible with the
+# SQL based backends.
+
+module MemoryUtils
+
+	# FIXME: find a neutral name.
+	
+	def table(klass)
+		klass.to_s
+	end
+
+	# FIXME: find a neutral name.
+
+	def join_table(class1, class2, postfix = nil)
+		"#{class1}#{class2}"
+	end
+
+	def quote(val)
+		val.inspect
+	end
+
+end
+
+# A Store that 'persists' objects into (RAM) memory.
+#--
+# TODO: fully working query.
+# TODO: arbitrary pk.
+#++
+
+class MemoryStore < Store
+	extend MemoryUtils; include MemoryUtils
+	
+	class ObjectHash < Hash
+		def [](key)
+			super(key.to_s)
+		end
+		
+		def []=(key, value)
+			super(key.to_s, value)
+		end
+	end
+	
+	# This hash implements an in-memory database.
+	
+	@objects = ObjectHash.new
+
+	def self.objects
+		@objects
+	end
+
+	def self.objects=(val)
+		@objects = val
+	end
+		
+	# A pseudo-connection to the actual object store.
+	
+	attr_accessor :conn
+
+	def self.destroy(options)
+		FileUtils.rm_rf("#{options[:name]}.db")
+	rescue 
+		Logger.info "Cannot destroy '#{name}'"
+	end
+	
+	def initialize(options)
+		super
+		begin
+			@conn = self.class.objects = YAML.load_file("#{@options[:name]}.db")
+		rescue
+			@conn = self.class.objects = ObjectHash.new
+		end
+	end
+
+	def close
+		File.open("#{@options[:name]}.db", 'w') { |f| f << @conn.to_yaml }
+	end
+
+	# Enchants a class. 
+
+	def enchant(klass, manager)
+		klass.property :oid, Fixnum
+
+		super
+		
+		@conn[klass] ||= {}
+		
+		eval_og_insert(klass)
+		eval_og_update(klass)
+		eval_og_read(klass)
+		eval_og_delete(klass)
+	end
+
+	# :section: Lifecycle methods.
+
+	# Loads an object from the store using the primary key.
+
+	def load(pk, klass)
+		@conn[klass][pk]
+	end
+
+	# Update selected properties of an object or class of
+	# objects.
+	
+	def update_properties(target, set, options = nil)
+		set = set.gsub(/,/, ';')
+		if target.is_a?(Class)
+			if options
+				condition = options[:condition] || options[:where]
+			else 
+				condition = 'true'
+			end
+			for obj in @conn[target].values
+				obj.instance_eval %{
+					if #{condition.gsub(/=/, '==')}
+						#{set}
+					end
+				}
+			end
+		else
+			target.instance_eval(set)
+		end			
+	end
+	alias_method :pupdate, :update_properties
+	alias_method :update_property, :update_properties
+
+	# Find a collection of objects.
+	#
+	# === Examples
+	#
+	# User.find(:condition  => 'age > 15', :order => 'score ASC', :offet => 10, :limit =>10)
+	# Comment.find(:include => :entry)
+	# store.find(:class => User, :where => 'age > 15')
+	
+	def find(options)	
+		query(options)
+	end
+
+	# Find one object.
+	
+	def find_one(options)
+		query(options).first
+	end
+
+	# Reloads an object from the store.
+
+	def reload(obj, pk)
+		# Nop, the memory store is always synchronized.
+	end
+
+	# Count results.
+	
+	def count(options)
+		objects = 0
+		
+		if condition = options[:condition] || options[:where]
+			condition = "obj." + condition.gsub(/=/, '==')
+		else
+			condition = true
+		end
+		
+		eval %{
+			for obj in @conn[options[:class]].values
+				objects += 1 if #{condition}
+			end
+		}		
+		
+		return objects
+	end
+
+	# Relate two objects through an intermediate join table.
+	# Typically used in joins_many and many_to_many relations.
+	
+	def join(obj1, obj2, table)
+		# nop
+	end 
+	
+	# Query.
+	
+	def query(options)
+		objects = []
+		
+		if condition = options[:condition] || options[:where]
+			condition = "obj." + condition.gsub(/=/, '==')
+		else
+			condition = true
+		end
+		
+		eval %{
+			for obj in @conn[options[:class]].values
+				objects << obj if #{condition}
+			end
+		}		
+
+		if order = options[:order]
+			desc = (order =~ /DESC/)
+			order = order.gsub(/DESC/, '').gsub(/ASC/, '')
+			eval "objects.sort { |x, y| x.#{order} <=> y.#{order} }"
+			objects.reverse! if desc
+		end
+				
+		return objects		
+	end
+	
+	# :section: Transaction methods.
+	
+	# Start a new transaction.
+	
+	def start
+	end
+	
+	# Commit a transaction.
+	
+	def commit
+	end
+	
+	# Rollback a transaction.
+	
+	def rollback
+	end
+
+private
+
+	# :section: Lifecycle method compilers.
+	
+	# Compile the og_update method for the class.
+
+	def eval_og_insert(klass)
+		pk = klass.primary_key.first
+
+		klass.class_eval %{ 
+			def og_insert(store)
+				#{Aspects.gen_advice_code(:og_insert, klass.advices, :pre) if klass.respond_to?(:advices)}
+				@#{pk} = store.conn[#{klass}].size + 1
+				store.conn[#{klass}][@#{pk}] = self
+				#{Aspects.gen_advice_code(:og_insert, klass.advices, :post) if klass.respond_to?(:advices)}
+			end
+		}
+	end
+
+	# Compile the og_update method for the class.
+
+	def eval_og_update(klass)
+		pk = klass.primary_key.first
+
+		klass.class_eval %{
+			def og_update(store)
+				#{Aspects.gen_advice_code(:og_update, klass.advices, :pre) if klass.respond_to?(:advices)}
+				store.conn[#{klass}][@#{pk}] = self
+				#{Aspects.gen_advice_code(:og_update, klass.advices, :post) if klass.respond_to?(:advices)}
+			end
+		}
+	end
+
+	# Not really useful in this store, kept for compatibility,
+	# just to call the aspects.
+		
+	def eval_og_read(klass)
+		klass.class_eval %{
+	 		def og_read
+				#{Aspects.gen_advice_code(:og_read, klass.advices, :pre) if klass.respond_to?(:advices)}
+				#{Aspects.gen_advice_code(:og_read, klass.advices, :post) if klass.respond_to?(:advices)}
+			end
+		}
+	end				
+
+	def eval_og_delete(klass)
+		klass.module_eval %{
+	 		def og_delete(store, pk, cascade = true)
+				#{Aspects.gen_advice_code(:og_delete, klass.advices, :pre) if klass.respond_to?(:advices)}
+				pk ||= @#{klass.primary_key.first}
+				transaction do |tx|
+					tx.conn[#{klass}].delete(pk)
+					if cascade and #{klass}.__meta[:descendants]
+						#{klass}.__meta[:descendants].each do |dclass, foreign_key|
+							eval "tx.conn[dclass].delete_if { |dobj| dobj.\#{foreign_key} == \#{pk} }"
+						end
+					end
+				end
+				#{Aspects.gen_advice_code(:og_delete, klass.advices, :post) if klass.respond_to?(:advices)}
+			end
+		}		
+	end
+
+end
+
+end