perobs 3.0.1 → 4.3.0

data/lib/perobs/version.rb

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

data/perobs.gemspec

@@ -16,9 +16,9 @@ GEM_SPEC = Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
-  spec.required_ruby_version = '>=2.0'
+  spec.required_ruby_version = '>=2.4'
 
-  spec.add_development_dependency 'bundler', '~> 1.6'
-  spec.add_development_dependency 'yard', '~>0.8.7'
-  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'bundler', '~> 2.3'
+  spec.add_development_dependency 'yard', '~>0.9.12'
+  spec.add_development_dependency 'rake', '~> 12.3.3'
 end

data/test/Array_spec.rb

@@ -33,7 +33,7 @@ require 'perobs'
 
 class PO < PEROBS::Object
 
-  po_attr :name
+  attr_persist :name
 
   def initialize(store, name = nil)
     super(store)
@@ -65,7 +65,7 @@ describe PEROBS::Array do
     @store.transaction do
       @store['b'] = @store.new(PEROBS::Array)
     end
-    @store.sync
+    @store.exit
     @store = nil
     GC.start
 
@@ -85,7 +85,7 @@ describe PEROBS::Array do
     expect(a[0]).to eq('A')
     expect(a[1]).to eq('B')
     expect(a[2].name).to eq('foobar')
-    @store.sync
+    @store.exit
 
     @store = PEROBS::Store.new(@db_name)
     a = @store['a']
@@ -102,7 +102,7 @@ describe PEROBS::Array do
     vs = ''
     a.each { |v| vs << v }
     expect(vs).to eq('ABC')
-    @store.sync
+    @store.exit
 
     @store = PEROBS::Store.new(@db_name)
     a = @store['a']
@@ -113,15 +113,15 @@ describe PEROBS::Array do
   end
 
   # Utility method to create a PEROBS::Array from a normal Array.
-  def cpa(ary = nil)
+  def cpa(ary = nil, id = 'a')
     a = @store.new(PEROBS::Array)
     a.replace(ary) unless ary.nil?
-    @store['a'] = a
+    @store[id] = a
   end
 
   def pcheck
     yield
-    @store.sync
+    @store.exit
     @store = PEROBS::Store.new(@db_name)
     yield
   end
@@ -147,44 +147,54 @@ describe PEROBS::Array do
   it 'should support re-writing methods' do
     x = cpa([2, 5, 3, 1, 7])
     x.sort!{ |a, b| a <=> b }
-    pcheck { expect(x).to eq([ 1, 2, 3, 5, 7 ]) }
-    x.sort!{ |a, b| b - a }
-    pcheck { expect(x).to eq([ 7, 5, 3, 2, 1 ]) }
+    pcheck { expect(@store['a']).to eq([ 1, 2, 3, 5, 7 ]) }
+    @store['a'].sort!{ |a, b| b - a }
+    pcheck { expect(@store['a']).to eq([ 7, 5, 3, 2, 1 ]) }
 
-    x.clear
-    pcheck { expect(x).to eq([]) }
+    @store['a'].clear
+    pcheck { expect(@store['a']).to eq([]) }
   end
 
   it 'should support <<()' do
     a = cpa([ 0, 1, 2 ])
     a << 4
-    pcheck { expect(a).to eq([ 0, 1, 2, 4 ]) }
+    pcheck { expect(@store['a']).to eq([ 0, 1, 2, 4 ]) }
   end
 
   it 'should support []=' do
     a = cpa([ 0, nil, 2 ])
     a[1] = 1
-    pcheck { expect(a).to eq([ 0, 1, 2 ]) }
+    pcheck { expect(@store['a']).to eq([ 0, 1, 2 ]) }
   end
 
   it 'should support collect!()' do
     a = cpa([ 1, 'cat', 1..1 ])
