libcdb-ruby 0.0.1-x86-mingw32

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__ */

data/ext/libcdb/ruby_cdb_writer.c

@@ -0,0 +1,301 @@
+#include "ruby_libcdb.h"
+
+static void
+rcdb_writer_free(void *ptr) {
+  free(ptr);
+}
+
+static VALUE
+rcdb_writer_alloc(VALUE klass) {
+  struct cdb_make *cdbm = ALLOC_N(struct cdb_make, 1);
+  return Data_Wrap_Struct(klass, NULL, rcdb_writer_free, cdbm);
+}
+
+/*
+ * call-seq:
+ *   writer.closed? -> true | false
+ *
+ * Whether _writer_ is closed.
+ */
+static VALUE
+rcdb_writer_closed_p(VALUE self) {
+  return rb_attr_get(self, rb_intern("closed"));
+}
+
+/*
+ * call-seq:
+ *   new(io) -> aWriter
+ *
+ * Creates a new Writer instance to interface with +io+. +io+ must be opened
+ * for writing (+w+); in addition, it must be opened for read-write (<tt>w+</tt>)
+ * if #insert or #replace are to be used.
+ */
+static VALUE
+rcdb_writer_initialize(VALUE self, VALUE io) {
+  struct cdb_make *cdbm = NULL;
+  rb_io_t *fptr;
+
+  Check_Type(io, T_FILE);
+  GetOpenFile(io, fptr);
+
+  rb_io_check_writable(fptr);
+  rb_iv_set(self, "@io", io);
+  rb_iv_set(self, "closed", Qfalse);
+
+  Get_CDB_Writer(self, cdbm);
+
+  if (cdb_make_start(cdbm, GetFileFD(fptr)) == -1) {
+    rb_sys_fail(0);
+  }
+
+  if (lseek(cdb_fileno(cdbm), 0, SEEK_SET) == -1)  {
+    rb_sys_fail(0);
+  }
+
+  return self;
+}
+
+/* Helper method */
+static int
+rcdb_writer_push_pair(st_data_t key, st_data_t val, st_data_t ary) {
+  rb_ary_push((VALUE)ary, rb_ary_new3(2, (VALUE)key, (VALUE)val));
+  return ST_CONTINUE;
+}
+
+/* Helper method */
+static void
+rcdb_writer_put_pair(struct cdb_make *cdbm, VALUE key, VALUE val, enum cdb_put_mode mode) {
+  StringValue(key);
+  StringValue(val);
+
+  if (cdb_make_put(cdbm,
+        RSTRING_PTR(key), RSTRING_LEN(key),
+        RSTRING_PTR(val), RSTRING_LEN(val),
+        mode) == -1) {
+    rb_sys_fail(0);
+  }
+}
+
+/* Helper method */
+static void
+rcdb_writer_put_value(struct cdb_make *cdbm, VALUE key, VALUE val, enum cdb_put_mode mode) {
+  long i;
+
+  switch (TYPE(val)) {
+    case T_ARRAY:
+      switch (mode) {
+        case CDB_PUT_REPLACE:
+          /* remove any existing record */
+          cdb_make_find(cdbm,
+            RSTRING_PTR(key),
+            RSTRING_LEN(key),
+            CDB_FIND_REMOVE);
+
+          /* add all */
+          mode = CDB_PUT_ADD;
+
+          break;
+        case CDB_PUT_INSERT:
+          /* see if key already exists */
+          switch (cdb_make_exists(cdbm,
+                RSTRING_PTR(key),
+                RSTRING_LEN(key))) {
+            case 0:
+              /* doesn't exist, add all */
+              mode = CDB_PUT_ADD;
+              break;
+            case -1:
+              /* error */
+              rb_sys_fail(0);
+              break;
+            default:
+              /* ignore, won't add any */
+              break;
+          }
+
+          break;
+        default:
+          /* no need to touch mode */
+          break;
+      }
+
+      for (i = 0; i < RARRAY_LEN(val); i++) {
+        rcdb_writer_put_pair(cdbm, key, RARRAY_PTR(val)[i], mode);
+      }
+
+      break;
+    default:
+      rcdb_writer_put_pair(cdbm, key, val, mode);
+      break;
+  }
+}
+
+/* Helper method */
+static VALUE
+rcdb_writer_put(int argc, VALUE *argv, VALUE self, enum cdb_put_mode mode) {
+  struct cdb_make *cdbm = NULL;
+  VALUE arg, val;
+  long i;
+
+  Get_CDB_Writer(self, cdbm);
+
+  switch (argc) {
+    case 1:
+      arg = argv[0];
+
+      switch (TYPE(arg)) {
+        case T_ARRAY:
+          val = rb_str_new2("");
+
+          for (i = 0; i < RARRAY_LEN(arg); i++) {
+            rcdb_writer_put_pair(cdbm, RARRAY_PTR(arg)[i], val, mode);
+          }
+
+          break;
+        case T_HASH:
+          val = rb_ary_new();
+          st_foreach(RHASH_TBL(arg), rcdb_writer_push_pair, val);
+
+          for (i = 0; i < RARRAY_LEN(val); i++) {
+            rcdb_writer_put_value(cdbm,
+              rb_ary_entry(RARRAY_PTR(val)[i], 0),
+              rb_ary_entry(RARRAY_PTR(val)[i], 1),
+              mode);
+          }
+
+          break;
+        default:
+          rb_raise(rb_eTypeError,
+            "wrong argument type %s (expected Array or Hash)",
+            rb_obj_classname(arg));
+
+          break;
+      }
+
+      break;
+    case 2:
+      rcdb_writer_put_value(cdbm, argv[0], argv[1], mode);
+      break;
+    default:
+      rb_raise(rb_eArgError, "wrong number of arguments (%d for 1-2)", argc);
+      break;
+  }
+
+  return self;
+}
+
+/*
+ * call-seq:
+ *   writer.store(key, val) -> writer
+ *   writer.store(key, [val, ...]) -> writer
+ *   writer.store([key, ...]) -> writer
+ *   writer.store({ key => val, ... }) -> writer
+ *
+ * Stores records in the database and returns _writer_. Records are stored
+ * unconditionally, so duplicate keys will produce multiple records.
+ *
+ * If a single key/value pair is given, a record with key +key+ and value
+ * +val+ is created; if +val+ is an array, one record per value is created
+ * for +key+. If an array of keys is given, one record per key with an empty
+ * value is created. If a hash of key/value pairs is given, one record per
+ * key/value pair is created; the same logic as for a single key/value pair
+ * applies.
+ */
+static VALUE
+rcdb_writer_store(int argc, VALUE *argv, VALUE self) {
+  return rcdb_writer_put(argc, argv, self, CDB_PUT_ADD);
+}
+
+/*
+ * call-seq:
+ *   writer.replace(key, val) -> writer
+ *   writer.replace(key, [val, ...]) -> writer
+ *   writer.replace([key, ...]) -> writer
+ *   writer.replace({ key => val, ... }) -> writer
+ *
+ * Stores records in the database and returns _writer_. Records with
+ * duplicate keys are replaced.
+ *
+ * The arguments are treated the same as in #store, so duplicate keys
+ * <em>in the arguments</em> will produce multiple records.
+ */
+static VALUE
+rcdb_writer_replace(int argc, VALUE *argv, VALUE self) {
+  return rcdb_writer_put(argc, argv, self, CDB_PUT_REPLACE);
+}
+
+/*
+ * call-seq:
+ *   writer.insert(key, val) -> writer
+ *   writer.insert(key, [val, ...]) -> writer
+ *   writer.insert([key, ...]) -> writer
+ *   writer.insert({ key => val, ... }) -> writer
+ *
+ * Stores records in the database and returns _writer_. Records will only
+ * be inserted if they don't already exist in the database.
+ *
+ * The arguments are treated the same as in #store, so duplicate keys
+ * <em>in the arguments</em> will produce multiple records.
+ */
+static VALUE
+rcdb_writer_insert(int argc, VALUE *argv, VALUE self) {
+  return rcdb_writer_put(argc, argv, self, CDB_PUT_INSERT);
+}
+
+/*
+ * call-seq:
+ *   writer.close -> nil
+ *
+ * Closes _writer_, as well as the underlying IO object.
+ */
+static VALUE
+rcdb_writer_close(VALUE self) {
+  struct cdb_make *cdbm = NULL;
+
+  if (RTEST(rcdb_writer_closed_p(self))) {
+    return Qnil;
+  }
+
+  Get_CDB_Writer(self, cdbm);
+  rb_iv_set(self, "closed", Qtrue);
+
+  if (cdb_make_finish(cdbm) == -1) {
+    rb_sys_fail(0);
+  }
+
+  rb_io_close(rb_iv_get(self, "@io"));
+
+  return Qnil;
+}
+
+/* :nodoc: */
+static VALUE
+rcdb_writer_inspect(VALUE self) {
+  VALUE str = rb_call_super(0, NULL);
+
+  if (RTEST(rcdb_writer_closed_p(self))) {
+    rb_funcall(str,
+      rb_intern("insert"), 2, INT2FIX(-2), rb_str_new2(" (closed)"));
+  }
+
+  return str;
+}
+
+void rcdb_init_writer(void) {
+  /*
+   * The writer for creating CDB files. See Reader for reading them.
+   */
+  cCDBWriter = rb_define_class_under(cCDB, "Writer", rb_cObject);
+  rb_define_alloc_func(cCDBWriter, rcdb_writer_alloc);
+
+  rb_define_method(cCDBWriter, "close",      rcdb_writer_close,       0);
+  rb_define_method(cCDBWriter, "closed?",    rcdb_writer_closed_p,    0);
+  rb_define_method(cCDBWriter, "initialize", rcdb_writer_initialize,  1);
+  rb_define_method(cCDBWriter, "insert",     rcdb_writer_insert,     -1);
+  rb_define_method(cCDBWriter, "inspect",    rcdb_writer_inspect,     0);
+  rb_define_method(cCDBWriter, "replace",    rcdb_writer_replace,    -1);
+  rb_define_method(cCDBWriter, "store",      rcdb_writer_store,      -1);
+
+  rb_define_alias(cCDBWriter, "[]=", "replace");
+  rb_define_alias(cCDBWriter, "add", "store");
+}

