og 0.24.0 → 0.25.0

data/lib/og/manager.rb

@@ -16,7 +16,7 @@ class Manager
   class EntityInfo
     attr_accessor :klass
     attr_accessor :enchanted
-    attr_accessor :options    
+    attr_accessor :options
 
     def initialize(klass = nil)
       @klass = klass
@@ -31,7 +31,7 @@ class Manager
 
   # The store used for persistence. This is a virtual field
   # when running in thread_safe mode.
-  
+
   attr_accessor :store
 
   # The collection of Entities managed by this manager.
@@ -42,30 +42,31 @@ class Manager
     @options = options
     @entities = {}
     @pool = Pool.new
-        
+
     @store_class = Store.for_name(options[:store])
     @store_class.destroy(options) if options[:destroy]
+    @store_class.destroy_tables(options) if options[:destroy_tables]
 
     if Og.thread_safe
       (options[:connection_count] || 5).times do
         @pool << @store_class.new(options)
-      end    
+      end
     else
       @store = @store_class.new(options)
     end
   end
 
-  # Get a store from the pool. 
-  
+  # Get a store from the pool.
+
   def get_store
     if Og.thread_safe
       thread = Thread.current
-      
+
       unless st = thread[:og_store] and st.is_a?(@store_class)
         st = @pool.pop()
         thread[:og_store] = st
       end
-      
+
       return st
     else
       return @store
@@ -75,20 +76,20 @@ class Manager
   alias_method :conn, :get_store
 
   # Return a store to the pool.
-  
+
   def put_store
     if Og.thread_safe
       thread = Thread.current
-      
+
       if conn = thread[:og_store]
         thread[:og_store] = nil
         return @pool.push(conn)
       end
     end
-  end  
+  end
 
   # Resolve polymorphic relations.
-  
+
   def resolve_polymorphic(klass)
     Relations.resolve_polymorphic(klass)
   end
@@ -100,6 +101,7 @@ class Manager
 
     info = EntityInfo.new(klass)
 
