perobs 2.1.1 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 231bcc1e34113cad62eefa5bdac4b84d18937638
-  data.tar.gz: dfe932b0e210297a4a24a5a2c076d52db04c5ff6
+  metadata.gz: 862c67d14741c0fe0145af7c5eb1c1c147ebe189
+  data.tar.gz: c88f1c19c16db2c6b3f2fd046cbb4d41e9fce2c3
 SHA512:
-  metadata.gz: 433b39b2568538a634e53adc0bf6ae2ac8f4f8d6a24178b406d5b6de92981d141f6a29ce6a344388eedc5b1c0632e02d4bef6c2996c18650b7805501de29718a
-  data.tar.gz: 78904802a71bb2b958f79eebb70c945d5506267bf83c1e921de8ec4478a4e88e5fcfe9bf5409beecda8dd7fb4ea6358a366e3640dbd0965365a387f9b324d4e0
+  metadata.gz: 11fd013bb0da3088a4ed88dfac390aac5b8cef823fd2bdeb06ab8c7ad4fedbde997365e0f135bae63b72acf5ee9ad3ac10f5640ac6b703785876514be3a480f1
+  data.tar.gz: d13b9dd12084975bc5d6e84e6fcc0f91b3f455e56d4532c7a37983c53dd1054db211e8244c8317da5f0cb85e32ce4ce01564e9a3684b442c01bfdf889735a393

data/README.md

@@ -32,8 +32,17 @@ When you derive your own class from PEROBS::Object you need to
 specify which instance variables should be persistent. By using
 po_attr you can provide a list of symbols that describe the instance
 variables to persist. This will also create getter and setter methods
-for these instance varables.  You can use attr_init in the constructor
-to define default values for your persistent objects.
+for these instance varables.  You can set default values in the
+constructor . The constructor of PEROBS::ObjectBase derived objects
+must have at least one argument. The first argument is a PEROBS
+internal object that must be passed to super() as first thing in
+initialize(). You can have other arguments if needed. Be aware that
+initialize() is not called when objects are restored from the
+database! You can define a restore() method to deal with object
+initialization or modification after restore from database. restore()
+is also the proper place to initialize non-persistent instance
+variables.  New objects are created via Store.new() so you cannot call
+the constructor directly in your code.
 
 To start off you must create at least one PEROBS::Store object that
 owns your persistent objects. The store provides the persistent
@@ -52,10 +61,10 @@ almost every Ruby data type. YAML is much slower than JSON and Marshal
 is not guaranteed to be compatible between Ruby versions.
 
 Once you have created a store you can assign objects to it. All
-persistent objects must be created with @store.new(). This is
+persistent objects must be created with Store.new(). This is
 necessary as you will only deal with proxy objects in your code.
 Except for the member methods, you will never deal with the objects
-directly. Instead @store.new() returns a POXReference object that acts
+directly. Instead Store.new() returns a POXReference object that acts
 as a transparent proxy. This proxy is needed as your code never knows
 if the actual object is really loaded into the memory or not. PEROBS
 will handle this transparently for you.
@@ -85,13 +94,19 @@ class Person < PEROBS::Object
 
   po_attr :name, :mother, :father, :kids, :spouse, :status
 
-  def initialize(store, name)
-    super
+  def initialize(p, name)
+    super(p)
     attr_init(:name, name)
     attr_init(:kids, store.new(PEROBS::Array))
     attr_init(:status, :single)
   end
 
+  def restore
+    # Use block version of attr_init() to avoid creating unneded
+    # objects. The block is only called when @father doesn't exist yet.
+    attr_init(:father) do { store.new(Person, 'Dad') }
+  end
+
   def merry(spouse)
     self.spouse = spouse
     self.status = :married
@@ -148,6 +163,12 @@ when it detects such objects. Just remember to use myself() instead of
 self() if you want to pass a reference to the current persistent
 object to another object.
 
+### Caveats and known issues
+
+PEROBS is currently not thread-safe. You cannot simultaneously access
+the database from multiple application. You must provide your own
+locking mechanism to prevent this from happening.
+
 ## Installation
 
 Add this line to your application's Gemfile:

data/lib/perobs/Array.rb

@@ -79,13 +79,16 @@ module PEROBS
     # New PEROBS objects must always be created by calling # Store.new().
     # PEROBS users should never call this method or equivalents of derived
     # methods directly.
-    # @param store [Store] The Store this hash is stored in
+    # @param p [PEROBS::Handle] PEROBS handle
     # @param size [Fixnum] The requested size of the Array
     # @param default [Any] The default value that is returned when no value is
     #        stored for a specific key.
-    def initialize(store, size = 0, default = nil)
-      super(store)
+    def initialize(p, size = 0, default = nil)
+      super(p)
       @data = ::Array.new(size, default)
+
+      # Ensure that the newly created object will be pushed into the database.
+      @store.cache.cache_write(self)
     end
 
     # Return a list of all object IDs of all persistend objects that this Array