data/ext/libcdb/ruby_cdb_writer.h

@@ -0,0 +1,16 @@
+#ifndef __RCDB_WRITER_H__
+#define __RCDB_WRITER_H__
+
+#define Get_CDB_Writer(obj, var) {\
+  if (RTEST(rcdb_writer_closed_p(obj))) {\
+    rb_raise(rb_eRuntimeError, "closed stream");\
+  }\
+  else {\
+    Data_Get_Struct((obj), struct cdb_make, (var));\
+  }\
+}
+
+VALUE cCDBWriter;
+void rcdb_init_writer(void);
+
+#endif  /* __RCDB_WRITER_H__ */

data/ext/libcdb/ruby_libcdb.h

@@ -0,0 +1,27 @@
+#ifndef __RUBY_LIBCDB_H__
+#define __RUBY_LIBCDB_H__
+
+#include <ruby.h>
+#if HAVE_RUBY_IO_H
+#include <ruby/io.h>
+#else
+#include <rubyio.h>
+#endif
+#if HAVE_RUBY_ST_H
+#include <ruby/st.h>
+#else
+#include <st.h>
+#endif
+#include <cdb.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <fcntl.h>
+
+#include "ruby_cdb.h"
+#include "ruby_cdb_reader.h"
+#include "ruby_cdb_writer.h"
+
+VALUE mLibCDB;
+
+#endif  /* __RUBY_LIBCDB_H__ */

