perobs 4.4.0 → 4.6.0

data/lib/perobs/BigArrayNode.rb

@@ -1,4 +1,4 @@
-# encoding: UTF-8
+# # frozen_string_literal: true
 #
 # = BigArrayNode.rb -- Persistent Ruby Object Store
 #
@@ -26,11 +26,10 @@
 # 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/Object'
-require 'perobs/Array'
+require_relative 'Object'
+require_relative 'Array'
 
 module PEROBS
-
   # The BigArrayNode class provides the BTree nodes for the BigArray objects.
   # A node can either be a branch node or a leaf node. Branch nodes don't
   # store values, only offsets and references to child nodes. Leaf nodes don't
@@ -57,9 +56,8 @@ module PEROBS
   # Index     0 1 2 3    4 5 6    7 8 9 10    11 12    13 14 15    16 17
   #
   class BigArrayNode < PEROBS::Object
-
     attr_persist :tree, :parent, :offsets, :values, :children,
-      :prev_sibling, :next_sibling
+                 :prev_sibling, :next_sibling
 
     # Internal constructor. Use Store.new(BigArrayNode, ...) instead.
     # @param p [Handle]
@@ -118,16 +116,13 @@ module PEROBS
       count = 0
       node = self
       while node
-        if node.is_leaf?
-          return count + node.values.size
-        else
-          count += node.offsets.last
-          node = node.children.last
-        end
+        return count + node.values.size if node.is_leaf?
+
+        count += node.offsets.last
+        node = node.children.last
       end
     end
 
-
     # Set the given value at the given index.
     # @param index [Integer] Position to insert at
     # @param value [Integer] value to insert
@@ -135,27 +130,29 @@ module PEROBS
       node = self
 
       # Traverse the tree to find the right node to add or replace the value.
-      while node do
+      idx = index
+      while node
         # Once we have reached a leaf node we can insert or replace the value.
         if node.is_leaf?
-          if index >= node.values.size
-            node.fatal "Set index (#{index}) larger than values array " +
-              "(#{node.values.size})."
+          if idx >= node.values.size
+            node.fatal "Set index (#{index}) larger than values array " \
+                       "(#{idx} >= #{node.values.size})."
           end
-          node.values[index] = value
+          node.values[idx] = value
           return
         else
           # Descend into the right child node to add the value to.
-          cidx = node.search_child_index(index)
-          if (index -= node.offsets[cidx]) < 0
-            node.fatal "Index (#{index}) became negative"
+          cidx = node.search_child_index(idx)
+          if (idx -= node.offsets[cidx]).negative?
+            node.fatal "Idx (#{idx}) became negative while looking for " \
+                       "index #{index}."
           end
           node = node.children[cidx]
         end
       end
 
-      node.fatal "Could not find proper node to set the value while " +
-        "looking for index #{index}"
+      node.fatal 'Could not find proper node to set the value while ' \
+                 "looking for index #{index}."
     end
 
     # Insert the given value at the given index. All following values will be
@@ -167,7 +164,7 @@ module PEROBS
       cidx = nil
 
       # Traverse the tree to find the right node to add or replace the value.
-      while node do
+      while node
         # All nodes that we find on the way that are full will be split into
         # two half-full nodes.
         if node.size >= @tree.node_size
@@ -180,20 +177,20 @@ module PEROBS
         # Once we have reached a leaf node we can insert or replace the value.
         if node.is_leaf?
           node.values.insert(index, value)
-          node.parent.adjust_offsets(node, 1) if node.parent
+          node.parent&.adjust_offsets(node, 1)
           return
         else
           # Descend into the right child node to add the value to.
           cidx = node.search_child_index(index)
-          if (index -= node.offsets[cidx]) < 0
+          if (index -= node.offsets[cidx]).negative?
             node.fatal "Index (#{index}) became negative"
           end
           node = node.children[cidx]
         end
       end
 