data/lib/perobs/BTreeBlob.rb

@@ -118,7 +118,7 @@ module PEROBS
 
       unless found
         raise ArgumentError,
-              "Cannot find an entry for ID #{'%016X' % id} to mark"
+              "Cannot find an entry for ID #{'%016X' % id} #{id} to mark"
       end
 
       write_index
@@ -126,12 +126,15 @@ module PEROBS
 
     # Check if the entry for a given ID is marked.
     # @param id [Fixnum or Bignum] ID of the entry
+    # @param ignore_errors [Boolean] If set to true no errors will be raised
+    #        for non-existing objects.
     # @return [TrueClass or FalseClass] true if marked, false otherwise
-    def is_marked?(id)
+    def is_marked?(id, ignore_errors = false)
       @entries.each do |entry|
         return entry[MARKED] != 0 if entry[ID] == id
       end
 
+      return false if ignore_errors
       raise ArgumentError,
             "Cannot find an entry for ID #{'%016X' % id} to check"
     end
@@ -266,7 +269,10 @@ module PEROBS
 
       # Create a new entry and insert it. The order must match the above
       # defined constants!
-      entry = [ id, bytes, best_fit_start || end_of_last_entry, 0 ]
+      # Object reads can trigger creation of new objects. As the marking
+      # process triggers reads as well, all newly created objects are always
+      # marked to prevent them from being collected right after creation.
+      entry = [ id, bytes, best_fit_start || end_of_last_entry, 1 ]
       @entries.insert(best_fit_index, entry)
       @entries_by_id[id] = entry
 

data/lib/perobs/BTreeDB.rb

@@ -173,8 +173,10 @@ module PEROBS
 
     # Check if the object is marked.
     # @param id [Fixnum or Bignum] ID of the object to check
-    def is_marked?(id)
-      (blob = find_blob(id)) && blob.is_marked?(id)
+    # @param ignore_errors [Boolean] If set to true no errors will be raised
+    #        for non-existing objects.
+    def is_marked?(id, ignore_errors = false)
+      (blob = find_blob(id)) && blob.is_marked?(id, ignore_errors)
     end
 
     # Basic consistency check.

data/lib/perobs/Cache.rb

@@ -69,7 +69,9 @@ module PEROBS
         # If this condition triggers, we have a bug in the library.
         raise RuntimeError, "POXReference objects should never be cached"
       end
+
       if @transaction_stack.empty?
+        # We are not in transaction mode.
         idx = index(obj)
         if (old_obj = @writes[idx]) && old_obj._id != obj._id
           # There is another old object using this cache slot. Before we can
@@ -83,45 +85,29 @@ module PEROBS
         cache_read(obj)
         # Push the reference of the modified object into the write buffer for
         # this transaction level.
-        unless @transaction_stack.last.include?(obj)
-          @transaction_stack.last << obj
+        unless @transaction_stack.last.include?(obj._id)
+          @transaction_stack.last << obj._id
+          @transaction_objects[obj._id] = obj
         end
       end
     end
 
-    # Remove an object from the write cache. This will prevent a modified
-    # object from being written to the back-end store.
-    def unwrite(obj)
-      if @transaction_stack.empty?
-        idx = index(obj)
-        if (old_obj = @writes[idx]).nil? || old_obj._id != obj._id
-          raise RuntimeError, "Object to unwrite is not in cache"
-        end
-        @writes[idx] = nil
-      else
-        unless @transaction_stack.last.include?(obj)
-          raise RuntimeError, 'unwrite failed'
-        end
-        @transaction_stack.last.delete(obj)
-      end
-    end
-
     # Return the PEROBS::Object with the specified ID or nil if not found.
     # @param id [Fixnum or Bignum] ID of the cached PEROBS::ObjectBase
-    def object_by_id(id)
-      idx = id & @mask
-      # The index is just a hash. We still need to check if the object IDs are
-      # actually the same before we can return the object.
-      if (obj = @writes[idx]) && obj._id == id
-        # The object was in the write cache.
-        return obj
-      elsif (obj = @reads[idx]) && obj._id == id
-        # The object was in the read cache.
-        return obj
-      end
-
-      nil
-    end
+    #def object_by_id(id)
+    #  idx = id & @mask
+    #  # The index is just a hash. We still need to check if the object IDs are
+    #  # actually the same before we can return the object.
+    #  if (obj = @writes[idx]) && obj._id == id
+    #    # The object was in the write cache.
+    #    return obj
+    #  elsif (obj = @reads[idx]) && obj._id == id
+    #    # The object was in the read cache.
+    #    return obj
+    #  end
+
+    #  nil
+    #end
 
     # Flush all pending writes to the persistant storage back-end.
     def flush
@@ -140,12 +126,14 @@ module PEROBS
     # active, the write cached is flushed before the transaction is started.
     def begin_transaction
       if @transaction_stack.empty?
