og 0.31.0 → 0.40.0

data/lib/og/entity/clone.rb

@@ -0,0 +1,119 @@
+require 'og/entity'
+
+# Add cloning functionality to entities.
+#--
+# WARNING, gmosx: I haven't tested this extensively,
+# this is a donated patch.
+#++
+
+module EntityMixin
+
+  def og_clone(*args)
+    Og::Entity.clone(self,*args)
+  end  
+
+end
+
+class Entity
+
+  class << self
+
+    # Entity copying support. Eventually this should all
+    # be eval'd in at enchanting stage for the minor
+    # speed increase.
+    # TODO: Convert to enchantments on objects
+    
+    # Accepts source object, destination and ignore.
+    # Source and destination are self explanatory; ignore
+    # is a list of properties not to copy (i.e.
+    # :create_time,:update_time).
+    # By default sets the class variables directly on the
+    # remote model instance, if you set use_setter_method to
+    # true, uses create_time= style copying tactics,
+    
+    def copy_properties(source, destination, ignore = [], use_setter_method = false)
+      property_copier(source, destination, ignore, use_setter_method, false)
+    end
+    
+    # Copies relations of one record to another. Only copies
+    # has_one, refers_to, belongs_to relationships as 
+    # has_many requires modifying of other objects and
+    # cannot be copied (by design). If you think you need to copy
+    # these relations, what you need is a joins_many relationship
+    # which can be copied.
+    
+    def copy_inferior_relations(source, destination, ignore = [])
+      real_ignore = Array.new
+      
+      # Map relation symbols to foreign keys.
+      
+      ignore.each do |symbol|
+         source.class.relations.reject{|r| [Og::JoinsMany, Og::ManyToMany, Og::HasMany].include?(r.class)}.each do |relation|
+           if relation.name == symbol.to_s
+             real_ignore << relation.foreign_key.to_sym
+             break
+           end
+         end
+      end      
+      
+      # Use instance variable property copier method.
+      
+      property_copier(source, destination, real_ignore, false, true)
+    end
+    
+    def copy_equal_relations(source, destination, ignore = [])
+      source.class.relations.reject{|r| not [Og::JoinsMany, Og::ManyToMany].include?(r.class)}.each do |relation|
+        next if relation.name == nil or ignore.include?(relation.name)
+        source.send(relation.name).each do |related|
+          destination.send(relation.name).send(:<<, related)
+        end
+      end
+    end
+    
+    # Copies all relations *except* HasMany which is impossible
+    # to copy. Use a JoinsMany relation instead if you need a
+    # copyable HasMany (which is irrational).
+        
+    def copy_relations(source, destination, ignore = [])
+      copy_inferior_relations(source, destination, ignore)
+      copy_equal_relations(source, destination, ignore)
+    end
+    
+    # Clones an object in every possible way (cannot copy
+    # HasMany but can copy all others - BelongsTo, etc).
+    # Provide a source object as first arguments, the rest
+    # (if any) are passed along to the initialize constructor
+    # when calling new to make the copied object.
+    
+    def clone(source,*args)
+      destination = source.class.new(*args)
+      copy_properties(source, destination, [], false)
+      # Must save here to copy join tables.      
+      destination.save!
+      copy_relations(source, destination, [])
+      destination.save!
+      destination
+    end
+
+    # Does the work of clone_properties and copy_inferior_relations. 
+    # Syntax is the same with one extra field to tell the 
+    # routine what it is copying.
+    
+    def property_copier(source,destination,ignore,use_setter_method,relations)
+      primary_key_symbol = source.class.primary_key.symbol
+      source.class.properties.to_a.each do |symbol, property|
+        next if primary_key_symbol == symbol or ignore.include?(symbol) or
+         (relations and not property.relation) or (not relations and property.relation)
+         
+        variable = "@#{symbol}"
+        if use_setter_method
+          destination.send("#{symbol}=".to_sym,source.instance_variable_get(variable))
+        else      
+          destination.instance_variable_set(variable, source.instance_variable_get(variable))        
+        end
+      end
+    end    
+  
+  end
+  
+end

