radix_tree 1.0.0.dev

data/README

@@ -0,0 +1,34 @@
+radix_tree - Naive implementation of Radix Tree for Ruby
+Copyright (C) 2012 Hiroshi Nakamura <nahi@ruby-lang.org>
+
+My intention is using Radix Tree instead of Hash for parsing external input
+to avoid DoS via Algorithmic Complexity Attacks.
+
+
+== Performance
+
+* 25 times slower for 10 bytes key insertion
+* 20 times slower for 10 bytes key 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
+
+
+== Author
+
+Name:: Hiroshi Nakamura
+E-mail:: nahi@ruby-lang.org
+Project web site:: http://github.com/nahi/radix_tree
+
+
+== License
+
+This program is copyrighted free software by Hiroshi Nakamura.  You can
+redistribute it and/or modify it under the same terms of Ruby's license;
+either the dual license version in 2003, or any later version.

data/lib/radix_tree.rb

@@ -0,0 +1,214 @@
+# 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
+#
+# 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
+
+  class Node
+    UNDEFINED = Object.new
+
+    attr_reader :key, :value
+    attr_reader :children
+
+    def initialize(key, value = UNDEFINED, children = nil)
+      @key, @value, @children = key, value, children
+    end
+
+    def empty?
+      @children.nil? and @value == UNDEFINED
+    end
+
+    def size
+      count = @value != UNDEFINED ? 1 : 0
+      if @children
+        @children.inject(count) { |r, (k, v)| r + v.size }
+      else
+        count
+      end
+    end
+
+    def each(prefix, &block)
+      prefix += @key
+      if @value != UNDEFINED
+        block.call(prefix, @value)
+      end
+      if @children
+        @children.each do |key, child|
+          child.each(prefix, &block)
+        end
+      end
+    end
+
+    def keys(prefix)
+      collect(prefix) { |k, v| k }
+    end
+
+    def values(prefix)
+      collect(prefix) { |k, v| v }
+    end
+
+    def store(key, value)
+      if @key == key
+        @value = value
+      else
+        index = head_match_length(key)
+        if index == @key.bytesize
+          push(key[index..-1], value)
+        else
+          split(index)
+          store(key, value) # search again
+        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
+          child.retrieve(key)
+        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
+          value = child.delete(key)
+        end
+        delete_child(child) if value and child.children.nil?
+        value
+      end
+    end
+
+    protected
+
+    def value=(value)
+      @value = value
+    end
+
+    private
+
+    def collect(prefix)
+      pool = []
+      each(prefix) do |key, value|
+        pool << yield(key, value)
+      end
+      pool
+    end
+
+    def push(key, value)
+      if child = find_child(key)
+        child.store(key, value)
+      else
+        add_child(Node.new(key, value))
+      end
+    end
+
+    def split(index)
+      @key, new_key = @key[0, index], @key[index..-1]
+      child = Node.new(new_key, @value, @children)
+      @value, @children = UNDEFINED, nil
+      add_child(child)
+    end
+
+    def child_key(key)
+      index = head_match_length(key)
+      key[index..-1]
+    end
+
+    def head_match_length(check)
+      0.upto([check.bytesize, @key.bytesize].min) do |index|
+        return index if check[index] != @key[index]
+      end
+      raise 'assert check != @key'
+    end
+
+    def find_child(key)
+      @children[key[0]] if @children
+    end
+
+    def add_child(child)
+      @children ||= {}
+      @children[child.key[0]] = child
+    end
+
+    def delete_child(child)
+      @children.delete(child.key[0])
+      @children = nil if @children.empty?
+    end
+  end
+
+  DEFAULT = Object.new
+  
+  def initialize(default = DEFAULT, &block)
+    raise ArgumentError, 'wrong number of arguments' if block && default != DEFAULT
+    @root = Node.new('')
+    @default = default
+    @default_proc = block
+  end
+
+  def empty?
+    @root.empty?
+  end
+
+  def size
+    @root.size
+  end
+
+  def each(&block)
+    @root.each('', &block)
+  end
+
+  def keys
+    @root.keys('')
+  end
+
+  def values
+    @root.values('')
+  end
+
+  def []=(key, value)
+    @root.store(key, value)
+  end
+
+  def key?(key)
+    @root.retrieve(key) != Node::UNDEFINED
+  end
+  alias has_key? key?
+
+  def [](key)
+    value = @root.retrieve(key)
+    if value == Node::UNDEFINED
+      if @default != DEFAULT
+        @default
+      elsif @default_proc
+        @default_proc.call
+      else
+        nil
+      end
+    else
+      value
+    end
+  end
+
+  def delete(key)
+    @root.delete(key)
+  end
+end

data/test/helper.rb

@@ -0,0 +1,2 @@
+require "test/unit"
+require "radix_tree"

data/test/test_radix_tree.rb