-        # This is the top-level transaction. Flush the write buffer to save
-        # the current state of all objects.
+        # The new transaction is the top-level transaction. Flush the write
+        # buffer to save the current state of all objects.
         flush
       else
-        @transaction_stack.last.each do |o|
-          o._stash(@transaction_stack.length - 1)
+        # Save a copy of all objects that were modified during the enclosing
+        # transaction.
+        @transaction_stack.last.each do |id|
+          @transaction_objects[id]._stash(@transaction_stack.length - 1)
         end
       end
       # Push a transaction buffer onto the transaction stack. This buffer will
@@ -163,7 +151,8 @@ module PEROBS
       when 1
         # All transactions completed successfully. Write all modified objects
         # into the backend storage.
-        @transaction_stack.pop.each { |o| o._sync }
+        @transaction_stack.pop.each { |id| @transaction_objects[id]._sync }
+        @transaction_objects = ::Hash.new
       else
         # A nested transaction completed successfully. We add the list of
         # modified objects to the list of the enclosing transaction.
@@ -182,7 +171,9 @@ module PEROBS
       if @transaction_stack.empty?
         raise RuntimeError, 'No ongoing transaction to abort'
       end
-      @transaction_stack.pop.each { |o| o._restore(@transaction_stack.length) }
+      @transaction_stack.pop.each do |id|
+        @transaction_objects[id]._restore(@transaction_stack.length)
+      end
     end
 
     # Clear all cached entries. You must call flush before calling this
@@ -193,7 +184,8 @@ module PEROBS
       # the read or write cache Arrays.
       @reads = ::Array.new(2 ** @bits)
       @writes = ::Array.new(2 ** @bits)
-      @transaction_stack = []
+      @transaction_stack = ::Array.new
+      @transaction_objects = ::Hash.new
     end
 
     # Don't include the cache buffers in output of other objects that

data/lib/perobs/Handle.rb

@@ -0,0 +1,44 @@
+# encoding: UTF-8
+#
+# = Handle.rb -- Persistent Ruby Object Store
+#
+# Copyright (c) 2015, 2016 by Chris Schlaeger <chris@taskjuggler.org>
+#
+# MIT License
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+module PEROBS
+
+  # The Handle is the first paramter of the initialize() method of every
+  # PEROBS object. By convention this parameter should be called 'p'.
+  class Handle
+
+    attr_reader :store, :id
+
+    def initialize(store, id)
+      @store = store
+      @id = id
+    end
+
+  end
+
+end
+

data/lib/perobs/Hash.rb

@@ -77,13 +77,16 @@ module PEROBS
     # New PEROBS objects must always be created by calling # Store.new().
     # PEROBS users should never call this method or equivalents of derived
     # methods directly.
-    # @param store [Store] The Store this hash is stored in
+    # @param p [PEROBS::Handle] PEROBS handle
     # @param default [Any] The default value that is returned when no value is
     #        stored for a specific key.
-    def initialize(store, default = nil)
-      super(store)
+    def initialize(p, default = nil)
+      super(p)
       @default = nil
       @data = {}
+
+      # Ensure that the newly created object will be pushed into the database.
+      @store.cache.cache_write(self)
     end
 
     # Return a list of all object IDs of all persistend objects that this Hash

data/lib/perobs/Object.rb

@@ -79,14 +79,17 @@ module PEROBS
     # New PEROBS objects must always be created by calling # Store.new().
     # PEROBS users should never call this method or equivalents of derived
     # methods directly.
-    def initialize(store)
-      super
+    # @param p [PEROBS::Handle] PEROBS handle
+    def initialize(p)
+      super(p)
+
+      # Ensure that the newly created object will be pushed into the database.
+      @store.cache.cache_write(self)
     end
 
-    # Initialize the specified attribute _attr_ with the value _val_ unless
-    # the attribute has been initialized already. Use this method in the class
-    # constructor to avoid overwriting values that have been set when the
-    # object was reconstructed from the store.
+    # This method is deprecated. It will be removed in future versions. Please
+    # use attr_init() instead.
+    # the database.
     # @param attr [Symbol] Name of the attribute
     # @param val [Any] Value to be set
     # @return [true|false] True if the value was initialized, otherwise false.
@@ -99,6 +102,26 @@ module PEROBS
       false
     end
 
+    # Use this method to initialize persistent attributes in the restore()
+    # method that have not yet been initialized. This is the case when the
+    # object was saved with an earlier version of the program that did not yet
+    # have the instance variable. If you want to assign another PEROBS object
+    # to the variable you should use the block variant to avoid unnecessary
+    # creation of PEROBS object that later need to be collected again.
+    def attr_init(attr, val = nil, &block)
+      if _all_attributes.include?(attr)
+        unless instance_variable_defined?('@' + attr.to_s)
+          _set(attr, block_given? ? yield : val)
+        end
+        return true
+      else
+        raise ArgumentError, "'#{attr}' is not a defined persistent " +
+                             "attribute of class #{self.class}"
+      end
+
+      false
+    end
+
     # Call this method to manually mark the object as modified. This is
     # necessary if you are using the '@' notation to access instance variables
     # during assignment operations (=, +=, -=, etc.). To avoid having to call