-      node.fatal "Could not find proper node to insert the value while " +
-        "looking for index #{index}"
+      node.fatal 'Could not find proper node to insert the value while ' \
+                 "looking for index #{index}"
     end
 
     # Return the value that matches the given key or return nil if they key is
@@ -204,23 +201,21 @@ module PEROBS
       node = self
 
       # Traverse the tree to find the right node to add or replace the value.
-      while node do
+      while node
         # Once we have reached a leaf node we can insert or replace the value.
-        if node.is_leaf?
-          return node.values[index]
-        else
-          # Descend into the right child node to add the value to.
-          cidx = (node.offsets.bsearch_index { |o| o > index } ||
-                  node.offsets.length) - 1
-          if (index -= node.offsets[cidx]) < 0
-            node.fatal "Index (#{index}) became negative"
-          end
-          node = node.children[cidx]
+        return node.values[index] if node.is_leaf?
+
+        # Descend into the right child node to add the value to.
+        cidx = (node.offsets.bsearch_index { |o| o > index } ||
+                node.offsets.length) - 1
+        if (index -= node.offsets[cidx]).negative?
+          node.fatal "Index (#{index}) became negative"
         end
+        node = node.children[cidx]
       end
 
-      PEROBS.log.fatal "Could not find proper node to get from while " +
-        "looking for index #{index}"
+      PEROBS.log.fatal 'Could not find proper node to get from while ' \
+                       "looking for index #{index}"
     end
 
     # Delete the element at the specified index, returning that element, or
@@ -231,14 +226,12 @@ module PEROBS
       node = self
       deleted_value = nil
 
-      while node do
+      while node
         if node.is_leaf?
           deleted_value = node.values.delete_at(index)
           if node.parent
             node.parent.adjust_offsets(node, -1)
-            if node.size < min_size
-              node.parent.consolidate_child_nodes(node)
-            end
+            node.parent.consolidate_child_nodes(node) if node.size < min_size
           end
 
           return deleted_value
@@ -246,15 +239,15 @@ module PEROBS
           # Descend into the right child node to add the value to.
           cidx = (node.offsets.bsearch_index { |o| o > index } ||
                   node.offsets.length) - 1
-          if (index -= node.offsets[cidx]) < 0
+          if (index -= node.offsets[cidx]).negative?
             node.fatal "Index (#{index}) became negative"
           end
           node = node.children[cidx]
         end
       end
 
-      PEROBS.log.fatal "Could not find proper node to delete from while " +
-        "looking for index #{index}"
+      PEROBS.log.fatal 'Could not find proper node to delete from while ' \
+                       "looking for index #{index}"
     end
 
     # Iterate over all the values of the node.
@@ -285,13 +278,13 @@ module PEROBS
       branch_depth = nil
 
       traverse do |node, position, stack|
-        if position == 0
+        if position.zero?
           # Nodes should have between min_size() and
           # @tree.node_size children or values. Only the root node may have
           # less.
           if node.size > @tree.node_size
-            node.error "BigArray node #{node._id} is too large. It has " +
-              "#{node.size} nodes instead of max. #{@tree.node_size}."
+            node.error "BigArray node #{node._id} is too large. It has " \
+                       "#{node.size} nodes instead of max. #{@tree.node_size}."
             return false
           end
           if node.parent && node.size < min_size
@@ -303,7 +296,7 @@ module PEROBS
             # All leaf nodes must have same distance from root node.
             if branch_depth
               unless branch_depth == stack.size
-                node.error "All leaf nodes must have same distance from root"
+                node.error 'All leaf nodes must have same distance from root'
                 return false
               end
             else
@@ -313,24 +306,24 @@ module PEROBS
             return false unless node.check_leaf_node_links
 
             if node.children
-              node.error "children must be nil for a leaf node"
+              node.error 'children must be nil for a leaf node'
               return false
             end
           else
             unless node.children.size == node.offsets.size
-              node.error "Offset count (#{node.offsets.size}) must be equal " +
-                "to children count (#{node.children.size})"
-                return false
+              node.error "Offset count (#{node.offsets.size}) must be equal " \
+                         "to children count (#{node.children.size})"
+              return false
             end
 
             if node.values
