libcdb-ruby 0.0.1-x86-mingw32

data/ChangeLog

@@ -0,0 +1,5 @@
+= Revision history for libcdb-ruby
+
+== 0.0.1 [2012-01-12]
+
+* Birthday :-)

data/README

@@ -0,0 +1,96 @@
+= libcdb-ruby - Ruby bindings for CDB Constant Databases.
+
+== VERSION
+
+This documentation refers to libcdb-ruby version 0.0.1
+
+
+== DESCRIPTION
+
+The libcdb-ruby library provides Ruby bindings for the
+TinyCDB[http://corpit.ru/mjt/tinycdb.html] package for
+creating and reading {constant databases}[http://cr.yp.to/cdb.html].
+
+  require 'libcdb'
+
+  # creating
+  LibCDB::CDB.open('foo.cdb', 'w') { |cdb|
+    cdb['a'] = 'one'
+    cdb['b'] = '123'
+  }
+
+  # reading
+  LibCDB::CDB.open('foo.cdb') { |cdb|
+    cdb['a']  #=> "one"
+    cdb['b']  #=> "123"
+    cdb['c']  #=> nil
+  }
+
+  # hybrid
+  LibCDB::CDB.open('foo.cdb', 'w+') { |cdb|
+    cdb['a'] = 'one'
+    cdb['b'] = '123'
+
+    cdb['a']  #=> "one"
+    cdb['b']  #=> "123"
+    cdb['c']  #=> nil
+
+    cdb['a'] = 'two'
+    cdb['c'] = 'xyz'
+
+    cdb['a']  #=> "two"
+    cdb['b']  #=> nil
+    cdb['c']  #=> "xyz"
+  }
+
+  # update existing database
+  LibCDB::CDB.open('foo.cdb', 'r+') { |cdb|
+    cdb.store(cdb.to_h)
+
+    cdb['d'] = '42'
+
+    cdb['a']  #=> "two"
+    cdb['b']  #=> nil
+    cdb['c']  #=> "xyz"
+    cdb['d']  #=> "42"
+  }
+
+
+== SUPPORTED PLATFORMS
+
+Linux::   1.8 & 1.9
+Windows:: 1.9 only
+
+
+== LINKS
+
+<b></b>
+Documentation:: http://blackwinter.github.com/libcdb-ruby
+Source code::   http://github.com/blackwinter/libcdb-ruby
+RubyGem::       http://rubygems.org/gems/libcdb-ruby
+TinyCDB::       http://corpit.ru/mjt/tinycdb.html
+CDB::           http://cr.yp.to/cdb.html
+
+
+== AUTHORS
+
+* Jens Wille <mailto:jens.wille@uni-koeln.de>
+
+
+== LICENSE AND COPYRIGHT
+
+Copyright (C) 2012 University of Cologne,
+Albertus-Magnus-Platz, 50923 Cologne, Germany
+
+libcdb-ruby is free software: you can redistribute it and/or modify it
+under the terms of the GNU Affero General Public License as published by
+the Free Software Foundation, either version 3 of the License, or (at your
+option) any later version.
+
+libcdb-ruby is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public
+License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with libcdb-ruby. If not, see <http://www.gnu.org/licenses/>.

data/Rakefile

@@ -0,0 +1,30 @@
+require File.expand_path(%q{../lib/libcdb/version}, __FILE__)
+
+begin
+  require 'hen'
+
+  cco = []
+
+  if dir = ENV['TINYCDB']
+    cco << "--with-cdb-include=#{dir}"
+    cco << "--with-cdb-lib=#{dir}"
+  end
+
+  if dir = ENV['MINGW32']
+    cco << "--with-cflags=\"-I#{dir}/include -L#{dir}/lib\""
+  end
+
+  Hen.lay! {{
+    :gem => {
+      :name      => %q{libcdb-ruby},
+      :version   => LibCDB::CDB::VERSION,
+      :summary   => %q{Ruby bindings for CDB Constant Databases.},
+      :author    => %q{Jens Wille},
+      :email     => %q{jens.wille@uni-koeln.de},
+      :homepage  => :blackwinter,
+      :extension => { :cross_config_options => cco }
+    }
+  }}
+rescue LoadError => err
+  warn "Please install the `hen' gem. (#{err})"
+end

data/TODO

@@ -0,0 +1,4 @@
+* More specs!!
+* More Documentation!
+* Atomic updates? (rename after create)
+* Benchmarks?

data/ext/libcdb/extconf.rb

@@ -0,0 +1,11 @@
+require 'mkmf'
+
+dir_config('cdb')
+
+if have_library('cdb', 'cdb_init') && have_header('cdb.h') && have_macro('TINYCDB_VERSION', 'cdb.h')
+  have_header('ruby/io.h')
+  have_header('ruby/st.h')
+  create_makefile('libcdb/libcdb_ruby')
+else
+  abort '*** ERROR: missing required library to compile this module'
+end

data/ext/libcdb/libcdb.c

@@ -0,0 +1,16 @@
+#include "ruby_libcdb.h"
+
+void
+Init_libcdb_ruby(void) {
+  char libcdb_version[8];
+  snprintf(libcdb_version, 7, "%g", TINYCDB_VERSION);
+
+  /*
+   * LibCDB namespace.
+   */
+  mLibCDB = rb_define_module("LibCDB");
+
+  rcdb_init_cdb();
+  rcdb_init_reader();
+  rcdb_init_writer();
+}

data/ext/libcdb/libcdb_ruby.def

@@ -0,0 +1,8 @@
+LIBRARY libcdb_ruby.so
+EXPORTS
+Init_libcdb_ruby
+
+cCDBReader DATA
+cCDBWriter DATA
+mLibCDB DATA
+cCDB DATA

data/ext/libcdb/ruby_cdb.c

@@ -0,0 +1,15 @@
+#include "ruby_libcdb.h"
+
+void
+rcdb_init_cdb(void) {
+  char libcdb_version[8];
+  snprintf(libcdb_version, 7, "%g", TINYCDB_VERSION);
+
+  /*
+   * See README.
+   */
+  cCDB = rb_define_class_under(mLibCDB, "CDB", rb_cObject);
+
+  /* The TinyCDB library version. */
+  rb_define_const(cCDB, "LIBCDB_VERSION", rb_str_new2(libcdb_version));
+}

data/ext/libcdb/ruby_cdb.h

@@ -0,0 +1,13 @@
+#ifndef __RUBY_CDB_H__
+#define __RUBY_CDB_H__
+
+#ifdef HAVE_RUBY_IO_H
+#define GetFileFD(fptr) (fptr)->fd
+#else
+#define GetFileFD(fptr) fileno((fptr)->f)
+#endif
+
+VALUE cCDB;
+void rcdb_init_cdb(void);
+
+#endif  /* __RUBY_CDB_H__ */

data/ext/libcdb/ruby_cdb_reader.c

@@ -0,0 +1,677 @@
+#include "ruby_libcdb.h"
+
+static void
+rcdb_reader_free(void *ptr) {
+  free(ptr);
+}
+
+static VALUE
+rcdb_reader_alloc(VALUE klass) {
+  struct cdb *cdb = ALLOC_N(struct cdb, 1);
+  return Data_Wrap_Struct(klass, NULL, rcdb_reader_free, cdb);
+}
+
+/*
+ * call-seq:
+ *   reader.closed? -> true | false
+ *
+ * Whether _reader_ is closed.
+ */
+static VALUE
+rcdb_reader_closed_p(VALUE self) {
+  return rb_attr_get(self, rb_intern("closed"));
+}
+
+/*
+ * call-seq:
+ *   new(io) -> aReader
+ *
+ * Creates a new Reader instance to interface with +io+. +io+ must be opened
+ * for reading (+r+).
+ */
+static VALUE
+rcdb_reader_initialize(VALUE self, VALUE io) {
+  struct cdb *cdb = NULL;
+  rb_io_t *fptr;
+
+  Check_Type(io, T_FILE);
+  GetOpenFile(io, fptr);
+
+  rb_io_check_readable(fptr);
+  rb_iv_set(self, "@io", io);
+  rb_iv_set(self, "closed", Qfalse);
+
+  Get_CDB_Reader(self, cdb);
+
+  if (cdb_init(cdb, GetFileFD(fptr)) == -1) {
+    rb_sys_fail(0);
+  }
+
+  return self;
+}
+
+/* Helper method */
+static VALUE
+rcdb_reader_read_key(struct cdb *cdb) {
+  size_t len;
+  VALUE key;
+
+  len = cdb_keylen(cdb);
+  key = rb_str_buf_new(len);
+
+  cdb_read(cdb, RSTRING_PTR(key), len, cdb_keypos(cdb));
+  rb_str_set_len(key, len);
+
+  return key;
+}
+
+/* Helper method */
+static VALUE
+rcdb_reader_read_value(struct cdb *cdb) {
+  size_t len;
+  VALUE val;
+
+  len = cdb_datalen(cdb);
+  val = rb_str_buf_new(len);
+
+  cdb_read(cdb, RSTRING_PTR(val), len, cdb_datapos(cdb));
+  rb_str_set_len(val, len);
+
+  return val;
+}
+
+/* Helper method */
+static VALUE
+rcdb_reader_iter_push(VALUE val, VALUE ary) {
+  return rb_ary_push(ary, val);
+}
+
+/* Helper method */
+static VALUE
+rcdb_reader_iter_aset(VALUE pair, VALUE hash) {
+  VALUE key = rb_ary_entry(pair, 0), val = rb_ary_entry(pair, 1), old;
+
+  if (!st_lookup(RHASH_TBL(hash), key, 0)) {
+    rb_hash_aset(hash, key, val);
+  }
+  else {
+    old = rb_hash_aref(hash, key);
+
+    switch (TYPE(old)) {
+      case T_ARRAY:
+        rb_ary_push(old, val);
+        break;
+      default:
+        rb_hash_aset(hash, key, rb_ary_new3(2, old, val));
+        break;
+    }
+  }
+
+  return Qnil;
+}
+
+/* Helper method */
+static VALUE
+rcdb_reader_break_equal(VALUE val, VALUE ary) {
+  if (VALUE_EQUAL(val)) {
+    rb_ary_store(ary, 0, Qtrue);
+    rb_iter_break();
+  }
+
+  return Qnil;
+}
+
+/* Helper method */
+static VALUE
+rcdb_reader_break_equal2(VALUE pair, VALUE ary) {
+  if (VALUE_EQUAL(rb_ary_entry(pair, 1))) {
+    rb_ary_store(ary, 0, rb_ary_entry(pair, 0));
+    rb_iter_break();
+  }
+
+  return Qnil;
+}
+
+/* Helper method */
+static VALUE
+rcdb_reader_break_shift(VALUE val, VALUE ary) {
+  rb_ary_shift(ary);
+  rb_iter_break();
+
+  return Qnil;
+}
+
+/* Helper method */
+static VALUE
+rcdb_reader_iter_inc(VALUE val, VALUE ary) {
+  rb_ary_store(ary, 0, rb_funcall(rb_ary_entry(ary, 0), rb_intern("succ"), 0));
+  return Qnil;
+}
+
+/* Helper method */
+static VALUE
+rcdb_reader_iter_dump(VALUE val, VALUE ary) {
+  VALUE str = rb_ary_entry(ary, 0);
+
+  rb_str_append(str, val);
+  rb_str_cat2(str, "\n");
+
+  return Qnil;
+}
+
+/* Helper method */
+static VALUE
+rcdb_reader_dump_pair(VALUE key, VALUE val) {
+  VALUE str = rb_str_new2("");
+
+  rb_str_cat2(str, "+");
+  rb_str_append(str, rb_fix2str(LONG2NUM(RSTRING_LEN(key)), 10));
+  rb_str_cat2(str, ",");
+  rb_str_append(str, rb_fix2str(LONG2NUM(RSTRING_LEN(val)), 10));
+  rb_str_cat2(str, ":");
+  rb_str_append(str, key);
+  rb_str_cat2(str, "->");
+  rb_str_append(str, val);
+
+  return str;
+}
+
+/* Helper method */
+static VALUE
+rcdb_reader_yield_dump(VALUE pair, VALUE ary) {
+  return rb_yield(rcdb_reader_dump_pair(
+    rb_ary_entry(pair, 0), rb_ary_entry(pair, 1)));
+}
+
+/* Helper method */
+static VALUE
+rcdb_reader_yield_dump2(VALUE val, VALUE ary) {
+  return rb_yield(rcdb_reader_dump_pair(rb_ary_entry(ary, 0), val));
+}
+
+/* Helper method */
+static VALUE
+rcdb_reader_call_each(VALUE args) {
+  CALL_ITERATOR("each")
+}
+
+/* Helper method */
+static VALUE
+rcdb_reader_call_each_key(VALUE args) {
+  CALL_ITERATOR("each_key")
+}
+
+/* Helper method */
+static VALUE
+rcdb_reader_call_each_value(VALUE args) {
+  CALL_ITERATOR("each_value")
+}
+
+/* Helper method */
+static VALUE
+rcdb_reader_call_each_dump(VALUE args) {
+  CALL_ITERATOR("each_dump")
+}
+
+/*
+ * call-seq:
+ *   reader.each { |key, val| ... } -> reader
+ *   reader.each(key) { |val| ... } -> reader
+ *   reader.each([key]) -> anEnumerator
+ *
+ * Iterates over each key/value pair, or, if +key+ is given, each value
+ * for +key+. Returns _reader_, or, if no block is given, an enumerator.
+ */
+static VALUE
+rcdb_reader_each(int argc, VALUE *argv, VALUE self) {
+  struct cdb *cdb = NULL;
+  struct cdb_find cdbf;
+  unsigned cdbp;
+  VALUE key;
+
+  if (argc > 1) {
+    rb_raise(rb_eArgError, "wrong number of arguments (%d for 0-1)", argc);
+  }
+
+  RETURN_ENUMERATOR(self, argc, argv);
+
+  Get_CDB_Reader(self, cdb);
+
+  if (rb_scan_args(argc, argv, "01", &key) == 1 && !NIL_P(key)) {
+    StringValue(key);
+
+    if (cdb_findinit(&cdbf, cdb, RSTRING_PTR(key), RSTRING_LEN(key)) == -1) {
+      rb_sys_fail(0);
+    }
+
+    while (cdb_findnext(&cdbf) > 0) {
+      rb_yield(rcdb_reader_read_value(cdb));
+    }
+  }
+  else {
+    cdb_seqinit(&cdbp, cdb);
+
+    while (cdb_seqnext(&cdbp, cdb) > 0) {
+      rb_yield(rb_ary_new3(2,
+        rcdb_reader_read_key(cdb),
+        rcdb_reader_read_value(cdb)));
+    }
+  }
+
+  return self;
+}
+
+/*
+ * call-seq:
+ *   reader.each_dump { |dump| ... } -> reader
+ *   reader.each_dump(key) { |dump| ... } -> reader
+ *   reader.each_dump([key]) -> anEnumerator
+ *
+ * Iterates over each record dump, or, if +key+ is given, each record dump
+ * for +key+. Returns _reader_, or, if no block is given, an enumerator.
+ */
+static VALUE
+rcdb_reader_each_dump(int argc, VALUE *argv, VALUE self) {
+  VALUE key, args = rb_ary_new3(1, self), ary = rb_ary_new();
+  VALUE (*block)(ANYARGS) = rcdb_reader_yield_dump;
+
+  if (argc > 1) {
+    rb_raise(rb_eArgError, "wrong number of arguments (%d for 0-1)", argc);
+  }
+
+  RETURN_ENUMERATOR(self, argc, argv);
+
+  if (rb_scan_args(argc, argv, "01", &key) == 1 && !NIL_P(key)) {
+    rb_ary_push(ary,  key);
+    rb_ary_push(args, key);
+
+    block = rcdb_reader_yield_dump2;
+  }
+
+  rb_iterate(rcdb_reader_call_each, args, block, ary);
+
+  return self;
+}
+
+/*
+ * call-seq:
+ *   reader.each_key { |key| ... } -> reader
+ *   reader.each_key -> anEnumerator
+ *
+ * Iterates over each _unique_ key. Returns _reader_,
+ * or, if no block is given, an enumerator.
+ */
+static VALUE
+rcdb_reader_each_key(VALUE self) {
+  struct cdb *cdb = NULL;
+  unsigned cdbp;
+  VALUE key, hash = rb_hash_new();
+
+  Get_CDB_Reader(self, cdb);
+  cdb_seqinit(&cdbp, cdb);
+
+  while (cdb_seqnext(&cdbp, cdb) > 0) {
+    if (!st_lookup(RHASH_TBL(hash), key = rcdb_reader_read_key(cdb), 0)) {
+      rb_hash_aset(hash, key, Qtrue);
+      rb_yield(key);
+    }
+  }
+
+  return self;
+}
+
+/*
+ * call-seq:
+ *   reader.each_value { |val| ... } -> reader
+ *   reader.each_value -> anEnumerator
+ *
+ * Iterates over each value. Returns _reader_,
+ * or, if no block is given, an enumerator.
+ */
+static VALUE
+rcdb_reader_each_value(VALUE self) {
+  struct cdb *cdb = NULL;
+  unsigned cdbp;
+
+  Get_CDB_Reader(self, cdb);
+  cdb_seqinit(&cdbp, cdb);
+
+  while (cdb_seqnext(&cdbp, cdb) > 0) {
+    rb_yield(rcdb_reader_read_value(cdb));
+  }
+
+  return self;
+}
+
+/*
+ * call-seq:
+ *   reader.fetch(key) -> anArray
+ *
+ * Fetch all values for +key+.
+ */
+static VALUE
+rcdb_reader_fetch(VALUE self, VALUE key) {
+  VALUE ary = rb_ary_new();
+
+  rb_iterate(rcdb_reader_call_each,
+    rb_ary_new3(2, self, key), rcdb_reader_iter_push, ary);
+
+  return ary;
+}
+
+/*
+ * call-seq:
+ *   reader.fetch_first(key) -> aString | nil
+ *
+ * Fetch first value for +key+. Returns +nil+ if +key+ was not found.
+ */
+static VALUE
+rcdb_reader_fetch_first(VALUE self, VALUE key) {
+  struct cdb *cdb = NULL;
+  VALUE val = Qnil;
+
+  StringValue(key);
+  Get_CDB_Reader(self, cdb);
+
+  if (cdb_find(cdb, RSTRING_PTR(key), RSTRING_LEN(key)) > 0) {
+    val = rcdb_reader_read_value(cdb);
+  }
+
+  return val;
+}
+
+/*
+ * call-seq:
+ *   reader.fetch_last(key) -> aString | nil
+ *
+ * Fetch last value for +key+. Returns +nil+ if +key+ was not found.
+ */
+static VALUE
+rcdb_reader_fetch_last(VALUE self, VALUE key) {
+  struct cdb *cdb = NULL;
+  struct cdb_find cdbf;
+  VALUE val = Qnil;
+  unsigned pos = 0;
+  size_t len = 0;
+
+  StringValue(key);
+  Get_CDB_Reader(self, cdb);
+
+  if (cdb_findinit(&cdbf, cdb, RSTRING_PTR(key), RSTRING_LEN(key)) == -1) {
+    rb_sys_fail(0);
+  }
+
+  while (cdb_findnext(&cdbf) > 0) {
+    pos = cdb_datapos(cdb);
+    len = cdb_datalen(cdb);
+  }
+
+  if (pos > 0) {
+    val = rb_str_buf_new(len);
+    cdb_read(cdb, RSTRING_PTR(val), len, pos);
+    rb_str_set_len(val, len);
+  }
+
+  return val;
+}
+
+/*
+ * call-seq:
+ *   reader.keys -> anArray
+ *
+ * Returns an array of all _unique_ keys.
+ */
+static VALUE
+rcdb_reader_keys(VALUE self) {
+  VALUE ary = rb_ary_new();
+
+  rb_iterate(rcdb_reader_call_each_key,
+    rb_ary_new3(1, self), rcdb_reader_iter_push, ary);
+
+  return ary;
+}
+
+/*
+ * call-seq:
+ *   reader.values -> anArray
+ *
+ * Returns an array of all values.
+ */
+static VALUE
+rcdb_reader_values(VALUE self) {
+  VALUE ary = rb_ary_new();
+
+  rb_iterate(rcdb_reader_call_each_value,
+    rb_ary_new3(1, self), rcdb_reader_iter_push, ary);
+
+  return ary;
+}
+
+/*
+ * call-seq:
+ *   reader.values_at(key, ...) -> anArray
+ *
+ * Returns an array containing the values associated with the given keys.
+ */
+static VALUE
+rcdb_reader_values_at(int argc, VALUE *argv, VALUE self) {
+  VALUE ary = rb_ary_new();
+  long i;
+
+  for (i = 0; i < argc; i++) {
+    rb_ary_push(ary, rcdb_reader_fetch(self, argv[i]));
+  }
+
+  return ary;
+}
+
+/*
+ * call-seq:
+ *   reader.has_key?(key) -> true | false
+ *
+ * Whether key +key+ exists in the database.
+ */
+static VALUE
+rcdb_reader_has_key_p(VALUE self, VALUE key) {
+  VALUE ary = rb_ary_new3(2, Qfalse, key);
+  ITER_RESULT(rcdb_reader_call_each_key, rcdb_reader_break_equal)
+}
+
+/*
+ * call-seq:
+ *   reader.has_value?(val) -> true | false
+ *
+ * Whether value +val+ exists in the database.
+ */
+static VALUE
+rcdb_reader_has_value_p(VALUE self, VALUE val) {
+  VALUE ary = rb_ary_new3(2, Qfalse, val);
+  ITER_RESULT(rcdb_reader_call_each_value, rcdb_reader_break_equal)
+}
+
+/*
+ * call-seq:
+ *   reader.key(val) -> aString | nil
+ *
+ * Returns the first key associated with value
+ * +val+, or +nil+ if +val+ was not found.
+ */
+static VALUE
+rcdb_reader_key(VALUE self, VALUE val) {
+  VALUE ary = rb_ary_new3(2, Qnil, val);
+  ITER_RESULT(rcdb_reader_call_each, rcdb_reader_break_equal2)
+}
+
+/*
+ * call-seq:
+ *   reader.empty? -> true | false
+ *
+ * Whether the database is empty.
+ */
+static VALUE
+rcdb_reader_empty_p(VALUE self) {
+  VALUE ary = rb_ary_new3(2, Qtrue, Qfalse);
+  ITER_RESULT(rcdb_reader_call_each_key, rcdb_reader_break_shift)
+}
+
+/*
+ * call-seq:
+ *   reader.size -> anInteger
+ *
+ * The number of _unique_ records in the database. Cf. #total.
+ */
+static VALUE
+rcdb_reader_size(VALUE self) {
+  VALUE ary = rb_ary_new3(1, INT2FIX(0));
+  ITER_RESULT(rcdb_reader_call_each_key, rcdb_reader_iter_inc)
+}
+
+/*
+ * call-seq:
+ *   reader.total -> anInteger
+ *
+ * The number of _total_ records in the database. Cf. #size.
+ */
+static VALUE
+rcdb_reader_total(VALUE self) {
+  struct cdb *cdb = NULL;
+  unsigned cdbp;
+  long i = 0;
+
+  Get_CDB_Reader(self, cdb);
+  cdb_seqinit(&cdbp, cdb);
+
+  while (cdb_seqnext(&cdbp, cdb) > 0) {
+    i++;
+  }
+
+  return LONG2NUM(i);
+}
+
+/*
+ * call-seq:
+ *   reader.dump -> aString
+ *
+ * Returns a dump of the database.
+ */
+static VALUE
+rcdb_reader_dump(VALUE self) {
+  VALUE ary = rb_ary_new3(1, rb_str_new2(""));
+  ITER_RESULT(rcdb_reader_call_each_dump, rcdb_reader_iter_dump)
+}
+
+/*
+ * call-seq:
+ *   reader.to_h -> aHash
+ *
+ * Converts the database into a hash of #size keys associated with
+ * their value, or, if there are multiple, an array of their values.
+ *
+ *   reader.to_h.size == reader.size
+ */
+static VALUE
+rcdb_reader_to_h(VALUE self) {
+  VALUE hash = rb_hash_new();
+
+  rb_iterate(rcdb_reader_call_each,
+    rb_ary_new3(1, self), rcdb_reader_iter_aset, hash);
+
+  return hash;
+}
+
+/*
+ * call-seq:
+ *   reader.to_a -> anArray
+ *
+ * Converts the database into an array of #total key/value pairs.
+ *
+ *   reader.to_a.size == reader.total
+ */
+static VALUE
+rcdb_reader_to_a(VALUE self) {
+  VALUE ary = rb_ary_new();
+
+  rb_iterate(rcdb_reader_call_each,
+    rb_ary_new3(1, self), rcdb_reader_iter_push, ary);
+
+  return ary;
+}
+
+/*
+ * call-seq:
+ *   reader.close -> nil
+ *
+ * Closes _reader_, as well as the underlying IO object.
+ */
+static VALUE
+rcdb_reader_close(VALUE self) {
+  struct cdb *cdb = NULL;
+
+  if (RTEST(rcdb_reader_closed_p(self))) {
+    return Qnil;
+  }
+
+  Get_CDB_Reader(self, cdb);
+  rb_iv_set(self, "closed", Qtrue);
+
+  rb_io_close(rb_iv_get(self, "@io"));
+
+  return Qnil;
+}
+
+/* :nodoc: */
+static VALUE
+rcdb_reader_inspect(VALUE self) {
+  VALUE str = rb_call_super(0, NULL);
+
+  if (RTEST(rcdb_reader_closed_p(self))) {
+    rb_funcall(str,
+      rb_intern("insert"), 2, INT2FIX(-2), rb_str_new2(" (closed)"));
+  }
+
+  return str;
+}
+
+void
+rcdb_init_reader(void) {
+  /*
+   * The reader for reading CDB files. See Writer for creating them.
+   */
+  cCDBReader = rb_define_class_under(cCDB, "Reader", rb_cObject);
+  rb_define_alloc_func(cCDBReader, rcdb_reader_alloc);
+  rb_include_module(cCDBReader, rb_mEnumerable);
+
+  rb_define_method(cCDBReader, "close",       rcdb_reader_close,        0);
+  rb_define_method(cCDBReader, "closed?",     rcdb_reader_closed_p,     0);
+  rb_define_method(cCDBReader, "dump",        rcdb_reader_dump,         0);
+  rb_define_method(cCDBReader, "each",        rcdb_reader_each,        -1);
+  rb_define_method(cCDBReader, "each_dump",   rcdb_reader_each_dump,   -1);
+  rb_define_method(cCDBReader, "each_key",    rcdb_reader_each_key,     0);
+  rb_define_method(cCDBReader, "each_value",  rcdb_reader_each_value,   0);
+  rb_define_method(cCDBReader, "empty?",      rcdb_reader_empty_p,      0);
+  rb_define_method(cCDBReader, "fetch",       rcdb_reader_fetch,        1);
+  rb_define_method(cCDBReader, "fetch_first", rcdb_reader_fetch_first,  1);
+  rb_define_method(cCDBReader, "fetch_last",  rcdb_reader_fetch_last,   1);
+  rb_define_method(cCDBReader, "has_key?",    rcdb_reader_has_key_p,    1);
+  rb_define_method(cCDBReader, "has_value?",  rcdb_reader_has_value_p,  1);
+  rb_define_method(cCDBReader, "initialize",  rcdb_reader_initialize,   1);
+  rb_define_method(cCDBReader, "inspect",     rcdb_reader_inspect,      0);
+  rb_define_method(cCDBReader, "key",         rcdb_reader_key,          1);
+  rb_define_method(cCDBReader, "keys",        rcdb_reader_keys,         0);
+  rb_define_method(cCDBReader, "size",        rcdb_reader_size,         0);
+  rb_define_method(cCDBReader, "to_a",        rcdb_reader_to_a,         0);
+  rb_define_method(cCDBReader, "to_h",        rcdb_reader_to_h,         0);
+  rb_define_method(cCDBReader, "total",       rcdb_reader_total,        0);
+  rb_define_method(cCDBReader, "values",      rcdb_reader_values,       0);
+  rb_define_method(cCDBReader, "values_at",   rcdb_reader_values_at,   -1);
+
+  rb_define_alias(cCDBReader, "[]",        "fetch_first");
+  rb_define_alias(cCDBReader, "fetch_all", "fetch");
+  rb_define_alias(cCDBReader, "get",       "fetch_first");
+  rb_define_alias(cCDBReader, "include?",  "has_key?");
+  rb_define_alias(cCDBReader, "key?",      "has_key?");
+  rb_define_alias(cCDBReader, "length",    "size");
+  rb_define_alias(cCDBReader, "member?",   "has_key?");
+  rb_define_alias(cCDBReader, "rget",      "fetch_last");
+  rb_define_alias(cCDBReader, "value?",    "has_value?");
+}