og 0.23.0 → 0.24.0

data/lib/og/evolution.rb

@@ -0,0 +1,78 @@
+require 'fileutils'
+
+require 'nano/kernel/constant'
+require 'nano/kernel/assign_with'
+
+# $DBG = true
+
+module Og
+
+class Manager
+  
+  # Dump Og managed objects to the filesystem.
+  
+  def dump(options = {})
+    classes = options[:classes] || options[:class] || manageable_classes
+    basedir = options[:basedir] || 'ogdump'
+    
+    FileUtils.makedirs(basedir)
+    
+    for c in [ classes ].flatten      
+      Logger.info "Dumping class '#{c}'"
+      all = c.all.map { |obj| obj.properties_to_hash }
+      File.open("#{basedir}/#{c}.yml", 'w') { |f| f << all.to_yaml }
+    end
+  end
+  alias_method :export, :dump
+  
+  # Load Og managed objects from the filesystem. This method can apply
+  # optional transformation rules in order to evolve a schema.
+  
+  def load(options = {})
+    classes = options[:classes] || manageable_classes
+    basedir = options[:basedir] || 'ogdump'
+    rules = options[:rules] || rules[:evolution] || {}
+
+    classes.each { |c| c.destroy if managed?(c) }
+    unmanage_classes(classes)
+    manage_classes
+    
+    for f in Dir["#{basedir}/*.yml"]
+      all = YAML.load(File.read(f))
+      
+      unless all.empty?
+        klass = f.split(/\/|\./)[1]
+        
+        Logger.info "Loading class '#{klass}'"
+        
+        if krules = rules[klass.to_sym]
+          if krules[:self]
+            # Class name changed.
+            Logger.info "Renaming class '#{klass}' to '#{krules[:self]}'"
+            klass = krules[:self]
+          end
+          
+          Logger.info "Evolution transformation will be applied!"
+        end      
+
+        klass = constant(klass)
+        
+        for h in all
+          obj = klass.allocate
+          obj.assign_with(h)
+          if krules
+            krules.each do |old, new|
+              obj.instance_variable_set "@#{new}", h[old]
+            end
+          end
+          obj.insert
+        end
+      end
+    end
+  end
+  alias_method :import, :load
+  alias_method :evolve, :load
+  
+end
+  
+end

data/lib/og/manager.rb

@@ -1,4 +1,5 @@
 require 'mega/pool'
+require 'nano/class/descendents'
 
 require 'og/entity'
 require 'og/store'
@@ -86,17 +87,6 @@ class Manager
     end
   end  
 
-  # Resolves the inheritance for a class.
-  
-  def resolve_inheritance(klass)
-    if has_super?(klass)
-      sclass = klass.superclass
-      klass.meta :superclass, sclass
-      klass.meta :schema_inheritance
-      sclass.meta :subclasses, klass
-    end
-  end
-
   # Resolve polymorphic relations.
   
   def resolve_polymorphic(klass)
@@ -107,25 +97,25 @@ class Manager
 
   def manage(klass)
     return if managed?(klass) or klass.ancestors.include?(Unmanageable)
-    
+
     info = EntityInfo.new(klass)
 
     klass.module_eval %{
       def ==(other)
-        other ? @#{klass.primary_key.first} == other.#{klass.primary_key.first} : false
+        other ? @#{klass.primary_key.symbol} == other.#{klass.primary_key.symbol} : false
       end
     }
 
-    klass.instance_variable_set '@ogmanager', self
     klass.class.send(:attr_accessor, :ogmanager)
-
+    klass.instance_variable_set '@ogmanager', self
+    
     Relation.enchant(klass)    
-
+    
     # ensure that the superclass is managed before the
     # subclass.
 
-    manage(klass.superclass) if has_super?(klass)
-    
+    manage(klass.superclass) if manageable?(klass.superclass)
+
     # FIXME: uggly!
     store.enchant(klass, self); put_store
 
@@ -139,7 +129,7 @@ class Manager
   # Is this class manageable by Og?
   
   def manageable?(klass)
