og 0.31.0 → 0.40.0

data/lib/og/relation/belongs_to.rb

@@ -15,5 +15,3 @@ class BelongsTo < RefersTo
 end
 
 end
-
-# * George Moschovitis <gm@navel.gr>

data/lib/og/relation/has_many.rb

@@ -18,6 +18,8 @@ end
 # article.comments.size
 
 class HasMany < Relation
+  ann self, :collection => true # marker
+
   def resolve_polymorphic
     unless target_class.relations.empty?
       unless target_class.relations.find { |r| r.is_a?(BelongsTo) and  r.target_class == owner_class }
@@ -27,7 +29,12 @@ class HasMany < Relation
   end
 
   def enchant
-    self[:owner_singular_name] = owner_class.to_s.demodulize.underscore.downcase 
+    self[:owner_singular_name] = if owner_class.schema_inheritance?
+      owner_class.schema_inheritance_root_class
+    else
+      owner_class
+    end.to_s.demodulize.underscore.downcase
+    
     self[:target_singular_name] = target_plural_name.to_s.singular
     self[:foreign_key] = "#{foreign_name || owner_singular_name}_#{owner_class.primary_key}"
     # gmosx: DON'T set self[:foreign_field]
@@ -53,6 +60,25 @@ class HasMany < Relation
         @#{target_plural_name}.reload(options) if options and options[:reload]
         @#{target_plural_name}
       end
+      
+      def #{target_plural_name}=(*args)
+        options = args.last.is_a?(Hash) ? args.pop : nil
+        
+        if args.size == 1 && args.first.is_a?(HasManyCollection)
+          @#{target_plural_name} = args.first
+          @#{target_plural_name}.find_options = options if options
+          
+          return @#{target_plural_name}
+        end
+        
+        args.flatten!
+        
+        args.each do |obj|
+          add_#{target_singular_name}(obj, options)
+        end
+        
+        return #{target_plural_name}
+      end
 
       def add_#{target_singular_name}(obj, options = nil)
         return unless obj
@@ -89,6 +115,3 @@ class HasMany < Relation
 end
 
 end
-
-# * George Moschovitis <gm@navel.gr>
-# * Guillaunne Pierronnet <guillaunne.pierronnet@laposte.net>

data/lib/og/relation/joins_many.rb

@@ -14,10 +14,23 @@ end
 #
 # === Examples
 #
+# joins_many :categories
 # joins_many Category
-# joins_many :categories, Category
+# joins_many :categories, MyCategory
 
 class JoinsMany < Relation
+  ann self, :collection => true # marker
+
+  #--
+  # FIXME: better enchant polymorphic parents and then add 
+  # an alias to :objects.
+  #++
+  
+  def resolve_polymorphic
+    target_class.module_eval %{
+      joins_many :#{owner_class.to_s.demodulize.underscore.pluralize}
+    }
+  end
 
   def enchant
     self[:owner_singular_name] = owner_class.to_s.demodulize.underscore.downcase 
@@ -32,22 +45,44 @@ class JoinsMany < Relation
       join_class = sclass
     end
     join_table_info = store.join_table_info(self)
-
+    
     if through = self[:through] 
       # A custom class is used for the join. Use the class 
       # table and don't create a new table.
       through = Relation.symbol_to_class(through, owner_class) if through.is_a?(Symbol)
       join_table = self[:join_table] = store.table(through)
+      
+      tmp_join_class = through
     else    
-      # Calculate the name of the join table
+      # Calculate the name of the join table.
       join_table = self[:join_table] = join_table_info[:table]
       # Create a join table.
-      owner_class.ann :self, :join_tables => [] if owner_class.ann.self.join_tables.nil?
+      owner_class.ann :self, :join_tables => [] unless owner_class.ann.self.join_tables?
       owner_class.ann.self.join_tables! << join_table_info
+      
+      # Create temporary classes to be able to use ann.descendants to cascade
+      # delete joins_many relations when one side of the relation is removed.
+      
+      tmp_join_class_name = "OgTempJ_#{join_table}"
+      
+      unless self.class.constants.include?(tmp_join_class_name)
+        tmp_join_class = self.class.const_set(tmp_join_class_name, Class.new)
+        tmp_join_class.const_set('OGTABLE', join_table)
+      else
+        tmp_join_class = self.class.const_get(tmp_join_class_name)
+      end
+      
     end
     
     owner_key = join_table_info[:owner_key]
     target_key = join_table_info[:target_key]
+    
+    # Add join class to ann.descendants to be able to use cascade deletes.
+    
+    unless owner_class.ann.self[:descendants]
+      owner_class.ann(:self, :descendants => [])
+    end
+    owner_class.ann.self.descendants! << [tmp_join_class, owner_key]
 
     owner_class.module_eval %{ 
       attr_accessor :#{target_plural_name}
@@ -96,17 +131,13 @@ class JoinsMany < Relation
         #{target_class}.find(find_options)
       end      
 
-      #--
-      # FIXME/TODO: optimize this!! use count.
-      #++
-            
       def count_#{target_plural_name}
         find_options = {
           :join_table => "#{join_table}",
           :join_condition => "#{join_table}.#{target_key}=\#{#{target_class}::OGTABLE}.oid",
-          :condition => "#{join_table}.#{owner_key}=\#\{#{owner_class.primary_key}\}"          
+          :condition => "#{join_table}.#{owner_key}=\#\{#{owner_class.primary_key}\}"
         }
-        #{target_class}.find(find_options).size
+        #{target_class}.count(find_options)
       end
     }
     
@@ -122,7 +153,3 @@ class JoinsMany < Relation
 end
 
 end
-
-# * George Moschovitis <gm@navel.gr>
-# * Ysabel <deb@ysabel.org>
-# * Guillaume Pierronnet <guillaume.pierronnet@laposte.net>

data/lib/og/relation/many_to_many.rb

@@ -12,6 +12,16 @@ module Og
 # many_to_many :categories, Category
 
 class ManyToMany < JoinsMany
+  #--
+  # FIXME: better enchant polymorphic parents and then add 
+  # an alias to :objects.
+  #++
+  
+  def resolve_polymorphic
+    target_class.module_eval %{
+      many_to_many :#{owner_class.to_s.demodulize.underscore.pluralize}
+    }
+  end
 end
 
 end

data/lib/og/relation/refers_to.rb

@@ -2,6 +2,15 @@ require 'og/relation'
 
 module Og
 
+# A refers to relation. Stores the foreign key in the object.
+#--
+# TODO: No need to save user (should only call save aspects, for
+# example sweepers)
+#
+# THINK: Investigate if we should only store the key in the 
+# foreign object.
+#++
+
 class RefersTo < Relation
 
   def self.foreign_key(rel)
@@ -17,9 +26,14 @@ class RefersTo < Relation
       field = ", :field => :#{self[:field]}"
     end 
 
+    target_primary_key_class = target_class.ann(target_class.primary_key).class
+    
+    join_table_info = owner_class.ogmanager.store.join_table_info(self)
+    owner_key = join_table_info[:owner_key]
+    
     owner_class.module_eval %{
       attr_accessor :#{target_singular_name}
-      prop_accessor :#{foreign_key}, #{target_class.primary_key.klass}#{field}, :relation => true
+      attr_accessor :#{foreign_key}, #{target_primary_key_class}#{field}, :relation => true
 
       def #{target_singular_name}(reload = false)
         return nil if @#{foreign_key}.nil? 
@@ -32,7 +46,13 @@ class RefersTo < Relation
       end
 
       def #{target_singular_name}=(obj)
-        @#{foreign_key} = obj.#{target_class.primary_key} if obj
+        if obj
+          @#{foreign_key} = obj.#{target_class.primary_key}
+          obj.#{owner_key} = pk if obj.respond_to?(:#{owner_key}=)
+          # obj.save
+          save unless self.unsaved?
+        end
+        return obj
       end
     }    
   end
@@ -40,6 +60,3 @@ class RefersTo < Relation
 end
 
 end
-
-# * George Moschovitis <gm@navel.gr>
-# * Michael Neumann <mneumann@ntecs.de>

data/lib/og/store.rb

@@ -1,161 +1,164 @@
 module Og
 
-# A Store is responsible for the peristance of the ObjectGraph.
+# A Store is a backend of Og used to persist objects. An 
+# adapter specializes the Store. For example the SQL Store
+# has the MySQL, PostgreSQL, Sqlite3 etc adapters as 
+# specializations.
 
 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)
-    Logger.info "Og uses the #{name.to_s.capitalize} store."
-    # gmosx: to keep RDoc happy.
-    require('og/store/' + name.to_s)
-    return Og.const_get("#{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.
+  attr_accessor :ogmanager
 
   # Create a session to the store.
-
-  def initialize(options)
-    @options = options
+  #
+  # === Default options
+  #
+  # * :evolve_schema => :warn
+
+  def initialize options
+    @options = {
+      :evolve_schema => :warn
+    }.merge(options)
     @transaction_nesting = 0
   end
 
   # Close the session to the store.
 
   def close
+    raise 'Not implemented'
   end
-
+  
   # Enchants a class.
 
   def enchant(klass, manager)
-    # gmosx, FIXME: 
-    # ARGH, have to update this!
-    #
-    # klass.class.send(:define_method, :index) do |arg|
-    #   meta :index, arg 
-    # end
-
-    pk = klass.primary_key.symbol
-
+    pk = klass.primary_key
     klass.module_eval %{
+    
+      # A managed object is considered saved if it has 
+      # a valid primary key.
+      
       def saved?
-        return #{klass.primary_key.symbol}
+        return #{pk}
       end
 
+      # The inverse of saved.
+      
       def unsaved?
-        return !#{klass.primary_key.symbol}
+        return !#{pk}
       end
 
       # Evaluate an alias for the primary key.
 
       alias_method :pk, :#{pk}
       alias_method :pk=, :#{pk}=
-
-      def self.pk_symbol
-        :#{klass.primary_key.symbol}
-      end
     }
-    
   end
-
+    
   # :section: Lifecycle methods.
 
   # Loads an object from the store using the primary key.
 
   def load(pk, klass)
+    raise 'Not implemented'
   end
+  alias_method :exist?, :load
 
   # Reloads an object from the store.
 
   def reload(obj)
+    raise 'Not implemented'
   end
 
   # Save an object to store. Insert if this is a new object or
-  # update if this is already inserted in the database.
+  # update if this is already inserted in the database. Checks
+  # if the object is valid before saving. Returns false if the 
+  # object is invalid and populates obj.errors.
 
   def save(obj, options = nil)
     return false unless obj.valid?
 
     if obj.saved?
-      obj.og_update(self, options)
+      update_count = obj.og_update(self, options)
     else
-      obj.og_insert(self)
+      update_count = 1 if obj.og_insert(self)
     end
+
+    # Save building collections if any.
+    obj.save_building_collections
+  
+    return update_count
   end
   alias_method :<<, :save
   alias_method :validate_and_save, :save
 
+  # Force the persistence of an Object. Ignore any validation
+  # and/or other errors.
+  
   def force_save!(obj, options)
     if obj.saved?
-      obj.og_update(self, options)
+      obj.og_update self, options
     else
-      obj.og_insert(self)
+      obj.og_insert self
     end
   end
 
   # Insert an object in the store.
 
   def insert(obj)
-    obj.og_insert(self)
+    obj.og_insert self
   end
 
   # Update an object in the store.
 
-  def update(obj, options = nil)
-    obj.og_update(self, options)
+  def update obj, options = nil
+    obj.og_update self, options
   end
 
-  # Update selected properties of an object or class of
+  # Update selected attributes of an object or class of
   # objects.
-
-  def update_properties(obj_or_class, props, options = nil)
+  
+  def update_attributes target, *attributes
+    update(target, :only => attributes)
   end
-  alias_method :pupdate, :update_properties
-  alias_method :update_property, :update_properties
+  alias_method :aupdate, :update_attributes
+  alias_method :update_attribute, :update_attributes
 
   # 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
+    unless obj_or_pk.is_a? EntityMixin 
+      # create an 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)
+      # methods. This even allows to call og_delete aspects
+      # that use instance variable (for example, sophisticated
+      # cache sweepers).
+      #
+      # gmosx: the following is not enough!
+      # obj = klass.allocate
+      # obj.pk = obj_or_pk
+      obj = klass[obj_or_pk]
+      obj.og_delete(self, cascade)
     else
-      obj_or_pk.og_delete(self, nil, cascade)
+      obj_or_pk.og_delete(self, cascade)
     end
   end
 
+  # Delete all instances of the given class.
+  
+  def delete_all(klass)
+    raise 'Not implemented'
+  end
+
   # Perform a query.
 
   def find(klass, options)
+    raise 'Not implemented'
   end
 
   # Count the results returned by the query.
 
   def count(options)
+    raise 'Not implemented'
   end
 
   # :section: Transaction methods.
@@ -191,7 +194,7 @@ class Store
       start
       yield(self) 
       commit
-    rescue => ex
+    rescue Object => ex
       rollback
       raise ex
     end
@@ -199,22 +202,13 @@ class Store
 
 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
-
-  def eval_og_create_schema(klass)
+  #--
+  # A helper for inserting advices in the precompiled methods.
+  #++
+  
+  def insert_advices where, target, klass, advices # :nodoc: all
+    Aspects.gen_advice_code(target, klass.send(advices), where) if klass.respond_to?(advices)
   end
 end
 
 end
-
-# * George Moschovitis <gm@navel.gr>