og 0.20.0 → 0.21.0

data/lib/og/relation/belongs_to.rb

@@ -4,11 +4,11 @@ module Og
 
 class BelongsTo < RefersTo
 
-	def enchant
-		super
-		target_class.meta :descendants, [owner_class, foreign_key]
-	end
-	
+  def enchant
+    super
+    target_class.meta :descendants, [owner_class, foreign_key]
+  end
+  
 end
 
 end

data/lib/og/relation/has_many.rb

@@ -4,6 +4,7 @@ require 'facet/string/underscore'
 
 require 'og/relation'
 require 'og/collection'
+require 'og/relation/belongs_to'
 
 module Og
 
@@ -19,70 +20,71 @@ end
 # article.comments.size
 
 class HasMany < Relation
-=begin
-	def initialize(args, options = {})
-		super
+  def resolve_polymorphic
+    if target_class.relations
+      unless target_class.relations.find { |r| r.is_a?(BelongsTo) and  r.target_class == owner_class }
+        target_class.belongs_to(owner_class)      
+      end
+    end
+  end
 
-		# TODO: clean this up.
-		
-		unless target_class.relations.find { |r| r.is_a?(BelongsTo) and	r.target_class == owner_class }
-			target_class.belongs_to(owner_class)			
-		end
-	end
-=end
-	def resolve_polymorphic
-		if target_class.relations
-			unless target_class.relations.find { |r| r.is_a?(BelongsTo) and	r.target_class == owner_class }
-				target_class.belongs_to(owner_class)			
-			end
-		end
-	end
+  def enchant
+    self[:owner_singular_name] = owner_class.to_s.demodulize.underscore.downcase 
+    self[:target_singular_name] = target_plural_name.to_s.singular
+    self[:foreign_key] = "#{foreign_name || owner_singular_name}_#{owner_pk}"
+    
+    owner_class.module_eval %{ 
+      attr_accessor :#{target_plural_name}
 
-	def enchant
-		self[:owner_singular_name] = owner_class.to_s.demodulize.underscore.downcase 
-		self[:target_singular_name] = target_plural_name.to_s.singular
-		self[:foreign_key] = "#{foreign_name || owner_singular_name}_#{owner_pk}"
-		
-		owner_class.module_eval %{ 
-			attr_accessor :#{target_plural_name}
+      def #{target_plural_name}(options = nil)
+        unless @#{target_plural_name}
+          @#{target_plural_name} = HasManyCollection.new(
+            self, 
+            :add_#{target_singular_name},
+            :remove_#{target_singular_name},
+            :find_#{target_plural_name},
+            :count_#{target_plural_name},
+            options
+          )
+        end
+        
+        @#{target_plural_name}.find_options = options
+        @#{target_plural_name}.reload(options) if options and options[:reload]
+        @#{target_plural_name}
+      end
 
-			def #{target_plural_name}(options = nil)
-				unless @#{target_plural_name}
-					@#{target_plural_name} = HasManyCollection.new(
-						self, 
-						:add_#{target_singular_name},
-						:remove_#{target_singular_name},
-						:find_#{target_plural_name},
-						options
-					)
-				end
+      def add_#{target_singular_name}(obj, options = nil)
+        return unless obj
+        obj.#{foreign_key} = @#{owner_pk}
+        obj.save
+      end
 
-				@#{target_plural_name}.reload(options) if options and options[:reload]
-				@#{target_plural_name}
-			end
-
-			def add_#{target_singular_name}(obj)
-				obj.#{foreign_key} = @#{owner_pk}
-				obj.save
-			end
-
-			def remove_#{target_singular_name}(obj)
-				obj.#{foreign_key} = nil
-			end
-			
-			def find_#{target_plural_name}(options = {})
-				find_options = {
-					:condition => "#{foreign_key} = \#\{@#{owner_pk}\}"
-				}
-				find_options.update(options) if options
-				#{"find_options.update(:order => #{options[:order].inspect})" if options[:order]}
-				#{target_class}.find(find_options)
-			end
-		}
-	end
+      def remove_#{target_singular_name}(obj)
+        obj.#{foreign_key} = nil
+      end
+      
+      def find_#{target_plural_name}(options = {})
+        find_options = {
+          :condition => "#{foreign_key} = \#\{@#{owner_pk}\}"
+        }
+        if options
+          if condition = options.delete(:condition)
+            find_options[:condition] += " AND (\#{condition})"
+          end        
+          find_options.update(options)
+        end
+        #{target_class}.find(find_options)
+      end
+      
+      def count_#{target_plural_name}
+        #{target_class}.count(:condition => "#{foreign_key} = \#\{@#{owner_pk}\}")        
+      end
+    }
+  end
 
 end
 
 end
 