@@ -154,13 +177,13 @@ module PEROBS
     # Textual dump for debugging purposes
     # @return [String]
     def inspect
-      "{\n" +
+      "#{to_s}:#{@_id}\n{\n" +
       _all_attributes.map do |attr|
         ivar = ('@' + attr.to_s).to_sym
-        if (value = instance_variable_get(ivar)).respond_to?('is_poxreference?')
-          "  #{attr}=>#{value.class}:#{value._id}"
+        if (value = instance_variable_get(ivar)).respond_to?(:is_poxreference?)
+          "  #{attr} => <PEROBS::ObjectBase:#{value._id}>"
         else
-          "  #{attr}=>#{value}"
+          "  #{attr} => #{value.inspect}"
         end
       end.join(",\n") +
       "\n}\n"
@@ -195,7 +218,8 @@ module PEROBS
                              'you are trying to assign here?'
       end
       instance_variable_set(('@' + attr.to_s).to_sym, val)
-      # Let the store know that we have a modified object.
+      # Let the store know that we have a modified object. If we restored the
+      # object from the DB, we don't mark it as modified.
       mark_as_modified
 
       val

data/lib/perobs/ObjectBase.rb

@@ -120,23 +120,25 @@ module PEROBS
     # New PEROBS objects must always be created by calling # Store.new().
     # PEROBS users should never call this method or equivalents of derived
     # methods directly.
-    def initialize(store)
-      @store = store
-      unless @store.object_creation_in_progress
-        ::Kernel.raise ::RuntimeError,
-          "All PEROBS objects must exclusively be created by calling " +
-          "Store.new(). Never call the object constructor directly."
-      end
-      @_id = @store._new_id
+    # @param p [PEROBS::Handle] PEROBS handle
+    def initialize(p)
+      _initialize(p)
+    end
+
+    # This is the real code for initialize. It is called from initialize() but
+    # also when we restore objects from the database. In the later case, we
+    # don't call the regular constructors. But this code must be exercised on
+    # object creation with new() and on restore from DB.
+    # param p [PEROBS::Handle] PEROBS handle
+    def _initialize(p)
+      @store = p.store
+      @_id = p.id
       @store._register_in_memory(self, @_id)
       ObjectSpace.define_finalizer(self, ObjectBase._finalize(@store, @_id))
       @_stash_map = nil
       # Allocate a proxy object for this object. User code should only operate
       # on this proxy, never on self.
       @myself = POXReference.new(@store, @_id)
-
-      # Let the store know that we have a modified object.
-      @store.cache.cache_write(self)
     end
 
     # This method generates the destructor for the objects of this class. It
@@ -150,8 +152,10 @@ module PEROBS
     # This method can be overloaded by derived classes to do some massaging on
     # the data after it has been restored from the database. This could either
     # be some sanity check or code to migrate the object from one version to
-    # another.
-    def post_restore
+    # another. It is also the right place to initialize non-persistent
+    # instance variables as initialize() will only be called when objects are
+    # created for the first time.
+    def restore
     end
 
     # Two objects are considered equal if their object IDs are the same.
@@ -181,9 +185,10 @@ module PEROBS
 
       klass = store.class_map.id_to_class(db_obj['class_id'])
       # Call the constructor of the specified class.
-      obj = store._construct_po(Object.const_get(klass), id)
+      obj = Object.const_get(klass).allocate
+      obj._initialize(Handle.new(store, id))
       obj._deserialize(db_obj['data'])
-      obj.post_restore
+      obj.restore
 
       obj
     end
@@ -195,22 +200,21 @@ module PEROBS
       # any previous stash level or in the regular object DB. If the object
       # was created during the transaction, there is not previous state to
       # restore to.
-      id = nil
+      data = nil
       if @_stash_map
         (level - 1).downto(0) do |lvl|
           if @_stash_map[lvl]
-            id = @_stash_map[lvl]
+            data = @_stash_map[lvl]
             break
           end
         end
       end
-      unless id
-        if @store.db.include?(@_id)
-          id = @_id
-        end
-      end
-      if id
-        db_obj = store.db.get_object(id)
+      if data
+        # We have a stashed version that we can restore from.
+        _deserialize(data)
+      elsif @store.db.include?(@_id)
+        # We have no stashed version but can restore from the database.
+        db_obj = store.db.get_object(@_id)
         _deserialize(db_obj['data'])
       end
     end
@@ -219,25 +223,9 @@ module PEROBS
     # back-end. The object gets a new ID that is stored in @_stash_map to map
     # the stash ID back to the original data.
     def _stash(level)