-    klass.respond_to?(:__props) and (!klass.__props.empty?)
+    klass.respond_to?(:properties) and (!klass.properties.empty?) # and klass.ann.this.polymorphic.nil?
   end
 
   # Is the class managed by Og? 
@@ -149,13 +139,6 @@ class Manager
   end
   alias_method :entity?, :managed?
 
-  # Has this class a superclass?
-
-  def has_super?(klass)
-    manageable?(sclass = klass.superclass) and 
-        (klass.metadata.schema_inheritance || sclass.metadata.schema_inheritance)
-  end
-
   # Use Ruby's advanced reflection features to find
   # all manageable classes. Managable are all classes that 
   # define Properties.
@@ -168,25 +151,39 @@ class Manager
         classes << c
       end
     end
-    
+
     return classes
   end
 
   # Manage a collection of classes.
   
   def manage_classes(*classes)
-    classes = manageable_classes.flatten if classes.empty?
+    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| resolve_inheritance(c) }
-    classes.each { |c| Relation.resolve(c, :resolve_target) }
-    classes.each { |c| Relation.resolve(c, :resolve_polymorphic) }
-    classes.each { |c| Relation.resolve(c, :resolve_options) }
+    classes.each { |c| Relation.resolve_targets(c) }
+    classes.each { |c| Relation.resolve_names(c) }
     classes.each { |c| manage(c) }
   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/hierarchical.rb

@@ -1,4 +1,4 @@
-require 'mega/macro'
+require 'mega/dynamod'
 require 'mega/orm_support'
 
 module Og

data/lib/og/mixin/optimistic_locking.rb

@@ -1,4 +1,5 @@
-require 'mega/macro'
+require 'mega/dynamod'
+require 'glue/on_included'
 
 module Og
 
@@ -18,12 +19,8 @@ end
 module Locking
   property :lock_version, Fixnum, :default => 0
   pre "@lock_version = 0", :on => :og_insert
-
-  def self.append_features(base) #:nodoc:
-    PropertyUtils.copy_features(self, base)
-
-    super
-
+  
+  on_included %{
     base.module_eval do
       def self.enchant
         self.send :alias_method, :update_without_lock, :update
@@ -32,7 +29,7 @@ module Locking
         self.send :alias_method, :save, :save_with_lock
       end
     end
-  end
+  }
   
   def update_with_lock
     lock = @lock_version

data/lib/og/mixin/orderable.rb

@@ -1,4 +1,4 @@
-require 'mega/macro'
+require 'mega/dynamod'
 
 module Og
 
@@ -70,7 +70,20 @@ module Orderable
         end                      
       end
 
-      def move_to
+      def move_to(dest_position)
+        return if @#{position} == dest_position
+        
+        #{base}.transaction do
+          if @#{position} < dest_position
+            #{base}.update("#{position}=(#{position} - 1)", #{cond_and}"#{position} > \#\{@#{position}\} AND #{position} <= \#\{dest_position\}")
+          else
+            #{base}.update("#{position}=(#{position} + 1)", #{cond_and}"#{position} >= \#\{dest_position\} AND #{position} < \#\{@#{position}\} ")
+          end
+          @#{position} = dest_position
+          update_property(:#{position})
+        end
+        
+        self
       end
 
       def add_to_top

data/lib/og/mixin/schema_inheritance_base.rb

@@ -0,0 +1,12 @@
+module Og
+
+# This is a marker module that denotes that the
+# base class follows the SingleTableInheritance
+# pattern. Ie, all the subclasses of the base
+# class are stored in the same schema (table).
+
+module SchemaInheritanceBase; end
+
+end
+
+# * George Moschovitis <gm@navel.gr>

data/lib/og/mixin/taggable.rb

@@ -1,5 +1,7 @@
-require 'mega/macro'
-require 'nano/object/assign_with'
+require 'mega/dynamod'
+require 'nano/kernel/assign_with'
+
+require 'og/relation'
 
 #--
 # gmosx: make polymorphic work with many_to_many.
@@ -45,15 +47,15 @@ module Taggable
   # Helper.
   
   def self.tags_to_names(the_tags, separator = ' ')
-    if the_tags.is_a? Array
+    if the_tags.is_a? Array
       names = the_tags 
-    elsif the_tags.is_a? String
-      names = the_tags.split(separator)
+    elsif the_tags.is_a? String
+      names = the_tags.split(separator)
     end
-    
+    
     names = names.flatten.uniq.compact
     
-    return names
+    return names
   end  
 
   def self.append_dynamic_features(base, options = nil)
@@ -63,8 +65,10 @@ module Taggable
     }
     o.update(options) if options
 
