perobs 1.1.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 34ecb42146422fb57aac3c2e41b914417f90521c
-  data.tar.gz: 941af4dcb9c8758ec16e82a4a14ec3c568d5a6de
+  metadata.gz: cea78483599ce586c57310a9d4aa622b3bfc3ca2
+  data.tar.gz: febaf3328e7a157a38529507a4a5a91a0bc49d2e
 SHA512:
-  metadata.gz: 84082c2754a7da996b04b09c1530f09f420ef03c4ff38db6287fb9fed96911cae9e6f442e20fb1d38185d477fb7ab7f95604a5bf0c7207b4feb5642984bfc8f8
-  data.tar.gz: 5df236bfeb70ca8434d9dd436407f17b5af159d20dc4a4398603d8200fb6964ddefa1fea247e16886c9bbbf2284336b4862efc2a64030be1bf8aff1b8eaa7afe
+  metadata.gz: 6be86d3f49ff2e7bb816d7a6a257f07642b01cd8bdb94636fc2ccbd571fd225e0cd281786372051fc940f84f5440001ab5519994980775bd710c73fef59cffeb
+  data.tar.gz: fc1632708462f8f81b15f28f8a0226d49521443bf6fc6a0b0f1470efcec0a9f81412a08093f956718d84ab9e02b3c5f6e31fa37fa9da3b949250f8c5904a8200

data/README.md

@@ -60,7 +60,7 @@ class Person < PEROBS::Object
   def initialize(store, name)
     super
     attr_init(:name, name)
-    attr_init(:kids, PEROBS::Array.new(store))
+    attr_init(:kids, store.new(PEROBS::Array))
   end
 
   def to_s
@@ -71,9 +71,9 @@ class Person < PEROBS::Object
 end
 
 store = PEROBS::Store.new('family')
-store['grandpa'] = joe = Person.new(store, 'Joe')
-store['grandma'] = jane = Person.new(store, 'Jane')
-jim = Person.new(store, 'Jim')
+store['grandpa'] = joe = store.new(Person, 'Joe')
+store['grandma'] = jane = store.new(Person, 'Jane')
+jim = store.new(Person, 'Jim')
 jim.father = joe
 joe.kids << jim
 jim.mother = jane

data/Rakefile

@@ -16,7 +16,5 @@ Dir.glob( 'tasks/*.rake').each do |fn|
   end
 end
 
-task :default  => :spec
-task :test => :spec
-
-desc 'Run all unit and spec tests'
+task :default  => :test
+desc 'Run all tests'

data/lib/perobs/Array.rb

@@ -30,11 +30,55 @@ require 'perobs/ObjectBase'
 module PEROBS
 
   # An Array that is transparently persisted onto the back-end storage. It is
-  # very similar to the Ruby built-in Array class but has some additional
-  # limitations. The hash key must always be a String.
+  # very similar to the Ruby built-in Array class but like other PEROBS
+  # object classes it converts direct references to other PEROBS objects into
+  # POXReference objects that only indirectly reference the other object. It
+  # also tracks all reads and write to any Array element and updates the cache
+  # accordingly.
+  #
+  # We don't support an Array.initialize_copy proxy as this would conflict
+  # with BasicObject.initialize_copy. You can use PEROBS::Array.replace()
+  # instead.
   class Array < ObjectBase
 
-    # Create a new PersistentArray object.
+    attr_reader :data
+
+    # These methods do not mutate the Array. They only perform read
+    # operations.
+    ([
+      :&, :*, :+, :-, :==, :[], :<=>, :at, :abbrev, :assoc, :bsearch, :collect,
+      :combination, :compact, :count, :cycle, :dclone, :drop, :drop_while,
+      :each, :each_index, :empty?, :eql?, :fetch, :find_index, :first,
+      :flatten, :frozen?, :hash, :include?, :index, :inspect, :join, :last,
+      :length, :map, :pack, :permutation, :pretty_print, :pretty_print_cycle,
+      :product, :rassoc, :reject, :repeated_combination,
+      :repeated_permutation, :reverse, :reverse_each, :rindex, :rotate,
+      :sample, :select, :shelljoin, :shuffle, :size, :slice, :sort, :take,
+      :take_while, :to_a, :to_ary, :to_s, :transpose, :uniq, :values_at, :zip,
+      :|
+    ] + Enumerable.instance_methods).uniq.each do |method_sym|
+      define_method(method_sym) do |*args, &block|
+        @store.cache.cache_read(self)
+        @data.send(method_sym, *args, &block)
+      end
+    end
+
+    # These methods mutate the Array.
+    [
+      :<<, :[]=, :clear, :collect!, :compact!, :concat, :delete, :delete_at,
+      :delete_if, :fill, :flatten!, :insert, :keep_if, :map!, :pop, :push,
+      :reject!, :replace, :select!, :reverse!, :rotate!, :shift, :shuffle!,
+      :slice!, :sort!, :sort_by!, :uniq!, :unshift
+    ].each do |method_sym|
+      define_method(method_sym) do |*args, &block|
+        @store.cache.cache_write(self)
+        @data.send(method_sym, *args, &block)
+      end
+    end
+
+    # 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 size [Fixnum] The requested size of the Array
     # @param default [Any] The default value that is returned when no value is