-      db_obj = {
-        'class' => self.class.to_s,
-        'data' => _serialize
-      }
-      @_stash_map = [] unless @_stash_map
+      @_stash_map ||= ::Array.new
       # Get a new ID to store this version of the object.
-      @_stash_map[level] = stash_id = @store._new_id
-      @store.db.put_object(db_obj, stash_id)
-    end
-
-    # Library internal method. Do not use outside of this library.
-    # @private
-    def _change_id(id)
-      # Unregister the object with the old ID from the write cache to prevent
-      # cache corruption. The objects are index by ID in the cache.
-      @store.cache.unwrite(self)
-      @store._collect(@_id)
-      @store._register_in_memory(self, id)
-      @_id = id
+      @_stash_map[level] = _serialize
     end
 
   end

data/lib/perobs/Store.rb

@@ -28,6 +28,7 @@
 require 'set'
 require 'weakref'
 
+require 'perobs/Handle'
 require 'perobs/Cache'
 require 'perobs/ClassMap'
 require 'perobs/BTreeDB'
@@ -38,6 +39,9 @@ require 'perobs/Array'
 # PErsistent Ruby OBject Store
 module PEROBS
 
+  Statistics = Struct.new(:in_memory_objects, :root_objects,
+                          :marked_objects, :swept_objects)
+
   # PEROBS::Store is a persistent storage system for Ruby objects. Regular
   # Ruby objects are transparently stored in a back-end storage and retrieved
   # when needed. It features a garbage collector that removes all objects that
@@ -64,8 +68,8 @@ module PEROBS
   #
   #   po_attr :name, :mother, :father, :kids
   #
-  #   def initialize(store, name)
-  #     super
+  #   def initialize(cf, name)
+  #     super(cf)
   #     attr_init(:name, name)
   #     attr_init(:kids, @store.new(PEROBS::Array))
   #   end
@@ -89,7 +93,7 @@ module PEROBS
   #
   class Store
 
-    attr_reader :db, :cache, :class_map, :object_creation_in_progress
+    attr_reader :db, :cache, :class_map
 
     # Create a new Store.
     # @param data_base [String] the name of the database
@@ -125,14 +129,14 @@ module PEROBS
       # Create a map that can translate classes to numerical IDs and vice
       # versa.
       @class_map = ClassMap.new(@db)
-      # This flag is used to check that PEROBS objects are only created via
-      # the Store.new() call by PEROBS users.
-      @object_creation_in_progress = false
 
       # List of PEROBS objects that are currently available as Ruby objects
       # hashed by their ID.
       @in_memory_objects = {}
 
+      # This objects keeps some counters of interest.
+      @stats = Statistics.new
+
       # The Cache reduces read and write latencies by keeping a subset of the
       # objects in memory.
       @cache = Cache.new(options[:cache_bits] || 16)
@@ -141,8 +145,7 @@ module PEROBS
       unless (@root_objects = object_by_id(0))
         # The root object hash always has the object ID 0.
         @root_objects = _construct_po(Hash, 0)
-        # The ID change removes it from the write cache. We need to add it
-        # again.
+        # Mark the root_objects object as modified.
         @cache.cache_write(@root_objects)
       end
     end
@@ -151,29 +154,29 @@ module PEROBS
     # this Store.
     # @param klass [Class] The class of the object you want to create. This
     #        must be a derivative of ObjectBase.
-    # @param *args Optional list of other arguments that are passed to the
+    # @param args Optional list of other arguments that are passed to the
     #        constructor of the specified class.
     # @return [POXReference] A reference to the newly created object.
     def new(klass, *args)
-      _construct_po(klass, nil, *args).myself
+      unless klass.is_a?(BasicObject)
+        raise ArgumentError, "#{klass} is not a BasicObject derivative"
+      end
+
+      obj = _construct_po(klass, _new_id, *args)
+      # Mark the new object as modified so it gets pushed into the database.
+      @cache.cache_write(obj)
+      # Return a POXReference proxy for the newly created object.
+      obj.myself
     end
 
     # For library internal use only!
     # This method will create a new PEROBS object.
     # @param klass [BasicObject] Class of the object to create
-    # @param id [Fixnum, Bignum or nil] Requested object ID or nil
-    # @param *args [Array] Arguments to pass to the object constructor.
+    # @param id [Fixnum, Bignum] Requested object ID
+    # @param args [Array] Arguments to pass to the object constructor.
     # @return [BasicObject] Newly constructed PEROBS object
     def _construct_po(klass, id, *args)
-      unless klass.is_a?(BasicObject)
-        raise ArgumentError, "#{klass} is not a BasicObject derivative"
-      end
-      @object_creation_in_progress = true
-      obj = klass.new(self, *args)
-      @object_creation_in_progress = false
-      # If a specific object ID was requested we need to set it now.
-      obj._change_id(id) if id
-      obj
+      klass.new(Handle.new(self, id), *args)
     end
 
     # Delete the entire store. The store is no longer usable after this
