radix_tree 1.0.0.dev → 1.0.0.dev.2

data/README

@@ -7,8 +7,8 @@ to avoid DoS via Algorithmic Complexity Attacks.
 
 == Performance
 
-* 25 times slower for 10 bytes key insertion
-* 20 times slower for 10 bytes key retrieval
+* 25 times slower for 10 bytes key, 100000 elements insertion
+* 10 times slower for 10 bytes key, 100000 elements retrieval
 
 
 == TODO

data/lib/radix_tree.rb

@@ -1,14 +1,15 @@
 # Naive implementation of Radix Tree for avoiding DoS via Algorithmic
 # Complexity Attacks.
 #
-# 25 times slower for 10 bytes key insertion
-# 20 times slower for 10 bytes key retrieval
+# 25 times slower for 10 bytes key, 100000 elements insertion
+# 10 times slower for 10 bytes key, 100000 elements retrieval
 #
 # TODO: Implement following features for utilizing strength of Radix Tree.
 # * find predecessor
 # * find successor
 # * find_all by start string
 # * delete_all by start string
+#
 class RadixTree
   include Enumerable
 
@@ -22,8 +23,12 @@ class RadixTree
       @key, @value, @children = key, value, children
     end
 
+    def undefined?
+      @value == UNDEFINED
+    end
+
     def empty?
-      @children.nil? and @value == UNDEFINED
+      @children.nil? and undefined?
     end
 
     def size
@@ -60,47 +65,70 @@ class RadixTree
         @value = value
       else
         index = head_match_length(key)
-        if index == @key.bytesize
+        if index == @key.size
           push(key[index..-1], value)
         else
           split(index)
-          store(key, value) # search again
+          # search again after split the node
+          store(key, value)
         end
       end
     end
 
     def retrieve(key)
-      return UNDEFINED unless @children
-      key = child_key(key)
-      if child = find_child(key)
-        if child.key == key
-          child.value
-        else
+      if @key == key
+        @value
+      elsif !@children
+        UNDEFINED
+      else
+        key = child_key(key)
+        if child = find_child(key)
           child.retrieve(key)
+        else
+          UNDEFINED
         end
-      else
-        UNDEFINED
       end
     end
 
     def delete(key)
-      return nil unless @children
-      key = child_key(key)
-      if child = find_child(key)
-        if child.key == key
-          value, child.value = child.value, UNDEFINED
-        else
+      if @key == key
+        value, @value = @value, UNDEFINED
+        value
+      elsif !@children
+        nil
+      else
+        key = child_key(key)
+        if child = find_child(key)
           value = child.delete(key)
+          if value and child.undefined?
+            if child.children.nil?
+              delete_child(child)
+            elsif child.children.size == 1
+              # pull up the grand child as a child
+              delete_child(child)
+              grand = child.children.values.first
+              add_child(Node.new(child.key + grand.key, grand.value, grand.children))
+            end
+          end
+          value
         end
-        delete_child(child) if value and child.children.nil?
-        value
       end
     end
 
-    protected
-
-    def value=(value)
-      @value = value
+    def dump_tree(io, prefix = '', indent = '')
+      prefix += @key
+      indent += '  '
+      if undefined?
+        io << sprintf("#<%s:0x%010x %s>", self.class.name, __id__, prefix.inspect)
+      else
+        io << sprintf("#<%s:0x%010x %s> => %s", self.class.name, __id__, prefix.inspect, @value.inspect)
+      end
+      if @children
+        @children.each do |k, v|
+          io << $/ + indent
+          v.dump_tree(io, prefix, indent)
+        end
+      end
     end
 
     private
@@ -129,19 +157,23 @@ class RadixTree
     end
 
     def child_key(key)
-      index = head_match_length(key)
-      key[index..-1]
+      key[head_match_length(key)..-1]
     end
 
+    # assert: check != @key
     def head_match_length(check)
-      0.upto([check.bytesize, @key.bytesize].min) do |index|
-        return index if check[index] != @key[index]
+      0.upto(check.size) do |index|
+        if check[index] != @key[index]
+          return index
+        end
       end
-      raise 'assert check != @key'
+      raise 'assert: check != @key'
     end
 
     def find_child(key)
-      @children[key[0]] if @children
+      if @children
+        @children[key[0]]
+      end
     end
 
     def add_child(child)
@@ -151,14 +183,18 @@ class RadixTree
 
     def delete_child(child)
       @children.delete(child.key[0])
-      @children = nil if @children.empty?
+      if @children.empty?
+        @children = nil
+      end
     end
   end
 
   DEFAULT = Object.new
   
   def initialize(default = DEFAULT, &block)
-    raise ArgumentError, 'wrong number of arguments' if block && default != DEFAULT
+    if block && default != DEFAULT
+      raise ArgumentError, 'wrong number of arguments'
+    end
     @root = Node.new('')
     @default = default
     @default_proc = block
@@ -185,16 +221,16 @@ class RadixTree
   end
 
   def []=(key, value)
-    @root.store(key, value)
+    @root.store(key.to_s, value)
   end
 
   def key?(key)
-    @root.retrieve(key) != Node::UNDEFINED
+    @root.retrieve(key.to_s) != Node::UNDEFINED
   end
   alias has_key? key?
 
   def [](key)
-    value = @root.retrieve(key)
+    value = @root.retrieve(key.to_s)
     if value == Node::UNDEFINED
       if @default != DEFAULT
         @default
