og 0.23.0 → 0.24.0

data/lib/og/relation/all.rb

@@ -0,0 +1,6 @@
+require 'og/relation/belongs_to'
+require 'og/relation/has_many'
+require 'og/relation/has_one'
+require 'og/relation/joins_many'
+require 'og/relation/many_to_many'
+require 'og/relation/refers_to'

data/lib/og/relation/belongs_to.rb

@@ -6,7 +6,10 @@ class BelongsTo < RefersTo
 
   def enchant
     super
-    target_class.meta :descendants, [owner_class, foreign_key]
+    unless target_class.ann.this[:descendants]
+      target_class.ann(:this, :descendants => [])
+    end
+    target_class.ann.this.descendants! << [owner_class, foreign_key]
   end
   
 end

data/lib/og/relation/has_many.rb

@@ -19,7 +19,7 @@ end
 
 class HasMany < Relation
   def resolve_polymorphic
-    if target_class.relations
+    unless target_class.relations.empty?
       unless target_class.relations.find { |r| r.is_a?(BelongsTo) and  r.target_class == owner_class }
         target_class.belongs_to(owner_class)      
       end
@@ -29,7 +29,7 @@ class HasMany < Relation
   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}"
+    self[:foreign_key] = "#{foreign_name || owner_singular_name}_#{owner_class.primary_key}"
     # gmosx: DON'T set self[:foreign_field]
     foreign_field = self[:foreign_field] || self[:foreign_key]
     
@@ -55,17 +55,18 @@ class HasMany < Relation
 
       def add_#{target_singular_name}(obj, options = nil)
         return unless obj
-        obj.#{foreign_key} = @#{owner_pk}
+        obj.#{foreign_key} = @#{owner_class.primary_key}
         obj.save
       end
 
       def remove_#{target_singular_name}(obj)
         obj.#{foreign_key} = nil
+        obj.save
       end
       
       def find_#{target_plural_name}(options = {})
         find_options = {
-          :condition => "#{foreign_field} = \#{og_quote(@#{owner_pk})}"
+          :condition => "#{foreign_field} = \#{og_quote(#{owner_class.primary_key})}"
         }
         if options
           if condition = options.delete(:condition)
@@ -77,7 +78,7 @@ class HasMany < Relation
       end
       
       def count_#{target_plural_name}
-        #{target_class}.count(:condition => "#{foreign_field} = \#{og_quote(@#{owner_pk})}")        
+        #{target_class}.count(:condition => "#{foreign_field} = \#{og_quote(#{owner_class.primary_key})}")        
       end
     }
   end

data/lib/og/relation/joins_many.rb

@@ -28,25 +28,26 @@ class JoinsMany < Relation
     # handle schema_inheritance
     
     join_class = owner_class
-    if sclass = owner_class.metadata.superclass
-      join_class = sclass.first
+    if sclass = owner_class.ann.this[:superclass]
+      join_class = sclass
     end
     join_table_info = store.join_table_info(join_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)
+      through = Relation.symbol_to_class(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
+      # Create a join table.
+      owner_class.ann :this, :join_tables => []
+      owner_class.ann.this.join_tables! << join_table_info
     end
     
-    owner_key = join_table_info[:owner_key]
-    target_key = join_table_info[:target_key]
+    owner_key = join_table_info[:owner_key]
+    target_key = join_table_info[:target_key]
 
     owner_class.module_eval %{ 
       attr_accessor :#{target_plural_name}
@@ -82,8 +83,8 @@ class JoinsMany < Relation
       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}\}"          
+          :join_condition => "#{join_table}.#{target_key}=\#{#{target_class}::OGTABLE}.oid",
+          :condition => "#{join_table}.#{owner_key}=\#\{#{owner_class.primary_key}\}"          
         }
         if options
           if condition = options.delete(:condition)
@@ -101,8 +102,8 @@ class JoinsMany < Relation
       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}\}"          
+          :join_condition => "#{join_table}.#{target_key}=\#{#{target_class}::OGTABLE}.oid",
+          :condition => "#{join_table}.#{owner_key}=\#\{#{owner_class.primary_key}\}"          
         }
         #{target_class}.find(find_options).size
       end