@@ -230,7 +233,7 @@ module PEROBS
     # needed.
     def sync
       if @cache.in_transaction?
-        raise RuntimeError, 'You cannot call sync during a transaction'
+        raise RuntimeError, 'You cannot call sync() during a transaction'
       end
       @cache.flush
     end
@@ -241,6 +244,9 @@ module PEROBS
     # method periodically.
     # @return [Fixnum] The number of collected objects
     def gc
+      if @cache.in_transaction?
+        raise RuntimeError, 'You cannot call gc() during a transaction'
+      end
       sync
       mark
       sweep
@@ -282,7 +288,7 @@ module PEROBS
     # @param repair [TrueClass/FalseClass] true if a repair attempt should be
     #        made.
     # @return [Fixnum] The number of references to bad objects found.
-    def check(repair = true)
+    def check(repair = false)
       # All objects must have in-db version.
       sync
       # Run basic consistency checks first.
@@ -325,16 +331,18 @@ module PEROBS
       # Start with the object 0 and the indexes of the root objects. Push them
       # onto the work stack.
       stack = [ 0 ] + @root_objects.values
-      stack.each { |id| @db.mark(id) }
       while !stack.empty?
         # Get an object index from the stack.
-        obj = object_by_id(id = stack.pop)
-        yield(POXReference.new(self, id)) if block_given?
-        obj._referenced_object_ids.each do |id|
-          unless @db.is_marked?(id)
-            @db.mark(id)
-            stack << id
-          end
+        unless (obj = object_by_id(id = stack.pop))
+          raise RuntimeError, "Database is corrupted. Object with ID #{id} " +
+                              "not found."
+        end
+        # Mark the object so it will never be pushed to the stack again.
+        @db.mark(id)
+        yield(obj.myself) if block_given?
+        # Push the IDs of all unmarked referenced objects onto the stack
+        obj._referenced_object_ids.each do |r_id|
+          stack << r_id unless @db.is_marked?(r_id)
         end
       end
     end
@@ -382,10 +390,10 @@ module PEROBS
 
     # This method returns a Hash with some statistics about this store.
     def statistics
-      {
-        :in_memory_objects => @in_memory_objects.length,
-        :root_objects => 0 #@root_objects.length
-      }
+      @stats.in_memory_objects = @in_memory_objects.length
+      @stats.root_objects = @root_objects.length
+
+      @stats
     end
 
     private
@@ -394,16 +402,21 @@ module PEROBS
     # objects that are reachable from the root objects.
     def mark
       classes = Set.new
-      each { |obj| classes.add(obj.class) }
+      marked_objects = 0
+      each { |obj| classes.add(obj.class); marked_objects += 1 }
       @class_map.keep(classes.map { |c| c.to_s })
+
+      # The root_objects object is included in the count, but we only want to
+      # count user objects here.
+      @stats.marked_objects = marked_objects - 1
     end
 
     # Sweep phase of a mark-and-sweep garbage collector. It will remove all
     # unmarked objects from the store.
     def sweep
-      cntr = @db.delete_unmarked_objects.length
+      @stats.swept_objects = @db.delete_unmarked_objects.length
       @cache.reset
-      cntr
+      @stats.swept_objects
     end
 
     # Check the object with the given start_id and all other objects that are
@@ -431,11 +444,19 @@ module PEROBS
           obj._referenced_object_ids.each do |refd_id|
             # Push them onto the todo list unless they have been marked
             # already.
-            todo_list << [ obj, refd_id ] unless @db.is_marked?(refd_id)
+            todo_list << [ obj, refd_id ] unless @db.is_marked?(refd_id, true)
           end
         else
           # Remove references to bad objects.
-          ref_obj._delete_reference_to_id(id) if ref_obj && repair
+          if ref_obj && repair
+            $stderr.puts "Fixing broken reference to #{id} in\n" +
+                         ref_obj.inspect
+            ref_obj._delete_reference_to_id(id)
+          else
+            raise RuntimeError,
+              "The following object references a non-existing object #{id}:\n" +
+              ref_obj.inspect
+          end
           errors += 1
         end
       end

data/lib/perobs/version.rb

@@ -1,4 +1,4 @@
 module PEROBS
   # The version number
-  VERSION = "2.1.1"
+  VERSION = "2.2.0"
 end

data/test/Array_spec.rb

@@ -60,6 +60,21 @@ describe PEROBS::Array do
     @store.delete_store
   end
 
+  it 'should store an empty Array persistently' do
+    @store['a'] = @store.new(PEROBS::Array)
+    @store.transaction do
+      @store['b'] = @store.new(PEROBS::Array)
+    end
+    @store.sync
+    @store = nil
+    GC.start
+
+    @store = PEROBS::Store.new(@db_name)
+    a = @store['a']
+    expect(a.length).to eq(0)
+    expect(@store['b'].length).to eq(0)
+  end
+
   it 'should store simple objects persistently' do
     @store['a'] = a = @store.new(PEROBS::Array)
     a[0] = 'A'

