og 0.31.0 → 0.40.0

data/lib/og/adapter/postgresql/utils.rb

@@ -0,0 +1,35 @@
+require 'og/store/sql/utils'
+
+module Og
+
+module PostgresqlUtils
+  include SqlUtils
+  
+  def escape(str)
+    return nil unless str
+    return PGconn.escape(str.to_s)
+  end
+
+  # Blobs are actually a lot faster (and use up less 
+  # storage) for large data I think, as they need not to be 
+  # encoded and decoded. I'd like to have both ;-) BYTEA is 
+  # easier to handle than BLOBs, but if you implement BLOBs in a way
+  # that they are transparent to the user (as I did in Ruby/DBI), 
+  # I'd prefer that way.
+  
+  def blob(val)
+    val.gsub(/[\000-\037\047\134\177-\377]/) do |b|
+      "\\#{ b[0].to_s(8).rjust(3, '0') }" 
+    end
+  end  
+  
+  def parse_blob(val)
+    return '' unless val
+    
+    val.gsub(/\\(\\|'|[0-3][0-7][0-7])/) do |s|
+      if s.size == 2 then s[1,1] else s[1,3].oct.chr end
+    end
+  end 
+end
+
+end

data/lib/og/adapter/sqlite.rb

@@ -0,0 +1,132 @@
+begin
+  require 'sqlite3'
+rescue Object => ex
+  Logger.error 'Ruby-Sqlite3 bindings are not installed!'
+  Logger.error ex
+end
+
+require 'fileutils'
+require 'set'
+
+require 'og/store/sql'
+require 'og/adapter/sqlite/override'
+
+module Og
+
+# A Store that persists objects into an Sqlite3 database.
+#
+# As well as the usual options to the constructor, you can also pass a
+# :busy_timeout option which defines how quickly to retry a query, should the
+# database be locked. The default value is 50ms. The retry will currently
+# continue until successful.
+#
+# To read documentation about the methods, consult the documentation
+# for SqlStore and Store.
+
+class SqliteAdapter < SqlStore
+  include SqlUtils; extend SqlUtils
+
+  # Initialize the Sqlite store.
+  # This store provides a default name.
+  
+  def initialize(options)
+    super
+    @busy_timeout = (options[:busy_timeout] || 50)/1000
+    @conn = SQLite3::Database.new(db_filename(options))
+  end
+
+  def close
+    @conn.close
+    super
+  end
+
+  # Override if needed.
+
+  def db_filename(options)
+    options[:name] ||= 'data'
+    if options[:name] == ':memory:'
+      ':memory:'
+    else
+      "#{options[:name]}.db"
+    end
+  end
+
+  def destroy_db(options)
+    begin
+      FileUtils.rm(db_filename(options))  
+      super
+    rescue Errno::ENOENT => ex # FIXME: Lookup Win32/Linux/BSD error
+      Logger.info "Cannot drop '#{options[:name]}'!"
+    end
+  end
+
+  # The type used for default primary keys.
+  
+  def primary_key_type
+    'integer PRIMARY KEY'
+  end
+
+  def query_statement(sql)
+    return query(sql)
+  end
+
+  def exec_statement(sql)
+    query(sql).close()
+  end
+
+  def start
+    @conn.transaction if @transaction_nesting < 1
+    @transaction_nesting += 1
+  end
+
+  def commit
+    @transaction_nesting -= 1
+    @conn.commit if @transaction_nesting < 1
+  end
+
+  def rollback
+    @transaction_nesting -= 1
+    @conn.rollback if @transaction_nesting < 1
+  end
+
+  def sql_update(sql)
+    exec(sql)
+    @conn.changes
+  end
+
+  def last_insert_id(klass = nil)
+    query("SELECT last_insert_rowid()").first_value.to_i
+  end
+
+  # Returns the Sqlite information of a table within the database or
+  # nil if it doesn't exist. Mostly for internal usage.
+
+  def table_info(table)
+    r = query_statement("SELECT name FROM sqlite_master WHERE type='table' AND name='#{self.class.escape(table.to_s)}'");
+    return r && r.blank? ? nil : r.next
+  end
+
+  # SQLite send back a BusyException if the database is locked.
+  # Currently we keep sending the query until success or the universe implodes.
+  # Note that the SQLite3 ruby library provides a busy_timeout, and busy_handler
+  # facility, but I couldn't get the thing to work.
+  def query(sql)
+    begin
+      return @conn.query(sql)
+    rescue SQLite3::BusyException
+      sleep(@busy_timeout)
+      retry
+    end
+  end
+
+private
+
+  # gmosx: any idea how to better test this?
+
+  def table_already_exists_exception?(ex)
+    ex.to_s =~ /table .* already exists/i
+  end    
+
+end
+
+end

data/lib/og/adapter/sqlite/override.rb

@@ -0,0 +1,33 @@
+#--
+# Customize the standard Sqlite3 resultset to make
+# more compatible with Og.
+#++
+
+module SQLite3 # :nodoc: all
+
+class ResultSet # :nodoc: all
+  alias_method :blank?, :eof?
+
+  def each_row
+    each do |row|
+      yield(row, 0)
+    end
+  end
+
+  def first_value
+    val = self.next[0]
+    close
+    return val
+  end
+
+  alias_method :fields, :columns
+end
+
+class SQLException # :nodoc: all
+  def table_already_exists?
+    # gmosx: any idea how to better test this?
+    self.to_s =~ /table .* already exists/i
+  end    
+end
+
+end

data/lib/og/adapter/sqlite/script.rb

@@ -0,0 +1,15 @@
+# Helper for sqlite scripts.
+#
+# === Example
+#
+# sqlite 'filename', %{
+#   drop database if exists weblog_development;
+#   create database weblog_development;
+#   grant all on weblog_development.* to #{`id -un`.strip}@localhost;
+# }
+
+def sqlite(opts, stream)
+  IO.popen("mysql #{opts}", 'w') do |io| 
+    io.puts stream
+  end
+end

data/lib/og/collection.rb

@@ -15,6 +15,14 @@ class Collection
   
   attr_accessor :members
 
+  # When the collection is in building mode or the owner
+  # object is unsaved, added members are accumulated in the
+  # building_memebers array. These relations are serialized
+  # when the owner object is saved (or when save_building_members
+  # is explicitly called).
+  
+  attr_accessor :building_members
+  
   # The class of the members of this collection.
 
   attr_accessor :member_class
@@ -114,13 +122,21 @@ class Collection
   
   # Add a new member to the collection.
   # this method will overwrite any objects already
-  # existing in the collection
+  # existing in the collection.
+  #
+  # If the collection is in build mode or the object
+  # is unsaved, the member is accumulated in a buffer. All
+  # accumulated members relations are saved when the object
+  # is saved.
   
   def push(obj, options = nil)
     remove(obj) if members.include?(obj)
-    @members.push(obj)
+    @members << obj
     unless @building or owner.unsaved?
       @owner.send(@insert_proc, obj, options)
+    else
+      (@building_members ||= []) << obj
+      @owner.instance_variable_set '@pending_building_collections', true
     end
   end
   alias_method :<<, :push
@@ -217,17 +233,32 @@ class Collection
   # Allows to perform a scoped query.
   
   def find(options = {})
+    tmp = nil
     @member_class.with_scope(options) do
-      return @owner.send(@find_proc, @find_options)    
+      tmp = @owner.send(@find_proc, @find_options)
     end
+    return tmp
   end
 
   # Find one object.
   
-  def find_one(options = {})
+  def find_one options = {}
     find(options).first
   end
 
+  # In building mode, relations for this collection are 
+  # accumulated in @building_relations. These relations are
+  # saved my calling this method.
+  
+  def save_building_members(options = nil)
+    return unless @building_members
+    
+    for obj in @building_members
+      @owner.send(@insert_proc, obj, options)
+    end
+    @building_members = nil
+  end
+  
   # Try to execute an accumulator or else
   # redirect all other methods to the members array.
   #
@@ -252,6 +283,3 @@ private
 end
 
 end
-
-# * George Moschovitis <gm@navel.gr>
-# * Julien Perrot <jperrot@exosec.fr>

data/lib/og/{evolution.rb → dump.rb}

@@ -3,10 +3,10 @@ require 'fileutils'
 require 'facet/kernel/constant'
 require 'facet/kernel/assign_with'
 
-# $DBG = true
-
 module Og
 
+# Add import/export functionality to the Og Manager.
+
 class Manager
   
   # Dump Og managed objects to the filesystem.
@@ -23,7 +23,7 @@ class Manager
       File.open("#{basedir}/#{c}.yml", 'w') { |f| f << all.to_yaml }
     end
   end
-  alias_method :export, :dump
+  alias export dump
   
   # Load Og managed objects from the filesystem. This method can apply
   # optional transformation rules in order to evolve a schema.
@@ -70,8 +70,7 @@ class Manager
       end
     end
   end
-  alias_method :import, :load
-  alias_method :evolve, :load
+  alias import load
   
 end
   

data/lib/og/entity.rb

@@ -1,18 +1,15 @@
 require 'facets/core/module/class_extension'
-require 'facet/kernel/assign_with'
+require 'facets/core/kernel/assign_with'
 
-require 'glue/property'
 require 'og/relation'
 require 'og/ez/clause'
 require 'og/ez/condition'
 
-require 'rexml/document'  # for to_xml
-
 module Og
 
 # Include this module to classes to make them managable by Og.
 #--
-# gmosx, WARTNING: If you change the methods here, don't 
+# gmosx, WARNING: If you change the methods here, don't 
 # forget to update the Cacheable overrides.
 #++
 
@@ -33,8 +30,8 @@ module EntityMixin
   def save(options = nil)
     self.class.ogmanager.store.save(self, options)
   end
-  alias_method :save!, :save
-  alias_method :validate_and_save, :save
+  alias save! save
+  alias validate_and_save save
 
   # Force saving of the objects, even if the validations
   # don't pass.
@@ -56,24 +53,60 @@ module EntityMixin
     self.class.ogmanager.store.update(self, options)
   end
 
-  def update_properties(*properties)
-    self.class.ogmanager.store.update(self, :only => properties)
+  def update_attributes(*attrs)
+    self.class.ogmanager.store.update(self, :only => attrs)
   end
-  alias_method :update_property, :update_properties
-  alias_method :pupdate, :update_properties
+  alias update_attribute update_attributes
+  alias aupdate update_attributes
+  # For backwards compatibility, deprecated.
+  alias update_properties update_attributes
+  alias update_property update_attributes
 
   def update_by_sql(set)
     self.class.ogmanager.store.update_by_sql(self, set)
   end
-  alias_method :update_sql, :update_by_sql
-  alias_method :supdate, :update_by_sql
+  alias update_sql update_by_sql
+  alias supdate update_by_sql
+
+  # Set attributes (update + save).
+  #
+  # === Examples
+  #
+  # a = Article[oid]
+  # a.set_attributes :accepted => true, :update_time => Time.now
+  # a.set_attribute :accepted => true
+  #
+  #--
+  # gmosx, THINK: maybe make this the default behaviour of
+  # update_attributes?
+  #++
+
+  def set_attributes(attrs = {})
+    for a, val in attrs
+      instance_variable_set "@#{a}", val  
+    end
+    update_attributes(*attrs.keys)
+  end
+  alias set_attribute set_attributes
+
+  # Set attribute (like instance_variable_set)
+  #
+  # === Example
+  #
+  # a = Article[oid]
+  # a.instance_attribute_set :accepted, true
+
+  def instance_attribute_set(a, val)
+    instance_variable_set "@#{a}", val
+    update_attribute(a.to_sym)
+  end  
 
   # Reload this entity instance from the store.
 
   def reload
     self.class.ogmanager.store.reload(self, self.pk)
   end
-  alias_method :reload!, :reload
+  alias reload! reload
 
   # Delete this entity instance from the store.
 
@@ -93,11 +126,11 @@ module EntityMixin
   end
   alias_method :serialized?, :saved?
 
-  def assign_properties(values, options = {})
-    Property.populate_object(self, values, options)
+  def assign_attributes(values, options = {})
+    AttributeUtils.populate_object(self, values, options)
     return self
   end
-  alias_method :assign, :assign_properties
+  alias_method :assign, :assign_attributes
 
   # Returns a symbol => value hash of the object's 
   # properties.
@@ -109,36 +142,37 @@ module EntityMixin
     end
   end
 
-  def og_quote(obj)
-    self.class.ogmanager.store.quote(obj)
-  end
+  # Save all building collections. Transparently called
+  # when saving an object, allows efficient object relationship
+  # setup. Example:
+  #
+  # a = Article.new
+  # a.categories << c1
+  # a.categories << c2
+  # a.tags << t1
+  # a.tags << t2
+  # a.save
+  #
+  #-- 
+  # TODO: at the moment, this only handles collection relations.
+  # Should handle belongs_to/refers_to as well.
+  #++
   
-  def og_clone(*args)
-    Og::Entity.clone(self,*args)
-  end  
-  
-  # convert Og object to REXML-Object
-  # example usage:
-  # User[1].to_rexml
-
-  def to_rexml
-    xml = REXML::Element.new(self.class.to_s.downcase)
-    xml.add_attribute("oid", self.oid.to_s)
-    self.class.properties.keys.each do |key|
-      xml << REXML::Element.new(key.to_s).add_text(self.send(key).to_s) unless key == :oid
+  def save_building_collections(options = nil)
+    if @pending_building_collections
+      for rel in self.class.relations
+        next unless rel.class.ann.self.collection?
+        collection = send(rel.name.to_s)
+        collection.save_building_members
+      end
+      @pending_building_collections = false
     end
-    return xml
-  end
-  alias_method :to_xml_dom, :to_rexml
-  
-  # convert Og object to an XML-String
-  # example usage:
-  # User[1].to_xml
-  
-  def to_xml
-    self.to_rexml.to_s
   end
 
+  def og_quote(obj)
+    self.class.ogmanager.store.quote(obj)
+  end
+  
   include RelationDSL
 
   class_extension do
@@ -161,16 +195,25 @@ module EntityMixin
       return obj
     end
 
-    def assign_properties(values, options = {})
-      Property.populate_object(self.new, values, options)
+    def assign_attributes(values, options = {})
+      AttributeUtils.populate_object(self.new, values, options)
     end
-    alias_method :assign, :assign_properties
+    alias_method :assign, :assign_attributes
 
     # Load an instance of this Entity class using the primary
-    # key.
+    # key. If the class defines a text key, this string key
+    # may optionally be used!
 
     def load(pk)
-      ogmanager.store.load(pk, self)
+      # gmosx: leave the checks in this order (optimized)
+      if pk.to_i == 0 and (key = ann.self[:text_key]) 
+        # A string is passed as pk, try to use it as a 
+        # tesxt key too.
+        send("find_by_#{key}", pk)
+      else
+        # A valid pk is always > 0
+        ogmanager.store.load(pk, self)
+      end
     end
     alias_method :[], :load
     alias_method :exist?, :load
@@ -375,14 +418,7 @@ module EntityMixin
     # Returns the primary key for this class.
     
     def primary_key
-      # gmosx: LEAVE as is, seems to be a workaround for a
-      # nasty bug in the current facets version.
-      pk = ann.self.primary_key
-      if pk.nil?
-        pk = Entity.resolve_primary_key(self)
-        ann :self, :primary_key => pk
-      end
-      return pk
+      Entity.resolve_primary_key(self)
     end
 
     # Set the default find options for this entity.
@@ -446,8 +482,8 @@ module EntityMixin
     # Set the primary key.
 
     def set_primary_key(pk, pkclass = Fixnum)
-      #ann self, :primary_key => Property.new(:symbol => pk, :klass => pkclass)
-      ann self, :primary_key => properties[pk].dup
+      self.ann[pk].primary_key = true
+      self.ann[pk].class ||= pkclass
     end
 
     # Is this entity a polymorphic parent?
@@ -615,9 +651,8 @@ private
           field_name = relation.foreign_key
           value = value.send(relation.target_class.primary_key.symbol)          
         else
-          field_name = properties[name.to_sym][:field] ||
-            properties[name.to_sym][:name] ||
-            properties[name.to_sym][:symbol]
+          anno = ann(name.to_sym)
+          field_name = anno[:field] || anno[:name] || name.to_sym
           end
         options["#{name}_op".to_sym] = 'IN' if value.is_a?(Array)
         %|#{field_name} #{options.delete("#{name}_op".to_sym) || '='} #{ogmanager.store.quote(value)}|
@@ -645,23 +680,18 @@ class Entity
   class << self
 
     def resolve_primary_key(klass)
-      # Is the class annotated with a primary key?
-
-      if pk = klass.ann.self[:primary_key]
-        return pk
-      end
-
       # Search the properties, try to find one annotated as primary_key.
 
-      for p in klass.properties.values
-        if p.primary_key
-          return Property.new(:symbol => p.symbol, :klass => p.klass)
+      for a in klass.attributes
+        anno = klass.ann(a)
+        if anno.primary_key?
+          return a
         end
       end
 
       # The default primary key is oid.
 
-      return Property.new(:symbol => :oid, :klass => Fixnum)
+      return :oid
     end
 
     # Converts a string into it's corresponding class. Added to support STI.
@@ -673,7 +703,7 @@ class Entity
     
     def entity_from_string(str)
       res = nil
-      Og::Manager.managed_classes.each do |klass|
+      Og.manager.managed_classes.each do |klass|
         if klass.name == str
           res = klass
           break
@@ -681,110 +711,9 @@ class Entity
       end
       res
     end
-
-    # 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
 
 end
-
-# * George Moschovitis <gm@navel.gr>
-# * Tom Sawyer <transfire@gmail.com>
-# * Rob Pitt <rob@motionpath.com>
-# * Fabian Buch <fabian@fabian-buch.de>