-    expect(a.collect! { |e| e.class }).to eq([ Fixnum, String, Range ])
-    pcheck { expect(a).to eq([ Fixnum, String, Range ]) }
+    if RUBY_VERSION < '2.2'
+      expect(a.collect! { |e| e.class.to_s }.to_a).to eq([ 'Fixnum', 'String', 'Range' ])
+      pcheck { expect(@store['a'].to_a).to eq([ 'Fixnum', 'String', 'Range' ]) }
+    else
+      expect(a.collect! { |e| e.class.to_s }.to_a).to eq([ 'Integer', 'String', 'Range' ])
+      pcheck { expect(@store['a'].to_a).to eq([ 'Integer', 'String', 'Range' ]) }
+    end
 
     a = cpa([ 1, 'cat', 1..1 ])
     expect(a.collect! { 99 }).to eq([ 99, 99, 99])
-    pcheck { expect(a).to eq([ 99, 99, 99]) }
+    pcheck { expect(@store['a']).to eq([ 99, 99, 99]) }
   end
 
   it 'should support map!()' do
     a = cpa([ 1, 'cat', 1..1 ])
-    expect(a.map! { |e| e.class }).to eq([ Fixnum, String, Range ])
-    pcheck { expect(a).to eq([ Fixnum, String, Range ]) }
+    if RUBY_VERSION < '2.2'
+      expect(a.map! { |e| e.class.to_s }.to_a).to eq([ 'Fixnum', 'String', 'Range' ])
+      pcheck { expect(@store['a'].to_a).to eq([ 'Fixnum', 'String', 'Range' ]) }
+    else
+      expect(a.map! { |e| e.class.to_s }.to_a).to eq([ 'Integer', 'String', 'Range' ])
+      pcheck { expect(@store['a'].to_a).to eq([ 'Integer', 'String', 'Range' ]) }
+    end
 
     a = cpa([ 1, 'cat', 1..1 ])
     expect(a.map! { 99 }).to eq([ 99, 99, 99])
-    pcheck { expect(a).to eq ([ 99, 99, 99]) }
+    pcheck { expect(@store['a']).to eq ([ 99, 99, 99]) }
   end
 
   it 'should support fill()' do
@@ -194,39 +204,39 @@ describe PEROBS::Array do
   end
 
   it 'should support flatten!()' do
-    a1 = cpa([ 1, 2, 3])
-    a2 = cpa([ 5, 6 ])
-    a3 = cpa([ 4, a2 ])
-    a4 = cpa([ a1, a3 ])
-    pcheck { expect(a4.flatten).to eq([ 1, 2, 3, 4, 5, 6 ]) }
+    a1 = cpa([ 1, 2, 3], 'a1')
+    a2 = cpa([ 5, 6 ], 'a2')
+    a3 = cpa([ 4, a2 ], 'a3')
+    a4 = cpa([ a1, a3 ], 'a4')
+    pcheck { expect(@store['a4'].flatten).to eq([ 1, 2, 3, 4, 5, 6 ]) }
   end
 
   it 'should support replace()' do
-    a = cpa([ 1, 2, 3])
-    a_id = a.__id__
-    expect(a.replace(cpa([4, 5, 6]))).to eq([ 4, 5, 6 ])
-    pcheck { expect(a).to eq ([ 4, 5, 6 ]) }
+    a1 = cpa([ 1, 2, 3], 'a1')
+    a_id = a1.__id__
+    expect(a1.replace(cpa([4, 5, 6], 'a2'))).to eq([ 4, 5, 6 ])
+    pcheck { expect(@store['a1']).to eq ([ 4, 5, 6 ]) }
   end
 
   it 'should support insert()' do
     a = cpa([ 0 ])
     a.insert(1)
-    pcheck { expect(a).to eq([ 0 ]) }
-    a.insert(1, 1)
-    pcheck { expect(a).to eq([ 0, 1]) }
+    pcheck { expect(@store['a']).to eq([ 0 ]) }
+    @store['a'].insert(1, 1)
+    pcheck { expect(@store['a']).to eq([ 0, 1]) }
   end
 
   it 'should support push()' do
     a = cpa([ 1, 2, 3 ])
     a.push(4, 5)