data/test/Object_spec.rb

@@ -42,9 +42,9 @@ class O2 < PEROBS::Object
 
   def initialize(store)
     super
-    init_attr(:a1, 'a1')
-    init_attr(:a2, nil)
-    init_attr(:a4, 42)
+    attr_init(:a1, 'a1')
+    attr_init(:a2, nil)
+    attr_init(:a4, 42)
   end
 
   def a3_deref
@@ -110,15 +110,23 @@ describe PEROBS::Store do
     o2.a3 = o1
     o2.a4 = @store.new(PEROBS::Array)
     o2.a4 += [ 0, 1, 2 ]
+    @store.transaction do
+      @store['o3'] = o3 = @store.new(O1)
+      o3.a1 = @store.new(PEROBS::Array)
+    end
     @store.sync
+    @store = nil
+    GC.start
 
     @store = PEROBS::Store.new(@db_name)
     o1 = @store['o1']
     o2 = @store['o2']
+    o3 = @store['o3']
     expect(o1.a1).to eq('a1')
     expect(o2.a1).to be_nil
     expect(o2.a3).to eq(o1)
     expect(o2.a4).to eq([ 0, 1, 2 ])
+    expect(o3.a1).to eq([])
   end
 
   it 'should transparently access a referenced object' do

data/test/Store_spec.rb

@@ -35,9 +35,9 @@ class Person < PEROBS::Object
 
   def initialize(store)
     super
-    init_attr(:name, '')
-    init_attr(:bmi, 22.2)
-    init_attr(:married, false)
+    attr_init(:name, '')
+    attr_init(:bmi, 22.2)
+    attr_init(:married, false)
   end
 
 end
@@ -48,30 +48,30 @@ class PersonN < PEROBS::Object
 
   def initialize(store)
     super
-    init_attr(:name, '')
-    init_attr(:bmi, 22.2)
-    init_attr(:married, false)
+    attr_init(:name, '')
+    attr_init(:bmi, 22.2)
+    attr_init(:married, false)
   end
 
 end
 
 class O0 < PEROBS::Object
 
-  po_attr :r
+  po_attr :child
 
   def initialize(store)
     super
-    r = @store.new(O1, myself)
+    self.child = @store.new(O1, myself)
   end
 
 end
 class O1 < PEROBS::Object
 
-  po_attr :p
+  po_attr :parent
 
   def initialize(store, p = nil)
     super(store)
-    parent = p
+    self.parent = p
   end
 
 end
@@ -145,11 +145,6 @@ describe PEROBS::Store do
     end
   end
 
-  it 'should not allow calls to BasicObject.new()' do
-    @store = PEROBS::Store.new(@db_file)
-    expect { Person.new(@store) }.to raise_error RuntimeError
-  end
-
   it 'should flush cached objects when necessary' do
     @store = PEROBS::Store.new(@db_file, :cache_bits => 3)
     last_obj = nil
@@ -431,11 +426,13 @@ describe PEROBS::Store do
 
   it 'should handle nested constructors' do
     @store = PEROBS::Store.new(@db_file)
-    @store['r'] = @store.new(O0)
+    @store['root'] = @store.new(O0)
     @store.sync
     expect(@store.check).to eq(0)
+
     @store = PEROBS::Store.new(@db_file)
     expect(@store.check).to eq(0)
+    expect(@store['root'].child.parent).to eq(@store['root'])
   end
 
   it 'should survive a real world usage test' do
@@ -443,58 +440,70 @@ describe PEROBS::Store do
     @store = PEROBS::Store.new(@db_file, options)
     ref = {}
 
-    0.upto(2000) do |i|
+    deletions_since_last_gc = 0
+    0.upto(5000) do |i|
       key = "o#{i}"
-      case i % 8
+      case rand(8)
       when 0
+        # Add 'A' person
         value = 'A' * rand(512)
         @store[key] = p = @store.new(Person)
         p.name = value
         ref[key] = value
-        @store.sync
       when 1
+        # Add 'B' person
         value = 'B' * rand(128)
         @store[key] = p = @store.new(Person)
         p.name = value
         ref[key] = value
       when 2
-        index = i - rand(20)
-        if index >= 0
-          key = "o#{i - rand(20)}"
+        # Delete a root entry
+        if ref.keys.length > 11
+          key = ref.keys[(ref.keys.length / 11).to_i]
+          expect(@store[key]).not_to be_nil
           @store[key] = nil
           ref.delete(key)
+          deletions_since_last_gc += 1
         end
       when 3
-        @store.gc if rand(30) == 0
+        # Call garbage collector
+        if rand(30) == 0
+          @store.gc
+          stats = @store.statistics
+          expect(stats.marked_objects).to eq(ref.length)
+          expect(stats.swept_objects).to eq(deletions_since_last_gc)
+          deletions_since_last_gc = 0
+          expect(@store.gc).to eq(deletions_since_last_gc)
+        end
       when 4