data/lib/og/errors.rb

@@ -12,5 +12,3 @@ class StoreException < Exception
 end
 
 end
-
-# * George Moschovitis <gm@navel.gr>

data/lib/og/manager.rb

@@ -3,6 +3,7 @@ require 'facet/class/descendents'
 
 require 'og/entity'
 require 'og/store'
+require 'og/adapter'
 
 module Og
 
@@ -58,16 +59,24 @@ class Manager
   
   attr_accessor :cache
 
+  # Initialize the manager.
+  #
+  # === Options
+  #
+  # :store, :adapter = the adapter/store to use as backend.
+  
   def initialize(options)
     @options = options
     @entities = {}
 
-    @store_class = Store.for_name(options[:store])
-    @store_class.destroy(options) if options[:destroy]
-    @store_class.destroy_tables(options) if options[:destroy_tables]
-    init_store
+    @store_class = Adapter.for_name(options[:adapter] || options[:store])
+    @store_class.allocate.destroy_db(options) if Og.destroy_schema || options[:destroy]
+    
+    init_store()
   end
 
+  # Initialize a store.
+  
   def initialize_store
     if @pool
       close_store
@@ -77,9 +86,11 @@ class Manager
       @pool = Pool.new
       (options[:connection_count] || 5).times do
         @pool << @store_class.new(@options)
+        @pool.last.ogmanager = self
       end
     else
       @store = @store_class.new(@options)
+      @store.ogmanager = self
     end
   end
   alias :init_store :initialize_store 
@@ -87,7 +98,7 @@ class Manager
   # used when changing thread_safe mode
   
   def close_store
-    if @pool.empty?
+    unless @pool
       @store.close
     else
       @pool.each { |s| s.close }
@@ -103,10 +114,22 @@ class Manager
       thread = Thread.current
 
       unless st = thread[:og_store] and st.is_a?(@store_class)
-        if 0 == @pool.size()
-          initialize_store()
+        if 0 == @pool.size
+          initialize_store
         end
-        st = @pool.pop()
+        st = @pool.pop
+        thread[:og_store] = st
+      end
+
+      if st.ogmanager != self
+        # This normally shound't happen, there is a leftover store.
+        # Just return it to the original store and go on.
+        st.ogmanager.put_store
+
+        if 0 == @pool.size
+          initialize_store
+        end
+        st = @pool.pop
         thread[:og_store] = st
       end
 
@@ -125,6 +148,12 @@ class Manager
       thread = Thread.current
 
       if conn = thread[:og_store]
+
+        # store released to the wrong manager?
+        if conn.ogmanager != self
+          return conn.ogmanager.put_store
+        end
+
         thread[:og_store] = nil
         return @pool.push(conn)
       end
@@ -140,21 +169,39 @@ class Manager
   # Manage a class. Converts the class to an Entity.
 
   def manage(klass)
-    return if managed?(klass) or Og.unmanageable_classes.include?(klass)
+    return if managed?(klass) or (!manageable?(klass))
 
     info = EntityInfo.new(klass)
 
+    # Check if the class has a :text key.
+    
+    for a in klass.serializable_attributes
+      anno = klass.ann(a)
+      if anno[:key]
+        klass.ann.self[:text_key] = a
+        break
+      end
+    end
+
     # DON'T DO THIS!!!