-    pcheck { expect(a).to eq([ 1, 2, 3, 4, 5 ]) }
-    a.push(nil)
-    pcheck { expect(a).to eq([ 1, 2, 3, 4, 5, nil ]) }
+    pcheck { expect(@store['a']).to eq([ 1, 2, 3, 4, 5 ]) }
+    @store['a'].push(nil)
+    pcheck { expect(@store['a']).to eq([ 1, 2, 3, 4, 5, nil ]) }
   end
 
   it 'should support inspect' do
-    a1 = cpa([ 1 ])
-    a2 = cpa([ 1, a1 ])
+    a1 = cpa([ 1 ], 'a1')
+    a2 = cpa([ 1, a1 ], 'a2')
     expect(a1.inspect).to eq("<PEROBS::Array:#{a1._id}>\n[\n  1\n]\n")
     expect(a2.inspect).to eq("<PEROBS::Array:#{a2._id}>\n[\n  1,\n  <PEROBS::ObjectBase:#{a1._id}>\n]\n")
   end
@@ -242,9 +252,8 @@ describe PEROBS::Array do
   it 'should catch a leaked PEROBS::ObjectBase object' do
     @store['a'] = a = @store.new(PEROBS::Array)
     o = @store.new(PO)
-    a[0] = o.get_self
     PEROBS.log.open(StringIO.new)
-    expect { @store.sync }.to raise_error(PEROBS::FatalError)
+    expect { a[0] = o.get_self }.to raise_error(PEROBS::FatalError)
     PEROBS.log.open($stderr)
   end
 

data/test/BTreeDB_spec.rb