+        # Sync store and reload
         if rand(15) == 0
           @store.sync
           @store = PEROBS::Store.new(@db_file, options)
         end
       when 5
-        index = i - rand(10)
-        if rand(3) == 0 && index >= 0
-          key = "o#{i - rand(10)}"
+        # Replace an entry with 'C' person
+        if ref.keys.length > 13
+          key = ref.keys[(ref.keys.length / 13).to_i]
           value = 'C' * rand(1024)
           @store[key] = p = @store.new(Person)
           p.name = value
           ref[key] = value
+          deletions_since_last_gc += 1
         end
       when 6
+        # Sync and check store
         if rand(50) == 0
           @store.sync
           expect(@store.check(false)).to eq(0)
         end
       when 7
-        index = rand(i)
-        if ref[key]
+        # Compare a random entry with reference entry
+        if ref.keys.length > 0
+          key = ref.keys[rand(ref.keys.length - 1)]
           expect(@store[key].name).to eq(ref[key])
         end
       end
-
-      if ref[key]
-        expect(@store[key].name).to eq(ref[key])
-      end
     end
 
     ref.each do |k, v|

data/test/perobs_spec.rb

@@ -32,9 +32,9 @@ class Person < PEROBS::Object
 
   def initialize(store)
     super
-    init_attr(:name, '')
-    init_attr(:bmi, 22.2)
-    init_attr(:married, false)
+    attr_init(:name, '')
+    attr_init(:bmi, 22.2)
+    attr_init(:married, false)
   end
 
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: perobs
 version: !ruby/object:Gem::Version
-  version: 2.1.1
+  version: 2.2.0
 platform: ruby
 authors:
 - Chris Schlaeger
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-10 00:00:00.000000000 Z
+date: 2016-01-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -71,8 +71,8 @@ files:
 - lib/perobs/Cache.rb
 - lib/perobs/ClassMap.rb
 - lib/perobs/DataBase.rb
-- lib/perobs/Delegator.rb
 - lib/perobs/DynamoDB.rb
+- lib/perobs/Handle.rb
 - lib/perobs/Hash.rb
 - lib/perobs/Object.rb
 - lib/perobs/ObjectBase.rb

data/lib/perobs/Delegator.rb

@@ -1,78 +0,0 @@
-# encoding: UTF-8
-#
-# = Delegator.rb -- Persistent Ruby Object Store
-#
-# Copyright (c) 2015 by Chris Schlaeger <chris@taskjuggler.org>
-#
-# MIT License
-#
-# Permission is hereby granted, free of charge, to any person obtaining
-# a copy of this software and associated documentation files (the
-# "Software"), to deal in the Software without restriction, including
-# without limitation the rights to use, copy, modify, merge, publish,
-# distribute, sublicense, and/or sell copies of the Software, and to
-# permit persons to whom the Software is furnished to do so, subject to
-# the following conditions:
-#
-# The above copyright notice and this permission notice shall be
-# included in all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-require 'perobs/ClassMap'
-
-module PEROBS
-
-  # This Delegator module provides the methods to turn the PEROBS::Array and
-  # PEROBS::Hash into proxies for Array and Hash.
-  module Delegator
-
-    # Proxy all calls to unknown methods to the data object.
-    def method_missing(method_sym, *args, &block)
-      if self.class::READERS.include?(method_sym) ||
-         Enumerable.instance_methods.include?(method_sym)
-        # If any element of this class is read, we register this object as
-        # being read with the cache.
-        @store.cache.cache_read(self)
-        @data.send(method_sym, *args, &block)
-      elsif self.class::REWRITERS.include?(method_sym)
-        # Re-writers don't introduce any new elements. We just mark the object
-        # as written in the cache and call the class' method.
-        @store.cache.cache_write(self)
-        @data.send(method_sym, *args, &block)
-      elsif (alias_sym = self.class::ALIASES[method_sym])
-        @store.cache.cache_write(self)
-        send(alias_sym, *args, &block)
-      else
-        # Any method we don't know about must cause an error. A new class
-        # method needs to be added to the right bucket first.
-        raise NoMethodError.new("undefined method '#{method_sym}' for " +
-                                "#{self.class}")
-      end
-    end
-
-    def respond_to?(method_sym, include_private = false)
-      self.class::READERS.include?(method_sym) ||
-        Enumerable.instance_methods.include?(method_sym) ||
-        self.class::REWRITERS.include?(method_sym) ||
-        super
-    end
-
-    # Equivalent to Class::==
-    # This method is just a reader but also part of BasicObject. Hence
-    # BasicObject::== would be called instead of method_missing.
-    def ==(obj)
-      @store.cache.cache_read(self)
-      @data == obj
-    end
-
-  end
-
-end
-