-              node.error "values must be nil for a branch node"
+              node.error 'values must be nil for a branch node'
               return false
             end
 
             unless @prev_sibling.nil? && @next_sibling.nil?
-              node.error "prev_sibling and next_sibling must be nil for " +
-                "branch nodes"
+              node.error 'prev_sibling and next_sibling must be nil for ' \
+                         'branch nodes'
             end
 
             return false unless node.check_offsets
@@ -341,12 +334,10 @@ module PEROBS
           # These checks are done after we have completed the respective child
           # node with index 'position - 1'.
           index = position - 1
-          if node.is_leaf?
-            if block_given?
-              # If a block was given, call this block with the key and value.
-              return false unless yield(node.first_index + index,
-                                        node.values[index])
-            end
+          if node.is_leaf? && block_given?
+            # If a block was given, call this block with the key and value.
+            return false unless yield(node.first_index + index,
+                                      node.values[index])
           end
         end
       end
@@ -357,25 +348,25 @@ module PEROBS
     def check_leaf_node_links
       if @prev_sibling.nil?
         if @tree.first_leaf != self
-          error "Leaf node #{@_id} has no previous sibling " +
-            "but is not the first leaf of the tree"
+          error "Leaf node #{@_id} has no previous sibling " \
+                'but is not the first leaf of the tree'
           return false
         end
       elsif @prev_sibling.next_sibling != self
-        error "next_sibling of previous sibling does not point to " +
-          "this node"
+        error 'next_sibling of previous sibling does not point to ' \
+              'this node'
         return false
       end
 
       if @next_sibling.nil?
         if @tree.last_leaf != self
-          error "Leaf node #{@_id} has no next sibling " +
-            "but is not the last leaf of the tree"
+          error "Leaf node #{@_id} has no next sibling " \
+                'but is not the last leaf of the tree'
           return false
         end
       elsif @next_sibling.prev_sibling != self
-        error "previous_sibling of next sibling does not point to " +
-          "this node"
+        error 'previous_sibling of next sibling does not point to ' \
+              'this node'
         return false
       end
 
@@ -392,16 +383,16 @@ module PEROBS
 
       last_offset = nil
       @offsets.each_with_index do |offset, i|
-        if i > 0
+        if i.positive?
           if offset < last_offset
-            error "Offsets are not strictly monotoneously " +
-              "increasing: #{@offsets.inspect}"
+            error 'Offsets are not strictly monotoneously ' \
+                  "increasing: #{@offsets.inspect}"
             return false
           end
           expected_offset = last_offset + @children[i - 1].values_count
           if offset != expected_offset
-            error "Offset #{i} must be #{expected_offset} " +
-              "but is #{offset}."
+            error "Offset #{i} must be #{expected_offset} " \
+                  "but is #{offset}."
             return false
           end
         end
@@ -420,20 +411,20 @@ module PEROBS
 
       @children.each_with_index do |child, i|
         unless child.is_a?(BigArrayNode)
-          error "Child #{@_id} is of class #{child.class} " +
-            "instead of BigArrayNode"
+          error "Child #{@_id} is of class #{child.class} " \
+                'instead of BigArrayNode'
           return false
         end
 
         unless child.parent.is_a?(BigArrayNode)
-          error "Parent reference of child #{i} is of class " +
-            "#{child.class} instead of BigArrayNode"
+          error "Parent reference of child #{i} is of class " \
+                "#{child.class} instead of BigArrayNode"
           return false
         end
 
         if child.parent != self
-          error "Child node #{child._id} has wrong parent " +
-            "#{child.parent._id}. It should be #{@_id}."
+          error "Child node #{child._id} has wrong parent " \
+                "#{child.parent._id}. It should be #{@_id}."
           return false
         end
 
@@ -448,8 +439,8 @@ module PEROBS
         end
 
         unless child.parent == self