+    # DON'T DO THIS!!!
     klass.module_eval %{
       def ==(other)
         other ? @#{klass.primary_key.symbol} == other.#{klass.primary_key.symbol} : false
@@ -108,9 +110,9 @@ class Manager
 
     klass.class.send(:attr_accessor, :ogmanager)
     klass.instance_variable_set '@ogmanager', self
-    
-    Relation.enchant(klass)    
-    
+
+    Relation.enchant(klass)
+
     # ensure that the superclass is managed before the
     # subclass.
 
@@ -120,25 +122,32 @@ class Manager
     store.enchant(klass, self); put_store
 
     # Call special class enchanting code.
-    
+
     klass.enchant if klass.respond_to?(:enchant)
-    
+
     @entities[klass] = info
   end
 
   # Is this class manageable by Og?
-  
+
   def manageable?(klass)
-    klass.respond_to?(:properties) and (!klass.properties.empty?) # and klass.ann.this.polymorphic.nil?
+    klass.respond_to?(:properties) and (!klass.properties.empty?) # and klass.ann.self.polymorphic.nil?
   end
 
-  # Is the class managed by Og? 
+  # Is the class managed by Og?
 
   def managed?(klass)
     @entities.include?(klass)
   end
   alias_method :entity?, :managed?
 
+  # ==
+  # Returns an array containing all classes managed by this manager.
+  # ==
+  def managed_classes
+    @entities.map {|e| e[0]}
+  end
+
   # Use Ruby's advanced reflection features to find
   # all manageable classes. Managable are all classes that 
   # define Properties.
@@ -156,34 +165,58 @@ class Manager
   end
 
   # Manage a collection of classes.
-  
+
   def manage_classes(*classes)
     classes = manageable_classes.flatten # if classes.empty? FIXME!
-    
+
     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!
-    
+
     Logger.debug "Og manageable classes: #{classes.inspect}" if $DBG
-    
+
     classes.each { |c| Relation.resolve_targets(c) }
     classes.each { |c| Relation.resolve_names(c) }
     classes.each { |c| manage(c) }
+=begin
+    # gmosx: LETS better investigate this.
+
+    # Checks for obsolete tables lying around in the og store.
+    # rp: this shouldn't really be here but I can't think of a better 
+    # way to add this functionality.
+    
+    store = get_store()
+    
+    if store.respond_to? :unmanaged_tables
+      unmanaged_tables = store.unmanaged_tables(self)
+      unmanaged_tables.each do |table|
+
+        if @options[:evolve_schema] == true and @options[:evolve_schema_purge_tables] == true
+          sql = "DROP TABLE #{table}"
+          Logger.debug "Dropping unmanaged database table #{table}"
+          store.conn.exec(sql)
+        else
+          Logger.info "There is a table within the database named '#{table}' that is not managed by an Og class."
+        end
+      end
+    end
+=end
   end
   alias_method :manage_class, :manage_classes
 
   def unmanage_classes(*classes)
     classes = manageable_classes.flatten if classes.empty?
-    
+
     for c in classes
       @entities.delete_if { |k, v| v.klass == c }
     end
   end
   alias_method :unmanage_class, :unmanage_classes
+
 end
 
 end

data/lib/og/{mixin/schema_inheritance_base.rb → markers.rb}

@@ -1,5 +1,10 @@
 module Og
 
+# Marker module. If included in a class, the Og automanager
+# ignores this class.
+
+module Unmanageable; end
+
 # This is a marker module that denotes that the
 # base class follows the SingleTableInheritance
 # pattern. Ie, all the subclasses of the base
@@ -8,5 +13,3 @@ module Og
 module SchemaInheritanceBase; end
 
 end
-
-# * George Moschovitis <gm@navel.gr>

data/lib/og/relation.rb

@@ -6,7 +6,7 @@ require 'mega/annotation'
 
 module Og
 
-# A relation between Entities. 
+# A relation between Entities.
 #--
 # Relations are resolved in multiple passes. First
 # the relations are logged in :relations...
@@ -15,51 +15,51 @@ module Og
 class Relation
 
   # The parameters of this relation.
-  
+
   attr_accessor :options
-  
+
   # A generalized initialize method for all relations.
   # Contains common setup code.
-  
+
   def initialize(args, options = {})
     @options = options
     @options.update(args.pop) if args.last.is_a?(Hash)
 
     target_name = if collection
       :target_plural_name
-    else 
-      :target_singular_name 
+    else
+      :target_singular_name
     end
 
     # Check that all needed options are provided.
-    
+
     if args.empty? or (not (args.last.is_a?(Class) or args.last.is_a?(Symbol)))
       raise 'Class of target not defined' 
     end
 
     # Try to set the target class. Checks for class and 
     # class symbol.
-    
+
     if args.last.to_s.capitalized?
       @options[:target_class] = args.pop
     end
-    
+
     # Try to set the target name.
-    
+
     if args.last.is_a? Symbol
       @options[target_name] = args.pop
-    end      
-    
+    end
+
     # 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.
-  
+
   def [](key)
     @options[key]
   end
@@ -71,26 +71,26 @@ class Relation
   end
 
   # Is this a polymorphic marker?
-  
+
   def polymorphic_marker?
-    target_class == Object  
+    target_class == Object
   end
-  
+
   # Is this a polymorphic relation ?
-  
+
   def polymorphic?
-    target_class.ann.this[:polymorphic]
+    target_class.ann.self[:polymorphic]
   end
-  
+
   # Resolve a polymorphic target class.
   # Overrided in subclasses.
-    
+
   def resolve_polymorphic
   end
-  
+
   # This method is implemented in subclasses.
-  
-  def enchant 
+
+  def enchant
   end
 
   # Access the hash values as methods.
@@ -106,10 +106,10 @@ end
 
 class Relation
   class << self
-  
-  # To avoid forward declarations, references to undefined 
+
+  # To avoid forward declarations, references to undefined
   # (at the time of the creation of the relation) classes are
-  # stored as symbols. These symbols are resolved by this 
+  # stored as symbols. These symbols are resolved by this
   # method.
   #--
   # FIXME: do something more elegant here.
@@ -154,68 +154,68 @@ class Relation
   def resolve_polymorphic_markers(klass)
     for r in klass.relations
       if r.polymorphic_marker?
-        r.owner_class.ann :this, :polymorphic => r.owner_class  
+        r.owner_class.ann :self, :polymorphic => r.owner_class
       end
     end
   end
 
   # Resolve polymorphic relations.
   # If the target class is polymorphic, create a specialized
-  # version of that class (the target) enclosed in the 
+  # version of that class (the target) enclosed in the
   # owner namespace.
-  # 
+  #
   # For example:
   #
   # class Article
   #   has_many Comment
   #   ...
   # end
-          
+
   def resolve_polymorphic_relations(klass)
     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}")
       end
