trie-file 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8bc2e8641b2afc2c19a2e519a6af559efdf08a97
+  data.tar.gz: 85c0da8ef2d170d9588525adcccb6edad71ebad6
+SHA512:
+  metadata.gz: 3bab7cec0c62f28a54fce93b5e8f9eabc05390fd67c077317e0477663bcbe5bc9aa0b4feb15c50528c2fdc241183b8e4290faeea6d79aed6d04e2b5019645891
+  data.tar.gz: 55ec9c2d427f8a399a4470905dfb1c78ac2a37d799af20531b5525128e4da0707f6256db5e05531e37aaff7dc2b3612a106009d35a1017479ad54239ddc93d72

data/Gemfile

@@ -0,0 +1,13 @@
+source "https://rubygems.org"
+
+gemspec
+
+group :development, :test do
+  gem 'pry-nav'
+  gem 'rake'
+end
+
+group :test do
+  gem 'rspec'
+  gem 'rr'
+end

data/History.txt

@@ -0,0 +1,3 @@
+== 1.0.0
+
+* Birthday!

data/README.md

@@ -0,0 +1,77 @@
+trie-file
+=========
+
+Memory-efficient cached trie and trie storage.
+
+## Installation
+
+`gem install trie-file`
+
+Then, somewhere in your code:
+
+```ruby
+require 'trie-file'
+```
+
+## Rationale
+
+trie-file contains two things: an implementation of the [trie data structure](http://en.wikipedia.org/wiki/Trie), and a way to write them to disk and read them back again. It tries (ha!) to do this in a memory-efficient way by packing the trie structure in a specialized binary form. This special packing method means the trie can be searched entirely _on disk_ without needing to load the whole structure into memory (linear time). Each key you look up is cached so subsequent accesses are even faster (constant time). trie-file is also capable of reading and writing entire trie structures.
+
+Because tries (also known as prefix trees) rely on keys having common prefixes, you're required to use string keys. There are no type restrictions on values.
+
+## What's a Trie?
+
+For an in-depth explanation, see the Wikipedia link above. Essentially tries are key-value data structures that work similar to Ruby hashes. You add a key and a value to the trie and can later retrieve the value using the same key.
+
+## Basic Usage
+
+Create a trie and write it to disk:
+
+```ruby
+trie = TrieFile::Trie.new
+trie.add('foo', 'bar')
+
+TrieFile::File.open('/path/to/file', 'wb') do |f|
+  f.write_trie(trie)
+end
+```
+
+Open a file handle to a trie and search it _on disk_:
+
+```ruby
+trie_file = TrieFile::File.open('/path/to/file', 'rb')
+trie_file.find('foo')  # => 'bar'
+```
+
+To read an entire trie, use the `#read` method instead of `#open`:
+
+```ruby
+trie = TrieFile::File.read('/path/to/file')
+```
+
+## Choosing a Hash Method
+
+By default, trie-file does not hash your keys. Instead, it iterates over each character in the key and constructs the internal trie structure. trie-file also supports hashing keys with the md5 or sha1 algorithms to minimize your search space:
+
+```ruby
+trie = TrieFile::Trie.new(nil, :sha1)
+```
+
+If you wrote a trie to disk that was hashed using sha1, you'll need to supply an additional argument to `#open` and `#read`:
+
+```ruby
+trie_file = TrieFile::File.open('/path/to/file', 'rb', :sha1)
+trie = TrieFile::File.read('/path/to/file', :sha1)
+```
+
+## Requirements
+
+No external requirements.
+
+## Running Tests
+
+`bundle exec rspec` should do the trick :)
+
+## Authors
+
+* Cameron C. Dutro: http://github.com/camertron

data/Rakefile

@@ -0,0 +1,18 @@
+# encoding: UTF-8
+
+require 'rubygems' unless ENV['NO_RUBYGEMS']
+
+require 'bundler'
+require 'rspec/core/rake_task'
+require 'rubygems/package_task'
+
+require './lib/trie-file'
+
+Bundler::GemHelper.install_tasks
+
+task :default => :spec
+
+desc 'Run specs'
+RSpec::Core::RakeTask.new do |t|
+  t.pattern = './spec/**/*_spec.rb'
+end