@@ -0,0 +1,141 @@
+require File.expand_path('./helper', File.dirname(__FILE__))
+
+class TestRadixTree < Test::Unit::TestCase
+  def test_aref_nil
+    h = RadixTree.new
+    h['abc'] = 1
+    assert_equal nil, h['def']
+  end
+
+  def test_aref_empty
+    h = RadixTree.new
+    assert_equal nil, h['']
+  end
+
+  def test_aref_single
+    h = RadixTree.new
+    h['abc'] = 1
+    assert_equal 1, h['abc']
+  end
+
+  def test_aref_double
+    h = RadixTree.new
+    h['abc'] = 1
+    h['def'] = 2
+    assert_equal 1, h['abc']
+    assert_equal 2, h['def']
+  end
+
+  def test_aset_override
+    h = RadixTree.new
+    h['abc'] = 1
+    h['abc'] = 2
+    assert_equal 2, h['abc']
+  end
+
+  def test_split
+    h = RadixTree.new
+    h['abcd'] = 1
+    assert_equal 1, h['abcd']
+    h['abce'] = 2
+    assert_equal 1, h['abcd']
+    assert_equal 2, h['abce']
+    h['abd'] = 3
+    assert_equal 1, h['abcd']
+    assert_equal 2, h['abce']
+    assert_equal 3, h['abd']
+    h['ac'] = 4
+    assert_equal 1, h['abcd']
+    assert_equal 2, h['abce']
+    assert_equal 3, h['abd']
+    assert_equal 4, h['ac']
+  end
+
+  def test_split_and_assign
+    h = RadixTree.new
+    h['ab'] = 1
+    h['a'] = 2
+    assert_equal 1, h['ab']
+    assert_equal 2, h['a']
+  end
+
+  def test_push
+    h = RadixTree.new
+    assert_equal 0, h.size
+    h['a'] = 1
+    assert_equal 1, h['a']
+    h['ab'] = 2
+    assert_equal 1, h['a']
+    assert_equal 2, h['ab']
+    h['abc'] = 3
+    assert_equal 1, h['a']
+    assert_equal 2, h['ab']
+    assert_equal 3, h['abc']
+    h['abd'] = 4
+    assert_equal 1, h['a']
+    assert_equal 2, h['ab']
+    assert_equal 3, h['abc']
+    assert_equal 4, h['abd']
+    h['ac'] = 5
+    assert_equal 1, h['a']
+    assert_equal 2, h['ab']
+    assert_equal 3, h['abc']
+    assert_equal 4, h['abd']
+    assert_equal 5, h['ac']
+    h['b'] = 6
+    assert_equal 1, h['a']
+    assert_equal 2, h['ab']
+    assert_equal 3, h['abc']
+    assert_equal 4, h['abd']
+    assert_equal 5, h['ac']
+    assert_equal 6, h['b']
+    assert_equal ['a', 'ab', 'abc', 'abd', 'ac', 'b'].sort, h.keys.sort
+    assert_equal 6, h.size
+  end
+
+  def test_delete
+    h = RadixTree.new
+    h['a'] = 1
+    h['ab'] = 2
+    h['abc'] = 3
+    h['abd'] = 4
+    h['ac'] = 5
+    h['b'] = 6
+    assert_equal 6, h.size
+    assert_equal nil, h.delete('XXX')
+    # delete leaf
+    assert_equal 4, h.delete('abd')
+    assert_equal 5, h.size
+    assert_equal 1, h['a']
+    assert_equal 2, h['ab']
+    assert_equal 3, h['abc']
+    assert_equal nil, h['abd']
+    assert_equal 5, h['ac']
+    assert_equal 6, h['b']
+    # delete single leaf node
+    assert_equal 2, h.delete('ab')
+    assert_equal 4, h.size
+    assert_equal 1, h['a']
+    assert_equal nil, h['ab']
+    assert_equal 3, h['abc']
+    assert_equal nil, h['abd']
+    assert_equal 5, h['ac']
+    assert_equal 6, h['b']
+    # delete multiple leaf node
+    assert_equal 1, h.delete('a')
+    assert_equal 3, h.size
+    assert_equal nil, h['a']
+    assert_equal nil, h['ab']
+    assert_equal 3, h['abc']
+    assert_equal nil, h['abd']
+    assert_equal 5, h['ac']
+    assert_equal 6, h['b']
+    assert_equal ['abc', 'ac', 'b'].sort, h.keys.sort
+    # delete rest
+    assert_equal 3, h.delete('abc')
+    assert_equal 5, h.delete('ac')
+    assert_equal 6, h.delete('b')
+    assert_equal 0, h.size
+    assert h.empty?
+  end
+end

metadata

@@ -0,0 +1,48 @@
+--- !ruby/object:Gem::Specification
+name: radix_tree
+version: !ruby/object:Gem::Version
+  version: 1.0.0.dev
+  prerelease: 6
+platform: ruby
+authors:
+- Hiroshi Nakamura
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-01-05 00:00:00.000000000 Z
+dependencies: []
+description: 
+email: nahi@ruby-lang.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/radix_tree.rb
+- test/test_radix_tree.rb
+- test/helper.rb
+- README
+homepage: http://github.com/nahi/radix_tree
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>'
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: Naive implementation of Radix Tree for Ruby
+test_files: []