-    
+
       r.resolve_polymorphic
     end
   end
-  
+
   # Resolve the names of the relations.
-  
+
   def resolve_names(klass)
     for r in klass.relations
       target_name = if r.collection
         :target_plural_name
-      else 
+      else
         :target_singular_name 
       end
-      
+
       # Inflect the relation name.
-      
+
       unless r[target_name]
         r[target_name] = if r.collection
           r.target_class.to_s.demodulize.underscore.downcase.plural.intern 
         else
           r.target_class.to_s.demodulize.underscore.downcase.intern
-        end        
+        end
       end
-      
-      r[:name] = r[target_name]    
+
+      r[:name] = r[target_name]
     end
   end
-  
-  # General resovle method.
-  
+
+  # General resolve method.
+
   def resolve(klass, action = :resolve_polymorphic)
     for r in klass.relations
       r.send(action)
@@ -223,41 +223,36 @@ class Relation
   end
 
   # Perform relation enchanting on this class.
-  
-  def enchant(klass)      
+
+  def enchant(klass)
     # update inherited relations.
-    
+
     for r in klass.relations
       r[:owner_class] = klass 
     end
-    
-    # enchant.        
-    
+
+    # enchant.
+
     for r in klass.relations
       # p "=== #{klass} : #{r.class} : #{r.name}"
       r.enchant() unless r.polymorphic_marker?
     end
-    
+
   end
-  
+
   end
 end
 
-# Relations domain specific language (DSL). This 
+# Relations domain specific language (DSL). This
 # language defines macros that are used to define Entity
-# relations. Additional macros allow for relation 
+# relations. Additional macros allow for relation
 # inspection.
 
 module RelationDSL
-  def self.append_features(base)
-    super
-    base.module_eval do
-      inheritor(:relations, [], :+) unless @relations
-    end
-    base.extend(ClassMethods)
-  end
 
-  module ClassMethods
+  inheritor(:relations, [], :+) #unless @relations
+
+  class_inherit do
 
     # === Examples
     #
@@ -265,7 +260,7 @@ module RelationDSL
     # belongs_to Article  # inflects :article
     # belongs_to :article, Article
     # belongs_to :article, Article, :view => 'lala'
-    
+
     def belongs_to(*args)
       require 'og/relation/belongs_to'
       relations! << Og::BelongsTo.new(args, :owner_class => self)
@@ -275,7 +270,7 @@ module RelationDSL
     #
     # refers_to :topic # inflects Topic
     # refers_to Topic # inflects :topic
-    
+
     def refers_to(*args)
       require 'og/relation/refers_to'
       relations! << Og::RefersTo.new(args, :owner_class => self)
@@ -284,31 +279,31 @@ module RelationDSL
     # === Examples
     #
     #  has_one User
-    
+
     def has_one(*args)
       require 'og/relation/has_one'
       relations! << Og::HasOne.new(args, :owner_class => self)
     end
-  
+
     # === Examples
     #
     # has_many Comment
     # has_many :comments, Comment
-    
+
     def has_many(*args)
       require 'og/relation/has_many'
       relations! << Og::HasMany.new(args, :owner_class => self, :collection => true)
     end
 
     # ..
-    
+
     def joins_many(*args)
       require 'og/relation/joins_many'
       relations! << Og::JoinsMany.new(args, :owner_class => self, :collection => true)
     end
-    
+
     # ..
-    
+
     def many_to_many(*args)
       require 'og/relation/many_to_many'
       relations! << Og::ManyToMany.new(args, :owner_class => self, :collection => true)
@@ -318,8 +313,9 @@ module RelationDSL
       relations.find { |r| r[:name] == name }
     end
     alias_method :relation, :inspect_relation
-    
+
   end
+
 end
 
 end