perobs 4.0.0 → 4.4.0

data/lib/perobs.rb

@@ -27,3 +27,5 @@
 
 require "perobs/version"
 require 'perobs/Store'
+require 'perobs/ConsoleProgressMeter'
+require 'perobs/FuzzyStringMatcher'

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', '~> 13.0.3'
 end

data/test/Array_spec.rb

@@ -169,8 +169,13 @@ describe PEROBS::Array do
 
   it 'should support collect!()' do
     a = cpa([ 1, 'cat', 1..1 ])
-    expect(a.collect! { |e| e.class.to_s }).to eq([ 'Integer', 'String', 'Range' ])
-    pcheck { expect(@store['a'].to_a).to eq([ 'Integer', '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])
@@ -179,8 +184,13 @@ describe PEROBS::Array do
 
   it 'should support map!()' do
     a = cpa([ 1, 'cat', 1..1 ])
-    expect(a.map! { |e| e.class.to_s }).to eq([ 'Integer', 'String', 'Range' ])
-    pcheck { expect(@store['a']).to eq([ 'Integer', '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])
@@ -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.exit }.to raise_error(PEROBS::FatalError)
+    expect { a[0] = o.get_self }.to raise_error(PEROBS::FatalError)
     PEROBS.log.open($stderr)
   end
 

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
@@ -128,7 +132,7 @@ describe PEROBS::BTree do
   it 'should survive a real-world usage test' do
     @m.clear
     ref = {}
-    0.upto(50000) do
+    0.upto(20000) do
       case rand(5)
       when 0
         0.upto(2) do

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

data/test/BigHash_spec.rb

@@ -0,0 +1,152 @@
+# encoding: UTF-8
+#
+# Copyright (c) 2017, 2019 by Chris Schlaeger <chris@taskjuggler.org>
+#
+# This file contains tests for Hash that are similar to the tests for the
+# Hash 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/BigHash'
+
+class PEROBS::BigHash
+
+  # Redefine the hash method to make collisions very likely. This will help to
+  # test the collision handling with small amounts of data.
+  #def hash_key(key)
+  #  key.hash & 0xF
+  #end
+
+end
+
+ENTRIES = 200
+
+describe PEROBS::Hash do
+
+  before(:all) do
+    @db_name = generate_db_name(__FILE__)
+  end
+
+  before(:each) do
+    @store = PEROBS::Store.new(@db_name)
+    @h = @store.new(PEROBS::BigHash)
+    @store['hash'] = @h
+  end
+
+  after(:each) do
+    @store.delete_store
+  end
+
+  it 'should support storing and retrieving an object' do
+    expect(@h.check).to be true
+    expect(@h.length).to eql(0)
+    expect(@h.empty?).to be true
+    expect(@h.keys).to eql([])
+    @h['foo'] = 'bar'
+    expect(@h.check).to be true
+    expect(@h['foo']).to eql('bar')
+    expect(@h.length).to eql(1)
+    expect(@h.keys).to eql([ 'foo' ])
+  end
+
+  it 'should store a few objects' do
+    20.times do |i|
+      @h["bar#{i}"] = "foo#{i}"
+    end
+    expect(@h.size).to eql(20)
+  end
+
+  it 'should return nil for unknown objects' do
+    expect(@h['bar']).to be_nil
+  end
+
+  it 'should be able to store values with hash collisions' do
+    ENTRIES.times do |i|
+      @h["key#{i}"] = i
+    end
+    expect(@h.check).to be true
+    expect(@h.length).to eql(ENTRIES)
+
+    ENTRIES.times do |i|
+      expect(@h["key#{i}"]).to eql(i)
+    end
+  end
+
+  it 'should replace existing entries' do
+    ENTRIES.times do |i|
+      @h["key#{i}"] = 2 * i
+    end
+    expect(@h.check).to be true
+    expect(@h.length).to eql(ENTRIES)
+
+    ENTRIES.times do |i|
+      expect(@h["key#{i}"]).to eql(2 * i)
+    end
+    expect(@h.length).to eql(ENTRIES)
+  end
+
+  it 'should fail to delete a non-existing entry' do
+    expect(@h.delete('foo')).to be_nil
+    expect(@h.check).to be true
+  end
+
+  it 'should delete existing entries' do
+    (1..ENTRIES).to_a.shuffle.each do |i|
+      @h["key#{i}"] = 2 * i
+    end
+    expect(@h.check).to be true
+    expect(@h.length).to eql(ENTRIES)
+    (1..ENTRIES).to_a.shuffle.each do |i|
+      expect(@h.delete("key#{i}")).to eql(2 * i)
+    end
+  end
+
+  it 'should persist all objects' do
+    db_name = generate_db_name(__FILE__ + "_persist")
+    store = PEROBS::Store.new(db_name)
+    h = store['hash'] = store.new(PEROBS::BigHash)
+    n = ENTRIES
+    n.times do |i|
+      h["key#{i}"] = 2 * i
+    end
+    expect(h.check).to be true
+    expect(h.length).to eql(n)
+    expect(store.check).to eql(0)
+    store.exit
+
+    store = PEROBS::Store.new(db_name)
+    expect(store.check).to eql(0)
+    h = store['hash']
+    n.times do |i|
+      expect(h["key#{i}"]).to eql(2 * i)
+    end
+    expect(h.check).to be true
+    expect(h.length).to eql(n)
+    store.delete_store
+  end
+
+end
+

data/test/BigTreeNode_spec.rb

@@ -0,0 +1,153 @@
+# encoding: UTF-8
+#
+# Copyright (c) 2016, 2017 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 'fileutils'
+
+require 'spec_helper'
+require 'perobs/Store'
+require 'perobs/BigTree'
+
+describe PEROBS::BigTreeNode do
+
+  before(:all) do
+    @db_name = generate_db_name(__FILE__)
+    @store = PEROBS::Store.new(@db_name)
+    @store['bigtree'] = @t = @store.new(PEROBS::BigTree, 4)
+  end
+
+  before(:each) do
+    @t.clear
+  end
+
+  after(:all) do
+    @store.delete_store
+  end
+
+  it 'should insert a key/value pair' do
+    n = @t.root
+    n.insert(0, 0)
+    expect(@t.check).to be true
+    s = @t.statistics
+    expect(s.leaf_nodes).to eql(1)
+    expect(s.branch_nodes).to eql(0)
+    expect(s.min_depth).to eql(1)
+    expect(s.max_depth).to eql(1)
+    node_chain = @t.node_chain(0)
+    expect(node_chain.size).to eql(1)
+    expect(node_chain.first).to eql(n)
+  end
+
+  it 'should split a leaf node that becomes full' do
+    4.times { |n| @t.insert(n, n) }
+    expect(@t.check).to be true
+    s = @t.statistics
+    expect(s.leaf_nodes).to eql(1)
+    @t.insert(4, 4)
+    s = @t.statistics
+    expect(s.leaf_nodes).to eql(2)
+    expect(s.branch_nodes).to eql(1)
+    expect(s.min_depth).to eql(2)
+    expect(s.max_depth).to eql(2)
+  end
+
+  it 'should split a branch node that becomes full' do
+    11.times { |n| @t.insert(n, n) }
+    s = @t.statistics
+    expect(s.leaf_nodes).to eql(5)
+    expect(s.branch_nodes).to eql(1)
+    expect(s.min_depth).to eql(2)
+    expect(s.max_depth).to eql(2)
+    @t.insert(11, 11)
+    expect(@t.check).to be true
+    s = @t.statistics
+    expect(s.leaf_nodes).to eql(5)
+    expect(s.branch_nodes).to eql(3)
+    expect(s.min_depth).to eql(3)
+    expect(s.max_depth).to eql(3)
+  end
+
+  it 'should merge leaf node with next sibling' do
+    5.times { |n| @t.insert(n, n) }
+    expect(@t.check).to be true
+    s = @t.statistics
+    expect(s.leaf_nodes).to eql(2)
+
+    @t.remove(0)
+    expect(@t.check).to be true
+    s = @t.statistics
+    expect(s.leaf_nodes).to eql(1)
+    expect(s.min_depth).to eql(1)
+    expect(s.max_depth).to eql(1)
+  end
+
+  it 'should merge leaf node with previous siblin' do
+    5.times { |n| @t.insert(n, n) }
+    expect(@t.check).to be true
+    s = @t.statistics
+    expect(s.leaf_nodes).to eql(2)
+
+    @t.remove(2)
+    @t.remove(3)
+    expect(@t.check).to be true
+    s = @t.statistics
+    expect(s.leaf_nodes).to eql(1)
+  end
+
+  it 'should merge branch node with next sibling' do
+    12.times { |n| @t.insert(n, n) }
+    expect(@t.check).to be true
+    s = @t.statistics
+    expect(s.leaf_nodes).to eql(5)
+    expect(s.branch_nodes).to eql(3)
+
+    @t.remove(2)
+    @t.remove(3)
+    @t.remove(4)
+    @t.remove(5)
+    expect(@t.check).to be true
+    s = @t.statistics
+    expect(s.leaf_nodes).to eql(3)
+    expect(s.branch_nodes).to eql(1)
+  end
+
+  it 'should merge branch node with previous sibling' do
+    12.times { |n| @t.insert(n, n) }
+    expect(@t.check).to be true
+    s = @t.statistics
+    expect(s.leaf_nodes).to eql(5)
+    expect(s.branch_nodes).to eql(3)
+
+    @t.remove(4)
+    @t.remove(5)
+    @t.remove(2)
+    @t.remove(3)
+    expect(@t.check).to be true
+    s = @t.statistics
+    expect(s.leaf_nodes).to eql(3)
+    expect(s.branch_nodes).to eql(1)
+  end
+
+end
+