og 0.27.0 → 0.28.0

data/lib/glue/taggable.rb

@@ -1,4 +1,4 @@
-require 'nano/inflect'
+require 'facet/inflect'
 
 # The default Tag implementation. A tag attaches semantics to
 # a given object.
@@ -25,7 +25,10 @@ class Tag
   #++
   
   def tag(obj)
-    send(obj.class.name.underscore.pluralize.to_sym) << obj
+    class_name = obj.class.name
+    method_name = class_name.index('::') ? (class_name =~ /.*?\:\:(.*)/; $1) : class_name
+
+    send(method_name.pluralize.underscore.to_sym) << obj
     @count += 1
     save!
   end
@@ -119,7 +122,7 @@ module Taggable
     def find_with_tags(*names)
       info = ogmanager.store.join_table_info(self, Tag)
       count = names.size
-      names = names.map { |n| "'#{n}'" }.join(',')
+      names = names.map { |n| ogmanager.store.quote(n) }.join(',')
       sql = %{        
         SELECT o.* 
         FROM 
@@ -142,7 +145,7 @@ module Taggable
     def find_with_any_tag(*names)
       info = ogmanager.store.join_table_info(self, Tag)
       count = names.size
-      names = names.map { |n| "'#{n}'" }.join(',')
+      names = names.map { |n| ogmanager.store.quote(n) }.join(',')
       sql = %{        
         SELECT o.* 
         FROM 

data/lib/glue/timestamped.rb

@@ -1,4 +1,4 @@
-require 'nano/time/stamp'
+require 'facet/time/stamp'
 
 require 'glue/aspects'
 

data/lib/og.rb

@@ -1,15 +1,15 @@
 # = Og
 #
-# Copyright (c) 2004-2005, Navel Ltd (http://www.navel.gr)
 # Copyright (c) 2004-2005, George Moschovitis (http://www.gmosx.com)
+# Copyright (c) 2004-2005, Navel Ltd (http://www.navel.gr)
 #
 # Og (http://www.nitrohq.com) is copyrighted free software 
 # created and maintained by George Moschovitis (mailto:gm@navel.gr) 
 # and released under the standard BSD Licence. For details 
 # consult the file doc/LICENCE.
 
-require 'mega/synchash'
-require 'mega/syncarray'
+require 'facet/synchash'
+require 'facet/syncarray'
 
 require 'glue'
 require 'glue/logger'
@@ -43,7 +43,7 @@ module Og
 
   # The version.
 
-  Version = '0.27.0'
+  Version = '0.28.0'
 
   # Library path.
 
@@ -95,6 +95,14 @@ module Og
 
   setting :thread_safe, :default => true, :doc => 'Enable/dissable thread safe mode'
 
+  # Address of the Og cache (if distributed caching enabled).
+  
+  setting :cache_address, :default => '127.0.0.1', :doc => 'Address of the Og cache'
+  
+  # Port of the Og cache (if distributed caching enabled).
+  
+  setting :cache_port, :default => '9070', :doc => 'Port of the Og cache'
+  
   # The active manager
 
   mattr_accessor :manager
@@ -119,7 +127,7 @@ module Og
         
         m = @@manager = Manager.new(options)        
         m.manage_classes
-        
+
         # Allows functionality that requires a store is 
         # finalized to be implemented. A vastly superior 
         # method of constructing foreign key constraints is an 
@@ -147,7 +155,6 @@ module Og
     def escape(str)
       @@manager.store.escape(str)
     end
-
   end
 
 end

data/lib/og/entity.rb

@@ -1,30 +1,55 @@
-require 'mega/class_inherit'
-require 'nano/kernel/assign_with'
+require 'facet/classinherit'
+require 'facet/kernel/assign_with'
 
 require 'glue/property'
 require 'og/relation'
+require 'og/ez/clause'
+require 'og/ez/condition'
 
 module Og
 
 # Include this module to classes to make them managable by Og.
+#--
+# gmosx, WARTNING: If you change the methods here, don't 
+# forget to update the Cacheable overrides.
+#++
 
 module EntityMixin
 
+  def self.included(base)
+    # If the after_enchant callback is defined, call it 
+    # to allow for some customization. Have a look at cacheable
+    # for an example.
+
+    if base.respond_to?(:after_enchant)
+      base.after_enchant(base)
+    end
+  end
+
+  # Persist the object.
+  
   def save(options = nil)
     self.class.ogmanager.store.save(self, options)
   end
   alias_method :save!, :save
   alias_method :validate_and_save, :save
 
+  # Force saving of the objects, even if the validations
+  # don't pass.
+  
   def force_save!(options = nil)
     self.class.ogmanager.store.force_save(self, options)
   end
 
+  # Insert the object in the store.
+    
   def insert
     self.class.ogmanager.store.insert(self)
     return self
   end
 
+  # Update an existing object in the store.
+  
   def update(options = nil)
     self.class.ogmanager.store.update(self, options)
   end
@@ -59,15 +84,13 @@ module EntityMixin
     self.class.ogmanager.store.transaction(&block)
   end
 
+  # Is this object saved in the store?
+  
   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
@@ -84,6 +107,14 @@ module EntityMixin
     end
   end
 
+  def og_quote(obj)
+    self.class.ogmanager.store.quote(obj)
+  end
+  
+  def og_clone(*args)
+    Og::Entity.clone(self,*args)
+  end  
+
   include RelationDSL
 
   class_inherit do
@@ -129,8 +160,25 @@ module EntityMixin
 
     # Find a specific instance of this class according
     # to the given conditions.
+    #
+    # Unlike the lower level store.find method it accepts 
+    # Strings and Arrays instead of an option hash.
+    # 
+    # === Examples
+    #
+    # User.find :condition => "name LIKE 'g%'", :order => 'name ASC'
+    # User.find :where => "name LIKE 'g%'", :order => 'name ASC'
+    # User.find :sql => "WHERE name LIKE 'g%' ORDER BY name ASC"
+    # User.find :condition => [ 'name LIKE ?', 'g%' ], :order => 'name ASC', :limit => 10
+    # User.find "name LIKE 'g%'"
+    # User.find "WHERE name LIKE 'g%' LIMIT 10"
+    # User.find [ 'name LIKE ?', 'g%' ]
     
-    def find(options = {})
+    def find(options = {}, &block)
+      options = resolve_non_hash_options(options)
+      
+      ez_resolve_options(options, &block) if block_given?
+      
       if find_options = self.ann.self[:find_options]
         options = find_options.dup.update(options)
       end
@@ -144,17 +192,31 @@ module EntityMixin
 
     # Find a single instance of this class.
     
-    def find_one(options = {})
+    def find_one(options = {}, &block)
+      options = resolve_non_hash_options(options)
+      
+      ez_resolve_options(options, &block) if block_given?
+      
+      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_one(options)
     end
     alias_method :one, :find_one
     alias_method :first, :find_one
 
+    # Select an object using an sql query.
+
     def select(sql)
       ogmanager.store.select(sql, self)
     end
 
+    # Select one instance using an sqll query.
+    
     def select_one(sql)
       ogmanager.store.select_one(sql, self)
     end
@@ -375,6 +437,60 @@ module EntityMixin
 
 private
 
+    # Resolve String/Array options.
+    #--
+    # FIXME: move to sql store?
+    #++
+
+    def resolve_non_hash_options(options)      
+      if options.is_a? String
+        if options =~ /^WHERE/i
+          # pass the string as sql.
+          return { :sql => options }
+        else
+          # pass the string as a condition.
+          return { :condition => options }
+        end
+      elsif options.is_a? Array
+        # pass the array as condition (prepared statement style
+        # parsing/quoting.
+        return { :condition => options }
+      end
+      
+      return options
+    end    
+
+    # Resolve ez options, ie options provided using the 
+    # Ruby query language.
+    #--
+    # gmosx: investigate this.
+    #++
+    
+    def ez_resolve_options(options, &block)
+      klass = self.name.downcase.to_sym       
+      # conditions on self first
+      # conditions = [ez_condition(:outer => outer_mapping[klass], :inner => inner_mapping[klass])] 
+      conditions = [ez_condition()]
+
+      # options[:include].uniq.each do |assoc| 
+      #   conditions << reflect_on_association(assoc).klass.ez_condition(:outer => outer_mapping[assoc], :inner => inner_mapping[assoc])
+      # end
+      
+      yield *conditions
+      
+      condition = Caboose::EZ::Condition.new
+      conditions.each { |c| condition << c }
+      options[:condition] = condition.to_sql
+      # p options[:conditions] if $DEBUG
+    end    
+    
+    # Returns a Condition for this object.
+    
+    def ez_condition(options = {}, &block)
+      options[:table_name] ||= table()
+      Caboose::EZ::Condition.new(options, &block)
+    end          
+
     # Helper method for dynamic finders. Finds the object dynamically parsed 
     # method name is after.
 
@@ -386,7 +502,11 @@ private
       options = args.pop if args.last.is_a?(Hash)
 
       condition = attrs.zip(args).map do |name, value|
-        %|#{name} #{options.delete("#{name}_op".to_sym) || '='} #{ogmanager.store.quote(value)}|
+        field_name = properties[name.to_sym][:field] ||
+          properties[name.to_sym][:name] ||
+          properties[name.to_sym][:symbol]
+
+        %|#{field_name} #{options.delete("#{name}_op".to_sym) || '='} #{ogmanager.store.quote(value)}|
       end.join(' AND ')
 
       options.update(
@@ -448,6 +568,102 @@ class Entity
       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
@@ -456,3 +672,4 @@ end
 
 # * George Moschovitis <gm@navel.gr>
 # * Tom Sawyer <transfire@gmail.com>
+# * Rob Pitt <rob@motionpath.com>

data/lib/og/evolution.rb

@@ -1,7 +1,7 @@
 require 'fileutils'
 
-require 'nano/kernel/constant'
-require 'nano/kernel/assign_with'
+require 'facet/kernel/constant'
+require 'facet/kernel/assign_with'
 
 # $DBG = true
 

data/lib/og/ez/clause.rb

@@ -0,0 +1,147 @@
+# gmosx: Work in progress.
+
+module Caboose
+
+  module EZ
+    # EZ::Condition plugin for generating the :conditions where clause
+    # for ActiveRecord::Base.find. And an extension to ActiveRecord::Base
+    # called AR::Base.find_with_conditions that takes a block and builds
+    # the where clause dynamically for you.
+    
+    class AbstractClause
+      
+      attr_reader :test
+      attr_accessor :outer
+      
+      def to_sql; 'TRUE'; end
+      
+    end
+    
+    class Clause < AbstractClause
+      # need this so that id doesn't call Object#id
+      # left it open to add more methods that
+      # conflict when I find them
+      [:id].each { |m| undef_method m }
+      
+      attr_reader :name, :test, :value
+      
+      # Initialize a Clause object with the name of the
+      # column.    
+      def initialize(*args)
+        @table_prefix = ''
+        @negate = false
+        case args.length
+        when 0:
+          raise 'Expected at least one parameter'
+        when 1:
+          @name = args.first.to_s
+        when 2:
+          @table_prefix = args[0].to_s + '.' unless args[0].to_s.empty? 
+          @name = args[1].to_s
+        when 3:
+          @table_prefix = args[0].to_s + '.' unless args[0].to_s.empty? 
+          @name = args[1].to_s
+          @negate = args[2]
+        end
+        # append ! to negate the statement
+        if @name[-1] == '!'
+          @negate = true
+          @name = @name.slice(0, @name.length - 1) 
+        end
+        # prefix with esc_ to avoid clashes with standard methods like 'alias'
+        @name = @name.slice(4, @name.length) if @name =~ /^esc_.*/
+      end
+    
+      # The == operator has been over-ridden here to
+      # stand in for an exact match ["foo = ?", "bar"]
+      def ==(other)
+        @test = :equals
+        @value = other
+      end
+    
+      # The =~ operator has been over-ridden here to
+      # stand in for the sql LIKE "%foobar%" clause.
+      def =~(pattern)
+        @test = :like
+        @value = pattern
+      end
+      
+      # The spaceship <=> operator has been over-ridden here to
+      # stand in for the sql ["BETWEEN ? AND ?", 1, 5] "%foobar%" clause.
+      def <=>(range)
+        @test = :between
+        @value = range
+      end
+    
+      # The === operator has been over-ridden here to
+      # stand in for the sql ["IN (?)", [1,2,3]] clause.
+      def ===(range)
+        @test = :in
+        @value = range
+      end
+    
+      # switch on @test and build appropriate clause to 
+      # match the operation.
+      def to_sql
+        case @test
+        when :equals
+          if @value == :null
+            @negate ? ["#{@table_prefix}#{@name} IS NOT NULL"] : ["#{@table_prefix}#{@name} IS NULL"] 
+          else
+            @negate ? ["#{@table_prefix}#{@name} != ?", @value] : ["#{@table_prefix}#{@name} = ?", @value] 
+          end 
+        when :like
+          @negate ? ["#{@table_prefix}#{@name} NOT LIKE ?", @value] : ["#{@table_prefix}#{@name} LIKE ?", @value]
+        when :between
+          @negate ? ["#{@table_prefix}#{@name} NOT BETWEEN ? AND ?", @value.begin, @value.end] : ["#{@table_prefix}#{@name} BETWEEN ? AND ?", @value.begin, @value.end] 
+        when :in
+          @negate ? ["#{@table_prefix}#{@name} NOT IN (?)", @value.to_a] : ["#{@table_prefix}#{@name} IN (?)", @value.to_a] 
+        else
+          ["#{@table_prefix}#{@name} #{@test} ?", @value]
+        end
+      end
+    
+      # This method_missing takes care of setting
+      # @test to any operator thats not covered 
+      # above. And @value to the value
+      def method_missing(name, *args)
+        @test = name
+        @value = args.first
+      end
+    end
+    
+    class ArrayClause < AbstractClause
+      
+      # wraps around an Array in ActiveRecord format ['column = ?', 2]
+      
+      def initialize(cond_array)
+        @test = :array
+        @cond_array = cond_array
+      end
+            
+      def to_sql
+        return nil if @cond_array.first.to_s.empty?
+        query = (@cond_array.first =~ /^\([^\(\)]+\)$/) ? "#{@cond_array.first}" : "(#{@cond_array.first})"
+        [query, @cond_array[1..@cond_array.length] ]
+      end
+      
+    end
+    
+    class SqlClause < AbstractClause
+      
+      # wraps around a raw SQL string
+      
+      def initialize(sql)
+        @test = :sql
+        @sql = sql
+      end
+      
+      def to_sql
+        [@sql]
+      end
+      
+    end
+    
+  end # EZ
+      
+end # Caboose