libcdb-ruby 0.0.1

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?");
+}

data/ext/libcdb/ruby_cdb_reader.h

@@ -0,0 +1,30 @@
+#ifndef __RCDB_READER_H__
+#define __RCDB_READER_H__
+
+#define Get_CDB_Reader(obj, var) {\
+  if (RTEST(rcdb_reader_closed_p(obj))) {\
+    rb_raise(rb_eRuntimeError, "closed stream");\
+  }\
+  else {\
+    Data_Get_Struct((obj), struct cdb, (var));\
+  }\
+}
+
+#define CALL_ITERATOR(iter) {\
+  VALUE self = rb_ary_shift(args);\
+  return rb_funcall2(self, rb_intern(iter),\
+    RARRAY_LEN(args), RARRAY_PTR(args));\
+}
+
+#define ITER_RESULT(method, block) {\
+  rb_iterate(method, rb_ary_new3(1, self), block, ary);\
+  return rb_ary_entry(ary, 0);\
+}
+
+#define VALUE_EQUAL(val) \
+  RTEST(rb_funcall((val), rb_intern("=="), 1, rb_ary_entry(ary, 1)))
+
+VALUE cCDBReader;
+void rcdb_init_reader(void);
+
+#endif /* __RCDB_READER_H__ */