-__END__
+# * George Moschovitis <gm@navel.gr>
+# * Guillaunne Pierronnet <guillaunne.pierronnet@laposte.net>

data/lib/og/relation/joins_many.rb

@@ -21,54 +21,100 @@ end
 
 class JoinsMany < Relation
 
-	def enchant
-		self[:owner_singular_name] = owner_class.to_s.demodulize.underscore.downcase 
-		self[:target_singular_name] = target_plural_name.to_s.singular
-
-		store = owner_class.ogmanager.store
-		join_table, oidx, tidx = store.join_table(owner_class, target_class)
-		owner_class.meta :join_tables, join_table
-
-		owner_class.module_eval %{ 
-			attr_accessor :#{target_plural_name}
-
-			def #{target_plural_name}(options = nil)
-				reload = options and options[:reload]
-
-				unless @#{target_plural_name}
-					@#{target_plural_name} = JoinsManyCollection.new(
-						self, 
-						:add_#{target_singular_name},
-						:remove_#{target_singular_name},
-						:find_#{target_plural_name}
-					)
-				end
-
-				@#{target_plural_name}.reload(options) if options and options[:reload]
-				@#{target_plural_name}
-			end
-
-			def add_#{target_singular_name}(obj)
-				obj.save
-				obj.class.ogmanager.store.join(self, obj, "#{join_table}")
-			end
-
-			def remove_#{target_singular_name}(obj)
-				obj.class.ogmanager.store.unjoin(self, obj, "#{join_table}")
-			end
-
-			def find_#{target_plural_name}(options = {})
-				find_options = {
-					:join_table => "#{join_table}",
-					:join_condition => "#{join_table}.key#{tidx}=#{store.table(target_class)}.oid",
-					:condition => "#{join_table}.key#{oidx}=\#\{@#{owner_pk}\}"
-				}
-				find_options.update(options) if options
-				#{target_class}.find(find_options)
-			end			
-		}
-	end
+  def enchant
+    self[:owner_singular_name] = owner_class.to_s.demodulize.underscore.downcase 
+    self[:target_singular_name] = target_plural_name.to_s.singular
+
+    store = owner_class.ogmanager.store
+    join_table_info = store.join_table_info(owner_class, target_class)
+    
+    if through = self[:through] 
+      # A custom class is used for the join. Use the class 
+      # table and don't create a new table.
+      through = resolve_symbol(through, owner_class) if through.is_a?(Symbol)
+      join_table = self[:join_table] = through.table
+    else    
+      # Calculate the name of the join table
+      join_table = self[:join_table] = join_table_info[:table]
+      # Create a join table.
+      owner_class.meta :join_tables, join_table_info
+    end
+    
+    owner_key = join_table_info[:owner_key]
+    target_key = join_table_info[:target_key]
+
+    owner_class.module_eval %{ 
+      attr_accessor :#{target_plural_name}
+
+      def #{target_plural_name}(options = nil)
+        reload = options and options[:reload]
+
+        unless @#{target_plural_name}
+          @#{target_plural_name} = JoinsManyCollection.new(
+            self, 
+            :add_#{target_singular_name},
+            :remove_#{target_singular_name},
+            :find_#{target_plural_name},
+            :count_#{target_plural_name},
+            options
+          )
+        end
+
+        @#{target_plural_name}.find_options = options
+        @#{target_plural_name}.reload(options) if options and options[:reload]
+        @#{target_plural_name}
+      end
+
+      def add_#{target_singular_name}(obj, options = nil)
+        obj.save
+        obj.class.ogmanager.store.join(self, obj, "#{join_table}", options)
+      end
+
+      def remove_#{target_singular_name}(obj)
+        obj.class.ogmanager.store.unjoin(self, obj, "#{join_table}")
+      end
+
+      def find_#{target_plural_name}(options = {})
+        find_options = {
+          :join_table => "#{join_table}",
+          :join_condition => "#{join_table}.#{target_key}=#{store.table(target_class)}.oid",
+          :condition => "#{join_table}.#{owner_key}=\#\{@#{owner_pk}\}"          
+        }
+        if options
+          if condition = options.delete(:condition)
+            find_options[:condition] += " AND (\#{condition})"
+          end        
+          find_options.update(options)
+        end        
+        #{target_class}.find(find_options)
+      end      
+
+      #--
+      # TODO: optimize this!!
+      #++
+            
+      def count_#{target_plural_name}
+        find_options = {
+          :join_table => "#{join_table}",
+          :join_condition => "#{join_table}.#{target_key}=#{store.table(target_class)}.oid",
+          :condition => "#{join_table}.#{owner_key}=\#\{@#{owner_pk}\}"          
+        }
+        #{target_class}.find(find_options).size
+      end
+    }
+    
+    if through
+      owner_class.module_eval %{
+        def #{target_singular_name}_join_data(t)
+          #{through}.find_one(:condition => "#{owner_key}=\#{@#{owner_pk}} and #{target_key}=\#{t.pk}")
+        end
+      }
+    end    
+  end
 
 end
 
 end
