og 0.27.0 → 0.28.0

data/ProjectInfo

@@ -2,7 +2,7 @@
 
 TITLE    : &title Og
 NAME     : &pkg og
-VERSION  : '0.27.0'
+VERSION  : '0.28.0'
 STATUS   : beta
 
 AUTHOR   : George Moschovitis
@@ -17,7 +17,7 @@ DESCRIPTION: >
   KirbyBase, Filesystem and more.
 
 DEPENDENCIES:
- - [ glue, '= 0.27.0' ]
+ - [ glue, '= 0.28.0' ]
 
 DISTRIBUTE: [ gem, tgz, zip ]
 

data/README

@@ -1,4 +1,4 @@
-= Og 0.27.0 README
+= Og 0.28.0 README
 
 Og (ObjectGraph) is a powerful and elegant object-relational mapping 
 library. Og manages the lifecycle of Ruby objects and  provides 
@@ -16,8 +16,8 @@ automatically generates join tables for many_to_many relations
 and provides a collection of usefull Mixins to synthesize 
 common Entities.
 
-Adapters for PostgreSQL, MySQL, SQLite3, KirbyBase, Memory, Filesystem,
-Oracle and SQL Server are included.
+Adapters for PostgreSQL, MySQL, SQLite3, KirbyBase, Memory, 
+Filesystem, Oracle and SQL Server are included.
 
 Og is part of the Nitro project, released as a stand-alone library
 due to popular demand. You can find the ChangeLog in the Nitro 
@@ -44,6 +44,8 @@ The library provides the following features:
   stores in the same application.
 * Deserialize to Ruby Objects.
 * Deserialize sql join queries to Ruby Objects.
+* Can optionally use Ruby as a query language.
+* Supports model caching (even on distribbuted environments)
 * Eager associations.
 * Serialize arbitrary ruby object graphs through YAML.
 * Connection pooling.
@@ -81,7 +83,9 @@ Documentation for Og can be found at
 
 Don't forget to read the file doc/RELEASES for usefull
 documentation bits. Also, have a look at the test cases in