data/lib/trie-file.rb

@@ -0,0 +1,5 @@
+# encoding: UTF-8
+
+require 'trie-file/trie'
+require 'trie-file/node'
+require 'trie-file/file'

data/lib/trie-file/file.rb

@@ -0,0 +1,232 @@
+# encoding: UTF-8
+
+require 'thread'
+
+# root:
+# 2b value length
+# nb value
+# 2b (number of children)
+# children metadata:
+#   3b letter
+#   3b child location
+# children:
+#   node:
+#     2b value length
+#     ...
+
+module TrieFile
+  class File
+    attr_reader :handle, :hash_mode
+
+    def self.open(path, mode, hash_mode = :none)
+      handle = ::File.open(path, mode)
+
+      unless handle.binmode?
+        raise ArgumentError, 'TrieFile must be opened in binary mode.'
+      end
+
+      file = new(handle, hash_mode)
+
+      if block_given?
+        yield file
+        handle.close
+      end
+
+      file
+    end
+
+    def self.read(path, hash_mode = :none)
+      root = nil
+
+      ::File.open(path, 'rb') do |io|
+        root = read_node(io)
+      end
+
+      Trie.new(root, hash_mode)
+    end
+
+    def initialize(handle, hash_mode)
+      @handle = handle
+      @semaphore = Mutex.new
+      @hash_mode = hash_mode
+    end
+
+    def write_trie(trie)
+      mark(trie)
+      self.class.write_node(trie.root, handle)
+    end
+
+    def find(key)
+      if closed?
+        raise IOError, 'file is not currently open.'
+      end
+
+      @semaphore.synchronize do
+        key = hash_key(key)
+        cache.fetch(key) do
+          handle.seek(0, IO::SEEK_SET)
+          value = nil
+
+          key.each_char do |char|
+            value, child_metadata = self.class.read_node_header(handle)
+            metadata = child_metadata.find do |data|
+              data.first == char
+            end
+
+            return nil unless metadata
+            handle.seek(metadata.last, IO::SEEK_SET)
+          end
+
+          value = self.class.read_value(handle)
+          cache[key] = value
+          value
+        end
+      end
+    end
+
+    def closed?
+      @handle.closed?
+    end
+
+    def close
+      handle.close
+    end
+
+    private
+
+    BYTE_LENGTH = 8
+    LETTER_FIELD_LENGTH = 3
+    POSITION_FIELD_LENGTH = 3
+    POSITION_MAX = 2 ** (BYTE_LENGTH * POSITION_FIELD_LENGTH)
+    VALUE_FIELD_LENGTH = 2
+    CHILD_COUNT_FIELD_LENGTH = 2
+
+    def hash_key(key)
+      Trie.hash_key(key, hash_mode)
+    end
+
+    def cache
+      @cache ||= {}
+    end
+
+    def mark(trie)
+      mark_node(trie.root, 0)
+    end
+
+    def mark_node(node, byte_pos)
+      node.byte_pos = byte_pos
+      total_child_size = 0
+      node.children.each_pair do |letter, child|
+        offset = mark_node(child, byte_pos + node.bytesize + total_child_size)
+        total_child_size += child.bytesize + offset
+      end
+      total_child_size
+    end
+
+    def self.read_value(io)
+      # 2b value length
+      value_bytesize = read_int(io, VALUE_FIELD_LENGTH)
+
+      # nb value
+      value = io.read(value_bytesize)
+    end
+
+    def self.read_node_header(io)
+      value = read_value(io)
+
+      # 2b number of children
+      number_of_children = read_int(io, CHILD_COUNT_FIELD_LENGTH)
+
+      child_metadata = number_of_children.times.map do
+        # 2b letter
+        letter = read_bytes(io, LETTER_FIELD_LENGTH)
+
+        # 3b child location
+        child_pos = read_int(io, POSITION_FIELD_LENGTH)
+        [letter, child_pos]
+      end
+
+      [value, child_metadata]
+    end
+
+    def self.read_node(io)
+      value, child_metadata = read_node_header(io)
+      node = Node.new(value)
+
+      child_metadata.each do |metadata|
+        node.add_child(
+          metadata.first,
+          read_node(io)
+        )
+      end
+
+      node
+    end
+
+    def self.write_node(node, io)
+      # 2b value length
+      write_int(io, node.value_bytesize, VALUE_FIELD_LENGTH)
+
+      # nb value
+      write_bytes(io, node.value_bytes.to_a)
+
+      # 2b number of children
+      write_int(io, node.children.size, CHILD_COUNT_FIELD_LENGTH)
+
+      # children
+      node.children.each_pair do |letter, child_node|
+        # 2b letter
+        if letter.bytesize > LETTER_FIELD_LENGTH
+          raise "Letter #{letter} is larger than #{LETTER_FIELD_LENGTH} bytes."
+        else
+          write_bytes(io, letter.bytes.to_a, LETTER_FIELD_LENGTH)
+        end
+
+        # 3b child location
+        if child_node.byte_pos > POSITION_MAX
+          raise "Encountered write position greater than #{POSITION_FIELD_LENGTH} bytes."
+        else
+          write_int(io, child_node.byte_pos, POSITION_FIELD_LENGTH)
+        end
+      end
+
+      node.children.each_pair do |letter, child_node|
+        write_node(child_node, io)
+      end
+    end
+
+    def self.write_int(io, int, bytesize = int_bytesize(int))
+      actual_bytesize = int_bytesize(int)
+      (bytesize - actual_bytesize).times { io.putc("\0") }
+
+      actual_bytesize.times do |i|
+        # putc always writes the LSB if given a multibyte arg
+        io.putc(int >> ((actual_bytesize - i - 1) * BYTE_LENGTH))
+      end
+    end
+
+    def self.int_bytesize(int)
+      return 0 if int == 0
+      (Math.log2(int) / BYTE_LENGTH).to_i + 1
+    end
+
+    def self.write_bytes(io, bytes, bytesize = bytes.size)
+      (bytesize - bytes.size).times { io.putc("\0") }
+      bytes.each { |byte| io.putc(byte) }
+    end
+
+    def self.read_int(io, bytesize)
+      (bytesize - 1).downto(0).inject(0) do |sum, i|
+        sum + (io.readbyte << (i * BYTE_LENGTH))
+      end
+    end
+
+    def self.read_bytes(io, bytesize)
+      # remove leading zero bytes
+      bytes = bytesize.times.map { io.readbyte }
+      return [0] if bytes.all? { |byte| byte == 0 }
+      idx = bytes.find_index { |byte| byte != 0 }
+      bytes[idx..-1].pack("U*")
+    end
+  end
+end