-          error "Child #{i} does not have parent pointing " +
-            "to this node"
+          error "Child #{i} does not have parent pointing " \
+                'to this node'
           return false
         end
       end
@@ -462,11 +453,11 @@ module PEROBS
       str = ''
 
       traverse do |node, position, stack|
-        if position == 0
+        if position.zero?
           begin
-            str += "#{node.parent ? node.parent.tree_prefix + '  +' : 'o'}" +
-              "#{node.tree_branch_mark}-" +
-              "#{node.size == 0 ? '--' : 'v-'}#{node.tree_summary}\n"
+            str += "#{node.parent ? node.parent.tree_prefix + '  +' : 'o'}" \
+                   "#{node.tree_branch_mark}-" \
+                   "#{node.empty? ? '--' : 'v-'}#{node.tree_summary}\n"
           rescue => e
             str += "@@@@@@@@@@: #{e.message}\n"
           end
@@ -474,11 +465,11 @@ module PEROBS
           begin
             if node.is_leaf?
               if position <= node.size
-                str += "#{node.tree_prefix}  " +
-                  "#{position == node.size ? '-' : '|'} " +
-                  "[ #{node.value_index(position - 1)}: " +
-                  "#{node.values[position - 1].nil? ?
-                  'nil' : node.values[position - 1]} ]\n"
+                str += "#{node.tree_prefix}  " \
+                       "#{position == node.size ? '-' : '|'} " \
+                       "[ #{node.value_index(position - 1)}: " \
+                       "#{node.values[position - 1].nil? ?
+                       'nil' : node.values[position - 1]} ]\n"
               end
             end
           rescue => e
@@ -811,7 +802,7 @@ module PEROBS
 
     # Print and log an error message for the node.
     def fatal(msg)
-      msg = "Fatal error in BigArray node @#{@_id}: #{msg}\n" + @tree.to_s
+      msg = "Fatal error in BigArray node @#{@_id}: #{msg}\n"
       $stderr.puts msg
       PEROBS.log.fatal msg
     end
@@ -995,8 +986,5 @@ module PEROBS
         @parent.consolidate_child_nodes(self)
       end
     end
-
   end
-
 end
-

data/lib/perobs/BigHash.rb

@@ -1,4 +1,4 @@
-# encoding: UTF-8
+# # frozen_string_literal: true
 #
 # = BigHash.rb -- Persistent Ruby Object Store
 #
@@ -31,7 +31,6 @@ require 'perobs/Array'
 require 'perobs/FNV_Hash_1a_64'
 
 module PEROBS
-
   # The BigHash is similar to the Hash object in that it provides a simple
   # hash functionality. The difference is that this class scales to much
   # larger data sets essentially limited to the amount of space available on
@@ -40,7 +39,6 @@ module PEROBS
   # subset of the methods provided by the native Hash class that make sense
   # for giant data sets.
   class BigHash < PEROBS::Object
-
     # Internally this class uses BigTree to store the values by the hashed
     # key. We are using a 64 bit hash space so collisions are fairly unlikely
     # but not impossible. Therefor we have to store the originial key with the
@@ -52,7 +50,6 @@ module PEROBS
     # hashed key in a Collisions object instead of storing the Entry
     # directly in the BigTree.
     class Entry < PEROBS::Object
-
       attr_persist :key, :value
 
       def initialize(p, key, value)
@@ -60,7 +57,6 @@ module PEROBS
         self.key = key
         self.value = value
       end
-
     end
 
     # Since the BigHash can also store PEROBS::Array values we need to
@@ -78,8 +74,7 @@ module PEROBS
       self.btree = @store.new(PEROBS::BigTree)
     end
 
-    def restore
-    end
+    def restore; end
 
     # Insert a value that is associated with the given key. If a value for
     # this key already exists, the value will be overwritten with the newly
@@ -139,8 +134,8 @@ module PEROBS
         entry.each do |ae|
           return ae.value if ae.key == key
         end