@@ -111,7 +112,7 @@ class JoinsMany < Relation
     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}")
+          #{through}.find_one(:condition => "#{owner_key}=\#{#{owner_class.primary_key}} and #{target_key}=\#{t.pk}")
         end
       }
     end    

data/lib/og/relation/refers_to.rb

@@ -5,7 +5,7 @@ module Og
 class RefersTo < Relation
 
   def enchant
-    self[:foreign_key] = "#{foreign_name || target_singular_name}_#{target_pk}"
+    self[:foreign_key] = "#{foreign_name || target_singular_name}_#{target_class.primary_key}"
 
     if self[:field]
       field = ", :field => :#{self[:field]}"
@@ -13,7 +13,7 @@ class RefersTo < Relation
 
     owner_class.module_eval %{
       attr_accessor :#{target_singular_name}
-      prop_accessor :#{foreign_key}, #{target_pkclass}#{field}, :relation => true
+      prop_accessor :#{foreign_key}, #{target_class.primary_key.klass}#{field}, :relation => true
 
       def #{target_singular_name}(reload = false)
         return nil if @#{foreign_key}.nil? 
@@ -26,7 +26,7 @@ class RefersTo < Relation
       end
 
       def #{target_singular_name}=(obj)
-        @#{foreign_key} = obj.#{target_pk} if obj
+        @#{foreign_key} = obj.#{target_class.primary_key} if obj
       end
     }    
   end

data/lib/og/store.rb

@@ -55,15 +55,15 @@ class Store
       meta :index, arg 
     end
 
-    pk = klass.primary_key.first
+    pk = klass.primary_key.symbol
 
     klass.module_eval %{
       def saved?
-        return @#{klass.primary_key.first}
+        return #{klass.primary_key.symbol}
       end
 
       def unsaved?
-        return !@#{klass.primary_key.first}
+        return !#{klass.primary_key.symbol}
       end
 
       # Evaluate an alias for the primary key.
@@ -72,7 +72,7 @@ class Store
       alias_method :pk=, :#{pk}=
       
       def self.pk_symbol
-        :#{klass.primary_key.first}
+        :#{klass.primary_key.symbol}
       end
     }
     
@@ -80,16 +80,16 @@ class Store
   
     code = ''
     
-    for p in klass.properties
-      # gmosx: :uniq does NOT set a unique constrain in the
+    for p in klass.properties.values
+      # gmosx: :uniq does NOT set a unique constraint in the
       # database.