+
+# * George Moschovitis <gm@navel.gr>
+# * Ysabel <deb@ysabel.org>

data/lib/og/relation/refers_to.rb

@@ -4,28 +4,32 @@ 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
+  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)
+        return nil if @#{foreign_key}.nil? 
+
+        # will reload if forced or first load or
+        if reload or not @#{target_singular_name}
+          @#{target_singular_name} = #{target_class}[@#{foreign_key}]
+        end
+        @#{target_singular_name}
+      end
+
+      def #{target_singular_name}=(obj)
+        @#{foreign_key} = obj.#{target_pk} if obj
+      end
+    }
+  end
 
 end
 
 end
+
+# * George Moschovitis <gm@navel.gr>
+# * Michael Neumann <mneumann@ntecs.de>

data/lib/og/store.rb

@@ -3,223 +3,226 @@ module Og
 # A Store is responsible for the peristance of the ObjectGraph.
 
 class Store
-	
-	# Options.
-	
-	attr_accessor :options
-	
-	# Transaction nesting.
-	
-	attr_accessor :transaction_nesting
+  
+  # Options.
+  
+  attr_accessor :options
+  
+  # Transaction nesting.
+  
+  attr_accessor :transaction_nesting
 
-	# :section: Store methods.
+  # :section: Store methods.
 
-	# Return the store for the given name.
+  # Return the store for the given name.
 
-	def self.for_name(name)
-		# gmosx: to keep RDoc happy.
+  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
-			# gmosx: :uniq does NOT set a unique constrain in the
-			# database.
-			finder = p.meta[:uniq] || 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, options = nil)
-		if obj.saved?
-			obj.og_update(self, options)
-		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, options = nil)
-		obj.og_update(self, options)
-	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
+      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
+      # gmosx: :uniq does NOT set a unique constrain in the
+      # database.
+      finder = p.meta[:uniq] || 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, options = nil)
+    if obj.saved?
+      obj.og_update(self, options)
+    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, options = nil)
+    obj.og_update(self, options)
+  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_insert(klass)
+  end
 
-	def eval_og_update(klass)
-	end
+  def eval_og_update(klass)
+  end
 
-	def eval_og_read(klass)
-	end
+  def eval_og_read(klass)
+  end
 
-	def eval_og_delete(klass)
-	end
+  def eval_og_delete(klass)
+  end
+  
+  def eval_og_create_schema(klass)
+  end
 end
 
 end