@@ -44,113 +88,22 @@ module PEROBS
       @data = ::Array.new(size, default)
     end
 
-    # Equivalent to Array::[]
-    def [](index)
-      _dereferenced(@data[index])
-    end
-
-    # Equivalent to Array::[]=
-    def []=(index, obj)
-      @data[index] = _referenced(obj)
-      @store.cache.cache_write(self)
-
-      obj
-    end
-
-    # Equivalent to Array::<<
-    def <<(obj)
-      @store.cache.cache_write(self)
-      @data << _referenced(obj)
-    end
-
-    # Equivalent to Array::+
-    def +(ary)
-      @store.cache.cache_write(self)
-      @data + ary
-    end
-
-    # Equivalent to Array::push
-    def push(obj)
-      @store.cache.cache_write(self)
-      @data.push(_referenced(obj))
-    end
-
-    # Equivalent to Array::pop
-    def pop
-      @store.cache.cache_write(self)
-      _dereferenced(@data.pop)
-    end
-
-    # Equivalent to Array::clear
-    def clear
-      @store.cache.cache_write(self)
-      @data.clear
-    end
-
-    # Equivalent to Array::delete
-    def delete(obj)
-      @store.cache.cache_write(self)
-      @data.delete { |v| _dereferenced(v) == obj }
-    end
-
-    # Equivalent to Array::delete_at
-    def delete_at(index)
-      @store.cache.cache_write(self)
-      @data.delete_at(index)
-    end
-
-    # Equivalent to Array::delete_if
-    def delete_if
-      @data.delete_if do |item|
-        yield(_dereferenced(item))
-      end
-    end
-
-    # Equivalent to Array::each
-    def each
-      @data.each do |item|
-        yield(_dereferenced(item))
-      end
-    end
-
-    # Equivalent to Array::empty?
-    def empty?
-      @data.empty?
-    end
-
-    # Equivalent to Array::include?
-    def include?(obj)
-      @data.each { |v| return true if _dereferenced(v) == obj }
-
-      false
-    end
-
-    # Equivalent to Array::length
-    def length
-      @data.length
-    end
-    alias size length
-
-    # Equivalent to Array::map
-    def map
-      @data.map do |item|
-        yield(_dereferenced(item))
-      end
-    end
-    alias collect map
-
     # Return a list of all object IDs of all persistend objects that this Array
     # is referencing.
     # @return [Array of Fixnum or Bignum] IDs of referenced objects
     def _referenced_object_ids
-      @data.each.select { |v| v && v.is_a?(POReference) }.map { |o| o.id }
+      @data.each.select do |v|
+        v && v.respond_to?(:is_poxreference?)
+      end.map { |o| o.id }
     end
 
     # This method should only be used during store repair operations. It will
     # delete all referenced to the given object ID.
     # @param id [Fixnum/Bignum] targeted object ID
     def _delete_reference_to_id(id)
-      @data.delete_if { |v| v && v.is_a?(POReference) && v.id == id }
+      @data.delete_if do |v|
+        v && v.respond_to?(:is_poxreference?) && v.id == id
+      end
     end
 
     # Restore the persistent data from a single data structure.
@@ -158,19 +111,16 @@ module PEROBS
     # @param data [Array] the actual Array object
     # @private
     def _deserialize(data)
-      @data = data
-    end
-
-    # Textual dump for debugging purposes
-    # @return [String]
-    def inspect
-      "[\n" + @data.map { |v| "  #{v.inspect}" }.join(",\n") + "\n]\n"
+      @data = data.map { |v| v.is_a?(POReference) ?
+                         POXReference.new(@store, v.id) : v }
     end
 
     private
 
     def _serialize