@@ -56,7 +56,7 @@ describe PEROBS::BTreeDB do
     expect(@db.include?(0)).to be false
     h = {
           'String' => 'What god has wrought',
-          'Fixnum' => 42,
+          'Integer' => 42,
           'Float' => 3.14,
           'True' => true,
           'False' => false,
@@ -75,7 +75,7 @@ describe PEROBS::BTreeDB do
       expect(@db.include?(0)).to be false
       h = {
         'String' => 'What god has wrought',
-        'Fixnum' => 42,
+        'Integer' => 42,
         'Float' => 3.14,
         'True' => true,
         'False' => false,

data/test/BTree_spec.rb

@@ -27,13 +27,16 @@ require 'fileutils'
 
 require 'spec_helper'
 require 'perobs/BTree'
+require 'perobs/ProgressMeter'
 
 describe PEROBS::BTree do
 
   before(:all) do
     @db_dir = generate_db_name('BTree')
     FileUtils.mkdir_p(@db_dir)
-    @m = PEROBS::BTree.new(@db_dir, 'btree', 11)
+    @m = PEROBS::BTree.new(@db_dir, 'btree', 11, PEROBS::ProgressMeter.new)
+    PEROBS.log.level = Logger::ERROR
+    PEROBS.log.open($stderr)
   end
 
   after(:all) do
@@ -48,6 +51,7 @@ describe PEROBS::BTree do
     @m.open
     expect(@m.to_s).to eql("o--- @1\n")
     #expect(@m.to_a).to eql([])
+    expect(@m.check).to be true
   end
 
   it 'should support adding sequential key/value pairs' do
@@ -125,4 +129,49 @@ describe PEROBS::BTree do
     end
   end
 
+  it 'should survive a real-world usage test' do
+    @m.clear
+    ref = {}
+    0.upto(20000) do
+      case rand(5)
+      when 0
+        0.upto(2) do
+          key = rand(100000)
+          value = rand(10000000)
+          @m.insert(key, value)
+          ref[key] = value
+        end
+      when 1
+        if ref.length > 0
+          key = ref.keys[rand(ref.keys.length)]
+          expect(@m.remove(key)).to eql(ref[key])
+          ref.delete(key)
+        end
+      when 2
+        if ref.length > 0
+          0.upto(3) do
+            key = ref.keys[rand(ref.keys.length)]
+            expect(@m.get(key)).to eql(ref[key])
+          end
+        end
+      when 3
+        if ref.length > 0
+          key = ref.keys[rand(ref.keys.length)]
+          value = rand(10000000)
+          @m.insert(key, value)
+          ref[key] = value
+        end
+      when 4
+        if rand(50) == 0
+          expect(@m.check).to be true
+        end
+      when 5
+        if rand(50) == 0
+          @m.close
+          @m.open
+        end
+      end
+    end
+  end
+
 end

data/test/BigArray_spec.rb

@@ -0,0 +1,261 @@
+# encoding: UTF-8
+#
+# Copyright (c) 2015, 2016 by Chris Schlaeger <chris@taskjuggler.org>
+#
+# This file contains tests for Array that are similar to the tests for the
+# Array implementation in MRI. The ideas of these tests were replicated in
+# this code.
+#
+# 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 'spec_helper'
+
+require 'perobs'
+require 'perobs/BigArray'
+
+NODE_ENTRIES = 6
+
+describe PEROBS::BigArray do
+
+  before(:all) do
+    @db_name = generate_db_name(__FILE__)
+    @store = PEROBS::Store.new(@db_name)
+  end
+
+  before(:each) do
+    @store['array'] = @a = @store.new(PEROBS::BigArray, NODE_ENTRIES)
+  end
+
+  after(:each) do
+    @store['array'] = @a = nil
+    @store.gc
+  end
+
+  after(:all) do
+    @store.delete_store
+  end
+
+  it 'should be empty on create' do
+    expect(@a.empty?).to be true
+    expect(@a.length).to eq(0)
+    expect(@a.check).to be true
+    expect(@a[0]).to be nil
+    expect(@a.first).to be nil
+    expect(@a.last).to be nil
+  end
+
+  it 'should append the first element' do
+    @a << 0
+    expect(@a.empty?).to be false
+    expect(@a[0]).to eq(0)
+    expect(@a.first).to eq(0)
+    expect(@a.last).to eq(0)
+    expect(@a.length).to eq(1)
+    expect(@a.check).to be true
+  end
+
+  it 'should fill 10 nodes with appends' do
+    (10 * NODE_ENTRIES).times do |i|
+      @a << i
+      expect(@a.check).to be true
+      expect(@a.length).to eq(i + 1)
+    end
+    expect(@a.first).to eq(0)
+    expect(@a.last).to eq(10 * NODE_ENTRIES - 1)
+  end
+
+  it 'should insert at 0' do
+    @a.insert(0, 0)
+    expect(@a.empty?).to be false
+  end
+
+  it 'should insert at end' do
+    0.upto(3 * NODE_ENTRIES) do |i|
+      @a.insert(i, i)
+      expect(@a.check).to be true
+      expect(@a.length).to eq(i + 1)
+    end
+  end
+
+  it 'should insert in the middle' do
+    0.upto(NODE_ENTRIES - 1) do |i|
+      @a << 9999
+    end
+    0.upto(3 * NODE_ENTRIES) do |i|
+      @a.insert(i, i)
+      expect(@a.check).to be true
+      expect(@a.length).to eq(i + 1 + NODE_ENTRIES)
+    end
+  end
+
+  it 'should convert to a Ruby Array' do
+    expect(@a.to_a).to eql([])
+    (3 * NODE_ENTRIES).times do |i|
+      @a << i
+    end
+    expect(@a.to_a).to eql((0..3 * NODE_ENTRIES - 1).to_a)
+  end
+
+  it 'should support the [] operator' do
+    expect(@a[0]).to be nil
+    expect(@a[-1]).to be nil
+    @a[0] = 0
+    expect(@a[0]).to eq(0)
+    1.upto(3 * NODE_ENTRIES) do |i|
+      @a.insert(i, i)
+    end
+    0.upto(3 * NODE_ENTRIES) do |i|
+      expect(@a[i]).to eq(i)
+    end
+    expect(@a[3 * NODE_ENTRIES + 1]).to be nil
+    0.upto(3 * NODE_ENTRIES) do |i|
+      expect(@a[-3 * NODE_ENTRIES + i - 1]).to eq(i)
+    end
+    expect(@a[-3 * NODE_ENTRIES - 2]).to be nil
+    (3 * NODE_ENTRIES + 1).upto(4 * NODE_ENTRIES) do |i|
+      expect(@a[i]).to be nil
+    end
+  end
+
+  it 'should delete elements' do
+    expect(@a.delete_at(0)).to be nil
+    expect(@a.length).to eq(0)
+    expect(@a.check).to be true
+    expect(@a.delete_at(-1)).to be nil
+    expect(@a.length).to eq(0)
+    expect(@a.check).to be true
+    @a << 0
+    expect(@a.delete_at(0)).to eql(0)
+    expect(@a.length).to eq(0)
+    expect(@a.check).to be true
+
+    n = 5 * NODE_ENTRIES
+    0.upto(n) { |i| @a.insert(i, i) }
+    0.upto(n) do |i|
+      expect(@a.delete_at(0)).to eql(i)
+      expect(@a.check).to be true
+    end
+
+    0.upto(n) { |i| @a.insert(i, i) }
+    n.downto(0) do |i|
+      expect(@a.delete_at(-1)).to eql(i)
+      expect(@a.check).to be true
+    end
+
+    n = 15 * NODE_ENTRIES
+    0.upto(n - 1) { |i| @a.insert(i, i) }
+    expect(@a.delete_at(n + 2)).to be nil
+    expect(@a.delete_at(-(n + 2))).to be nil
+    expect(@a.size).to eql(n)
+
+    n.times do |i|
+      idx = rand(@a.size)
+      @a.delete_at(idx)
+      expect(@a.size).to be (n - 1 - i)
+      expect(@a.check).to be true
+    end
+    expect(@a.size).to eql(0)
+  end
+
+  it 'should fill the gaps' do
+    1.upto(4) do |i|
+      idx = i * NODE_ENTRIES * NODE_ENTRIES
+      @a[idx] = idx
+      expect(@a[idx - 1]).to be nil
+      expect(@a[idx + 1]).to be nil
+      expect(@a.check).to be true
+    end
+    expect(@a[0]).to be nil
+  end
+
+  it 'should insert after a gap' do
+    ref = []
+    10.times do |i|
+      idx = 10 + i * 3
+      @a[idx] = idx
+      ref[idx] = idx
+      expect(@a[idx]).to eql(idx)
+      expect(@a.check).to be true
+    end
+    10.times do |i|
+      idx = i * 5
+      @a[idx] = idx
+      ref[idx] = idx
+      expect(@a[idx]).to eql(idx)
+      expect(@a.check).to be true
+    end
+    expect(@a.check).to be true
+    expect(@a.to_a).to eql(ref)
+  end
+
+  it 'should iterate over all values' do
+    n = 3 * NODE_ENTRIES
+    0.upto(n) { |i| @a.insert(i, i) }
+
+    i = 0
+    @a.each do |v|
+      expect(v).to eql(i)
+      i += 1
+    end
+  end
+
+  it 'should iterate over all values in reverse order' do
+    n = 3 * NODE_ENTRIES
+    0.upto(n) { |i| @a.insert(i, i) }
+
+    i = 0
+    @a.reverse_each do |v|
+      expect(v).to eql(n - i)
+      i += 1
+    end
+  end
+
+  it 'should insert at the beginning' do
+    (5 * NODE_ENTRIES).downto(0) do |i|
+      @a.insert(0, i)
+    end
+    expect(@a.check).to be true
+    a = Array.new(5 * NODE_ENTRIES + 1) { |i| i }
+    expect(@a.to_a).to eq(a)
+  end
+
+  it 'should persist the data' do
+    db_name = generate_db_name(__FILE__ + "_persist")
+    store = PEROBS::Store.new(db_name)
+    store['array'] = a = store.new(PEROBS::BigArray, NODE_ENTRIES)
+
+    (3 * NODE_ENTRIES).times do |i|
+      a.insert(i, i)
+    end
+    expect(a.length).to eq(3 * NODE_ENTRIES)
+    store.exit
+
+    store = PEROBS::Store.new(db_name)
+    a = store['array']
+    (3 * NODE_ENTRIES).times do |i|
+      expect(a[i]).to eql(i)
+    end
+    expect(a.length).to eq(3 * NODE_ENTRIES)
+    store.delete_store
+  end
+
+end