-      else
-        return entry.value if entry.key == key
+      elsif entry.key == key
+        return entry.value
       end
 
       nil
@@ -159,8 +154,8 @@ module PEROBS
         entry.each do |ae|
           return true if ae.key == key
         end
-      else
-        return true if entry.key == key
+      elsif entry.key == key
+        return true
       end
 
       false
@@ -180,12 +175,10 @@ module PEROBS
 
       if entry.is_a?(PEROBS::Array)
         entry.each_with_index do |ae, i|
-          if ae.key == key
-            return entry.delete_at(i).value
-          end
+          return entry.delete_at(i).value if ae.key == key
         end
-      else
-        return entry.value if entry.key == key
+      elsif entry.key == key
+        return entry.value
       end
 
       nil
@@ -202,13 +195,13 @@ module PEROBS
     # Return true if hash is empty. False otherweise.
     # @return [TrueClass, FalseClass]
     def empty?
-      @btree.entry_counter == 0
+      @btree.entry_counter.zero?
     end
 
     # Calls the given block for each key/value pair.
     # @yield(key, value)
     def each(&block)
-      @btree.each do |index, entry|
+      @btree.each do |_, entry|
         if entry.is_a?(Collisions)
           break if entry.each do |c_entry|
             yield(c_entry.key, c_entry.value)
@@ -224,23 +217,20 @@ module PEROBS
     # @return [Array] A list of all keys
     def keys
       ks = []
-      each { |k, v| ks << k }
+      each { |k, _| ks << k }
       ks
     end
 
     # Check if the data structure contains any errors.
     # @return [Boolean] true if no erros were found, false otherwise
     def check
-      return @btree.check
+      @btree.check
     end
 
     private
 
     def hash_key(key)
-      FNV_Hash_1a_64::digest(key)
+      FNV_Hash_1a_64.digest(key)
     end
-
   end
-
 end
-

data/lib/perobs/BigTree.rb

@@ -1,4 +1,4 @@
-# encoding: UTF-8
+# frozen_string_literal: true
 #
 # = BigTree.rb -- Persistent Ruby Object Store
 #
@@ -35,10 +35,7 @@ module PEROBS
   # entries is limited by the space on the backing store, not the main
   # memory. Entries are addressed by a Integer key.
   class BigTree < PEROBS::Object
-
-    class Stats < Struct.new(:leaf_nodes, :branch_nodes, :min_depth,
-                             :max_depth)
-    end
+    Stats = Struct.new(:leaf_nodes, :branch_nodes, :min_depth, :max_depth)
 
     attr_persist :node_size, :root, :first_leaf, :last_leaf, :entry_counter
 
@@ -118,9 +115,7 @@ module PEROBS
       old_root = @root
       clear
       old_root.each do |k, v|
-        if !yield(k, v)
-          insert(k, v)
-        end
+        insert(k, v) unless yield(k, v)
       end
     end
 
@@ -131,7 +126,7 @@ module PEROBS
 
     # Return true if the BigTree has no stored entries.
     def empty?
-      @entry_counter == 0
+      @entry_counter.zero?
     end
 
     # Iterate over all entries in the tree. Entries are always sorted by the
@@ -141,6 +136,7 @@ module PEROBS
       node = @first_leaf
       while node
         break if node.each_element(&block).nil?
+
         node = node.next_sibling
       end
     end
@@ -156,7 +152,6 @@ module PEROBS
       end
     end
 
-
     # @return [String] Human reable form of the tree.
     def to_s
       @root.to_s
@@ -173,8 +168,8 @@ module PEROBS
       end
 
       unless @entry_counter == i
-        PEROBS.log.error "BigTree contains #{i} values but entry counter " +
-          "is #{@entry_counter}"
+        PEROBS.log.error "BigTree contains #{i} values but entry counter " \
+                         "is #{@entry_counter}"
         return false
       end
 
@@ -188,10 +183,5 @@ module PEROBS
       @root.statistics(stats)
       stats
     end
-
-    private
-
   end
-
 end
-