og 0.31.0 → 0.40.0

data/lib/og/store/sql/evolution.rb

@@ -0,0 +1,119 @@
+module Og
+
+#--
+# Implement Og's automatic schema evolution features.
+# Add schema evolution related methods to SqlStore.
+#++
+
+module Evolution
+
+  #--
+  # Override if needed in the actual Adapter implementation.
+  #++
+  
+  def add_sql_field(klass, a, anno)
+    Logger.info "Adding field '#{a}' to '#{klass.table}'"
+    query "ALTER TABLE #{klass.table} ADD COLUMN #{field_sql_for_attribute a, anno}"
+  end
+  alias add_sql_column add_sql_field
+  
+  #--
+  # Override if needed in the actual Adapter implementation.
+  #++
+  
+  def remove_sql_field(klass, a)
+    Logger.info "Removing field '#{a}' from '#{klass.table}'"
+    query "ALTER TABLE #{klass.table} DROP COLUMN #{a}"
+  end
+  alias add_sql_column add_sql_field
+
+  #--
+  # Override if needed in the actual Adapter implementation.
+  #++
+
+  def rename_sql_table(_old, _new)
+    Logger.info "Rename table '#{_old}' to '#{_new}'"
+    query "ALTER TABLE #{_old} RENAME #{_new}"
+  end
+  
+  # Evolve the schema (table in sql stores) for the given
+  # class. Compares the fields in the database schema with
+  # the serializable attributes of the given class and tries
+  # to fix mismatches by adding are droping columns.
+  #
+  # === Evolution options
+  # 
+  # * :evolve_schema => :add (only add, dont remove columns)
+  # * :evolve_schema => :full (add and delete columns)
+  # * :evolve_schema => :warn (only emit warnings, DEFAULT_
+  # * :evolve_schema => false (no evolution)
+  #
+  # === Example
+  #
+  # Og.setup(
+  #   ..
+  #   :evolve_schema => :full
+  #   ..
+  # )
+
+  def evolve_schema(klass)
+    return unless @options[:evolve_schema]
+
+    sql_fields = create_field_map(klass).keys
+    attrs = klass.serializable_attributes
+
+    # Add new fields to the table.
+    
+    for field in attrs
+      unless sql_fields.include? field
+        unless @options[:evolve_schema] == :warn
+          add_sql_field klass, field, klass.ann(field)
+        else
+          Logger.warn "Missing field '#{field}' on table '#{klass.table}'!"
+        end
+      end
+    end
+      
+    # Remove obsolete fields from the table.
+   
+    for field in sql_fields
+      unless attrs.include? field
+        if @options[:evolve_schema] == :full 
+          remove_sql_field klass, field
+        else
+          Logger.warn "Obsolete field '#{field}' found on table '#{klass.table}'!"
+        end
+      end
+    end   
+  end
+
+  # Renames the schema (table in sql stores) for the given
+  # class. 
+  #
+  # === Input
+  #
+  # * new_schema = the new schema (Class or table name)
+  # * old_schema = the old schema (Class or table name)
+  #
+  # === Example
+  #
+  # store.rename_schema(TicketArticle, Ticket::Article)
+  
+  def rename_schema(old_schema, new_schema)
+    if old_schema.is_a? Class
+      old_schema = table(old_schema)
+    end
+
+    if new_schema.is_a? Class
+      new_schema = table(new_schema)
+    end
+
+    rename_sql_table(old_schema, new_schema)     
+  end
+  
+end
+
+SqlStore.send :include, Evolution
+
+end
+

data/lib/og/store/sql/join.rb

