og 0.31.0 → 0.40.0

data/lib/glue/tree.rb

@@ -1,218 +0,0 @@
-# NOT WORKING YET !!!
-
-raise 'This is not working yet, do not require this file.'
-
-# 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'
-
-  def self.child(sum, n)
-    power = 2 ** n
-    return sum * power
-  end
-
-end
-
-__END__
-
-def xcoord(numer, denom)
-  num = numer + 1
-  den = denom * 2
-
-  while (num / 2).floor == (num / 2)
-    num /= 2
-    den /= 2
-  end
-
-  return num, den
-end
-
-#--
-# TODO: optimize this
-#++
-
-def ycoord(numer, denom)
-  num, den = xcoord(numer, denom)
-
-  while den < denom
-    num *= 2
-    den *= 2
-  end
-
-  num = numer - num
-
-  while (num / 2).floor == (num / 2)
-    num /= 2
-    den /= 2
-  end
-
-  return num, den
-end
-
-def parent(numer, denom)
-  return nil if numer == 3
-
-  num = (numer - 1) / 2
-  den = denom / 2
-
-  while ((num-1)/4).floor == ((num-1)/4)
-    num = (num + 1) / 2
-    den = den / 2
-  end
-  
-  return num, den
-end
-
-def sibling(numer, denom)
-  return nil if numer == 3
-
-  num = (numer - 1) / 2
-  den = denom / 2
-  sib = 1
-  
-  while ((num-1)/4).floor == ((num-1)/4)
-    return sib if num == 1 and den == 1
-    num = (num + 1) / 2
-    den /= 2
-    sib += 1
-  end
-  
-  return sib
-end
-
-def child(numer, denom, n)
-  power = 2 ** n
-
-  num =  (numer * power) + 3 - power
-  den = denom * power
-
-  return num, den
-end
-
-def path(numer, denom)
-  return '' if numer == nil
-  n, d = parent(numer, denom)
-  return "#{path(n, d)}.#{sibling(numer, denom)}"
-end
-
-def encode(path)
-  num = den = 1
-  postfix = ".#{path}."
-
-  while postfix.length > 1
-    sibling, postfix = postfix.split('.', 2)
-    num, den = child(num, den, sibling.to_i)
-  end
-
-  return num, den
-end
-
-
-require 'og'
-
-class Comment
-  property :path, String
-  property :x, :y, Float
-
-  def initialize(path = nil, x = nil, y = nil)
-    @path, @x, @y = path, x, y
-  end
-end
-
-Og::Database.new(
-  :database => 'test',
-  :adapter => 'psql',
-  :user => 'postgres',
-  :password => 'navelrulez',
-  :connection_count => 1,
-  :drop => true
-)
-
-def dp(path)
-  n, d =  encode(path)
-  n, d = Float(n), Float(d)
-  # puts "#{path} -> n: #{n} d: #{d} c: #{n/d}"
-  p = path(n, d)
-  # puts "=== #{p}"
-  xn, xd = xcoord(n, d)
-  yn, yd = ycoord(n, d)
-  Comment.create(path, xn/xd, yn/yd)
-end
-
-dp '1.1'
-dp '1.2'
-dp '1.3'
-dp '1.1.2.1'
-dp '1.5.2.1'
-dp '1.2.1.1.1'
-dp '1.4.1.1'
-dp '1.4.3'
-dp '1.4.1'
-dp '1.2.1'
-dp '1.2.1.2'
-dp '1.5'
-dp '1.5.1'
-
-for c in Comment.all('ORDER BY x DESC, y ASC')
-  puts "#{c.path.ljust(16)}#{c.inspect}"
-end
-
-class Article
-  property :title, :body, String
-  has_many: :comments, Comment, :tree => true
-end
-
-class Comment
-  property :body, String
-  belongs_to :article, Article
-  belongs_to :parent, Comment
-  has_many :children, Comment, :tree => true
-  has_many :roles, Role, :list => true
-end
-
-
-article.comments_tree
-comment.add_child(Comment.new('hello'))
-comment.children_tree
-comment.children
-
-    if options[:tree]
-      code << %{
-        property :#{prefix}_x, Fixnum
-        property :#{prefix}_y, Fixnum
-        sql_index '#{prefix}_x, #{prefix}_y'
-      }
-    end
-
-    if options[:tree]
-
-      code << %{
-        def #{name}_tree(extrasql = nil)
-          Og.db.select("SELECT * FROM #{Og::Adapter.table(klass)} WHERE #{linkback}=\#\@oid \#\{extrasql\} ORDER BY #{prefix}_x DESC, #{prefix}_y ASC", #{klass})
-        end
-      }
-
-    elsif options[:list]
-
-    else
-
-    end
-
-    }
-    
-    if options[:tree]
-      code << %{
-        n = Og.db.count("#{linkback}=\#\@oid", #{klass})
-        ptx = @#{prefix}_x || 0
-        pty = @#{prefix}_y || 0
-        obj.#{prefix}_x, obj.#{prefix}_y = TreeTraversal.child(ptx + pty, n)
-      }
-    end
-    
-    code << %{

data/lib/og/store/alpha/filesys.rb

@@ -1,110 +0,0 @@
-require 'yaml'
-require 'fileutils'
-
-require 'og/store'
-
-module Og
-
-# A Store that saves the object on the Filesystem.
-# An extension of the Memory store.
-
-class FilesysStore < Store
-
-  # :section: Store methods.
-
-  def self.dir(name)
-    "#{name}_db"
-  end
-
-  def self.create(options)
-    name = dir(options[:name])
-    FileUtils.mkdir_p(name)
-  rescue 
-    Logger.error "Cannot create '#{name}'"
-  end
-  
-  def self.destroy(options)
-    name = dir(options[:name])
-    FileUtils.rm_rf(name)
-  rescue 
-    Logger.error "Cannot destroy '#{name}'"
-  end
-
-  # Initialize a connection to this store.
-
-  def initialize(options)
-    super
-
-    @base_dir = self.class.dir(options[:name])
-  
-    unless File.directory?(@base_dir)
-      Logger.info "Database '#{options[:name]}' not found!"
-      self.class.create(options)
-    end
-  end
-
-  def enchant(klass, manager)    
-    super 
-
-    klass.const_set 'OGNAME', klass.to_s.gsub(/::/, "/").downcase
-    klass.property :oid, Fixnum
- 
-    FileUtils.mkdir_p(path(klass))
-    File.open(spath(klass), 'w') { |f| f << '1' }
-  rescue => ex
-    Logger.error "Cannot create directory to store '#{klass}' classes!"                      
-  end
-
-  # :section: Lifecycle methods.
-
-  def load(oid, klass)
-    obj = nil
-    File.open(path(klass, oid), 'r') { |f| obj = YAML::load(f.read) }
-    return obj            
-  rescue
-    return nil
-  end
-
-  def reload(obj)
-  end
-
-  def save(obj)
-    seq = nil
-    File.open(spath(obj.class), 'r') { |f| seq = f.read.to_i }
-    obj.oid = seq
-    File.open(path(obj.class, obj.oid), 'w') { |f| f << obj.to_yaml }
-    seq += 1
-    File.open(spath(obj.class), 'w') { |f| f << seq }                        
-  end
-
-  def delete(obj_or_pk, klass = nil, cascade = true)
-    pk = obj_or_pk.is_a?(Fixnum) ? obj_or_pk : obj_or_pk.oid
-    klass ||= obj_or_pk.class
-    FileUtils.rm(path(klass, pk))
-  end
-
-  def find
-  end
-
-  def count
-  end
-
-private
-
-  # Path helper.
-
-  def path(klass, pk = nil)
-    class_dir = File.join(@base_dir, klass::OGNAME)
-    pk ? File.join(class_dir, "#{pk}.yml") : class_dir
-  end
-
-  # Path to sequence helper.
-  
-  def spath(klass)
-    File.join(path(klass), 'seq')
-  end
-
-end
-
-end
-

data/lib/og/store/alpha/memory.rb

@@ -1,295 +0,0 @@
-require 'yaml'
-require 'fileutils'
-
-module Og
-
-# A collection of utilities. Mainly to stay compatible with the
-# SQL based backends.
-#
-# WARNING: This store does not yet support all Og features.
-
-module MemoryUtils
-
-  # FIXME: find a neutral name.
-
-  def table(klass)
-    klass.to_s
-  end
-
-  # FIXME: find a neutral name.
-
-  def join_table(class1, class2, postfix = nil)
-    "#{class1}#{class2}"
-  end
-
-  def quote(val)
-    val.inspect
-  end
-
-end
-
-# A Store that 'persists' objects into (RAM) memory.
-#--
-# TODO: fully working query.
-# TODO: arbitrary pk.
-#++
-
-class MemoryStore < Store
-  extend MemoryUtils; include MemoryUtils
-
-  class ObjectHash < Hash
-    def [](key)
-      super(key.to_s)
-    end
-
-    def []=(key, value)
-      super(key.to_s, value)
-    end
-  end
-
-  # This hash implements an in-memory database.
-
-  @objects = ObjectHash.new
-
-  def self.objects
-    @objects
-  end
-
-  def self.objects=(val)
-    @objects = val
-  end
-
-  # A pseudo-connection to the actual object store.
-
-  attr_accessor :conn
-
-  def self.destroy(options)
-    FileUtils.rm_rf("#{options[:name]}.db")
-  rescue 
-    Logger.info "Cannot destroy '#{name}'"
-  end
-
-  def initialize(options)
-    super
-    begin
-      @conn = self.class.objects = YAML.load_file("#{@options[:name]}.db")
-    rescue
-      @conn = self.class.objects = ObjectHash.new
-    end
-  end
-
-  def close
-    File.open("#{@options[:name]}.db", 'w') { |f| f << @conn.to_yaml }
-  end
-
-  # Enchants a class. 
-
-  def enchant(klass, manager)
-    klass.property :oid, Fixnum
-
-    super
-
-    @conn[klass] ||= {}
-
-    eval_og_insert(klass)
-    eval_og_update(klass)
-    eval_og_read(klass)
-    eval_og_delete(klass)
-  end
-
-  # :section: Lifecycle methods.
-
-  # Loads an object from the store using the primary key.
-
-  def load(pk, klass)
-    @conn[klass][pk]
-  end
-
-  # Update selected properties of an object or class of
-  # objects.
-
-  def update_properties(target, set, options = nil)
-    set = set.gsub(/,/, ';')
-    if target.is_a?(Class)
-      if options
-        condition = options[:condition] || options[:where]
-      else 
-        condition = 'true'
-      end
-      for obj in @conn[target].values
-        obj.instance_eval %{
-          if #{condition.gsub(/=/, '==')}
-            #{set}
-          end
-        }
-      end
-    else
-      target.instance_eval(set)
-    end
-  end
-  alias_method :pupdate, :update_properties
-  alias_method :update_property, :update_properties
-
-  # Find a collection of objects.
-  #
-  # === Examples
-  #
-  # User.find(:condition  => 'age > 15', :order => 'score ASC', :offet => 10, :limit =>10)
-  # Comment.find(:include => :entry)
-  # store.find(:class => User, :where => 'age > 15')
-
-  def find(options)
-    query(options)
-  end
-
-  # Find one object.
-
-  def find_one(options)
-    query(options).first
-  end
-
-  # Reloads an object from the store.
-
-  def reload(obj, pk)
-    # Nop, the memory store is always synchronized.
-  end
-
-  # Count results.
-
-  def count(options)
-    objects = 0
-
-    if condition = options[:condition] || options[:where]
-      condition = "obj." + condition.gsub(/=/, '==')
-    else
-      condition = true
-    end
-
-    eval %{
-      for obj in @conn[options[:class]].values
-        objects += 1 if #{condition}
-      end
-    }
-
-    return objects
-  end
-
-  # Relate two objects through an intermediate join table.
-  # Typically used in joins_many and many_to_many relations.
-
-  def join(obj1, obj2, table)
-    # nop
-  end
-
-  # Query.
-
-  def query(options)
-    objects = []
-
-    if condition = options[:condition] || options[:where]
-      condition = "obj." + condition.gsub(/=/, '==')
-    else
-      condition = true
-    end
-
-    eval %{
-      for obj in @conn[options[:class]].values
-        objects << obj if #{condition}
-      end
-    }
-
-    if order = options[:order]
-      desc = (order =~ /DESC/)
-      order = order.gsub(/DESC/, '').gsub(/ASC/, '')
-      eval "objects.sort { |x, y| x.#{order} <=> y.#{order} }"
-      objects.reverse! if desc
-    end
-
-    return objects
-  end
-
-  # :section: Transaction methods.
-
-  # Start a new transaction.
-
-  def start
-  end
-
-  # Commit a transaction.
-
-  def commit
-  end
-
-  # Rollback a transaction.
-
-  def rollback
-  end
-
-private
-
-  # :section: Lifecycle method compilers.
-
-  # Compile the og_update method for the class.
-
-  def eval_og_insert(klass)
-    pk = klass.primary_key.first
-
-    klass.class_eval %{ 
-      def og_insert(store)
-        #{::Aspects.gen_advice_code(:og_insert, klass.advices, :pre) if klass.respond_to?(:advices)}
-        @#{pk} = store.conn[#{klass}].size + 1
-        store.conn[#{klass}][@#{pk}] = self
-        #{::Aspects.gen_advice_code(:og_insert, klass.advices, :post) if klass.respond_to?(:advices)}
-      end
-    }
-  end
-
-  # Compile the og_update method for the class.
-
-  def eval_og_update(klass)
-    pk = klass.primary_key.first
-
-    klass.class_eval %{
-      def og_update(store, options)
-        #{::Aspects.gen_advice_code(:og_update, klass.advices, :pre) if klass.respond_to?(:advices)}
-        store.conn[#{klass}][@#{pk}] = self
-        #{::Aspects.gen_advice_code(:og_update, klass.advices, :post) if klass.respond_to?(:advices)}
-      end
-    }
-  end
-
-  # Not really useful in this store, kept for compatibility,
-  # just to call the aspects.
-
-  def eval_og_read(klass)
-    klass.class_eval %{
-       def og_read
-        #{::Aspects.gen_advice_code(:og_read, klass.advices, :pre) if klass.respond_to?(:advices)}
-        #{::Aspects.gen_advice_code(:og_read, klass.advices, :post) if klass.respond_to?(:advices)}
-      end
-    }
-  end
-
-  def eval_og_delete(klass)
-    klass.module_eval %{
-       def og_delete(store, pk, cascade = true)
-        #{::Aspects.gen_advice_code(:og_delete, klass.advices, :pre) if klass.respond_to?(:advices)}
-        pk ||= @#{klass.primary_key.first}
-        transaction do |tx|
-          tx.conn[#{klass}].delete(pk)
-          if cascade and #{klass}.__meta[:descendants]
-            #{klass}.__meta[:descendants].each do |dclass, foreign_key|
-              eval "tx.conn[dclass].delete_if { |dobj| dobj.\#{foreign_key} == \#{pk} }"
-            end
-          end
-        end
-        #{::Aspects.gen_advice_code(:og_delete, klass.advices, :post) if klass.respond_to?(:advices)}
-      end
-    }
-  end
-
-end
-
-end
-
-# * George Moschovitis <gm@navel.gr>