-the test directory for examples of usage.
+the test directory for examples of usage. Additional examples
+of Og usage can be found at the example distribution of the
+Nitro Web Framework (http://www.nitrohq.com)
 
 You can find a nice tutorial at www.rubygarden.com. Be warned
 that this tutorial describes an earlier version of Og. A *LOT*

data/Rakefile

@@ -30,7 +30,7 @@ task :default => :package
 # Run the tests.
 
 Rake::TestTask.new do |t|
-  cwd = File.expand_path(File.join(File.dirname(__FILE__) + '.'))
+  cwd = File.expand_path(File.join(File.dirname(__FILE__), '..'))
   t.libs << 'test'
   %w[glue nitro og].each do |dir|
     t.libs << File.join(cwd, dir, 'lib')

data/doc/AUTHORS

@@ -33,7 +33,7 @@ IDEAS, ADDITIONAL CODING, SUPPORT:
 * Matt Bowen <matt.bowen@farweststeel.com>
   Oracle driver, documentation.
 
-* Aidan Rogers <aidan@yoyo.org>
+* Aidan Rogers <aidan@infurious.com>
   Bug reports, patches.
     
 * Thomas Quas <tquas@yahoo.com>

data/doc/RELEASES

@@ -1,3 +1,84 @@
+== Version 0.28.0
+
+A snapshot of the latest developments. As always, cool new 
+features were added, the code is refactored, the security increased
+and reported bugs fixed.
+
+Most notable changes:
+
+* New generalized caching system. The caching code is refactored
+in a new Glue system. At the moment, caches in memory, DRb, 
+filesystem and Og are provided. A memcache version will be available
+in the near future. The new caching system is used to implement
+Session stores, Og caching, Fragment caching, and Application scoped
+parameters. A useful DRb cache management script is provided to 
+manage multiple DRb caches.
+
+* Introduced a new Og Cacheable mixin. By including this mixin
+in your classes you make them eligible to Og caching. Here comes
+an example:
+
+class User
+  is Cachable
+  property :name, String
+  property :age, Fixnum
+end
+
+Cacheable reuses the new generalized caching system to provide
+various options for distributed caching. At the moment entities
+(instances of managed classes) are cached by their primary key.
+
+* Og now advanced quering using Ruby as the data query language 
+to complement the usage of Ruby as a data definition language 
+and provide an end-to-end Ruby solution. At the moment only 
+supported for the SQL based adapters. Here comes an example:
+
+  users = User.find do |user|
+    user.age > 10
+    user.any { 
+      name == 'George'
+      name == 'Stella'
+    }
+  end
+
+  # => SELECT * FROM oguser WHERE (oguser.age > 10 AND (oguser.name = 'George' OR oguser.name = 'Stella'))
+
+This feature uses the Caboose/EZ code by Ezra. Pure magic!
+
+* Og find now supports prepared statement like syntax:
+
+  User.find :condition => ['name LIKE ? and create_time > ?', 'g%', Time.now]
+  
+The interpolated values are automatically escaped to avoid
+SQL injection attacks.
+
+Some additional forms of find are supported:
+
+User.find [['name = ? and create_time > ?', 'gmosx', Time.now]
+User.find "name = 'gmosx'"
+
+and more.
+
+* Added experimental support for  deep copying (cloning) of Og 
+managed objects. This mechanism handles properties (annotated 
+attributes) and some relation types.
+
+* Integration of Facets 1.0.1. The new library features a better
+API and better implementation of various features.
+
+* Added schema evolution support to the SQLite adapter. All major
+Og adapter support automatic schema evolution, ie Og detects common
+types of changes in your Ruby code to automatically alter the 
+underlying schema  for you.
+
+* Introduced Og SQLite2 (legacy SQLite) adapter.
+
+* Added more test cases, and improved RDoc comments throughout
+the code.
+
+* Many, many bug fixes.
+
+
 == Version 0.27.0
 
 Once again we have a great mix of cool new features, along

data/examples/README

@@ -1,15 +1,22 @@
 = Og Examples
 
+Here you can find some simple Og examples. For more examples 
+please download the Nitro examples tarball. Nitro is a Ruby
+Web Framework that uses Og.
+
+
 == run.rb
 
 A simple example that demonstrates some Og features. The example
 automatically creates a 'test' database.
 
+
 == mock_example.rb
 
 Demonstrates how easily the Og infrastructure can be mocked,
 for easy test unit writing.
 
+
 == mysql_to_psql.rb
 
 Demonstrates how easy it is to migrate a mysql database

data/lib/glue/cacheable.rb

@@ -0,0 +1,152 @@
+require 'facet/classinherit'
+
+module Glue
+
+# Include this module in your Og managed classes to make
+# them cacheable. Only queries by id are cached.
+#
+# If you use a distributed cache (drb, memcache, etc) , you may 
+# have to start a separate server.
+#
+#--
+# gmosx, WARNING: If the file lib/og/entity.rb is changed
+# this file should be updated to reflect the changes!
+#++
+
+module Cacheable
+
+  ClassInherit do
+  
+    def after_enchant(base)
+      base.module_eval do
+
+        alias_method :save_without_cache, :save      
+        def save(options = nil)
+          Cacheable.cache_delete(self.class, pk)
+          val = save_without_cache(options)
+          Cacheable.cache_set(self)
+          return val
+        end
+        alias_method :save!, :save
+        alias_method :validate_and_save, :save
+
+        alias_method :force_save_without_cache!, :force_save!      
+        def force_save!(options = nil)
+          Cacheable.cache_delete(self.class, pk)
+          val = force_save_without_cache!(options)
+          Cacheable.cache_set(self)
+          return val
+        end
+
+        alias_method :insert_without_cache, :insert      
+        def insert
+          insert_without_cache()
+          Cacheable.cache_set(self)
+          return self
+        end
+
+        alias_method :update_without_cache, :update      
+        def update(options = nil)
+          Cacheable.cache_delete(self.class, pk)
+          val = update_without_cache(options)
+          Cacheable.cache_set(self)
+          return val
+        end
+
+        alias_method :update_properties_without_cache, :update_properties      
+        def update_properties(*properties)
+          Cacheable.cache_delete(self.class, pk)
+          val = update_properties_without_cache(*properties)
+          Cacheable.cache_set(self)
+          return val
+        end
+        alias_method :update_property, :update_properties
+        alias_method :pupdate, :update_properties
+
+        alias_method :update_by_sql_without_cache, :update_by_sql      
+        def update_by_sql(set)
+          Cacheable.cache_delete(self.class, pk)
+          val = update_by_sql_without_cache(sql)
+          Cacheable.cache_set(self)
+          return val
+        end
+        alias_method :update_sql, :update_by_sql
+        alias_method :supdate, :update_by_sql
+
+        alias_method :reload_without_cache, :reload      
+        def reload
+          Cacheable.cache_delete(self.class, pk)
+          reload_without_cache()
+          Cacheable.cache_set(self)
+        end
+        alias_method :reload!, :reload
+
+        alias_method :delete_without_cache, :delete      
+        def delete(cascade = true)
+          delete_without_cache(cascade)
+          Cacheable.cache_delete(self.class, pk)
+        end
+        
+        def og_cache_key
+          "#{self.class}:#{pk}"
+        end
+        
+        class << self
+          alias_method :load_without_cache, :load
+          def load(pk)
+            key = og_cache_key(pk)
+            unless obj = ogmanager.cache.get(key)
+              obj = load_without_cache(pk)
+              ogmanager.cache.set(key, obj)
+            end
+            
+            return obj
+          end
+          alias_method :[], :load
+          alias_method :exist?, :load
+          
+          alias_method :delete_without_cache, :delete      
+          def delete(obj_or_pk, cascade = true)
+            delete_without_cache(obj_or_pk, cascade)
+            Cacheable.cache_delete(self, obj_or_pk)
+          end
+          
+          def og_cache_key(pk)
+            "#{self}:#{pk}"  
+          end          
+                    
+        end
+        
+      end
+    end
+    
+  end
+
+  # ...
+  
+  def self.cache_get(klass, pk)
+  end
+
+  # ...
+    
+  def self.cache_set(obj)
+    obj.class.ogmanager.cache.set(obj.og_cache_key, obj)         
+  end
+
+  # Invalidate the cache entry for an object. Og high level 
+  # methods (for example the entity methods) automatically
+  # call this method where needed. However if you manually alter
+  # the store using Og low level methods (for example a native
+  # SQL query) you should call this method explicitly.
+
+  def self.cache_delete(klass, pk)
+    key = "og#{klass}:#{pk}"
+#   self.og_local_cache.delete(key)
+    klass.ogmanager.cache.delete(key)
+  end
+
+end
+
+end
+
+# * George Moschovitis <gm@navel.gr>

data/lib/glue/hierarchical.rb

@@ -1,5 +1,6 @@
-require 'mega/dynamod'
-require 'mega/orm_support'
+require 'facet/ormsupport'
+
+require 'glue/paramix'
 
 module Glue
 
@@ -11,7 +12,7 @@ module Glue
 
 module NestedSets
 
-  def self.append_dynamic_features(base, options)
+  def self.included_with_params(base, options)
     c = {
       :left => 'lft',
       :right => 'rgt',
@@ -128,7 +129,7 @@ end
 
 module Hierarchical
 
-  def self.append_dynamic_features(base, options)
+  def self.included_with_params(base, options)
     o = {
       :method => :nested_sets, 
     }

data/lib/glue/optimistic_locking.rb

@@ -1,4 +1,3 @@
-require 'mega/dynamod'
 require 'glue/on_included'
 
 module Glue

data/lib/glue/orderable.rb

@@ -1,4 +1,4 @@
-require 'mega/dynamod'
+require 'glue/paramix'
 require 'glue/aspects'
 
 module Glue
@@ -8,63 +8,65 @@ module Glue
 module Orderable
   include Glue::Aspects
 
-  dynamic_feature do |opt|
+  def self.included_with_parameters(base, opt)
+    base.module_eval do
 
-    opt_position = opt[:position] || 'position'
+      opt_position = opt[:position] || 'position'
 
-    opt_type = opt[:type] || Fixnum
+      opt_type = opt[:type] || Fixnum
 
-    # provide a user defined condition.
-    
-    opt_condition = opt[:condition]
+      # provide a user defined condition.
+      
+      opt_condition = opt[:condition]
 
-    # provide a condition based on a key field (?)
-    
-    opt_scope = opt[:scope]
+      # provide a condition based on a key field (?)
+      
+      opt_scope = opt[:scope]
 
-    # clean scope field.
-    
-    if opt_scope
-      if opt_scope.to_s !~ /_oid$/
-        opt_scope = "#{opt_scope}_oid".to_sym
-      else
-        opt_scope = opt_scope.to_sym
+      # clean scope field.
+      
+      if opt_scope
+        if opt_scope.to_s !~ /_oid$/
+          opt_scope = "#{opt_scope}_oid".to_sym
+        else
+          opt_scope = opt_scope.to_sym
+        end
       end
-    end
 
-    define_method :orderable_position do
-      opt_position
-    end
+      define_method :orderable_position do
+        opt_position
+      end
 
-    define_method :orderable_type do
-      opt_type
-    end
+      define_method :orderable_type do
+        opt_type
+      end
 
-    define_method :orderable_scope do
-      opt_scope
-    end
+      define_method :orderable_scope do
+        opt_scope
+      end
 
-    define_method :orderable_condition do
-      scope = orderable_scope
-      if scope
-        scope_value = send(scope)
-        scope = scope_value ? "#{scope} = #{scope_value}" : "#{scope} IS NULL"
+      define_method :orderable_condition do
+        scope = orderable_scope
+        if scope
+          scope_value = send(scope)
+          scope = scope_value ? "#{scope} = #{scope_value}" : "#{scope} IS NULL"
+        end
+        return [ opt_condition, scope ].compact
       end
-      return [ opt_condition, scope ].compact
-    end
 
-    # How to check if property is already defined?
-    
-    unless method_defined?( opt_position )
-      define_method( opt_position ) do @position ; end
-      define_method( "#{opt_position}=" ) do |x| @position = x ; end
-      property opt_position, opt_type
-    end
+      # How to check if property is already defined?
+      
+      unless method_defined?( opt_position )
+        define_method( opt_position ) do @position ; end
+        define_method( "#{opt_position}=" ) do |x| @position = x ; end
+        property opt_position, opt_type
+      end
 
-    # Use position for general reference.
-    
-    attr_accessor :position
+      # Use position for general reference.
+      
+      attr_accessor :position
 
+    end
   end #dynamic_feature
 
   before "add_to_bottom", :on => :og_insert