data/lib/trie-file/node.rb

@@ -0,0 +1,42 @@
+# encoding: UTF-8
+
+module TrieFile
+  class Node
+    CHILD_FIELDS_LENGTH = 6
+    HEADER_FIELD_LENGTH = 4
+
+    attr_reader :children
+    attr_accessor :value, :byte_pos
+
+    def initialize(value = nil)
+      @value = value
+      @children = {}
+      @byte_pos = 0
+    end
+
+    def has_child?(char)
+      children.include?(char)
+    end
+
+    def child_at(char)
+      children[char]
+    end
+
+    def add_child(char, node)
+      @children[char] = node
+    end
+
+    def bytesize
+      # add some constants here
+      HEADER_FIELD_LENGTH + (children.size * CHILD_FIELDS_LENGTH) + value_bytesize
+    end
+
+    def value_bytesize
+      value ? value.bytesize : 0
+    end
+
+    def value_bytes
+      value ? value.bytes : []
+    end
+  end
+end

data/lib/trie-file/trie.rb

@@ -0,0 +1,54 @@
+# encoding: UTF-8
+
+require 'digest/md5'
+require 'digest/sha1'
+
+module TrieFile
+  class Trie
+    attr_reader :root, :hash_mode
+
+    def initialize(root = nil, hash_mode = :none)
+      @root = root || Node.new
+      @hash_mode = hash_mode
+    end
+
+    def add(str, value)
+      node = root
+      key = hash_key(str)
+
+      key.each_char do |char|
+        if node.has_child?(char)
+          node = node.child_at(char)
+        else
+          node = node.add_child(char, Node.new)
+        end
+      end
+
+      node.value = value
+    end
+
+    def find(key)
+      node = root
+      hash_key(key).each_char do |char|
+        node = node.child_at(char)
+        return nil unless node
+      end
+      node.value
+    end
+
+    def hash_key(key)
+      self.class.hash_key(key, hash_mode)
+    end
+
+    def self.hash_key(key, hash_mode)
+      case hash_mode
+        when :md5
+          Digest::MD5.hexdigest(key)
+        when :sha1
+          Digest::SHA1.hexdigest(key)
+        else
+          key
+      end
+    end
+  end
+end