+    #--
+    # gmosx: this is used though, dont remove without recoding 
+    # some stuff.
+    #++
     
     klass.module_eval %{
       def ==(other)
-        other.instance_of?(#{klass}) ? @#{klass.primary_key.symbol} == other.#{klass.primary_key.symbol} : false
+        other.instance_of?(#{klass}) ? @#{klass.primary_key} == other.#{klass.primary_key} : false
       end
     }
 
     klass.class.send(:attr_accessor, :ogmanager)
     klass.instance_variable_set '@ogmanager', self
 
+    # FIXME: move somewhere else.
+    
+    klass.define_force_methods
+
     Relation.enchant(klass)
 
     # ensure that the superclass is managed before the
@@ -162,7 +209,8 @@ class Manager
 
     manage(klass.superclass) if manageable?(klass.superclass)
 
-    # FIXME: uggly!
+    # Perform store related enchanting.
+    
     store.enchant(klass, self); put_store
 
     # Call special class enchanting code.
@@ -175,12 +223,15 @@ class Manager
   # Is this class manageable by Og?
   #
   # Unmanageable classes include classes:
-  # * without properties
+  # * without serializable attributes
   # * explicitly marked as Unmanageable (is Og::Unamanageable)
   # * are polymorphic_parents (ie thay are used to spawn polymorphic relations)
   
   def manageable?(klass)
-    klass.respond_to?(:properties) and (!klass.properties.empty?) and (!Og.unmanageable_classes.include?(klass)) and (!klass.polymorphic_parent?)
+    (klass.respond_to?(:serializable_attributes)) and
+    (!klass.serializable_attributes.empty?) and 
+    (!Og.unmanageable_classes.include?(klass)) and 
+    (!klass.polymorphic_parent?)
   end
 
   # Is the class managed by Og?
@@ -203,7 +254,6 @@ class Manager
   def manageable_classes
     classes = []
 
-#   for c in Property.classes
     ObjectSpace.each_object(Class) do |c|
       if manageable?(c)
         classes << c
@@ -216,17 +266,27 @@ class Manager
   # Manage a collection of classes.
 
   def manage_classes(*classes)
-    classes = manageable_classes.flatten # if classes.empty? FIXME!
-    classes = classes.reject { |c| self.class.managed?(c) }
+    classes.flatten!
+    classes.compact!
+    
+    mc = self.class.managed_classes
+    
+    classes = manageable_classes.flatten if classes.empty?
+    classes = classes.reject { |c| mc.member?(c) || !manageable?(c) }
+    
+    sc = @store_class.allocate
 
+    classes.each { |c| sc.force_primary_key(c) } 
     classes.each { |c| Relation.resolve_targets(c) }
     classes.each { |c| Relation.resolve_polymorphic_markers(c) }
-    classes.each { |c| Relation.resolve_polymorphic_relations(c) }
-
+    
     # The polymorpic resolution step creates more manageable classes.
-
-    classes = manageable_classes.flatten # if classes.empty? FIXME!
-    classes = classes.reject { |c| self.class.managed?(c) }
+    
+    classes += classes.map {|c| Relation.resolve_polymorphic_relations(c) }
+    
+    classes.flatten!
+    
+    classes = classes.reject { |c| !c or self.class.managed?(c) }
 
     Logger.debug "Og manageable classes: #{classes.inspect}" if $DBG
 
@@ -234,8 +294,10 @@ class Manager
     classes.each { |c| Relation.resolve_names(c) }
     classes.each { |c| manage(c) }
   end
-  alias_method :manage_class, :manage_classes
+  alias manage_class manage_classes
 
+  # Do not manage the given classes.
+  
   def unmanage_classes(*classes)
     classes = manageable_classes.flatten if classes.empty?
 
@@ -243,7 +305,7 @@ class Manager
       @entities.delete_if { |k, v| v.klass == c }
     end
   end
-  alias_method :unmanage_class, :unmanage_classes
+  alias unmanage_class unmanage_classes
 
   # Allows functionality that requires a store is finalized
   # to be implemented. A vastly superior method of constructing
@@ -258,20 +320,6 @@ class Manager
     store.post_setup if store.respond_to?(:post_setup)
   end
 
-  # Dump a nice name for this store.
-=begin  
-  def to_s
-    if store = get_store
-      store.to_s
-    else
-      'Uninitialized'
-    end
-  end  
-=end
 end
 
 end
-
-# * George Moschovitis <gm@navel.gr>
-# * Guillaume Pierronnet <guillaume.pierronnet@laposte.net>
-# * Rob Pitt

data/lib/og/relation.rb

@@ -2,7 +2,8 @@ require 'facet/kernel/constant'
 require 'facet/string/capitalized'
 require 'facet/ormsupport'
 require 'facet/inheritor'
-require 'facet/annotation'
+
+require 'facets/core/module/class_extension'
 
 module Og
 
@@ -53,9 +54,6 @@ class Relation
     # Inflect target_class if not provided.
 
     @options[:target_class] ||= @options[target_name].to_s.singular.camelize.intern
-
-    # FIXME: this is a hack!
-    # setup() rescue nil
   end
 
   # Get an option.
@@ -79,6 +77,8 @@ class Relation
   # Is this a polymorphic relation ?
 
   def polymorphic?
+    # hack fix!
+    return false unless target_class.is_a?(Class)
     target_class.ann.self[:polymorphic]
   end
 
@@ -116,23 +116,31 @@ class Relation
   # (at the time of the creation of the relation) classes are
   # stored as symbols. These symbols are resolved by this
   # method.
+  #
+  # First attempts to find a class in the form:
+  #
+  # owner_class::class
+  # (ie, Article::Category)
+  #
+  # then a class of the form:
+  #
+  # class
+  # (ie, ::Category)
   #--
-  # FIXME: do something more elegant here.
+  # The lookup is handled automatically by the #constant Facets
+  # method.
   #++
-
+  
   def symbol_to_class(sym, owner_class)
-    c = owner_class.name.dup
-    c = "::" + c unless c =~ /::/
-    c.gsub!(/::[^:]*$/, '::')
-    c << sym.to_s
+    owner_class = owner_class.name
+    
     begin
-      return constant(c)
-    rescue
-      unless c == sym
-        c = sym
-        retry
-      end
-    end
+      c = "#{owner_class}::#{sym}"
+      const = constant(c)
+      owner_class = owner_class.to_s.scan(/^(.*)::(?:[^:])*$/)
+    end while const.class != Class && !owner_class.empty?
+    
+    return const.class == Class ? const : nil
   end
   alias_method :resolve_symbol, :symbol_to_class
 
@@ -175,32 +183,45 @@ class Relation
   # For example:
   #
   # class Article
-  #   has_many Comment
+  #   has_many :comments
   #   ...
   # end
+  #
+  # generates:
+  #
+  # class Article::Comment < Comment
+  # end
 
   def resolve_polymorphic_relations(klass)
+    generated = []
+    
     for r in klass.relations
       if r.polymorphic?
-
         target_dm = r.target_class.to_s.demodulize
-
-        r.owner_class.module_eval %{
-          class #{r.owner_class}::#{target_dm} < #{r.target_class}
-          end
-        }
-
-        # Replace the target class.
-
-        r[:target_class] = eval("#{r.owner_class}::#{target_dm}")
+        
+        # Replace the target class by either creating or getting the
+        # polymorphic child if it already exists.
+        
+        r[:target_class] = if r.owner_class.constants.include?(target_dm)
+          r.owner_class.const_get(target_dm)
+        else
+          r.owner_class.const_set(target_dm, Class.new(r.target_class))
+        end
+        
+        r.resolve_polymorphic
+        
+        generated << r[:target_class]
       end
-
-      r.resolve_polymorphic
     end
+    
+    return generated
   end
 
   # Resolve the names of the relations.
-
+  #--
+  # For the target name it uses the demodulized class name.
+  #++
+  
   def resolve_names(klass)
     for r in klass.relations
       target_name = if r.collection
@@ -243,7 +264,6 @@ class Relation
     # enchant.
 
     for r in klass.relations
-      # p "=== #{klass} : #{r.class} : #{r.name}"
       r.enchant() unless r.polymorphic_marker?
     end
 
@@ -328,5 +348,3 @@ module RelationDSL
 end
 
 end
-
-# * George Moschovitis <gm@navel.gr>