-      finder = p.meta[:uniq] || p.meta[:unique] ? 'find_one' : 'find'
+      finder = p.uniq || p.unique ? 'find_one' : 'find'
       
       code << %{
-        def self.find_by_#{p.symbol}(val, operator = '=', options = {})
+        def self.find_by_#{p}(val, operator = '=', options = {})
           options.update(
             :class => #{klass},
-            :condition => "#{p.meta[:field] || p.symbol}\#{operator}\#{ogmanager.store.quote(val)}"
+            :condition => "#{p.field || p}\#{operator}\#{ogmanager.store.quote(val)}"
           )
           ogmanager.store.#{finder}(options)
         end; 

data/lib/og/store/alpha/kirby.rb

@@ -0,0 +1,284 @@
+begin
+  require 'lib/vendor/kirbybase'
+rescue Object => ex
+  Logger.error 'KirbyBase is not installed!'
+  Logger.error ex
+end
+
+require 'og/store/sql'
+
+module Og
+
+# A Store that persists objects into an KirbyBase database.
+# KirbyBase is a pure-ruby database implementation.
+# To read documentation about the methods, consult the 
+# documentation for SqlStore and Store.
+
+class KirbyStore < SqlStore
+
+  def self.db_dir(options)
+    "#{options[:name]}_db"
+  end
+  
+  def self.destroy(options)
+    begin
+      FileUtils.rm_rf(db_dir(options))  
+      super
+    rescue Object
+      Logger.info "Cannot drop '#{options[:name]}'!"
+    end
+  end
+
+  def initialize(options)
+    super
+    
+    if options[:embedded]
+      name = self.class.db_dir(options)
+      FileUtils.mkdir_p(name)
+      @conn = KirbyBase.new(:local, nil, nil, name)
+    else
+      # TODO
+    end
+  end
+
+  def close
+    super
+  end
+  
+  def enchant(klass, manager)
+    klass.property :oid, Fixnum, :sql => 'integer PRIMARY KEY'
+    super
+  end
+
+  def query(sql)
+    Logger.debug sql if $DBG
+    return @conn.query(sql)
+  rescue => ex
+    handle_sql_exception(ex, sql)
+  end
+
+  def exec(sql)
+    Logger.debug sql if $DBG
+    @conn.query(sql).close
+  rescue => ex
+    handle_sql_exception(ex, sql)
+  end
+
+  def start
+    # nop
+  end
+  
+  def commit
+    # nop
+  end
+  
+  def rollback
+    # nop
+  end
+
+private
+
+  def create_table(klass)
+    fields = fields_for_class(klass)
+
+    table = @conn.create_table(klass::OGTABLE, *fields) { |obj| obj.encrypt = false }
+
+    # Create join tables if needed. Join tables are used in
+    # 'many_to_many' relations.
+    
+     if klass.__meta and join_tables = klass.__meta[:join_tables] 
+      for join_table in join_tables
+        begin
+          @conn.create_table(join_table[:table],
+            join_table[:first_key], :Integer,
+            join_table[:second_key], :Integer)
+            # KirbyBase doesn't support indices.
+        rescue RuntimeError => error
+          # Unfortunately, KirbyBase just throws RuntimeErrors
+          # with no extra information, so we just have to look
+          # for the error message it uses.
+          if error.message =~ /table #{join_table[:table]} already exists/i          
+            Logger.debug 'Join table already exists' if $DBG
+          else
+            raise
+          end
+        end
+      end
+    end
+  end
+
+  def drop_table(klass)
+    @conn.drop_table(klass.table) if @conn.table_exists?(klass.table)
+  end
+
+  def fields_for_class(klass)
+    fields = []
+  
+    klass.properties.each do |p|
+      klass.index(p.symbol) if p.meta[:index]
+      
+      fields << p.symbol
+      
+      type = p.klass.name.intern
+      type = :Integer if type == :Fixnum
+      
+      fields << type
+    end
+
+    return fields
+  end
+
+  def create_field_map(klass)
+    map = {}
+    fields = @conn.get_table(klass.table).field_names
+
+    fields.size.times do |i|
+      map[fields[i]] = i
+    end
+  
+    return map
+  end
+
+  # Return an sql string evaluator for the property.
+  # No need to optimize this, used only to precalculate code.
+  # YAML is used to store general Ruby objects to be more 
+  # portable.
+  #--
+  # FIXME: add extra handling for float.
+  #++
+  
+  def write_prop(p)
+    if p.klass.ancestors.include?(Integer)
+      return "@#{p.symbol} || nil"
+    elsif p.klass.ancestors.include?(Float)
+      return "@#{p.symbol} || nil"    
+    elsif p.klass.ancestors.include?(String)
+      return %|@#{p.symbol} ? "'#\{#{self.class}.escape(@#{p.symbol})\}'" : nil|
+    elsif p.klass.ancestors.include?(Time)
+      return %|@#{p.symbol} ? "'#\{#{self.class}.timestamp(@#{p.symbol})\}'" : nil|
+    elsif p.klass.ancestors.include?(Date)
+      return %|@#{p.symbol} ? "'#\{#{self.class}.date(@#{p.symbol})\}'" : nil|
+    elsif p.klass.ancestors.include?(TrueClass)
+      return "@#{p.symbol} ? \"'t'\" : nil"
+    else 
+      # gmosx: keep the '' for nil symbols.
+      return %|@#{p.symbol} ? "'#\{#{self.class}.escape(@#{p.symbol}.to_yaml)\}'" : "''"|
+    end
+  end    
+
+  # Return an evaluator for reading the property.
+  # No need to optimize this, used only to precalculate code.
+  
+  def read_prop(p, col)
+    if p.klass.ancestors.include?(Integer)
+      return "#{self.class}.parse_int(res[#{col} + offset])"
+    elsif p.klass.ancestors.include?(Float)
+      return "#{self.class}.parse_float(res[#{col} + offset])"
+    elsif p.klass.ancestors.include?(String)
+      return "res[#{col} + offset]"
+    elsif p.klass.ancestors.include?(Time)
+      return "#{self.class}.parse_timestamp(res[#{col} + offset])"
+    elsif p.klass.ancestors.include?(Date)
+      return "#{self.class}.parse_date(res[#{col} + offset])"
+    elsif p.klass.ancestors.include?(TrueClass)
+      return "('0' != res[#{col} + offset])"
+    else 
+      return "YAML::load(res[#{col} + offset])"
+    end        
+  end
+
+  # :section: Lifecycle method compilers.
+  
+  # Compile the og_update method for the class.
+
+  def eval_og_insert(klass)
+    pk = klass.pk_symbol
+    props = klass.properties
+    
+    data = props.collect {|p| ":#{p.symbol} => #{write_prop(p)}"}.join(', ')
+#    data.gsub!(/#|\{|\}/, '')
+
+    klass.module_eval %{ 
+      def og_insert(store)
+        #{Aspects.gen_advice_code(:og_insert, klass.advices, :pre) if klass.respond_to?(:advices)}
+        store.conn.get_table('#{klass.table}').insert(#{data})
+        #{Aspects.gen_advice_code(:og_insert, klass.advices, :post) if klass.respond_to?(:advices)}
+      end
+    }
+  end
+
+  # Compile the og_update method for the class.
+
+  def eval_og_update(klass)
+    pk = klass.pk_symbol
+    props = klass.properties.reject { |p| pk == p.symbol }
+    
+    updates = props.collect { |p|
+      "#{p.symbol}=#{write_prop(p)}"
+    }
+
+    sql = "UPDATE #{klass::OGTABLE} SET #{updates.join(', ')} WHERE #{pk}=#\{@#{pk}\}"
+
+    klass.module_eval %{
+      def og_update(store)
+        #{Aspects.gen_advice_code(:og_update, klass.advices, :pre) if klass.respond_to?(:advices)}
+        store.exec "#{sql}"
+        #{Aspects.gen_advice_code(:og_update, klass.advices, :post) if klass.respond_to?(:advices)}
+      end
+    }
+  end
+
+  # Compile the og_read method for the class. This method is 
+  # used to read (deserialize) the  given class from the store. 
+  # In order to allow for changing field/attribute orders a 
+  # field mapping hash is used.
+  
+  def eval_og_read(klass)
+    code = []
+    props = klass.properties 
+    field_map = create_field_map(klass)
+
+    props.each do |p|
+      if col = field_map[p.symbol]
+        code << "@#{p.symbol} = #{read_prop(p, col)}"
+      end
+    end
+    
+    code = code.join('; ')
+
+    klass.module_eval %{
+       def og_read(res, row = 0, offset = 0)
+        #{Aspects.gen_advice_code(:og_read, klass.advices, :pre) if klass.respond_to?(:advices)}
+        #{code}
+        #{Aspects.gen_advice_code(:og_read, klass.advices, :post) if klass.respond_to?(:advices)}
+      end
+    }
+  end        
+
+  #--
+  # FIXME: is pk needed as parameter?
+  #++
+  
+  def eval_og_delete(klass)
+    klass.module_eval %{
+       def og_delete(store, pk, cascade = true)
+        #{Aspects.gen_advice_code(:og_delete, klass.advices, :pre) if klass.respond_to?(:advices)}
+        pk ||= @#{klass.pk_symbol}
+        transaction do |tx|
+          tx.exec "DELETE FROM #{klass.table} WHERE #{klass.pk_symbol}=\#{pk}"
+          if cascade and #{klass}.__meta[:descendants]
+            #{klass}.__meta[:descendants].each do |dclass, foreign_key|
+              tx.exec "DELETE FROM \#{dclass::OGTABLE} WHERE \#{foreign_key}=\#{pk}"
+            end
+          end
+        end
+        #{Aspects.gen_advice_code(:og_delete, klass.advices, :post) if klass.respond_to?(:advices)}
+      end
+    }    
+  end
+
+end
+
+end
+
+# * George Moschovitis <gm@navel.gr>