data/lib/trie-file/version.rb

@@ -0,0 +1,5 @@
+# encoding: UTF-8
+
+module TrieFile
+  VERSION = '1.0.0'
+end

data/spec/file_spec.rb

@@ -0,0 +1,154 @@
+# encoding: UTF-8
+
+require 'spec_helper'
+
+describe TrieFile::File do
+  def file
+    TrieFile::File
+  end
+
+  def trie
+    TrieFile::Trie
+  end
+
+  let(:tmpdir) { './' }
+  let(:tmpfile) { File.join(tmpdir, 'test.txt') }
+
+  after(:each) do
+    File.unlink(tmpfile) if File.exist?(tmpfile)
+  end
+
+  describe 'self#open' do
+    it "raises an exception if the file isn't opened in binary mode" do
+      proc = lambda { file.open(tmpfile, 'w') }
+      expect(proc).to raise_error(ArgumentError, 'TrieFile must be opened in binary mode.')
+    end
+
+    it 'yields the file when a block is given and closes then returns it afterwards' do
+      f = file.open(tmpfile, 'wb') do |f|
+        expect(f).to be_a(file)
+        expect(f).to respond_to(:write_trie)
+        expect(f).to_not be_closed
+      end
+
+      expect(f).to be_a(file)
+      expect(f).to respond_to(:write_trie)
+      expect(f).to be_closed
+    end
+
+    it 'returns the open file when a block is not given' do
+      file.open(tmpfile, 'wb').tap do |f|
+        expect(f).to be_a(file)
+        expect(f).to_not be_closed
+      end
+    end
+
+    it 'uses the given hash mode when passed' do
+      file.open(tmpfile, 'wb') do |f|
+        f.write_trie(trie.new(nil, :md5).tap { |t| t.add('foo', 'bar') })
+      end
+
+      f = file.open(tmpfile, 'rb', :md5)
+      expect(f.find('foo')).to eq('bar')
+      f.close
+    end
+  end
+
+  describe 'self#read' do
+    let(:bytes) do
+      [
+        0, 0, 0, 1, 0, 0, 102, 0, 0, 10, 0, 0, 0, 1, 0, 0, 111, 0, 0,
+        20, 0, 0, 0, 1, 0, 0, 111, 0, 0, 30, 0, 3, 98, 97, 114, 0, 0
+      ]
+    end
+
+    let(:sha1_bytes) do
+      [
+        0, 0, 0, 1, 0, 0, 48, 0, 0, 10, 0, 0, 0, 1, 0, 0, 98, 0, 0, 20,
+        0, 0, 0, 1, 0, 0, 101, 0, 0, 30, 0, 0, 0, 1, 0, 0, 101, 0, 0, 40,
+        0, 0, 0, 1, 0, 0, 99, 0, 0, 50, 0, 0, 0, 1, 0, 0, 55, 0, 0, 60,
+        0, 0, 0, 1, 0, 0, 98, 0, 0, 70, 0, 0, 0, 1, 0, 0, 53, 0, 0, 80,
+        0, 0, 0, 1, 0, 0, 101, 0, 0, 90, 0, 0, 0, 1, 0, 0, 97, 0, 0, 100,
+        0, 0, 0, 1, 0, 0, 51, 0, 0, 110, 0, 0, 0, 1, 0, 0, 102, 0, 0, 120,
+        0, 0, 0, 1, 0, 0, 48, 0, 0, 130, 0, 0, 0, 1, 0, 0, 102, 0, 0, 140,
+        0, 0, 0, 1, 0, 0, 100, 0, 0, 150, 0, 0, 0, 1, 0, 0, 98, 0, 0, 160,
+        0, 0, 0, 1, 0, 0, 99, 0, 0, 170, 0, 0, 0, 1, 0, 0, 57, 0, 0, 180,
+        0, 0, 0, 1, 0, 0, 53, 0, 0, 190, 0, 0, 0, 1, 0, 0, 100, 0, 0, 200,
+        0, 0, 0, 1, 0, 0, 48, 0, 0, 210, 0, 0, 0, 1, 0, 0, 100, 0, 0, 220,
+        0, 0, 0, 1, 0, 0, 100, 0, 0, 230, 0, 0, 0, 1, 0, 0, 52, 0, 0, 240,
+        0, 0, 0, 1, 0, 0, 55, 0, 0, 250, 0, 0, 0, 1, 0, 0, 102, 0, 1, 4, 0,
+        0, 0, 1, 0, 0, 51, 0, 1, 14, 0, 0, 0, 1, 0, 0, 99, 0, 1, 24, 0, 0,
+        0, 1, 0, 0, 53, 0, 1, 34, 0, 0, 0, 1, 0, 0, 98, 0, 1, 44, 0, 0, 0,
+        1, 0, 0, 99, 0, 1, 54, 0, 0, 0, 1, 0, 0, 50, 0, 1, 64, 0, 0, 0, 1,
+        0, 0, 55, 0, 1, 74, 0, 0, 0, 1, 0, 0, 53, 0, 1, 84, 0, 0, 0, 1, 0,
+        0, 100, 0, 1, 94, 0, 0, 0, 1, 0, 0, 97, 0, 1, 104, 0, 0, 0, 1, 0,
+        0, 56, 0, 1, 114, 0, 0, 0, 1, 0, 0, 97, 0, 1, 124, 0, 0, 0, 1, 0,
+        0, 51, 0, 1, 134, 0, 0, 0, 1, 0, 0, 51, 0, 1, 144, 0, 3, 98, 97,
+        114, 0, 0
+      ]
+    end
+
+    it 'reads a trie from disk' do
+      File.open(tmpfile, 'wb') do |f|
+        bytes.each { |byte| f.putc(byte) }
+      end
+
+      t = file.read(tmpfile)
+      check_trie(t.root, 'foo', 'bar')
+      expect(t.find('foo')).to eq('bar')
+    end
+
+    it 'reads a sha1-hashed trie from disk' do
+      File.open(tmpfile, 'wb') do |f|
+        sha1_bytes.each { |byte| f.putc(byte) }
+      end
+
+      t = file.read(tmpfile)
+      expect(t.find('foo')).to be_nil
+
+      t = file.read(tmpfile, :sha1)
+      check_trie(t.root, Digest::SHA1.hexdigest('foo'), 'bar')
+      expect(t.find('foo')).to eq('bar')
+    end
+  end
+
+  describe '#write_trie' do
+    it 'should write the trie to disk' do
+      file.open(tmpfile, 'wb') do |f|
+        f.write_trie(trie.new.tap { |t| t.add('foo', 'bar') })
+      end
+
+      t = file.read(tmpfile)
+      check_trie(t.root, 'foo', 'bar')
+      expect(t.find('foo')).to eq('bar')
+    end
+
+    it 'uses the given hash mode when passed' do
+      file.open(tmpfile, 'wb') do |f|
+        f.write_trie(trie.new(nil, :md5).tap { |t| t.add('foo', 'bar') })
+      end
+
+      t = file.read(tmpfile)
+      check_trie(t.root, Digest::MD5.hexdigest('foo'), 'bar')
+    end
+  end
+
+  describe '#find' do
+    it 'should traverse the file on disk and find the value' do
+      file.open(tmpfile, 'wb') do |f|
+        f.write_trie(trie.new.tap { |t| t.add('foo', 'bar') })
+      end
+
+      # notice we're calling 'open' instead of 'read'
+      f = file.open(tmpfile, 'rb')
+      expect(f.find('foo')).to eq('bar')
+      f.close
+    end
+
+    it 'raises an error if the file is already closed, eg. if open is called with a block' do
+      File.open(tmpfile, 'w+') { |f| f.write('test') }
+      f = file.open(tmpfile, 'rb') {}
+      expect(lambda { f.find('foo') }).to raise_error(IOError, 'file is not currently open.')
+    end
+  end
+end