data/lib/cdb.rb

@@ -0,0 +1,2 @@
+require 'libcdb'
+include LibCDB

data/lib/libcdb-ruby.rb

@@ -0,0 +1 @@
+require 'libcdb'

data/lib/libcdb.rb

@@ -0,0 +1,256 @@
+begin
+  require "libcdb/#{RUBY_VERSION[/\d+.\d+/]}/libcdb_ruby"
+rescue LoadError
+  require 'libcdb/libcdb_ruby'
+end
+
+require 'libcdb/version'
+require 'forwardable'
+
+module LibCDB
+
+  class CDB
+
+    extend Forwardable
+
+    MODE_READ  = 'r' # :nodoc:
+    MODE_WRITE = 'w' # :nodoc:
+
+    class << self
+
+      # call-seq:
+      #   CDB.open(path[, mode]) -> aReader | aWriter | aCDB
+      #   CDB.open(path[, mode]) { |cdb| ... }
+      #
+      # Opens +path+ with +mode+. If a block is given, yields a _cdb_ object
+      # according to +mode+ (see below) and returns the return value of the
+      # block; the object is closed afterwards. Otherwise just returns the
+      # object.
+      #
+      # <tt>r</tt>::  Reader
+      # <tt>w</tt>::  Writer
+      # <tt>r+</tt>:: CDB (initially opened for reading)
+      # <tt>w+</tt>:: CDB (initially opened for writing)
+      def open(path, mode = MODE_READ)
+        klass, args = self, []
+
+        case mode
+          when 'r+'       then args = [mode = MODE_READ]
+          when 'w+'       then args = [       MODE_WRITE]
+          when MODE_READ  then klass        = Reader
+          when MODE_WRITE then klass,  mode = Writer, 'w+'
+          else raise ArgumentError, "illegal access mode #{mode}"
+        end
+
+        cdb = begin
+          klass.new(io = File.open(path, mode), *args)
+        rescue
+          io.close if io
+          raise
+        end
+
+        if block_given?
+          begin
+            yield cdb
+          ensure
+            cdb.close
+          end
+        else
+          cdb
+        end
+      end
+
+      # call-seq:
+      #   CDB.foreach(path) { |key, val| ... }
+      #   CDB.foreach(path, key) { |val| ... }
+      #
+      # Opens +path+ for reading and iterates over each key/value pair,
+      # or, if +key+ is given, each value for +key+.
+      def foreach(path, *key)
+        open(path) { |cdb| cdb.each(*key) { |val| yield val } }
+      end
+
+      # call-seq:
+      #   CDB.dump(path[, target[, separator]]) -> target
+      #
+      # Opens +path+ for reading and shovels each record dump into +target+
+      # (followed by +separator+, if present). Returns +target+.
+      def dump(path, target = '', separator = $\ || $/)
+        open(path) { |cdb|
+          cdb.each_dump { |dump|
+            target << dump
+            target << separator if separator
+          }
+
+          target
+        }
+      end
+
+    end
+
+    # call-seq:
+    #   CDB.new(io[, mode]) -> aCDB
+    #
+    # Creates a new CDB object to interface with +io+. +mode+ must be the same
+    # mode +io+ was opened in, either +r+ or +w+. Responds to both Reader and
+    # Writer methods interchangeably by reopening +io+ in the corresponding mode
+    # and instantiating a new Reader or Writer object with it. Note that +io+
+    # will be truncated each time it's opened for writing.
+    def initialize(io, mode = MODE_WRITE)
+      @io, @mode = io, mode
+
+      case mode
+        when MODE_READ  then open_read
+        when MODE_WRITE then open_write
+        else raise ArgumentError, "illegal access mode #{mode}"
+      end
+    end
+
+    # The underlying IO object.
+    attr_reader :io
+
+    # The current IO mode, either +r+ or +w+.
+    attr_reader :mode
+
+    # call-seq:
+    #   cdb.reader -> aReader
+    #
+    # The Reader object associated with _cdb_.
+    def reader
+      @reader ||= open_read
+    end
+
+    # call-seq:
+    #   cdb.writer -> aWriter
+    #
+    # The Writer object associated with _cdb_.
+    def writer
+      @writer ||= open_write
+    end
+
+    def_delegators :reader, :[], :dump, :each, :each_dump, :each_key,
+                            :each_value, :empty?, :fetch, :fetch_all,
+                            :fetch_first, :fetch_last, :get, :has_key?,
+                            :has_value?, :include?, :key, :key?, :keys,
+                            :length, :member?, :rget, :size, :to_a,
+                            :to_h, :value?, :values, :values_at
+
+    def_delegators :writer, :[]=, :add, :insert, :replace, :store
+
+    # call-seq:
+    #   cdb.read? -> true | false
+    #
+    # Whether _cdb_ is currently opened for reading.
+    def read?
+      !!@reader
+    end
+
+    # call-seq:
+    #   cdb.write? -> true | false
+    #
+    # Whether _cdb_ is currently opened for writing.
+    def write?
+      !!@writer
+    end
+
+    # call-seq:
+    #   cdb.open_read -> aReader
+    #
+    # Opens _cdb_ for reading and reopens #io accordingly.
+    # Closes #writer if open.
+    def open_read
+      close_write(false)
+      @reader = Reader.new(reopen(MODE_READ))
+    end
+
+    # call-seq:
+    #   cdb.open_write -> aWriter
+    #
+    # Opens _cdb_ for writing and reopens #io accordingly.
+    # Closes #reader if open. Note that #io will be truncated.
+    def open_write
+      close_read(false)
+      @writer = Writer.new(reopen(MODE_WRITE))
+    end
+
+    # call-seq:
+    #   cdb.close_read([strict]) -> nil
+    #
+    # If _cdb_ is currently opened for reading, closes the #reader (and #io
+    # with it). Otherwise, if +strict+ is true, raises an IOError.
+    def close_read(strict = true)
+      if read?
+        @reader.close
+        @reader = nil
+      elsif strict
+        raise IOError, 'not opened for reading'
+      end
+    end
+
+    # call-seq:
+    #   cdb.close_write([strict]) -> nil
+    #
+    # If _cdb_ is currently opened for writing, closes the #writer (and #io
+    # with it). Otherwise, if +strict+ is true, raises an IOError.
+    def close_write(strict = true)
+      if write?
+        @writer.close
+        @writer = nil
+      elsif strict
+        raise IOError, 'not opened for writing'
+      end
+    end
+
+    # call-seq:
+    #   cdb.close -> nil
+    #
+    # Closes both the #reader and the #writer, as well as #io. Doesn't raise
+    # an IOError if either of them is already closed.
+    def close
+      close_read(false)
+      close_write(false)
+      io.close unless io.closed?
+    end
+
+    # call-seq:
+    #   cdb.closed_read? -> true | false | nil
+    #
+    # Whether #reader is closed if _cdb_ is currently opened for reading.
+    def closed_read?
+      reader.closed? if read?
+    end
+
+    # call-seq:
+    #   cdb.closed_write? -> true | false | nil
+    #
+    # Whether #writer is closed if _cdb_ is currently opened for writing.
+    def closed_write?
+      writer.closed? if write?
+    end
+
+    # call-seq:
+    #   cdb.closed? -> true | false | nil
+    #
+    # Whether _cdb_ is closed. See #closed_read? and #closed_write?.
+    def closed?
+      read? ? closed_read? : write? ? closed_write? : nil
+    end
+
+    private
+
+    # call-seq:
+    #   cdb.reopen([mode]) -> anIO
+    #
+    # Reopens #io in +mode+ and returns it.
+    def reopen(new_mode = MODE_READ)
+      return io if mode == new_mode
+
+      @mode = new_mode
+      new_mode += '+' if new_mode == MODE_WRITE
+
+      io.reopen(io.path, new_mode)
+    end
+
+  end
+
+end