@@ -0,0 +1,155 @@
+module Og
+
+# Add join related utility methods in SqlUtils.
+
+module SqlUtils
+
+  def join_object_ordering(obj1, obj2)
+    if obj1.class.to_s <= obj2.class.to_s
+      return obj1, obj2
+    else
+      return obj2, obj1, true
+    end
+  end
+
+  def join_class_ordering(class1, class2)
+    if class1.to_s <= class2.to_s
+      return class1, class2
+    else
+      return class2, class1, true
+    end
+  end
+
+  def build_join_name(class1, class2, postfix = nil)
+    # Don't reorder arguments, as this is used in places that
+    # have already determined the order they want.
+    "#{Og.table_prefix}j_#{tableize(class1)}_#{tableize(class2)}#{postfix}"
+  end
+
+  def join_table(class1, class2, postfix = nil)
+    first, second = join_class_ordering(class1, class2)
+    build_join_name(first, second, postfix)
+  end
+
+  def join_table_index(key)
+    "#{key}_idx"
+  end
+
+  def join_table_key(klass)
+    klass = klass.schema_inheritance_root_class if klass.schema_inheritance_child?
+    "#{klass.to_s.demodulize.underscore.downcase}_oid"
+  end
+
+  def join_table_keys(class1, class2)
+    if class1 == class2
+      # Fix for the self-join case.
+      return join_table_key(class1), "#{join_table_key(class2)}2"
+    else
+      return join_table_key(class1), join_table_key(class2)
+    end
+  end
+
+  def ordered_join_table_keys(class1, class2)
+    first, second = join_class_ordering(class1, class2)
+    return join_table_keys(first, second)
+  end
+
+  def join_table_info(relation, postfix = nil)
+
+    # some fixes for schema inheritance.
+
+    owner_class, target_class = relation.owner_class, relation.target_class
+    
+    raise "Undefined owner_class in #{target_class}" unless owner_class
+    raise "Undefined target_class in #{owner_class}" unless target_class
+    
+    owner_class = owner_class.schema_inheritance_root_class if owner_class.schema_inheritance_child?
+    target_class = target_class.schema_inheritance_root_class if target_class.schema_inheritance_child?
+
+    owner_key, target_key = join_table_keys(owner_class, target_class)
+    first, second, changed = join_class_ordering(owner_class, target_class)
+
+    if changed
+      first_key, second_key = target_key, owner_key
+    else
+      first_key, second_key = owner_key, target_key
+    end
+
+    table = (relation.table ?
+      relation.table :
+      join_table(owner_class, target_class, postfix)
+    )
+    
+    return {
+      :table => table,
+      :owner_key => owner_key,
+      :owner_table => table(owner_class),
+      :target_key => target_key,
+      :target_table => table(target_class),
+      :first_table => table(first),
+      :first_key => first_key,
+      :first_index => join_table_index(first_key),
+      :second_table => table(second),
+      :second_key => second_key,
+      :second_index => join_table_index(second_key)
+    }
+  end
+
+  # Subclasses can override this if they need a different 
+  # syntax.
+
+  def create_join_table_sql(join_table_info, suffix = 'NOT NULL', key_type = 'integer')
+    join_table = join_table_info[:table]
+    first_index = join_table_info[:first_index]
+    first_key = join_table_info[:first_key]
+    second_key = join_table_info[:second_key]
+    second_index = join_table_info[:second_index]
+
+    sql = []
+
+    sql << %{      
+      CREATE TABLE #{join_table} (
+        #{first_key} integer NOT NULL,
+        #{second_key} integer NOT NULL,
+        PRIMARY KEY(#{first_key}, #{second_key})
+      )
+    }
+
+    # gmosx: not that useful?
+    # sql << "CREATE INDEX #{first_index} ON #{join_table} (#{first_key})"
+    # sql << "CREATE INDEX #{second_index} ON #{join_table} (#{second_key})"
+
+    return sql
+  end
+
+end
+
+# Extends SqlStore by adding join related methods.
+
+class SqlStore < Store
+
+  # Relate two objects through an intermediate join table.
+  # Typically used in joins_many and many_to_many relations.
+
+  def join(obj1, obj2, table, options = nil)
+    first, second = join_object_ordering(obj1, obj2)
+    first_key, second_key = ordered_join_table_keys(obj1.class, obj2.class)
+    if options
+      exec "INSERT INTO #{table} (#{first_key},#{second_key}, #{options.keys.join(',')}) VALUES (#{first.pk},#{second.pk}, #{options.values.map { |v| quote(v) }.join(',')})"
+    else
+      exec "INSERT INTO #{table} (#{first_key},#{second_key}) VALUES (#{first.pk}, #{second.pk})"
+    end
+  end
+
+  # Unrelate two objects be removing their relation from the
+  # join table.
+
+  def unjoin(obj1, obj2, table)
+    first, second = join_object_ordering(obj1, obj2)
+    first_key, second_key = ordered_join_table_keys(obj1.class, obj2.class)
+    exec "DELETE FROM #{table} WHERE #{first_key}=#{first.pk} AND #{second_key}=#{second.pk}"    
+  end
+
+end
+
+end

data/lib/og/store/sql/utils.rb