data/spec/node_spec.rb

@@ -0,0 +1,98 @@
+# encoding: UTF-8
+
+require 'spec_helper'
+
+describe TrieFile::Node do
+  def create_node(value = nil)
+    node = TrieFile::Node.new(value)
+    yield node if block_given?
+    node
+  end
+
+  def header_field_length
+    TrieFile::Node::HEADER_FIELD_LENGTH
+  end
+
+  def child_fields_length
+    TrieFile::Node::CHILD_FIELDS_LENGTH
+  end
+
+  describe '#has_child?' do
+    it 'returns true if the node contains the child, false otherwise' do
+      node = create_node do |node|
+        node.add_child('a', create_node('foo'))
+      end
+
+      expect(node.has_child?('a')).to be(true)
+      expect(node.has_child?('b')).to be(false)
+    end
+  end
+
+  describe '#child_at' do
+    it 'returns the child at the given letter, nil otherwise' do
+      child = create_node('foo')
+      node = create_node do |node|
+        node.add_child('a', child)
+      end
+
+      expect(node.child_at('a')).to be(child)
+      expect(node.child_at('b')).to be(nil)
+    end
+  end
+
+  describe '#add_child' do
+    it 'should add the child at the given letter' do
+      node = create_node
+      node.add_child('a', create_node('foo'))
+      expect(node.children).to include('a')
+      expect(node.children['a'].value).to eq('foo')
+    end
+  end
+
+  describe '#bytesize' do
+    it 'when no children and no value, returns just the header size' do
+      expect(create_node.bytesize).to eq(header_field_length)
+    end
+
+    it 'when no children and a value, returns the header size plus the size of the value' do
+      expect(create_node('foo').bytesize).to eq(header_field_length + 3)
+    end
+
+    it 'when a child and a value, returns the header size plus the size of the children plus the size of the value' do
+      expect(
+        create_node('foo') do |node|
+          node.add_child('a', create_node('foo'))
+        end.bytesize
+      ).to eq(header_field_length + 3 + child_fields_length)
+    end
+
+    it 'when multiple children and a value, returns the header size plus the size of the children plus the size of the value' do
+      expect(
+        create_node('foo') do |node|
+          node.add_child('a', create_node('foo'))
+          node.add_child('b', create_node('bar'))
+        end.bytesize
+      ).to eq(header_field_length + 3 + child_fields_length * 2)
+    end
+  end
+
+  describe '#value_bytesize' do
+    it 'returns the number of bytes in the value' do
+      expect(create_node('foo').value_bytesize).to eq(3)
+    end
+
+    it 'returns zero if the value is nil' do
+      expect(create_node.value_bytesize).to eq(0)
+    end
+  end
+
+  describe '#value_bytes' do
+    it 'returns an enumerator of the bytes in the value' do
+      expect(create_node('foo').value_bytes.to_a).to eq([102, 111, 111])
+    end
+
+    it 'returns an empty array if the value is nil' do
+      expect(create_node.value_bytes).to eq([])
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,19 @@
+# encoding: UTF-8
+
+require 'rspec'
+require 'trie-file'
+require 'pry-nav'
+
+RSpec.configure do |config|
+  config.mock_with :rr
+end
+
+def check_trie(root, key, val)
+  node = root
+  key.each_char do |char|
+    expect(node.children.size).to eq(1)
+    expect(node.children).to include(char)
+    node = node.children[char]
+  end
+  expect(node.value).to eq(val)
+end