+    base.send :include, Og::RelationDSL
+
     code = ''
-                
+ 
     unless o[:tag_class]
       o[:tag_class] = 'Tag'
       code << %{
@@ -96,28 +100,28 @@ module Taggable
         options = {
           :clear => true
         }.merge(options)
-        
+        
         names = Taggable.tags_to_names(the_tags, #{separator})
         
         tags.load_members
         
         # clear the collection if needed.    
-        
-        self.tags.clear if options[:clear]
-
+        
+        self.tags.clear if options[:clear]
+
         # append the tag names to the collection    
-        
-        names.each do |name| 
+        
+        names.each do |name| 
           name = name.strip
-          unless tagged_with?(name)
+          unless tagged_with?(name)
             unless tag_obj = #{tag_class}.find_by_name(name) 
               tag_obj = #{tag_class}.create(name)
             end
              tags << tag_obj
-           end
+           end
         end
         
-        self.save
+        self.save
       end
     }
 
@@ -130,18 +134,18 @@ module Taggable
     # Returns an array of strings containing the tags applied to 
     # this object.
     
-    code << %{  
-      def tag_names
-        tags.map { |t| t.name }
-      end
-    }  
+    code << %{  
+      def tag_names
+        tags.map { |t| t.name }
+      end
+    }  
 
     # Checks to see if this object has been tagged 
     # with +tag_name+.
 
-    code << %{      
-      def tagged_with?(tag_name)
-        tag_names.include?(tag_name)
+    code << %{      
+      def tagged_with?(tag_name)
+        tag_names.include?(tag_name)
       end
       alias_method :tagged_by?, :tagged_with?      
     }

data/lib/og/mixin/timestamped.rb

@@ -5,9 +5,11 @@ module Og
 # Adds timestamping functionality.
 
 module Timestamped
+  include Glue::Aspects
+  
   property :create_time, Time
-  property :update_time, Time
-  property :access_time, Time
+  property :update_time, Time, :editor => :none
+  property :access_time, Time, :editor => :none
 
   before "@create_time = @update_time = Time.now", :on => :og_insert
   before "@update_time = Time.now", :on => :og_update

data/lib/og/mixin/tree.rb

@@ -18,7 +18,6 @@ module TreeTraversal
 
   def self.child(sum, n)
     power = 2 ** n
-
     return sum * power
   end
 

data/lib/og/relation.rb

@@ -1,11 +1,16 @@
-require 'nano/object/constant'
-require 'nano/string/capitalized%3F'
-
+require 'nano/kernel/constant'
+require 'nano/string/capitalized'
 require 'mega/orm_support'
+require 'mega/inheritor'
+require 'mega/annotation'
 
 module Og
 
 # A relation between Entities. 
+#--
+# Relations are resolved in multiple passes. First
+# the relations are logged in :relations...
+#++
 
 class Relation
 
@@ -13,10 +18,6 @@ class Relation
   
   attr_accessor :options
   
-  # Is this a polymorphic relation?
-  
-  attr_accessor :is_polymorphic
-  
   # A generalized initialize method for all relations.
   # Contains common setup code.
   
@@ -53,74 +54,59 @@ class Relation
     
     @options[:target_class] ||= @options[target_name].to_s.singular.camelize.intern
     
-    setup()
-  end
-
-  def setup
-    if target_class == Object
-      # If the target class is just an Object mark that class
-      # as a polymorphic parent class.
-      # This class acts as template
-      # to generate customized versions of this class.
-      owner_class.meta(:polymorphic, owner_class)
-    elsif target_class.respond_to?(:metadata) and target_class.metadata.polymorphic
-      # If the target class is polymorphic, create a specialized
-      # version of the class enclosed in the owner namespace.
-      
-      target_dm = target_class.to_s.demodulize
-      owner_class.module_eval %{
-        class #{owner_class}::#{target_dm} < #{target_class}
-        end
-      }
-      eval %{
-        @options[:target_class] = #{owner_class}::#{target_dm}
-      }
-    end
-    
-    target_name = if collection
-      :target_plural_name
-    else 
-      :target_singular_name 
-    end
-    
-    # Inflect the relation name.
-    
-    unless @options[target_name]
-      @options[target_name] = if collection
-        target_class.to_s.demodulize.underscore.downcase.plural.intern 
-      else
-        target_class.to_s.demodulize.underscore.downcase.intern
-      end        
-    end
-    
-    @options[:name] = options[target_name]    
+    # FIXME: this is a hack!
+    # setup() rescue nil
   end
 
+  # Get an option.
+  
   def [](key)
     @options[key]
   end
 
+  # Set an option.
+
   def []=(key, val)
     @options[key] = val
   end
 
-  # Is the relation polymorphic?
+  # Is this a polymorphic marker?
   
-  def polymorphic?
+  def polymorphic_marker?
     target_class == Object  
   end
-
-  #--
-  # gmosx, TODO: remove, this is not really needed.
-  #++
   
-  def resolve_options
-    @options[:owner_pk], @options[:owner_pkclass] = owner_class.primary_key
-    if target_class.respond_to?(:primary_key)
-      @options[:target_pk], @options[:target_pkclass] = target_class.primary_key
-    end
+  # Is this a polymorphic relation ?
+  
+  def polymorphic?
+    target_class.ann.this[:polymorphic]
+  end
+  
+  # Resolve a polymorphic target class.
+  # Overrided in subclasses.
+    
+  def resolve_polymorphic
+  end
+  
+  # This method is implemented in subclasses.
+  
+  def enchant 
   end
 
+  # Access the hash values as methods.
+
+  def method_missing(sym, *args)
+    return @options[sym]
+  end
+
+end
+
+# A collection of helper methods and resolvers
+# for relations.
+
+class Relation
+  class << self
+  
   # 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 
@@ -129,7 +115,7 @@ class Relation
   # FIXME: do something more elegant here.
   #++
 
-  def resolve_symbol(sym, owner_class)
+  def symbol_to_class(sym, owner_class)
     c = owner_class.name.dup
     c = "::" + c unless c =~ /::/
     c.gsub!(/::.*$/, '::')
@@ -143,69 +129,131 @@ class Relation
       end
     end
   end
+  alias_method :resolve_symbol, :symbol_to_class
 
-  def resolve_target
-    if target_class.is_a?(Symbol)
-      klass = resolve_symbol(target_class, owner_class)
-      @options[:target_class] = klass
+  def resolve_targets(klass)
+    for r in klass.relations
+      if r.target_class.is_a? Symbol
+        klass = symbol_to_class(r.target_class, r.owner_class)
+        r.options[:target_class] = klass
+      end
     end
   end
-  
-  # Resolve a polymorphic target class.
-  # Overrided in subclasses.
+
+  # If the target class is just an Object mark this class
+  # (self) as a polymorphic parent class. This class acts 
+  # as template to generate customized versions of this class.
+  #
+  # For example:
+  #
+  # class Comment
+  #    belongs_to :parent, Object # <= polymorphic
+  #    ...
+  # end
+
+  def resolve_polymorphic_markers(klass)
+    for r in klass.relations
+      if r.polymorphic_marker?
+        r.owner_class.ann :this, :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 
+  # 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
     
-  def resolve_polymorphic
+      r.resolve_polymorphic
+    end
   end
   
-  # This method is implemented in subclasses.
+  # Resolve the names of the relations.
   
-  def enchant 
+  def resolve_names(klass)
+    for r in klass.relations
+      target_name = if r.collection
+        :target_plural_name
+      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
+      
+      r[:name] = r[target_name]    
+    end
   end
-
-  # Access the hash values as methods.
-
-  def method_missing(sym, *args)
-    return @options[sym]
+  
+  # General resovle method.
+  
+  def resolve(klass, action = :resolve_polymorphic)
+    for r in klass.relations
+      r.send(action)
+    end
   end
 
-  class << self
-
-    def resolve(klass, action)
-      if relations = klass.metadata.relations
-        for relation in klass.metadata.relations
-          relation.send(action)
-        end
-      end    
+  # Perform relation enchanting on this class.
+  
+  def enchant(klass)      
+    # update inherited relations.
+    
+    for r in klass.relations
+      r[:owner_class] = klass 
     end
     
-    def enchant(klass)      
-      if relations = klass.metadata.relations
-        # update inherited relations.
-        # gmosx, FIXME: implement a better fix/rethink this!
-        for relation in relations
-          relation[:owner_class] = klass 
-          unless relation.target_class == Object or relation.target_class.metadata.polymorphic
-            relation.setup 
-          end
-        end
-        
-        # enchant.        
-        for relation in relations
-          relation.enchant unless relation.target_class == Object
-        end
-      end
+    # enchant.        
+    
+    for r in klass.relations
+      # p "=== #{klass} : #{r.class} : #{r.name}"
+      r.enchant() unless r.polymorphic_marker?
     end
-
+    
+  end
+  
   end
-
 end
 
-# Relation macros. These macros are used to define Entity
-# relations.
+# Relations domain specific language (DSL). This 
+# language defines macros that are used to define Entity
+# relations. Additional macros allow for relation 
+# inspection.
 
-module RelationMacros
+module RelationDSL
   def self.append_features(base)
     super
+    base.module_eval do
+      inheritor(:relations, [], :+) unless @relations
+    end
     base.extend(ClassMethods)
   end
 
@@ -220,7 +268,7 @@ module RelationMacros
     
     def belongs_to(*args)
       require 'og/relation/belongs_to'
-      meta :relations, Og::BelongsTo.new(args, :owner_class => self)
+      relations! << Og::BelongsTo.new(args, :owner_class => self)
     end
 
     # === Examples
@@ -230,7 +278,7 @@ module RelationMacros
     
     def refers_to(*args)
       require 'og/relation/refers_to'
-      meta :relations, Og::RefersTo.new(args, :owner_class => self)
+      relations! << Og::RefersTo.new(args, :owner_class => self)
     end
 
     # === Examples
@@ -239,7 +287,7 @@ module RelationMacros
     
     def has_one(*args)
       require 'og/relation/has_one'
-      meta :relations, Og::HasOne.new(args, :owner_class => self)
+      relations! << Og::HasOne.new(args, :owner_class => self)
     end
   
     # === Examples
@@ -249,30 +297,25 @@ module RelationMacros
     
     def has_many(*args)
       require 'og/relation/has_many'
-      meta :relations, Og::HasMany.new(args, :owner_class => self, :collection => true)
+      relations! << Og::HasMany.new(args, :owner_class => self, :collection => true)
     end
 
     # ..
     
     def joins_many(*args)
       require 'og/relation/joins_many'
-      meta :relations, Og::JoinsMany.new(args, :owner_class => self, :collection => true)
+      relations! << Og::JoinsMany.new(args, :owner_class => self, :collection => true)
     end
     
     # ..
     
     def many_to_many(*args)
       require 'og/relation/many_to_many'
-      meta :relations, Og::ManyToMany.new(args, :owner_class => self, :collection => true)
+      relations! << Og::ManyToMany.new(args, :owner_class => self, :collection => true)
     end
 
-    def inspect_relations
-      __meta[:relations]
-    end        
-    alias_method :relations, :inspect_relations
-
     def inspect_relation(name)
-      __meta[:relations].find { |r| r[:name] == name }
+      relations.find { |r| r[:name] == name }
     end
     alias_method :relation, :inspect_relation
     
@@ -280,3 +323,5 @@ module RelationMacros
 end
 
 end
+
+# * George Moschovitis <gm@navel.gr>