Rubernate 0.1.0

data/lib/rubernate/impl/memory.rb

@@ -0,0 +1,147 @@
+require 'rubernate/queries'
+
+module Rubernate
+module Memory
+  module Queries
+    class Query < Rubernate::Queries::Generic::Expr 
+      def params v
+        case v
+          when Array: v
+          when Hash: v.values
+          else [v]
+        end
+      end
+    end
+    class Factory < Rubernate::Queries::Factory
+      def initialize
+        super
+        @query = Query        
+      end
+    end
+  end
+  class Reference
+    attr_reader  :primary_key, :object_class
+    def initialize pk, klass
+      @primary_key, @object_class = pk, klass
+    end
+    
+    def == other
+      @primary_key  == other.primary_key and 
+      @object_class == other.object_class
+    end
+  end
+  
+  class RuntimeFactory
+    def initialize
+      @pk, @database = 1001, {}
+    end         
+    def pk_next
+      @pk+= 1
+    end
+    def create
+      Runtime.new @database, self
+    end
+  end
+  
+  class Runtime < Rubernate::Runtime
+    attr :pk, true
+    
+    # Database is maps {pk => [class, {key => value}]}
+    def initialize database, pk_seq
+      super()
+      @pk_seq, @database, @factory = pk_seq, database, Queries::Factory.new
+    end
+    
+    # Loads object by primary_key
+    def load_by_pk pk
+      klass, data = @database[pk]
+      return nil unless data
+      object = instantiate pk, klass, load_peer(data)
+      post_load object
+      object
+    end
+    
+    # Loads objects by query        
+    def load_by_query query, params=[]
+      result = []
+      if query =~ /\s*all\s*/
+        result = @database.keys 
+      else
+        result = query.split.collect! {|pk_str| pk_str.to_i} * @database.keys
+      end
+      result.collect! {|pk| load_by_pk pk}
+    end
+    
+    def load_peer data
+      peer = Rubernate::Peer.new
+      data.each_pair {|p_name, p_data| peer[p_name] = load_param p_data}
+      peer
+    end
+    
+    def load_param p_data
+      case p_data
+        when Reference: 
+          instantiate p_data.primary_key, p_data.object_class
+        when Array: 
+          p_data.collect{|ref| instantiate(ref.primary_key, ref.object_class)}
+        when Hash:
+          result = {}
+          p_data.each_pair {|key, ref| 
+            result[key] = instantiate(ref.primary_key, ref.object_class)
+          }
+          result
+        when Fixnum 
+          p_data
+        else p_data.dup
+      end            
+    end               
+    
+    # Saves objects and clears dirty flag
+    def save objects
+      objects = [objects] unless objects.kind_of? Array
+      for object in objects
+        @database[object.primary_key] = [object.class, save_peer(object.peer)]
+        object.peer.dirty = false
+      end
+    end
+    
+    def save_peer peer
+      result = {}
+      peer.each {|key, value| result[key] = save_param value }
+      result
+    end
+    
+    def save_param value
+      case value
+        when Entity: 
+          Reference.new value.primary_key, value.class
+        when Array: 
+          value.collect{ |item| Reference.new item.primary_key, item.class }
+        when Hash:
+          result = {}
+          value.each {|key, value| 
+            result[key] = Reference.new value.primary_key, value.class
+          }
+          result
+        when Fixnum:
+          value
+        else
+          value.dup
+      end
+    end
+    
+    # Creates object. Object must have peer.
+    def create object
+      object.primary_key = @pk_seq.pk_next
+      save object
+      object.primary_key
+    end
+    
+    # Deletes object
+    def delete object
+      @database.delete object.primary_key
+      object.primary_key = nil
+    end            
+  end
+end
+end

data/lib/rubernate/mixins.rb