data/spec/trie_spec.rb

@@ -0,0 +1,59 @@
+# encoding: UTF-8
+
+require 'spec_helper'
+
+describe TrieFile::Trie do
+  def trie
+    TrieFile::Trie
+  end
+
+  describe '#add' do
+    it 'should add the item' do
+      trie.new.tap do |t|
+        t.add('foo', 'bar')
+        check_trie(t.root, 'foo', 'bar')
+      end
+    end
+
+    it 'should hash the key with md5 if asked' do
+      trie.new(nil, :md5).tap do |t|
+        t.add('foo', 'bar')
+        check_trie(
+          t.root, Digest::MD5.hexdigest('foo'), 'bar'
+        )
+      end
+    end
+
+    it 'should hash the key with sha1 if asked' do
+      trie.new(nil, :sha1).tap do |t|
+        t.add('foo', 'bar')
+        check_trie(
+          t.root, Digest::SHA1.hexdigest('foo'), 'bar'
+        )
+      end
+    end
+  end
+
+  describe '#find' do
+    it 'should be able to find the item' do
+      trie.new.tap do |t|
+        t.add('foo', 'bar')
+        expect(t.find('foo')).to eq('bar')
+      end
+    end
+
+    it 'should be able to find the item using the md5 hash mode' do
+      trie.new(nil, :md5).tap do |t|
+        t.add('foo', 'bar')
+        expect(t.find('foo')).to eq('bar')
+      end
+    end
+
+    it 'should be able to find the item using the sha1 hash mode' do
+      trie.new(nil, :sha1).tap do |t|
+        t.add('foo', 'bar')
+        expect(t.find('foo')).to eq('bar')
+      end
+    end
+  end
+end