@@ -209,6 +245,11 @@ class RadixTree
   end
 
   def delete(key)
-    @root.delete(key)
+    @root.delete(key.to_s)
+  end
+
+  def dump_tree(io = '')
+    @root.dump_tree(io)
+    io
   end
 end

data/test/helper.rb

@@ -1,2 +1,4 @@
+require 'simplecov'
+SimpleCov.start
 require "test/unit"
 require "radix_tree"

data/test/test_radix_tree.rb

@@ -1,3 +1,4 @@
+# -*- encoding: utf-8 -*-
 require File.expand_path('./helper', File.dirname(__FILE__))
 
 class TestRadixTree < Test::Unit::TestCase
@@ -7,8 +8,13 @@ class TestRadixTree < Test::Unit::TestCase
     assert_equal nil, h['def']
   end
 
-  def test_aref_empty
+  def test_empty
     h = RadixTree.new
+    h['abc'] = 0
+    assert_equal nil, h['']
+    h[''] = 1
+    assert_equal 1, h['']
+    h.delete('')
     assert_equal nil, h['']
   end
 
@@ -138,4 +144,115 @@ class TestRadixTree < Test::Unit::TestCase
     assert_equal 0, h.size
     assert h.empty?
   end
+
+  def test_delete_compaction_middle
+    h = RadixTree.new
+    h['a'] = 1
+    h['abc'] = 2
+    h['bb'] = 3
+    h['abcdefghi'] = 4
+    h['abcdefghijzz'] = 5
+    h['abcdefghikzz'] = 6
+    assert_equal 7, h.dump_tree.split($/).size
+    h.delete('a')
+    assert_equal 6, h.dump_tree.split($/).size
+    h['a'] = 1
+    assert_equal 7, h.dump_tree.split($/).size
+  end
+
+  def test_delete_compaction_leaf
+    h = RadixTree.new
+    h['a'] = 1
+    h['abc'] = 2
+    h['bb'] = 3
+    h['abcdefghijzz'] = 4
+    assert_equal 5, h.dump_tree.split($/).size
+    h['abcdefghikzz'] = 5
+    assert_equal 7, h.dump_tree.split($/).size
+    h.delete('abcdefghijzz')
+    assert_equal 5, h.dump_tree.split($/).size
+    h['abcdefghijzz'] = 4
+    assert_equal 7, h.dump_tree.split($/).size
+  end
+
+  def test_each
+    h = RadixTree.new
+    s = { 'aa' => 1, 'ab' => 2, 'bb' => 3, 'bc' => 4, 'a' => 5, 'abc' => 6 }
+    s.each do |k, v|
+      h[k] = v
+    end
+    values = []
+    h.each do |k, v|
+      values << [k, v]
+    end
+    assert_equal s.to_a.sort_by { |k, v| k }, values.sort_by { |k, v| k }
+  end
+
+  def test_keys
+    h = RadixTree.new
+    s = { 'aa' => 1, 'ab' => 2, 'bb' => 3, 'bc' => 4, 'a' => 5, 'abc' => 6 }
+    s.each do |k, v|
+      h[k] = v
+    end
+    assert_equal s.keys.sort, h.keys.sort
+  end
+
+  def test_values
+    h = RadixTree.new
+    s = { 'aa' => 1, 'ab' => 2, 'bb' => 3, 'bc' => 4, 'a' => 5, 'abc' => 6 }
+    s.each do |k, v|
+      h[k] = v
+    end
+    assert_equal s.values.sort, h.values.sort
+  end
+
+  def test_to_s
+    h = RadixTree.new
+    h[:abc] = 1
+    assert_equal 1, h["abc"]
+    assert_equal 1, h[:abc]
+  end
+
+  def test_key?
+    h = RadixTree.new
+    assert !h.key?('a')
+    s = { 'aa' => 1, 'ab' => 2, 'bb' => 3, 'bc' => 4, 'a' => 5, 'abc' => 6 }
+    s.each do |k, v|
+      h[k] = v
+    end
+    assert h.key?('a')
+  end
+
+  def test_default
+    assert_raise(ArgumentError) do
+      RadixTree.new('both') { :not_allowed }
+    end
+
+    h = RadixTree.new('abc')
+    assert_equal 'abc', h['foo']
+    assert_equal 'abc', h['bar']
+    assert h['baz'].object_id == h['qux'].object_id
+
+    h = RadixTree.new { [1, 2] }
+    assert_equal [1, 2], h['foo']
+    assert_equal [1, 2], h['bar']
+    assert h['baz'].object_id != h['qux'].object_id
+  end
+
+  if RUBY_VERSION >= '1.9.0'
+    def test_encoding
+      h = RadixTree.new
+      s = { 'ああ' => 1, 'あい' => 2, 'いい' => 3, 'いう' => 4, 'あ' => 5, 'あいう' => 6 }
+      s.each do |k, v|
+        h[k] = v
+      end
+      assert_equal 6, h.size
+      s.each do |k, v|
+        assert_equal v, h[k]
+      end
+      str = 'ああ'
+      str.force_encoding('US-ASCII')
+      assert_equal nil, h[str]
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: radix_tree
 version: !ruby/object:Gem::Version
-  version: 1.0.0.dev
+  version: 1.0.0.dev.2
   prerelease: 6
 platform: ruby
 authors: