Rubernate 0.1.0 → 0.1.1

data/db/mysql.sql

@@ -20,6 +20,7 @@ CREATE TABLE R_PARAMS (
     NAME            VARCHAR(100)    NOT NULL,
     FLAGS           INTEGER(5)      NOT NULL,
     INT_VALUE       INTEGER(20),
+    FLT_VALUE       FLOAT,
     STR_VALUE       VARCHAR(255),
     DAT_VALUE       DATETIME,
     REF_VALUE       INTEGER(20),

data/db/oracle.sql

@@ -12,6 +12,7 @@ CREATE TABLE R_PARAMS (
     NAME            VARCHAR2(100) NOT NULL,
     FLAGS           NUMBER(5)     NOT NULL,
     INT_VALUE       NUMBER(20),
+    FLT_VALUE       FLOAT,
     STR_VALUE       VARCHAR2(1000),
     DAT_VALUE       DATE,
     REF_VALUE       NUMBER(20),

data/lib/rubernate/callbacks.rb

@@ -5,7 +5,7 @@ module Rubernate
 # in other to extend basic functionality.
 module Callbacks
   # This module contains callback methods and 
-  # included in module Rubernate::Entity
+  # included in all persisten classes.
   module Entity
     # Invoked if object has just been created in database.
     def on_create
@@ -23,7 +23,7 @@ module Callbacks
     def on_load
     end
 
-    # Invoked if property of object has just been reassigned by +=+ operator.
+    # Invoked if property of object has just been changed via = or [] = operator.
     def on_change prop_name, old_value, new_value
     end
 

data/lib/rubernate/entity.rb

@@ -6,7 +6,7 @@ module Entity
   include Callbacks::Entity
 
   # This property holds objects primary key.
-  # The primary key is not +nil+ for objects attached to session.
+  # The primary key is not nil for objects attached to session.
   attr :primary_key, true
   
   # Attaches object to session returns self
@@ -26,13 +26,13 @@ module Entity
     @removed
   end
   
-  # Retruns objects +peer+ if ther is one or +nil+ in other case 
+  # Retruns objects peer if ther is one or nil in other case 
   def peer
     @peer
   end
   
   # Sets peer if there is no one and invokes on_load callback else skip.
-  # If value is _nil_ peer will be lazy initialized in ensure_loaded.
+  # If value is nil peer will be lazy initialized in ensure_loaded.
   # This method should be invoked only once with not nil value.
   def peer= value
     return if @peer

data/lib/rubernate/impl/dbigeneric.rb

@@ -5,23 +5,27 @@ module Rubernate
 module DBI
   # Param flags constants
   PARAM_FLAG_INT      =    (1 << 0).to_i
-  PARAM_FLAG_STRING   =    (1 << 1).to_i
-  PARAM_FLAG_TIME     =    (1 << 2).to_i
-  PARAM_FLAG_DATE     =    (1 << 3).to_i
-  PARAM_FLAG_REF      =    (1 << 4).to_i
-  PARAM_FLAG_ARRAY    =    (1 << 5).to_i
-  PARAM_FLAG_HASH     =    (1 << 6).to_i
+  PARAM_FLAG_FLOAT    =    (1 << 1).to_i
+  PARAM_FLAG_STRING   =    (1 << 2).to_i
+  PARAM_FLAG_TIME     =    (1 << 3).to_i
+  PARAM_FLAG_DATE     =    (1 << 4).to_i
+  PARAM_FLAG_REF      =    (1 << 5).to_i
+  PARAM_FLAG_ARRAY    =    (1 << 6).to_i
+  PARAM_FLAG_HASH     =    (1 << 7).to_i
 
   # Array and Hashs combinations
   ARRAY_INT_REF       = (PARAM_FLAG_ARRAY | PARAM_FLAG_INT).to_i
   HASH_INT_REF        = (PARAM_FLAG_HASH  | PARAM_FLAG_INT).to_i
+  HASH_FLOAT_REF      = (PARAM_FLAG_HASH  | PARAM_FLAG_FLOAT).to_i
   HASH_STRING_REF     = (PARAM_FLAG_HASH  | PARAM_FLAG_STRING).to_i
   HASH_TIME_REF       = (PARAM_FLAG_HASH  | PARAM_FLAG_TIME).to_i
   HASH_DATE_REF       = (PARAM_FLAG_HASH  | PARAM_FLAG_DATE).to_i
   
+  TimeType = ::DBI::Timestamp
+  
   # Represents factory for +Runtime+ implementors.
   class RuntimeFactory
-    # Accepts +Runtime+ impl. class, database url, user name, and user password
+    # Accepts Runtime impl. class, database url, user name, and user password
     def initialize klass, db_url, db_user, db_password
       @klass, @db_url, @db_user, @db_password = klass, db_url, db_user, db_password
       # @params = {'AutoCommit' => false} #TODO: refine  
@@ -45,11 +49,11 @@ module DBI
   end    
 
   # Represent base class for all Runtime implementation.
-  # Contains generic sql implementations of all required methods except +create+.
-  # The +create+ method should be implemented in subclasses.
+  # Contains generic sql implementations of all required methods except create.
+  #Method create should be implemented in subclasses.
   class Runtime < Rubernate::Runtime
     include DBI
-
+    
     # Parameters are deleted automatically with corresponding r_object records    
     #DELETE_PARAMS = <<-SQL    
     #    DELETE FROM R_PARAMS WHERE OBJECT_PK = ? 
@@ -61,35 +65,34 @@ module DBI
         DELETE FROM R_OBJECTS WHERE OBJECT_PK = ?
         SQL
     SAVE_PARAMS = <<-SQL
-        INSERT INTO R_PARAMS VALUES (?, ?, ?, ?, ?, ?, ?)
+        INSERT INTO R_PARAMS VALUES (?, ?, ?, ?, ?, ?, ?, ?)
         SQL
     SELECT_PARAMS = <<-SQL
-        SELECT P.*, O.OBJECT_CLASS, R.OBJECT_CLASS
+        SELECT P.*, R.OBJECT_CLASS, O.OBJECT_CLASS
             FROM R_PARAMS P JOIN R_OBJECTS O ON (O.OBJECT_PK = P.OBJECT_PK)
             LEFT OUTER JOIN R_OBJECTS R ON (P.REF_VALUE = R.OBJECT_PK)
                 WHERE O.OBJECT_PK IN 
         SQL
     SELECT_ONE_OBJECT = <<-SQL
-        SELECT  O.OBJECT_PK, P.NAME, P.FLAGS, P.INT_VALUE, P.STR_VALUE, 
-                P.DAT_VALUE, P.REF_VALUE,  O.OBJECT_CLASS, R.OBJECT_CLASS
+        SELECT  O.OBJECT_PK, P.NAME, P.FLAGS, P.INT_VALUE, P.FLT_VALUE, P.STR_VALUE, 
+                P.DAT_VALUE, P.REF_VALUE, R.OBJECT_CLASS, O.OBJECT_CLASS
             FROM R_OBJECTS O
                 LEFT OUTER JOIN R_PARAMS  P ON (O.OBJECT_PK = P.OBJECT_PK)
                 LEFT OUTER JOIN R_OBJECTS R ON (P.REF_VALUE = R.OBJECT_PK)
                 WHERE O.OBJECT_PK = ?
         SQL
-        
-    # R_OBJECTS table's column's indexes
-    CI_O_PK     =   0
-    CI_O_CLASS  =   1
-
+    
     # R_PARAMS table's column's indexes
-    CI_P_PK     =   0
-    CI_P_NAME   =   1
-    CI_P_FLAGS  =   2    
-    CI_P_INT    =   3
-    CI_P_STR    =   4
-    CI_P_TIME   =   5
-    CI_P_REF    =   6
+    P_PK     =   0 
+    P_NAME   =   1
+    P_FLAGS  =   2    
+    P_INT    =   3
+    P_FLT    =   4
+    P_STR    =   5
+    P_TIME   =   6
+    P_REF    =   7 # Refered object PK
+    P_REF_CLASS =   8 # Refered object Class
+    P_CLASS     =   9 # Self object Class
     
     attr :dbh, false
     
@@ -121,14 +124,14 @@ module DBI
     # Loads object by primary_key
     def load_by_pk pk
       klass, peer = nil
-      dbh.execute(SELECT_ONE_OBJECT, pk) { |sth|
-        sth.fetch { |row|        
-          klass, peer = row[7], Rubernate::Peer.new unless klass
+      dbh.execute SELECT_ONE_OBJECT, pk do |sth|
+        sth.fetch do |row|        
+          klass, peer = row[P_CLASS], Rubernate::Peer.new unless klass
           fetch_param peer, row
-        }
-      }
+        end
+      end
       return nil unless klass      
-      obj = instantiate pk, class_by_name(klass), peer
+      obj = instantiate pk, klass, peer
       post_load obj
       obj
     end        
@@ -140,7 +143,7 @@ module DBI
       # selects objects and stores not loaded to buffer
       dbh.execute(query, *params) { |sth| 
         sth.fetch { |row|
-          obj = instantiate row[0].to_i, class_by_name(row[1])
+          obj = instantiate row[0].to_i, row[1]
           buffer[obj.primary_key], obj.peer = obj, Rubernate::Peer.new unless obj.peer
           result << obj
         }        
@@ -148,8 +151,8 @@ module DBI
       return result if buffer.empty?
       # load peers for objects in buffer.
       dbh.execute(SELECT_PARAMS + object_ids_p(buffer.values)) {|sth|
-        sth.fetch {|row|
-          fetch_param buffer[row[0].to_i].peer, row
+        sth.fetch {|row| 
+          fetch_param buffer[row[P_PK].to_i].peer, row
         }
       }
       # clears dirty flags
@@ -182,70 +185,72 @@ module DBI
           when Hash:      save_hash  sth, pk, name, param
           when Array:     save_array sth, pk, name, param
           when Integer:   save_int   sth, pk, name, param
+          when Float:     save_float sth, pk, name, param
           when Time:      save_time  sth, pk, name, param
           when Date:      save_date  sth, pk, name, param
-          else            save_str   sth, pk, name, param
+          else            save_str   sth, pk, name, param.to_s
         end
       end
-      
-      def save_ref sth, pk, name, ref
-        sth.execute pk, name, PARAM_FLAG_REF, nil, nil, nil, ref.primary_key unless ref.removed?
+
+      def save_int sth, pk, name, int
+        sth.execute pk, name, PARAM_FLAG_INT, int, nil, nil, nil, nil
       end
+
+      def save_float sth, pk, name, float
+        sth.execute pk, name, PARAM_FLAG_FLOAT, nil, float, nil, nil, nil
+      end
+
+      def save_str sth, pk, name, str
+        sth.execute pk, name, PARAM_FLAG_STRING, nil, nil, str, nil, nil
+      end   
       
       def save_time sth, pk, name, time
-        sth.execute pk, name, PARAM_FLAG_TIME, nil, nil, ::DBI::Timestamp.new(time), nil
+        sth.execute pk, name, PARAM_FLAG_TIME, nil, nil, nil, TimeType.new(time), nil
       end
       
       def save_date sth, pk, name, date
-        sth.execute pk, name, PARAM_FLAG_DATE, nil, nil, ::DBI::Timestamp.new(date), nil
+        sth.execute pk, name, PARAM_FLAG_DATE, nil, nil, nil, TimeType.new(date), nil
       end      
+
+      def save_ref sth, pk, name, ref
+        sth.execute pk, name, PARAM_FLAG_REF, nil, nil, nil, nil, ref.primary_key unless ref.removed?
+      end
       
       def save_hash sth, pk, name, hash
-        hash.delete_if {|key, ref| ref.removed?}
+        hash.delete_if {|key, ref| ref.removed?} # Discard removed objects
         if hash.empty?
-          sth.execute pk, name, PARAM_FLAG_HASH, 0, nil, nil, nil          
+          sth.execute pk, name, PARAM_FLAG_HASH, 0, nil, nil, nil, nil
         else
           hash.each {|key, ref| save_key_value sth, pk, name, key, ref.primary_key}
         end
       end  
       
       def save_key_value sth, pk, name, key, ref
-        if key.is_a? String
-          sth.execute pk, name, HASH_STRING_REF, nil, key, nil, ref
-        elsif key.is_a? Integer
-          sth.execute pk, name, HASH_INT_REF, key, nil, nil, ref
-        elsif key.is_a? ::Time # TODO:  chek time and date scopes?
-          sth.execute pk, name, HASH_TIME_REF, nil, nil, ::DBI::Timestamp.new(key), ref 
-        elsif key.is_a? ::Date
-          sth.execute pk, name, HASH_DATE_REF, nil, nil, ::DBI::Timestamp.new(key), ref 
-        elsif key.nil? 
-          sth.execute pk, name, PARAM_FLAG_HASH, nil, nil, nil, ref
-        else
-          raise "invalid hash key value #{key}"
+        case key
+          when Integer: sth.execute pk, name, HASH_INT_REF,    key, nil, nil, nil, ref
+          when Float:   sth.execute pk, name, HASH_FLOAT_REF,  nil, key, nil, nil, ref
+          when String:  sth.execute pk, name, HASH_STRING_REF, nil, nil, key, nil, ref
+          when ::Date:  sth.execute pk, name, HASH_DATE_REF, nil, nil, nil, TimeType.new(key), ref
+          when ::Time:  sth.execute pk, name, HASH_TIME_REF, nil, nil, nil, TimeType.new(key), ref
+          when nil:     sth.execute pk, name, PARAM_FLAG_HASH, nil, nil, nil, nil, ref
+          else
+            raise "invalid hash key value #{key}"
         end
       end
       
       def save_array sth, pk, name, array
-        array.delete_if {|ref| !ref or ref.removed?} # Reject removed and nil items
+        array.delete_if {|ref| !ref or ref.removed?} # Discard removed and nil items
         if array.empty? # Empty arrays should also be stored
-          sth.execute pk, name, ARRAY_INT_REF, 0, nil, nil, nil
+          sth.execute pk, name, ARRAY_INT_REF, 0, nil, nil, nil, nil
         else
-          array.each_index { |idx|  sth.execute pk, name, 
-            ARRAY_INT_REF, idx, nil, nil, array[idx].primary_key}
+          array.each_index {|idx| sth.execute pk, name, 
+            ARRAY_INT_REF, idx, nil, nil, nil, array[idx].primary_key}
         end
       end
       
-      def save_int sth, pk, name, param
-        sth.execute pk, name, PARAM_FLAG_INT, param, nil, nil, nil
-      end
-      
-      def save_str sth, pk, name, param
-        sth.execute pk, name, PARAM_FLAG_STRING, nil, param.to_s, nil, nil
-      end   
-
       def fetch_param peer, row
-        return unless row[1] # there are no params for this object
-        name, flags, ref = row[1].to_sym, row[2].to_i
+        return unless row[P_NAME] # there are no params for this object
+        name, flags, ref = row[P_NAME].to_sym, row[P_FLAGS].to_i
         if flags & PARAM_FLAG_ARRAY != 0
           peer[name] = [] unless peer[name] 
           peer[name][fetch_value(row, flags)] = ref if ref = fetch_ref_value(row)
@@ -258,17 +263,18 @@ module DBI
       end 
       
       def fetch_value row, flags
-        return row[CI_P_INT].to_i if flags & PARAM_FLAG_INT != 0
-        return row[CI_P_STR].to_s if flags & PARAM_FLAG_STRING != 0
-        return instantiate(row[CI_P_REF].to_i, class_by_name(row[CI_P_REF + 2])) if flags & PARAM_FLAG_REF != 0
-        return row[CI_P_TIME].to_time if flags & PARAM_FLAG_TIME != 0
-        return row[CI_P_TIME].to_date if flags & PARAM_FLAG_DATE != 0
+        return row[P_INT].to_i if flags & PARAM_FLAG_INT    != 0
+        return row[P_FLT].to_f if flags & PARAM_FLAG_FLOAT  != 0
+        return row[P_STR].to_s if flags & PARAM_FLAG_STRING != 0
+        return instantiate(row[P_REF].to_i, row[P_REF_CLASS]) if flags & PARAM_FLAG_REF != 0
+        return row[P_TIME].to_time if flags & PARAM_FLAG_TIME != 0
+        return row[P_TIME].to_date if flags & PARAM_FLAG_DATE != 0
         return nil
       end
       
       def fetch_ref_value row
         ref_pk = nil
-        instantiate ref_pk, class_by_name(row[8]) if ref_pk = row[6]
+        instantiate ref_pk, row[P_REF_CLASS] if ref_pk = row[P_REF]
       end      
             
       def object_ids objects

data/lib/rubernate/impl/memory.rb

@@ -32,6 +32,7 @@ module Memory
   end
   
   class RuntimeFactory
+    attr_accessor :database
     def initialize
       @pk, @database = 1001, {}
     end         
@@ -44,9 +45,9 @@ module Memory
   end
   
   class Runtime < Rubernate::Runtime
-    attr :pk, true
+    attr_accessor :pk, :database
     
-    # Database is maps {pk => [class, {key => value}]}
+    # Database is maps {pk => [class, {attr => value}]}
     def initialize database, pk_seq
       super()
       @pk_seq, @database, @factory = pk_seq, database, Queries::Factory.new

data/lib/rubernate/mixins.rb

@@ -52,7 +52,7 @@ class Class
   # Returns subclasses names (self is not included)
   attr :subclasses
   
-  # Register +klass+ as descendant in all superclasses
+  # Register klass as descendant in all superclasses
   def update_superclass klass
     @subclasses ||= []
     @subclasses << klass.name if klass != self

data/lib/rubernate/peer.rb

@@ -50,8 +50,8 @@ class Peer < Hash
     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
+  # This module for including to collections of Persistent
+  # objects. It adds field that contains copy of collection
   # and controls dirty status of collection.
   module Container
     attr_writer :copy

data/lib/rubernate/queries.rb

@@ -9,37 +9,37 @@ module Queries
   
   # Contains operations definitions
   module Operations
-    # Declares +And+ sql clause.
+    # Declares And sql clause.
     def And expr1, expr2
       @factory.bin_op expr1, expr2, 'and'
     end
     
-    # Declares +Or+ sql clause.
+    # Declares Or sql clause.
     def Or expr1, expr2
       @factory.bin_op expr1, expr2, 'or', true
     end
     
-    # Declares +=+ sql clause.
+    # Declares = sql clause.
     def Eq expr1, expr2
       @factory.bin_op expr1, expr2, '='
     end
     
-    # Declares +Not+ sql clause.
+    # Declares Not sql clause.
     def Not expr
       @factory.un_op expr, 'not', true      
     end
     
-    # Declares +is null+ sql clause
+    # Declares is null sql clause
     def IsNil expr
       @factory.bin_op expr, @factory.expr(nil), 'is'
     end
     
-    # Declares +is not null+ sql clause    
+    # Declares is not null sql clause    
     def IsNotNil expr
       @factory.bin_op expr, @factory.expr(nil), 'is not'
     end 
     
-    # Declares +in+ sql clause
+    # Declares in sql clause
     def In expr, list
       @factory.bin_op expr, @factory.list(list), 'in'
     end
@@ -55,7 +55,7 @@ module Queries
   end
   
   # Defines query elements factory. By default it creates elements defined 
-  # in module +Generic+, but this befavior can be changed by seting of appropriate class.
+  # in module Generic, but this befavior can be changed by seting of appropriate class.
   # Following example changes implementation of BinOpConst
   #
   # :call-seq:
@@ -82,7 +82,7 @@ module Queries
     end
     private
       # Defines factory method that will instantiate element instance 
-      # and pass +self+ as element factory.
+      # and pass self as element factory.
       def self.def_factory name
         module_eval %{
           attr_writer :#{name}
@@ -212,7 +212,7 @@ module Queries
       end
     end
     
-    # Represent +r_params+ for hashes and arrays constrained by key
+    # Represent r_params for hashes and arrays constrained by key
     class KeyRefExpr < BinOpConstr
       def initialize factory, r_param, key_field, key_value
         @factory, @r_param, @key_field, @key_value = factory, r_param, key_field, key_value
@@ -258,19 +258,20 @@ module Queries
       # Fields accessors.
       def pk   () f_expr 'object_pk'; end
       def int  () f_expr 'int_value'; end
+      def float() f_expr 'flt_value'; end
       def str  () f_expr 'str_value'; end
       def time () f_expr 'dat_value'; end
-      def date () f_expr 'dat_value'; end # TODO: make proper convertation
+      def date () f_expr 'dat_value'; end
       def ref  () f_expr 'ref_value'; end
       def flags() f_expr 'flags';     end
       
-      # The following methods checks +r_param.flags+ value. (r_param.flags)
+      # The following methods checks r_param.flags value. (r_param.flags)
       def is_int () Eq flags, PARAM_FLAG_INT;    end
       def is_str () Eq flags, PARAM_FLAG_STRING; end
       def is_time() Eq flags, PARAM_FLAG_TIME;   end
       def is_ref () Eq flags, PARAM_FLAG_REF;    end
       
-      # Shortcut for +Eq+ method
+      # Shortcut for Eq method
       def == expr
         expr.is_a?(RObject) ?
           @factory.bin_op(ref, expr.pk, '=') :
@@ -288,7 +289,7 @@ module Queries
         end
       end
       private
-        # Creates +FieldExpr+ witch field of this (r_param) table 
+        # Creates FieldExpr witch field of this (r_param) table 
         def f_expr field
           @factory.field self, field
         end
@@ -368,7 +369,7 @@ module Queries
         @exprs.inject([]){|result, expr| result.concat expr.markers}
       end
       
-      # Arranges map: +values+ {marker=>value} to ordered array of values 
+      # Arranges map: values {marker=>value} to ordered array of values 
       # accroding to markers in query. 
       def params values
         markers.inject([]){|r, m| r << values[m]}
@@ -403,18 +404,18 @@ module Queries
           @evaluated = true
         end
 
-        # Generates +where+ clause for each expression joined by +and+ clause
+        # Generates where clause for each expression joined by and clause
         def where_sql        
           r_params.collect{|rp| rp.to_sql + '.name = \'' + rp.name + '\''}.concat(
             @exprs.collect{|ex| ex.to_sql}).join(" and\n\t\t")
         end
         
-        # Generates +order by+ sql clause
+        # Generates order by sql clause
         def order_by_sql
           @order.collect{|ord| ord.to_sql}.join(', ')
         end
         
-        # Generates left outer join for each +r_params+ used in query
+        # Generates left outer join for each r_params used in query
         def tables_sql
           r_objects.collect{|r_object| 'r_objects ' + r_object.to_sql}.join(', ') + 
             r_params.collect{|r_param| 
@@ -423,7 +424,7 @@ module Queries
           }.join()
         end      
         
-        # Retruns +r_params+ used in query. List of +RParam+.
+        # Retruns r_params used in query. List of RParam.
         def r_params
           res = @exprs.inject([]) {|res, exp| res.concat exp.r_params}
           @order.inject(res) {|res, ord| res.concat ord.r_params}
@@ -431,7 +432,7 @@ module Queries
           res
         end
         
-        # Retruns +r_objects+ used in query. List of +RObject+.
+        # Retruns r_objects used in query. List of RObject.
         def r_objects
           res = (@r_objects.values + r_params.inject([]){|res, rp| res << rp.r_object})
           res.uniq!

data/lib/rubernate/runtime.rb

@@ -1,6 +1,5 @@
 module Rubernate
-  # Base class for all "Runtime+ implementations.
-  # Most of these methods should be overriden by subclasses.
+  # Base class for all Runtime implementations.
   class Runtime
     include Callbacks::Runtime
 
@@ -116,20 +115,32 @@ module Rubernate
     end
 
     private     
-      # Creates new object instance or returns pooled one
+      # Creates new object instance or returns insance from pool
+      # Parameter klass can be Class or String (class name)
       def instantiate pk, klass, peer = nil
         object = @pool[pk]
-        if object and object.class != klass
-          raise "invalid class #{klass} of object pk: #{pk}: #{object.class}"
-        end
         unless object
-          object, object.primary_key = klass.allocate, pk
+          clazz  = klass.is_a?(Class) ? klass : get_class(klass)
+          object = clazz ? clazz.allocate : FakeEntity.new(klass)
+          object.primary_key = pk
           @pool[pk] = object
         end
-        object.peer = peer
+        object.peer = peer # TODO: TEST!!! and write description
         object
       end
-          
+       
+      #Classes cache.
+      @@classes = {}
+
+      # Returns class with specified name or nil if there is no one.
+      def get_class name
+        klass = @@classes[name]
+        return klass if klass
+        klass = Module.find_class name
+        return nil unless klass
+        @@classes[name] = klass
+      end
+      
       # Returns modified objects.
       def modified
         @pool.values.find_all {|object| object.peer and object.dirty?}
@@ -192,24 +203,20 @@ module Rubernate
           when Class: p.name
           else p
         end
-      end
-      
-      # TODO: continue from here!!!
-      class FakeEntity
-        persistent
-        def method_not_defined
-          raise 'object #{primary_key} has undefined class'
-        end
-      end
-       
-      @@classes = {}
-      # Returns class with specified name or throw error if there is on one.
-      def class_by_name name
-        klass = @@classes[name]
-        return klass if klass
-        klass =  Module.find_class name
-        @@classes[name] = klass if klass
-        klass
-      end
+      end      
+  end
+
+  # Represetns fake entity. - objects whose class wasn't found during loading.
+  class FakeEntity
+    persistent
+    def initialize class_name
+      @class_name = class_name
+    end
+    def method_missing name, *args
+      raise ObjectLoadError.new("class: #{@class_name} not found for object: #{primary_key}")
+    end
+    def to_s
+      "Fake Entity: #{primaty_key}, for class: #{@class_name}"
+    end
   end
 end

data/lib/rubernate.rb

@@ -35,6 +35,9 @@ require 'rubernate/impl/dbimysql'
 require 'rubernate/impl/dbioracle'
 
 
+
+# Contains most useful methods. This module is included 
+# in all persistent classes.
 module Rubernate
   # Common Rubernate Log instance
   Log = Log4r::Logger.new self.name
@@ -42,7 +45,7 @@ module Rubernate
   # Rubernate core singelton methods.
   class << self
     # Allows you setup Rubernate by yours implementaion of RuntimeFactory.
-    # See also method configure
+    # See also method config
     def runtime_factory= factory
       Log.info "Rubernate configured by #{factory}"
       @runtime_factory = factory
@@ -124,4 +127,8 @@ module Rubernate
       @msg
     end
   end
+  
+  # Signals about errors occured during object loading.
+  class ObjectLoadError < RuntimeError
+  end
 end

data/tests/config.rb

@@ -1,5 +1,5 @@
 # Set to true to run tests or Oracle
-$run_oracle_tests  = true
+$run_oracle_tests  = false
 
 ORA_RUNTIME_CLASS = Rubernate::DBI::OracleRuntime
 ORA_DB_URL        = 'dbi:OCI8:dbg91'
@@ -7,7 +7,7 @@ ORA_DB_USER       = 'netcracker65'
 ORA_DB_PWD        = 'netcracker65'
 
 # Set to true to run tests on MySQL
-$run_mysql_tests     = true
+$run_mysql_tests     = false
 
 MYSQL_RUNTIME_CLASS = Rubernate::DBI::MySqlRuntime
 MYSQL_DB_URL        = 'dbi:Mysql:rubernate_db:localhost'

data/tests/rubernate/fixtures.rb

@@ -23,5 +23,8 @@ module FixtureClasses
     def initialize pk = nil 
       @primary_key = pk
     end
-  end 
+  end
+  class Full
+    persistent :p_nil, :p_int, :p_float, :p_str, :p_date, :p_time, :p_array, :p_hash
+  end
 end

data/tests/rubernate/impl/dbigeneric_stub.rb

@@ -130,6 +130,7 @@ module DBI::GenericTests
       assert_equal o.primary_key, row['OBJECT_PK'].to_i
       assert_equal PARAM_FLAG_INT | PARAM_FLAG_HASH, row['FLAGS'].to_i
       assert hash.has_key?(row['INT_VALUE'].to_i)
+      assert_nil row['FLT_VALUE']
       assert_nil row['STR_VALUE']
       assert_nil row['DAT_VALUE']
       assert_equal hash[row['INT_VALUE'].to_i].primary_key, row['REF_VALUE'].to_i
@@ -156,17 +157,19 @@ module DBI::GenericTests
       if row['FLAGS'].to_i == HASH_INT_REF
         assert_equal o.primary_key, row['OBJECT_PK'].to_i
         assert hash.has_key?(row['INT_VALUE'].to_i)
+        assert_nil row['FLT_VALUE']
         assert_nil row['STR_VALUE']
         assert_nil row['DAT_VALUE']
         assert_equal hash[row['INT_VALUE'].to_i].primary_key, row['REF_VALUE'].to_i
       elsif row['FLAGS'].to_i == HASH_STRING_REF
         assert_equal o.primary_key, row['OBJECT_PK'].to_i
         assert_nil row['INT_VALUE']
+        assert_nil row['FLT_VALUE']
         assert hash.has_key?(row['STR_VALUE'])
         assert_nil row['DAT_VALUE']
         assert_equal hash[row['STR_VALUE']].primary_key, row['REF_VALUE'].to_i
       else 
-        flunk 'Invalid flags ' + row['FLAGS'].to_i
+        flunk 'Invalid flags: ' + row['FLAGS'].to_i
       end
     end
   end
@@ -286,8 +289,8 @@ module DBI::GenericTests
     Rubernate.session {o = C1.new.attach; o.p1 = {time => o}; pk = o.primary_key}
     Rubernate.session {
       o = find_by_pk pk
-      assert_equal 1, o.p1.size
-      _time, _obj = o.p1.shift
+      assert_equal 1, o.p1.size # check hash size
+      _time, _obj = o.p1.shift  # get hash value
       assert_equal time.to_a[0..5], _time.to_a[0..5] # Ignore time-zone
       assert_equal o, _obj
     }
@@ -298,8 +301,8 @@ module DBI::GenericTests
     Rubernate.session {o = C1.new.attach; o.p1 = {date => o}; pk = o.primary_key}
     Rubernate.session {
       o = find_by_pk pk
-      assert_equal 1, o.p1.size
-      _date, _obj = o.p1.shift
+      assert_equal 1, o.p1.size # check hash size
+      _date, _obj = o.p1.shift  # get hash value
       assert_equal date, _date 
       assert_equal o, _obj
     }
@@ -345,7 +348,52 @@ module DBI::GenericTests
       o = find_by_pk pk
       assert_equal ({}), o.p1
     end
-  end  
+  end
+  
+  def test_param_all_types
+    pk, time, date = nil, Time.now, Date.today
+    Rubernate.session do
+      o = Full.new.attach
+      pk = o.primary_key
+      o.p_nil   = nil
+      o.p_int   = 123
+      o.p_float = 77.5
+      o.p_str   = 'Test String'
+      o.p_time  = time
+      o.p_date  = date
+      o.p_array = [o, o, o]
+      o.p_hash  = {nil => o,
+        777  => o,
+        1.23 => o,
+        'Str.Key' => o,
+        time => o,
+        date => o
+      }
+    end
+    Rubernate.session do
+      o = find_by_pk pk
+      assert_nil o.p_nil
+      assert_equal 123, o.p_int
+      assert_equal 77.5, o.p_float
+      assert_equal 'Test String', o.p_str
+      assert_equal time.to_a[0..5], o.p_time.to_a[0..5] # Ignore time zone
+      assert_equal date, o.p_date # Ignore time zone
+      assert_equal [o, o, o], o.p_array      
+      assert_equal 6, o.p_hash.size
+      
+      o.p_hash.each {|key, val|
+        assert_equal time.to_a[0..5], key.to_a[0..5] if key.is_a? Time
+        assert_equal date, key if key.is_a? Date          
+      }
+      o.p_hash.delete_if {|key, val| key.is_a? Time or key.is_a? Date}
+      
+      assert_equal ({nil => o,
+          777  => o,
+          1.23 => o,
+          'Str.Key' => o
+        }), o.p_hash
+    end
+  end
 end
 
 module GenericRuntimeTests

data/tests/rubernate/rubernate_test.rb

@@ -251,15 +251,15 @@ class Rubernate::BaseRuntimeTest < Test::Unit::TestCase
   end    
   
   def test_instantiate
-    object = @runtime.instantiate 1, C1
+    object = @runtime.instantiate 1, C1.name
     assert object
     assert_equal  1, object.primary_key
     assert_equal C1, object.class
   end
   
   def test_instantiate_existing
-    o0 = @runtime.instantiate 1, C1
-    o1 = @runtime.instantiate 1, C1
+    o0 = @runtime.instantiate 1, C1.name
+    o1 = @runtime.instantiate 1, C1.name
 
     assert o0.equal?(o1)
     assert_equal o0, o1
@@ -284,10 +284,15 @@ class Rubernate::BaseRuntimeTest < Test::Unit::TestCase
       assert_equal o_.object_id, o__.object_id       
     end
   end
-  
-  def test_instantiate_invalid_class
-    @runtime.instantiate 1, C1
-    assert_raise(RuntimeError) { @runtime.instantiate 1, C2 }
+    
+  def test_instantiate_fake_class
+    @factory.database = {27 => ['NoSuchClass', {}]}
+    Rubernate.session do 
+      o = find_by_pk 27
+      assert_equal FakeEntity, o.class
+      assert_equal 27, o.primary_key
+      assert_raise(ObjectLoadError) {o.test}
+    end
   end
   
   def test_modified

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.8.11
 specification_version: 1
 name: Rubernate
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
-date: 2006-03-06 00:00:00 +03:00
+  version: 0.1.1
+date: 2006-03-07 00:00:00 +03:00
 summary: Object-oriented storage for Ruby objects based on relational database model
 require_paths: 
 - lib