data/trie-file.gemspec

@@ -0,0 +1,18 @@
+$:.unshift File.join(File.dirname(__FILE__), 'lib')
+require 'trie-file/version'
+
+Gem::Specification.new do |s|
+  s.name     = "trie-file"
+  s.version  = ::TrieFile::VERSION
+  s.authors  = ["Cameron Dutro"]
+  s.email    = ["camertron@gmail.com"]
+  s.homepage = "http://github.com/camertron"
+
+  s.description = s.summary = "Memory-efficient cached trie and trie storage."
+
+  s.platform = Gem::Platform::RUBY
+  s.has_rdoc = true
+
+  s.require_path = 'lib'
+  s.files = Dir["{lib,spec}/**/*", "Gemfile", "History.txt", "README.md", "Rakefile", "trie-file.gemspec"]
+end

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification
+name: trie-file
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Cameron Dutro
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-07-28 00:00:00.000000000 Z
+dependencies: []
+description: Memory-efficient cached trie and trie storage.
+email:
+- camertron@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- History.txt
+- README.md
+- Rakefile
+- lib/trie-file.rb
+- lib/trie-file/file.rb
+- lib/trie-file/node.rb
+- lib/trie-file/trie-file.rb
+- lib/trie-file/trie.rb
+- lib/trie-file/version.rb
+- spec/file_spec.rb
+- spec/node_spec.rb
+- spec/spec_helper.rb
+- spec/trie_spec.rb
+- trie-file.gemspec
+homepage: http://github.com/camertron
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Memory-efficient cached trie and trie storage.
+test_files: []