og 0.24.0 → 0.25.0

data/lib/glue/revisable.rb

@@ -0,0 +1,2 @@
+
+raise 'This is not working yet, do not require this file.'

data/lib/glue/taggable.rb

@@ -0,0 +1,176 @@
+require 'nano/inflect'
+
+# The default Tag implementation. A tag attaches semantics to
+# a given object.
+#--
+# FIXME: use index and char() instead of String.
+#++
+
+class Tag
+  property :name, String, :uniq => true
+  property :count, Fixnum
+  
+  # An alias for count.
+  
+  alias_method :freq, :count
+  alias_method :frequency, :count  
+  
+  def initialize(name = nil)
+    @name = name
+    @count = 0
+  end
+  
+  #--
+  # FIXME: use update_properties here!
+  #++
+  
+  def tag(obj)
+    send(obj.class.name.underscore.pluralize.to_sym) << obj
+    @count += 1
+    save!
+  end
+
+  # Return all tagged objects from all categories.
+  
+  def tagged
+    # TODO.  
+  end
+  
+  # Helper method
+  
+  def self.total_frequency(tags = Tag.all)
+    tags.inject(1) { |total, t| total += t.count }
+  end
+end
+
+module Glue
+
+# Add tagging methods to the target class.
+# For more information on the algorithms used surf:
+# http://www.pui.ch/phred/archives/2005/04/tags-database-schemas.html
+#
+# === Example
+#
+# class Article
+#    include Taggable
+#    ..
+#  end
+#
+# article.tag('navel', 'gmosx', 'nitro')
+# article.tags
+# article.tag_names
+# Article.find_with_tags('navel', 'gmosx')
+# Article.find_with_any_tag('name', 'gmosx')
+#
+# Tag.find_by_name('ruby').articles
+
+module Taggable
+  include Og::EntityMixin
+  many_to_many Tag
+  
+  # Add a tag for this object.
+  
+  def tag(the_tags, options = {})
+    options = {
+      :clear => true
+    }.merge(options)
+      
+    self.tags.clear if options[:clear]
+    
+    for name in Taggable.tags_to_names(the_tags)
+      Tag.find_or_create_by_name(name).tag(self)
+    end    
+  end
+  alias_method :tag!, :tag  
+
+  # Return the names of the tags.
+  
+  def tag_names
+    tags.collect { |t| t.name }
+  end
+
+  # Checks to see if this object has been tagged 
+  # with +tag_name+.
+  
+  def tagged_with?(tag_name)
+    tag_names.include?(tag_name)
+  end
+  alias_method :tagged_by?, :tagged_with?      
+
+  module ClassMethods
+    # Find objects with all of the provided tags.
+    # INTERSECTION (AND)
+  
+    def find_with_tags(*names)
+      info = ogmanager.store.join_table_info(self, Tag)
+      count = names.size
+      names = names.map { |n| "'#{n}'" }.join(',')
+      sql = %{        
+        SELECT o.* 
+        FROM 
+          #{info[:first_table]} AS o, 
+          #{info[:second_table]} as t, 
+          #{info[:table]} as j  
+        WHERE o.oid = j.#{info[:first_key]} 
+          AND t.oid = j.#{info[:second_key]} 
+          AND (t.name in (#{names}))
+        GROUP BY o.oid
+        HAVING COUNT(o.oid) = #{count};
+      }
+      return self.select(sql)
+    end
+    alias_method :find_with_tag, :find_with_tags
+  
+    # Find objects with any of the provided tags.
+    # UNION (OR)
+  
+    def find_with_any_tag(*names)
+      info = ogmanager.store.join_table_info(self, tag)
+      count = names.size
+      names = names.map { |n| "'#{n}'" }.join(',')
+      sql = %{        
+        SELECT o.* 
+        FROM 
+          #{info[:first_table]} AS o, 
+          #{info[:second_table]} as t, 
+          #{info[:table]} as j  
+        WHERE 
+          o.oid = j.#{info[:first_key]} 
+          AND t.oid = j.#{info[:second_key]} 
+          AND (t.name in (#{names}))
+        GROUP BY o.oid
+      }
+      return self.select(sql)
+    end
+  end
+  
+  def self.included(base)
+    Tag.module_eval do
+      many_to_many base
+    end
+    base.extend(ClassMethods)
+    #--
+    # FIXME: Og should handle this automatically.
+    #++
+    base.send :include, Aspects
+    base.before 'tags.clear', :on => [:og_delete]
+  end
+  
+  # Helper.
+  
+  def self.tags_to_names(the_tags, separator = ' ')
+    if the_tags.is_a? Array
+      names = the_tags 
+    elsif the_tags.is_a? String
+      names = the_tags.split(separator)
+    end
+    
+    names = names.flatten.uniq.compact
+    
+    return names
+  end    
+end
+
+end
+
+# * George Moschovitis <gm@navel.gr>

data/lib/{og/mixin/taggable.rb → glue/taggable_old.rb}

@@ -23,6 +23,10 @@ class Tag
   end
 end
 
+end
+
+module Glue
+
 # Add tagging methods to the target class.
 # For more information on the algorithms used surf:
 # http://www.pui.ch/phred/archives/2005/04/tags-database-schemas.html
@@ -97,6 +101,8 @@ module Taggable
 
     code << %{      
       def tag(the_tags, options = {})
+        return unless the_tags
+        
         options = {
           :clear => true
         }.merge(options)

data/lib/glue/timestamped.rb

@@ -0,0 +1,37 @@
+require 'nano/time/stamp'
+
+require 'glue/aspects'
+
+module Glue
+
+# Adds timestamping functionality.
+
+module Timestamped
+  include Aspects
+
+  property :create_time, Time, :editor => :none
+  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
+
+  def touch!
+    @access_time = Time.now
+  end
+end
+
+# Adds simple timestamping functionality on create.
+# Only the create_time field is added, to add 
+# create/update/access fields use the normal timestamped
+# module.
+
+module TimestampedOnCreate
+  include Aspects
+  property :create_time, Time, :editor => :none
+  before "@create_time = @update_time = Time.now", :on => :og_insert
+end
+
+end
+
+# * George Moschovitis <gm@navel.gr>

data/lib/{og/mixin → glue}/tree.rb

@@ -4,17 +4,15 @@ raise 'This is not working yet, do not require this file.'
 
 require 'glue/attribute'
 
-module Og
-
 # A useful encapsulation of the nested intervals pattern for 
 # hierarchical SQL queries. Slightly adapted from the original
 # article (http://www.dbazine.com/tropashko4.shtml)
 
 module TreeTraversal
-  
+
   # The default prefix for the tree traversal helpers.
-  
-  cattr_accessor :prefix, 'tree'  
+
+  cattr_accessor :prefix, 'tree'
 
   def self.child(sum, n)
     power = 2 ** n
@@ -23,9 +21,6 @@ module TreeTraversal
 
 end
 
-end
-
-
 __END__
 
 def xcoord(numer, denom)

data/lib/og.rb

@@ -48,24 +48,24 @@ module Og
   # Library path.
 
   LibPath = File.dirname(__FILE__)
-  
+
   # If true, check for implicit changes in the object 
   # graph. For example when you add an object to a parent
   # the object might be removed from his previous parent.
   # In this case Og emmits a warning.
 
   setting :check_implicit_graph_changes, :default => false, :doc => 'If true, check for implicit changes in the object graph'
-  
+
   # If true, only allow reading from the database. Usefull
   # for maintainance.
   # WARNING: not implemented yet.
-  
+
   setting :read_only_mode, :default => false, :doc => 'If true, only allow reading from the database'
 
   # Prepend the following prefix to all generated SQL table names.
   # Usefull on hosting scenarios where you have to run multiple
   # web applications/sites on a single database.
-  # 
+  #
   # Don't set the table_prefix to nil, or you may face problems 
   # with reserved words on some RDBM systems. For example User 
   # maps to user which is reserved in postgresql). The prefix 
@@ -74,7 +74,7 @@ module Og
   #--
   # TODO: move this to the sql store.
   #++
-  
+
   setting :table_prefix, :default => 'og', :doc => 'Prepend the prefix to all generated SQL table names'
 
   # If true, Og tries to create/update the schema in the
@@ -82,7 +82,7 @@ module Og
   # false and only set to true when the object model is 
   # upadated. For debug/development environments this should 
   # stay true for convienience.
-  
+
   setting :create_schema, :default => true, :doc => 'If true, Og tries to create/update the schema in the data store'
 
   # If true raises exceptions on store errors, usefull when
@@ -90,44 +90,42 @@ module Og
   # set to false to make the application more fault tolerant.
 
   setting :raise_store_exceptions, :default => true, :doc => 'If true raises exceptions on store errors'
-  
+
   # Enable/dissable thread safe mode.
-  
-  setting :thread_safe, :default => true, :doc => 'Enable/dissable thread safe mode'
-    
-  # Marker module. If included in a class, the Og automanager
-  # ignores this class.
 
-  module Unmanageable; end
+  setting :thread_safe, :default => true, :doc => 'Enable/dissable thread safe mode'
 
   # The active manager
-  
+
   mattr_accessor :manager
-  
+
   # Pseudo type for binary data
-  
+
   class Blob; end
 
   class << self
-    
+
     # Helper method, useful to initialize Og.
+    # If no options are passed, sqlite is selected
+    # as the default store.
 
-    def setup(options = {})
+    def setup(options = {:store => :sqlite})
       m = @@manager = Manager.new(options)
       m.manage_classes
       return m
     end
     alias_method :connect, :setup
     alias_method :options=, :setup
+    alias_method :start, :setup
 
     # Helper method.
-    
+
     def escape(str)
       @@manager.store.escape(str)
     end
 
   end
-   
+
 end
 
 #--
@@ -138,3 +136,6 @@ require 'og/manager'
 require 'og/errors'
 require 'og/types'
 require 'og/validation'
+require 'og/markers'
+
+# * George Moschovitis <gm@navel.gr>

data/lib/og/collection.rb

@@ -15,6 +15,10 @@ class Collection
   
   attr_accessor :members
 
+  # The class of the members of this collection.
+
+  attr_accessor :member_class
+
   # A method used to add insert objects in the collection.
    
   attr_accessor :insert_proc
@@ -47,10 +51,11 @@ class Collection
 
   # Initialize the collection.
     
-  def initialize(owner = nil, insert_proc = nil, 
+  def initialize(owner = nil, member_class = nil, insert_proc = nil, 
       remove_proc = nil, find_proc = nil, 
       count_proc = nil, find_options = {})
     @owner = owner
+    @member_class = member_class
     @insert_proc = insert_proc
     @remove_proc = remove_proc
     @find_proc = find_proc
@@ -175,6 +180,7 @@ class Collection
       self.each { |obj| @owner.send(@remove_proc, obj) }
     end
     @members.clear
+    @loaded = false # gmosx: IS this needed?
   end
   alias_method :clear, :remove_all
 
@@ -199,6 +205,14 @@ class Collection
   end
   alias_method :count, :size
 
+  # Allows to perform a scoped query.
+  
+  def find(options = {})
+    @member_class.with_scope(options) do
+      return @owner.send(@find_proc, @find_options)    
+    end
+  end
+
   # Redirect all other methods to the members array.
   
   def method_missing(symbol, *args, &block)

data/lib/og/entity.rb

@@ -1,101 +1,96 @@
+require 'mega/class_inherit'
+require 'nano/kernel/assign_with'
+
+require 'glue/property'
 require 'og/relation'
-require 'og/mixin/schema_inheritance_base'
 
 module Og
 
-# Include this module to classes to make them  managable by Og.
+# Include this module to classes to make them managable by Og.
 
 module EntityMixin
 
-  def self.append_features(base)
-    super
+  def save(options = nil)
+    self.class.ogmanager.store.save(self, options)
+    # return self
+  end
+  alias_method :save!, :save
 
-    base.extend(ClassMethods)
+  def insert
+    self.class.ogmanager.store.insert(self)
+    return self
+  end
 
-    base.module_eval <<-end_eval, __FILE__, __LINE__ 
-      def save(options = nil)
-        self.class.ogmanager.store.save(self, options)
-        # return self
-      end
-      alias_method :save!, :save
+  def update(options = nil)
+    self.class.ogmanager.store.update(self, options)
+  end
 
-      def insert
-        self.class.ogmanager.store.insert(self)
-        return self
-      end
-            
-      def update(options = nil)
-        self.class.ogmanager.store.update(self, options)
-      end
-      
-      def update_properties(*properties)
-        self.class.ogmanager.store.update(self, :only => properties)
-      end
-      alias_method :update_property, :update_properties
-      alias_method :pupdate, :update_properties
+  def update_properties(*properties)
+    self.class.ogmanager.store.update(self, :only => properties)
+  end
+  alias_method :update_property, :update_properties
+  alias_method :pupdate, :update_properties
 
-      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
-      
-      # Reload this entity instance from the store.
-      
-      def reload
-        self.class.ogmanager.store.reload(self, self.pk)
-      end
-      alias_method :reload!, :reload
+  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
 
-      # Delete this entity instance from the store.
-      
-      def delete(cascade = true)
-        self.class.ogmanager.store.delete(self, self.class, cascade)
-      end
-      alias_method :delete!, :delete
+  # Reload this entity instance from the store.
 
-      def transaction(&block)
-        self.class.ogmanager.store.transaction(&block)
-      end
+  def reload
+    self.class.ogmanager.store.reload(self, self.pk)
+  end
+  alias_method :reload!, :reload
 
-      def saved?
-        not @oid.nil?
-      end
-      alias_method :serialized?, :saved?
-      
-      def og_quote(obj)
-        self.class.ogmanager.store.quote(obj)
-      end      
-      
-      def assign_properties(values, options = {})
-        Property.populate_object(self, values, options)
-        return self
-      end
-      alias_method :assign, :assign_properties
-    end_eval
+  # Delete this entity instance from the store.
 
-    base.send :include, RelationDSL
+  def delete(cascade = true)
+    self.class.ogmanager.store.delete(self, self.class, cascade)
+  end
+  alias_method :delete!, :delete
 
-    # If base is a Module setup a propageting
-    # append_features method.
-    
-    unless base.is_a? Class
-      base.module_eval do
-        def self.append_features(cbase)
-          super
-          cbase.send :include, EntityMixin
-        end
-      end
-    end
+  def transaction(&block)
+    self.class.ogmanager.store.transaction(&block)
+  end
+
+  def saved?
+    not @oid.nil?
+  end
+  alias_method :serialized?, :saved?
+
+  def og_quote(obj)
+    self.class.ogmanager.store.quote(obj)
+  end
+
+  def assign_properties(values, options = {})
+    Property.populate_object(self, values, options)
+    return self
   end
+  alias_method :assign, :assign_properties
+
+  include RelationDSL
+
+  class_inherit do
 
-  module ClassMethods
     def create(*args)
       obj = self.new(*args)
       yield(obj) if block_given?
       ogmanager.store.save(obj)
       return obj
     end
+    
+    # An alternative creation helper, only works
+    # with objects that have an initialize method
+    # tha works with no arguments.
+    
+    def create_with(hash)
+      obj = self.new
+      obj.assign_with(hash)
+      ogmanager.store.save(obj)
+      return obj
+    end
 
     def assign_properties(values, options)
       Property.fill(self.new, values, options)
@@ -104,7 +99,7 @@ module EntityMixin
 
     # Load an instance of this Entity class using the primary
     # key.
-            
+
     def load(pk)
       ogmanager.store.load(pk, self)
     end
@@ -114,15 +109,15 @@ module EntityMixin
     def update(set, options = nil)
       ogmanager.store.update_by_sql(self, set, options)
     end
-    
+
     def find(options = {})
-      if find_options = self.ann.this[:find_options]
-        options = find_options.first.dup.update(options)
+      if find_options = self.ann.self[:find_options]
+        options = find_options.dup.update(options)
       end
 
       options[:class] = self
       options[:type] = self if self.schema_inheritance_child?
-      
+
       ogmanager.store.find(options)
     end
     alias_method :all, :find
@@ -141,7 +136,7 @@ module EntityMixin
     def select_one(sql)
       ogmanager.store.select_one(sql, self)
     end
-    
+
     def count(options = {})
       options[:class] = self
       ogmanager.store.count(options)
@@ -149,7 +144,7 @@ module EntityMixin
 
     # Delete an instance of this Entity class using the actual
     # instance or the primary key.
-    
+
     def delete(obj_or_pk, cascade = true)
       ogmanager.store.delete(obj_or_pk, self, cascade)
     end
@@ -159,7 +154,7 @@ module EntityMixin
     #--
     # TODO: add cascade option.
     #++
-    
+
     def delete_all
       ogmanager.store.delete_all(self)
     end
@@ -167,7 +162,7 @@ module EntityMixin
     def destroy
       ogmanager.store.send :destroy, self
     end
-    
+
     def escape(str)
       ogmanager.store.escape(str)
     end
@@ -177,28 +172,29 @@ module EntityMixin
     end
 
     # Return the store (connection) for this class.
-    
+
     def ogstore
       ogmanager.store
     end
-        
+
     def primary_key
-      if ann.this.primary_key.nil?
-        ann :this, :primary_key => Entity.resolve_primary_key(self)
+      unless pk = ann.self[:primary_key]
+        pk = Entity.resolve_primary_key(self)
+        ann :self, :primary_key => pk
       end
-      return ann.this.primary_key
+      return pk
     end
-    
+
     # Set the default find options for this entity.
-    
+
     def set_find_options(options)
-      ann :this, :find_options => options
+      ann self, :find_options => options
     end
     alias_method :find_options, :set_find_options
 
     # Enable schema inheritance for this Entity class.
     # The Single Table Inheritance pattern is used.
-        
+
     def set_schema_inheritance
       include Og::SchemaInheritanceBase
     end
@@ -219,7 +215,7 @@ module EntityMixin
     #--
     # farms/rp: is there not another way to access the root class?
     #++
-    
+
     def schema_inheritance_root_class
       klass = self
       until !Og.manager.manageable?(klass) or klass.schema_inheritance_root?
@@ -229,68 +225,214 @@ module EntityMixin
     end
 
     # Set the default order option for this entity.
-    
+
     def set_order(order_str)
-      # FIXME
-      # self.ann :this, :find_options, :order => order_str
+      unless ann.self.find_options.nil?
+        ann.self.find_options[:order] = order_str
+      else
+        ann self, :find_options => { :order => order_str }
+      end
     end
     alias_method :order, :set_order 
+    alias_method :order_by, :set_order
 
     # Set a custom table name.
-    
+
     def set_sql_table(table)
-      ann :this, :sql_table => table.to_s
+      ann self, :sql_table => table.to_s
     end
     alias_method :set_table, :set_sql_table
 
     # Set the primary key.
-    
+
     def set_primary_key(pk, pkclass = Fixnum)
-      ann :this, :primary_key => Property.new(:symbol => pk, :klass => pkclass)
+      ann self, :primary_key => Property.new(:symbol => pk, :klass => pkclass)
     end
 
     # Is this entity a polymorphic parent?
-        
+
     def polymorphic_parent?
-      self.to_s == self.ann.this.polymorphic.to_s
+      self.to_s == self.ann.self.polymorphic.to_s
     end
 
     # Used internally to fix the forward reference problem.
-        
+
     def const_missing(sym) # :nodoc: all
       return sym
-    end    
+    end
+
+    # Returns an array of all relations formed by other og managed
+    # classes with the class of this object.
+    #
+    # This is needed by the PostgreSQL foreign key constraints
+    # system.
+    
+    def resolve_remote_relations
+      klass = self
+      manager = klass.ogmanager
+      relations = Array.new
+      manager.managed_classes.each do |managed_class|
+        next if managed_class == klass
+        managed_class.relations.each do |rel|
+          relations << rel if rel.target_class == klass
+        end
+      end
+      relations
+    end
+
+    # Define a scope for the following og method invocations
+    # on this managed class. The scope options are stored
+    # in a thread variable.
+    #
+    # At the moment the scope is only considered in find
+    # queries.
+
+    def set_scope(options)
+      Thread.current["#{self}_scope"] = options
+    end
+
+    # Get the scope.
+    
+    def get_scope
+      Thread.current["#{self}_scope"]
+    end
+    
+    # Execute some Og methods in a scope.
+
+    def with_scope(options)
+      set_scope(options)
+      yield
+      set_scope(nil)
+    end
+    
+    # Handles dynamic finders. Handles methods such as:
+    #
+    # class User
+    #  property :name, String
+    #  property :age, Fixnum
+    # end
+    #    
+    # User.find_by_name('tml')
+    # User.find_by_name_and_age('tml', 3)
+    # User.find_all_by_name_and_age('tml', 3)
+    # User.find_all_by_name_and_age('tml', 3, :name_op => 'LIKE', :age_op => '>', :limit => 4)
+    # User.find_or_create_by_name_and_age('tml', 3)
+    #--
+    # TODO: refactor this method.
+    #++
+    
+    def method_missing(sym, *args)
+      if match = /find_(all_by|by)_([_a-zA-Z]\w*)/.match(sym.to_s)    
+        finder = (match.captures.first == 'all_by' ? :find : :find_one)
+        attrs = match.captures.last.split('_and_')
+        
+        if args.last.is_a?(Hash)
+          options = args.pop
+        else
+          options = {}
+        end
+        
+        condition = []
+        attrs.each_with_index do |a, idx| 
+          condition << %|#{a} #{options.delete("#{a}_op".to_sym) || '='} #{ogmanager.store.quote(args[idx])}|
+        end
+
+        options.update(
+          :class => self,
+          :condition => condition.join(' AND ')
+        )
+        
+        return ogmanager.store.send(finder, options)
+      elsif match = /find_or_create_by_([_a-zA-Z]\w*)/.match(sym.to_s)
+        finder = (match.captures.first == 'all_by' ? :find : :find_one)
+        attrs = match.captures.last.split('_and_')
+        
+        if args.last.is_a?(Hash)
+          options = args.pop
+        else
+          options = {}
+        end
+        
+        condition = []
+        attrs.each_with_index do |a, idx| 
+          condition << %|#{a} #{options.delete("#{a}_op".to_sym) || '='} #{ogmanager.store.quote(args[idx])}|
+        end
+
+        options.update(
+          :class => self,
+          :condition => condition.join(' AND ')
+        )
+        
+        unless obj = ogmanager.store.send(finder, options)
+          obj = self.create do |obj|
+            attrs.each_with_index do |a, idx| 
+              obj.instance_variable_set "@#{a}", args[idx]
+            end
+          end 
+        end
+        
+        return obj          
+      else
+        super
+      end
+    end
+    
   end
+
 end
 
 # An Og Managed class. Also contains helper
 # methods.
 
-class Entity 
+class Entity
+
+  include EntityMixin
+
   class << self
+
     def resolve_primary_key(klass)
       # Is the class annotated with a primary key?
-      
-      if pk = klass.ann.this[: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)
         end
       end
-      
+
       # The default primary key is oid.
-      
+
       return Property.new(:symbol => :oid, :klass => Fixnum)
     end
+
+    # Converts a string into it's corresponding class. Added to support STI.
+    # Ex: x = "Dave" becomes: (x.class.name == Dave) == true.
+    # Returns nil if there's no such class.
+    #--
+    # gmosx: investigate this patch!
+    #++
+    
+    def entity_from_string(str)
+      res = nil
+      Og.manager.managed_classes.each do |klass|
+        if klass.name == str
+          res = klass
+          break
+        end
+      end
+      res
+    end
+
   end
-  
-  include EntityMixin
-end
 
+end
 
 end
+
+# * George Moschovitis <gm@navel.gr>
+# * Tom Sawyer <transfire@gmail.com>