-      @data
+      @data.map do |v|
+        v.respond_to?(:is_poxreference?) ? POReference.new(v.id) : v
+      end
     end
 
   end

data/lib/perobs/BTreeDB.rb

@@ -103,7 +103,7 @@ module PEROBS
     # Return true if the object with given ID exists
     # @param id [Fixnum or Bignum]
     def include?(id)
-      (blob = find_blob(id)) && blob.find(id)
+      !(blob = find_blob(id)).nil? && !blob.find(id).nil?
     end
 
     # Store a simple Hash as a JSON encoded file into the DB directory.

data/lib/perobs/Cache.rb

@@ -51,12 +51,24 @@ module PEROBS
     # Add an PEROBS::Object to the read cache.
     # @param obj [PEROBS::ObjectBase]
     def cache_read(obj)
+      # This is just a safety check. It can probably be disabled in the future
+      # to increase performance.
+      if obj.respond_to?(:is_poxreference?)
+        # If this condition triggers, we have a bug in the library.
+        raise RuntimeError, "POXReference objects should never be cached"
+      end
       @reads[index(obj)] = obj
     end
 
     # Add a PEROBS::Object to the write cache.
     # @param obj [PEROBS::ObjectBase]
     def cache_write(obj)
+      # This is just a safety check. It can probably be disabled in the future
+      # to increase performance.
+      if obj.respond_to?(:is_poxreference?)
+        # If this condition triggers, we have a bug in the library.
+        raise RuntimeError, "POXReference objects should never be cached"
+      end
       if @transaction_stack.empty?
         idx = index(obj)
         if (old_obj = @writes[idx]) && old_obj._id != obj._id

data/lib/perobs/Delegator.rb

@@ -0,0 +1,78 @@
+# 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
+

data/lib/perobs/DynamoDB.rb

@@ -87,7 +87,7 @@ module PEROBS
     # Return true if the object with given ID exists
     # @param id [Fixnum or Bignum]
     def include?(id)
-      dynamo_get_item(id.to_s)
+      !dynamo_get_item(id.to_s).nil?
     end
 
     # Store a simple Hash as a JSON encoded file into the DB directory.

data/lib/perobs/Hash.rb

@@ -32,9 +32,51 @@ module PEROBS
   # A Hash that is transparently persisted in the back-end storage. It is very
   # similar to the Ruby built-in Hash class but has some additional
   # limitations. The hash key must always be a String.
+  #
+  # The implementation is largely a proxy around the standard Hash class. But
+  # all mutating methods must be re-implemented to convert PEROBS::Objects to
+  # POXReference objects and to register the object as modified with the
+  # cache.
+  #
+  # We explicitely don't support Hash::store() as it conflicts with
+  # ObjectBase::store() method to access the store.
   class Hash < ObjectBase
 
-    # Create a new PersistentHash object.
+    # These methods do not mutate the Hash. They only perform read
+    # operations.
+    ([
+      :==, :[], :assoc, :compare_by_identity, :compare_by_identity?, :default,
+      :default_proc, :each, :each_key, :each_pair, :each_value, :empty?,
+      :eql?, :fetch, :flatten, :has_key?, :has_value?, :hash, :include?,
+      :inspect, :invert, :key, :key?, :keys, :length, :member?, :merge,
+      :pretty_print, :pretty_print_cycle, :rassoc, :reject, :select, :size,
+      :to_a, :to_h, :to_hash, :to_s, :value?, :values, :values_at
+    ] + Enumerable.instance_methods).uniq.each do |method_sym|
+      # Create a wrapper method that passes the call to @data.
+      define_method(method_sym) do |*args, &block|
+        # Register the read operation with the cache.
+        @store.cache.cache_read(self)
+        @data.send(method_sym, *args, &block)
+      end
+    end
+
+    # These methods mutate the Hash.
+    [
+      :[]=, :clear, :default=, :default_proc=, :delete, :delete_if,
+      :initialize_copy, :keep_if, :merge!, :rehash, :reject!, :replace,
+      :select!, :shift, :update
+    ].each do |method_sym|
+      # Create a wrapper method that passes the call to @data.
+      define_method(method_sym) do |*args, &block|
+        # Register the write operation with the cache.
+        @store.cache.cache_write(self)
+        @data.send(method_sym, *args, &block)
+      end
+    end
+
+    # 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 default [Any] The default value that is returned when no value is
     #        stored for a specific key.