@@ -0,0 +1,149 @@
+require 'time'
+
+module Og
+
+# A collection of useful SQL utilities.
+
+module SqlUtils
+
+  # Escape an SQL string
+
+  def escape(str)
+    return nil unless str
+    return str.gsub(/'/, "''")
+  end
+
+  # Convert a ruby time to an sql timestamp.
+  #--
+  # TODO: Optimize this.
+  #++
+
+  def timestamp(time = Time.now)
+    return nil unless time
+    return time.strftime("%Y-%m-%d %H:%M:%S")
+  end
+
+  # Output YYY-mm-dd
+  #--
+  # TODO: Optimize this.
+  #++
+
+  def date(date)
+    return nil unless date
+    return "#{date.year}-#{date.month}-#{date.mday}" 
+  end
+
+  #--
+  # TODO: implement me!
+  #++
+
+  def blob(val)
+    val
+  end
+
+  # Parse an integer.
+
+  def parse_int(int)
+    int = int.to_i if int
+    return int
+  end
+
+  # Parse a float.
+
+  def parse_float(fl)
+    fl = fl.to_f if fl
+    fl
+  end
+
+  # Parse sql datetime
+  #--
+  # TODO: Optimize this.
+  #++
+
+  def parse_timestamp(str)
+    return nil unless str
+    return Time.parse(str)    
+  end
+
+  # Input YYYY-mm-dd
+  #--
+  # TODO: Optimize this.
+  #++
+
+  def parse_date(str)
+    return nil unless str
+    return Date.strptime(str)
+  end
+
+  # Parse a boolean
+  # true, 1, t  => true
+  # other       => false
+
+  def parse_boolean(str)
+    return true if (str=='true' || str=='t' || str=='1')
+    return false
+  end
+
+  #--
+  # TODO: implement me!!
+  #++
+
+  def parse_blob(val)
+    val
+  end
+
+  # Escape the various Ruby types.
+
+  def quote(vals)
+    vals = [vals] unless vals.is_a?(Array)
+    quoted = vals.inject('') do |s,val|
+      s += case val
+        when Fixnum, Integer, Float
+          val ? val.to_s : 'NULL'
+        when String
+          val ? "'#{escape(val)}'" : 'NULL'
+        when Time
+          val ? "'#{timestamp(val)}'" : 'NULL'
+        when Date
+          val ? "'#{date(val)}'" : 'NULL'
+        when TrueClass, FalseClass
+          val ? "'t'" : 'NULL'
+        else
+          # gmosx: keep the '' for nil symbols.
+          val ? escape(val.to_yaml) : ''
+      end + ','
+    end
+    quoted.chop!
+    vals.size > 1 ? "(#{quoted})" : quoted
+  end
+
+  # Escape the Array Ruby type.
+
+  def quote_array(val)
+    case val
+      when Array
+        val.collect{ |v| quotea(v) }.join(',')
+      else
+        quote(val)
+    end
+  end
+  alias_method :quotea, :quote_array
+
+  # Apply table name conventions to a class name.
+
+  def tableize(klass)
+    "#{klass.to_s.gsub(/::/, "_").downcase}"
+  end
+
+  # Return the table name for the given class.
+  
+  def table(klass)
+    #klass.ann.self[:sql_table] || klass.ann.self[:table] || "#{Og.table_prefix}#{tableize(klass)}"
+    (klass.ann.self[:sql_table] rescue nil) ||
+      (klass.ann.self[:table] rescue nil) ||
+      "#{Og.table_prefix}#{tableize(klass)}"
+  end
+
+end
+
+end

data/lib/og/test/assertions.rb

@@ -141,7 +141,7 @@ module Test::Unit::Assertions
     assert_block(msg) { cookie.value == value }
   end
 
-  # :section: Glue::Template related assertions.
+  # :section: Nitro::Template related assertions.
   
   # :section: Redirection assertions.
 
@@ -171,5 +171,3 @@ module Test::Unit::Assertions
   end
 
 end
-
-# * George Moschovitis <gm@navel.gr>

data/lib/og/test/testcase.rb

@@ -51,5 +51,3 @@ class TestCase
 end
 
 end
-
-# * George Moschovitis <gm@navel.gr>

data/lib/og/types.rb

@@ -2,11 +2,11 @@ module Og
 
 # Some useful type macros to help when defining properties.
 # You can easily code your own type macros. Just return the 
-# array that should be passed to the property macro.
+# array that should be passed to the attr_xxx macros.
 #
 # === Example
 #
-# property :name, VarChar(30)
+# attr_accessor :name, VarChar(30)
 
 def self.VarChar(size)
   return String, :sql => "VARCHAR(#{size})"
@@ -17,6 +17,3 @@ NotNull = { :sql => 'NOT NULL' }.freeze
 Null = { :sql => 'NULL' }.freeze
 
 end
-
-# * Michael Neumann <mneumann@ntecs.de>
-# * George Moschovitis <gm@navel.gr>