@@ -0,0 +1,91 @@
+require 'set'
+
+class Module
+  # Finds class defined in current module.
+  # :call-seq:
+  #   Module.find_class 'ClassName' # finds class 'ClassName' in global space
+  #   SomeModule.find_class 'ClassName' # finds class 'ClassName' in module SomeModule
+  #   
+  def find_class name, scaned = Set.new
+    scaned << self
+    for unit in module_units - scaned
+      return unit if unit.name == name
+      result = unit.find_class name, scaned
+      return result if result
+    end
+    nil
+  end
+
+  # Iterates over all classes.   
+  def find_all scaned = Set.new, &filter # :yeild: class
+    scaned << self    
+    result = []
+    for unit in module_units - scaned
+      if unit.is_a? Class
+        result << unit if yield unit
+      end
+      result.concat unit.find_all(scaned, &filter)
+    end
+    return result        
+  end
+  private
+    # Returns all modules and classes defined inside this module
+    def module_units
+      constants.collect { |name| const_get name }.
+        find_all { |const| 
+          const.class == Class or 
+          const.class == Module 
+        }.to_set
+    end
+end
+  
+class Class
+  # Creates persistent property in a class
+  # The class MUST have an empty constructor.
+  def persistent *props
+    include Rubernate::Entity
+    for prop in props
+      define_accessor prop
+    end
+  end
+
+  # Returns subclasses names (self is not included)
+  attr :subclasses
+  
+  # Register +klass+ as descendant in all superclasses
+  def update_superclass klass
+    @subclasses ||= []
+    @subclasses << klass.name if klass != self
+    superclass.update_superclass klass if superclass
+  end
+    
+  # Defines accessor for persistent property. Should not be used by users
+  def define_accessor name
+    module_eval %{
+      def #{name}                
+        ensure_loaded
+        peer[:#{name}]
+      end
+
+      def #{name}= value
+        ensure_loaded
+        peer.set :#{name}, value, &on_change_callback
+      end
+    }
+  end
+  private :persistent, :define_accessor
+
+  alias old_inherited inherited
+  # Collect subclasses
+  def inherited klass
+    old_inherited klass
+    update_superclass klass
+  end
+
+  # Update classes already loaded
+  Module.find_all do |klass| 
+    klass.update_superclass klass
+  end
+  # Hide update_superclass
+  protected :update_superclass
+end  

data/lib/rubernate/peer.rb

@@ -0,0 +1,70 @@
+module Rubernate
+# Represent objects peer - properties holder.
+class Peer < Hash
+  # Sets peers dirty flag to specified value.
+  # And resets dirty flag for all properites which stored in this peer.
+  def dirty= f_dirty
+    @dirty = f_dirty
+    for value in values
+      value.memorize! if value.is_a? Container
+    end
+  end
+
+  # If peers dirty flag set to true returns it immediately
+  # else iterate over all properties and returns true if dirty
+  # property apperas. +on_modify+ callback invoked if dirty is +true+.
+  def dirty? &on_modify
+    return true if @dirty
+    f_dirty, name, value, old_value = false
+    each do |name, value|
+      if value.is_a? Container
+        old_value = value.recall
+        if old_value
+          f_dirty = dirty = true
+          break
+        end
+      end
+    end
+    yield name, old_value, value if block_given? and f_dirty
+    f_dirty
+  end
+
+  alias old_set []=
+
+  def []= key, value
+    set key, value
+  end
+
+  def set key, value, &on_change
+    old_value = self[key]
+    return if old_value == value
+    @dirty = true
+    if value.is_a? Array or value.is_a? Hash
+      value.extend Container
+    end
+    if value
+      old_set key, value
+    else
+      delete key
+    end
+    yield key, old_value, value if block_given?
+  end
+    
+  # This module is for including to collections of Persistent
+  # objects. It adds fied that contains copy of collection
+  # and controls dirty status of collection.
+  module Container
+    attr_writer :copy
+    
+    # Remember state of collection
+    def memorize!
+      @copy = dup
+    end
+    
+    # Returns remembered state of collection if it different now
+    def recall
+      return self != @copy ? @copy : nil 
+    end
+  end
+end
+end