@@ -44,115 +86,21 @@ module PEROBS
       @data = {}
     end
 
-    # Retrieves the value object corresponding to the
-    # key object. If not found, returns the default value.
-    def [](key)
-      #unless key.is_a?(String)
-      #  raise ArgumentError, 'The Hash key must be of type String'
-      #end
-      _dereferenced(@data.include?(key) ? @data[key] : @default)
-    end
-
-    # Associates the value given by value with the key given by key.
-    # @param key [String] The key
-    # @param value [Any] The value to store
-    def []=(key, value)
-      #unless key.is_a?(String)
-      #  raise ArgumentError, 'The Hash key must be of type String'
-      #end
-      @data[key] = _referenced(value)
-      @store.cache.cache_write(self)
-
-      value
-    end
-
-    # Equivalent to Hash::clear
-    def clear
-      @store.cache.cache_write(self)
-      @data.clear
-    end
-
-    # Equivalent to Hash::delete
-    def delete(key)
-      @store.cache.cache_write(self)
-      @data.delete(key)
-    end
-
-    # Equivalent to Hash::delete_if
-    def delete_if
-      @store.cache.cache_write(self)
-      @data.delete_if do |k, v|
-        yield(k, _dereferenced(v))
-      end
-    end
-
-    # Equivalent to Hash::each
-    def each
-      @data.each do |k, v|
-        yield(k, _dereferenced(v))
-      end
-    end
-
-    # Equivalent to Hash::each_key
-    def each_key
-      @data.each_key { |k| yield(k) }
-    end
-
-    # Equivalent to Hash::each_value
-    def each_value
-      @data.each_value do |v|
-        yield(_dereferenced(v))
-      end
-    end
-
-    # Equivalent to Hash::empty?
-    def emtpy?
-      @data.empty?
-    end
-
-    # Equivalent to Hash::has_key?
-    def has_key?(key)
-      @data.has_key?(key)
-    end
-    alias include? has_key?
-    alias key? has_key?
-    alias member? has_key?
-
-    # Equivalent to Hash::keys
-    def keys
-      @data.keys
-    end
-
-    # Equivalent to Hash::length
-    def length
-      @data.length
-    end
-    alias size length
-
-    # Equivalent to Hash::map
-    def map
-      @data.map do |k, v|
-        yield(k, _dereferenced(v))
-      end
-    end
-
-    # Equivalent to Hash::values
-    def values
-      @data.values.map { |v| _dereferenced(v) }
-    end
-
     # Return a list of all object IDs of all persistend objects that this Hash
     # is referencing.
     # @return [Array of Fixnum or Bignum] IDs of referenced objects
     def _referenced_object_ids
-      @data.each_value.select { |v| v && v.is_a?(POReference) }.map { |o| o.id }
+      @data.each_value.select { |v| v && v.respond_to?(:is_poxreference?) }.
+        map { |o| o.id }
     end
 
     # This method should only be used during store repair operations. It will
     # delete all referenced to the given object ID.
     # @param id [Fixnum/Bignum] targeted object ID
     def _delete_reference_to_id(id)
-      @data.delete_if { |k, v| v && v.is_a?(POReference) && v.id == id }
+      @data.delete_if do |k, v|
+        v && v.respond_to?(:is_poxreference?) && v.id == id
+      end
     end
 
     # Restore the persistent data from a single data structure.
@@ -160,21 +108,19 @@ module PEROBS
     # @param data [Hash] the actual Hash object
     # @private
     def _deserialize(data)
-      @data = data
-    end
-
-    # Textual dump for debugging purposes
-    # @return [String]
-    def inspect
-      "{\n" +
-      @data.map { |k, v| "  #{k.inspect}=>#{v.inspect}" }.join(",\n") +
-      "\n}\n"
+      @data = {}
+      data.each { |k, v| @data[k] = v.is_a?(POReference) ?
+                                    POXReference.new(@store, v.id) : v }
+      @data
     end
 
     private
 
     def _serialize
-      @data
+      data = {}
+      @data.each { |k, v| data[k] = v.respond_to?(:is_poxreference?) ?
+                                    POReference.new(v.id) : v }
+      data
     end
 
   end