cdb 0.0.2

data/README

@@ -0,0 +1,67 @@
+====================
+cdb library for ruby
+====================
+
+Author: Markus Schirp, Seonic GbR
+License: Ruby's License
+
+Description:
+
+Simple CDB reading an writing Plugin for Ruby.
+
+Constant - Database Reference: 
+
+  http://cr.yp.to/cdb.html
+
+Requirements:
+=============
+
+   -l:cdb.a -l:unix.a -l:buffer.a -l:byte -l:alloc
+   cdb.h
+
+Installing cdb under Gentoo:
+
+  portage: 
+    emerge dev-db/cdb
+
+  paludis:
+    paludis -i dev-db/cdb
+
+
+Examples:
+=========
+
+reading:
+
+# read example begin
+
+require 'cdb'
+
+File.open("some.cdb") do |file|
+  reader = CDB::CDBReader.new(file)
+  reader.each_value("somekey") do |value|
+    # do something with value
+  end
+end
+
+# read example end
+
+writing:
+
+# write example begin
+
+require 'cdb'
+
+File.open("some.cdb","w") do |file|
+  CDB::CDBMaker.fill(file) do |maker|
+    (1..10).each do |x|
+      key = "key#{x}"
+      1.upto(x) do |y|
+        value = "value#{x}.#{y}"
+        maker.store(key,value)
+      end
+    end
+  end
+end
+
+# write example end

data/ext/cdb_ext.c

@@ -0,0 +1,257 @@
+#include "ruby.h"
+#include "rubyio.h"
+#include <cdb.h>
+
+#ifndef TINYCDB_VERSION
+  #include <cdb_make.h>
+  #include <uint32.h>
+#else
+  #define uint32 unsigned int
+#endif /* TINYCDB_VERSION */
+ 
+typedef struct cdb_make cdb_make;
+typedef struct cdb cdb;
+
+VALUE CDBMaker_alloc(VALUE klass);
+VALUE CDBMaker_initialize(VALUE self,VALUE io);
+VALUE CDBMaker_store(VALUE self,VALUE key,VALUE value);
+VALUE CDBMaker_finish(VALUE self);
+VALUE CDBMaker_is_finished(VALUE self);
+
+VALUE CDBReader_alloc(VALUE klass);
+VALUE CDBReader_initialize(VALUE self,VALUE io);
+VALUE CDBReader_has_key(VALUE self,VALUE key);
+VALUE CDBReader_each_for_key(VALUE self,VALUE key);
+VALUE CDBReader_each(VALUE self);
+VALUE CDBReader_each_key(VALUE self);
+VALUE CDBReader_each_value(VALUE self);
+
+void _cdb_read(cdb *db,void *buf,uint32 len,uint32 *pos) {
+  if(cdb_read(db,buf,len,*pos) == -1) {
+    rb_sys_fail(0);
+  }
+  *pos+=len;
+  return;
+}
+
+void 
+getnum(cdb *db,uint32 *num,uint32 *pos) {
+#ifndef TINYCDB_VERSION
+  char buf[4];
+#else
+  unsigned char buf[4];
+#endif /* TINYCDB_VERSION */
+  _cdb_read(db,buf,4,pos);
+  // Can we skip unpack on little endian?
+#ifndef TINYCDB_VERSION
+  uint32_unpack(buf,num); 
+#else
+  *num=cdb_unpack(buf);
+#endif /* TINYDB_VERSION */
+}
+
+/* Implements CDB::CDBMaker */
+static void 
+CDBMaker_free(void *ptr) { free(ptr); }
+
+VALUE 
+CDBMaker_alloc(VALUE klass) {
+  cdb_make *db = ALLOC_N(cdb_make,1);
+  return Data_Wrap_Struct(klass,NULL,CDBMaker_free,db);
+}
+
+VALUE 
+CDBMaker_initialize(VALUE self,VALUE io) {
+  OpenFile *fptr = NULL;
+  cdb_make *db = NULL;
+  rb_check_type(io,T_FILE);
+  GetOpenFile(io, fptr);
+  rb_io_check_writable(fptr);
+  rb_iv_set(self,"finished",Qfalse);
+  Data_Get_Struct(self,cdb_make,db);
+  if(cdb_make_start(db,fileno(GetReadFile(fptr))) == -1) 
+    rb_sys_fail(0);
+  return self;
+}
+
+VALUE
+CDBMaker_store(VALUE self,VALUE key,VALUE value) {
+  if(rb_iv_get(self,"finished") == Qtrue) 
+    rb_raise(rb_eRuntimeError,"cdb is already finished!");
+  cdb_make *db = NULL;
+  Data_Get_Struct(self,cdb_make,db);
+  key = StringValue(key);
+  value = StringValue(value);
+  if(cdb_make_add(db,RSTRING(key)->ptr,RSTRING(key)->len,RSTRING(value)->ptr,RSTRING(value)->len) == -1) 
+    rb_sys_fail(0);
+  return Qnil;
+}
+
+VALUE 
+CDBMaker_finish(VALUE self) {
+  cdb_make *db = NULL;
+  if(rb_iv_get(self,"finished") == Qtrue) 
+    rb_raise(rb_eRuntimeError,"cdb is already finished!");
+  rb_iv_set(self,"finished",Qtrue);
+  Data_Get_Struct(self,cdb_make,db);
+  if(cdb_make_finish(db) == -1) rb_sys_fail(0);
+  return Qnil;
+}
+
+VALUE 
+CDBMaker_is_finished(VALUE self) {
+  return rb_iv_get(self,"finished");
+}
+
+/* Implements CDB::CDBReader */
+
+static void CDBReader_free(void *ptr) {
+  free(ptr);
+}
+
+VALUE 
+CDBReader_alloc(VALUE klass) {
+  cdb *db = ALLOC_N(cdb,1);
+  return Data_Wrap_Struct(klass,NULL,CDBReader_free,db);
+}
+
+VALUE 
+CDBReader_initialize(VALUE self,VALUE io) {
+  OpenFile *fptr = NULL;
+  cdb *db = NULL;
+  rb_check_type(io,T_FILE);
+  GetOpenFile(io, fptr);
+  rb_io_check_readable(fptr);
+  Data_Get_Struct(self,cdb,db);
+  cdb_init(db,fileno(GetReadFile(fptr)));
+  return self;
+}
+
+VALUE 
+CDBReader_has_key(VALUE self,VALUE key) {
+  cdb *db = NULL;
+  Data_Get_Struct(self,cdb,db);
+  key = StringValue(key);
+  return cdb_find(db,RSTRING(key)->ptr,RSTRING(key)->len) ? Qtrue : Qfalse;
+}
+
+
+
+VALUE
+CDBReader_each_key(VALUE self) {
+  VALUE key;
+  cdb *db = NULL;
+  uint32 eod,klen,dlen,pos=0;
+  Data_Get_Struct(self,cdb,db);
+  getnum(db,&eod,&pos);
+  pos = 2048;
+
+  while(pos < eod) {
+    getnum(db,&klen,&pos);
+    getnum(db,&dlen,&pos);
+    key = rb_str_buf_new(klen);
+    RSTRING(key)->len = klen;
+    _cdb_read(db,RSTRING(key)->ptr,klen,&pos);
+    pos+=dlen;
+    rb_yield(key);
+  }
+
+  return Qnil;
+}
+
+VALUE 
+CDBReader_each_value(VALUE self) {
+  VALUE value;
+  cdb *db = NULL;
+  uint32 eod,klen,dlen,pos=0;
+  Data_Get_Struct(self,cdb,db);
+  getnum(db,&eod,&pos);
+  pos = 2048;
+
+  while(pos < eod) {
+    getnum(db,&klen,&pos);
+    getnum(db,&dlen,&pos);
+    value = rb_str_buf_new(dlen);
+    RSTRING(value)->len = dlen;
+    pos+=klen;
+    _cdb_read(db,RSTRING(value)->ptr,dlen,&pos);
+    rb_yield(value);
+  }
+  return Qnil;
+}
+
+VALUE 
+CDBReader_each(VALUE self) {
+  VALUE key,value;
+  cdb *db = NULL;
+  uint32 eod,klen,dlen,pos=0;
+  Data_Get_Struct(self,cdb,db);
+  getnum(db,&eod,&pos); 
+  pos = 2048;
+
+  while(pos < eod) {
+    getnum(db,&klen,&pos);
+    getnum(db,&dlen,&pos);
+    key = rb_str_buf_new(klen);
+    RSTRING(key)->len = klen;
+    value = rb_str_buf_new(dlen);
+    RSTRING(value)->len = dlen;
+
+    _cdb_read(db,RSTRING(key)->ptr,klen,&pos);
+    _cdb_read(db,RSTRING(value)->ptr,dlen,&pos);
+
+    rb_yield(rb_ary_new3(2,key,value));
+  }
+  return Qnil;
+}
+
+VALUE 
+CDBReader_each_for_key(VALUE self,VALUE key) {
+  cdb *db = NULL;
+  Data_Get_Struct(self,cdb,db);
+  VALUE value;
+  key = StringValue(key);
+#ifndef TINYCDB_VERSION
+  if(cdb_find(db,RSTRING(key)->ptr,RSTRING(key)->len) == -1) rb_sys_fail(0);
+  do {
+    value = rb_str_buf_new(cdb_datalen(db));
+    RSTRING(value)->len = cdb_datalen(db);
+    _cdb_read(db,RSTRING(value)->ptr,cdb_datalen(db),&cdb_datapos(db));
+    rb_yield(value);
+  } while(cdb_findnext(db,RSTRING(key)->ptr,RSTRING(key)->len));
+#else 
+  struct cdb_find find;
+  cdb_findinit(&find,db,RSTRING(key)->ptr,RSTRING(key)->len);
+  while(cdb_findnext(&find) > 0) {
+    value = rb_str_buf_new(cdb_datalen(db));
+    RSTRING(value)->len = cdb_datalen(db);
+    _cdb_read(db,RSTRING(value)->ptr,cdb_datalen(db),&cdb_datapos(db));
+    rb_yield(value);
+  }
+#endif /* TINYCDB_VERSION */
+  return Qnil;
+}
+
+VALUE mCDB;
+VALUE cCDBReader;
+VALUE cCDBMaker;
+
+void Init_cdb_ext() {
+  mCDB = rb_define_module("CDB");
+
+  cCDBReader = rb_define_class_under(mCDB,"CDBReader",rb_cObject);
+  rb_define_alloc_func(cCDBReader,CDBReader_alloc);
+  rb_define_method(cCDBReader,"initialize",CDBReader_initialize,1);
+  rb_define_method(cCDBReader,"has_key?",CDBReader_has_key,1);
+  rb_define_method(cCDBReader,"each_for_key",CDBReader_each_for_key,1);
+  rb_define_method(cCDBReader,"each_key",CDBReader_each_key,0);
+  rb_define_method(cCDBReader,"each_value",CDBReader_each_value,0);
+  rb_define_method(cCDBReader,"each",CDBReader_each,0);
+
+  cCDBMaker = rb_define_class_under(mCDB,"CDBMaker",rb_cObject);
+  rb_define_alloc_func(cCDBMaker,CDBMaker_alloc);
+  rb_define_method(cCDBMaker,"initialize",CDBMaker_initialize,1);
+  rb_define_method(cCDBMaker,"store",CDBMaker_store,2);
+  rb_define_method(cCDBMaker,"finish!",CDBMaker_finish,0);
+  rb_define_method(cCDBMaker,"finished?",CDBMaker_is_finished,0);
+}

data/ext/extconf.rb

@@ -0,0 +1,11 @@
+require 'mkmf'
+have_header("cdb.h") || exit
+if macro_defined?("TINYCDB_VERSION",cpp_include("cdb.h"))
+  $LDFLAGS << " -lcdb"
+else
+  %w(cdb unix buffer byte alloc).each do |ld|
+    $LDFLAGS << " -l:#{ld}.a"
+  end
+end
+$CFLAGS << " -Wall"
+create_makefile("cdb/cdb_ext")

data/lib/cdb.rb

@@ -0,0 +1,3 @@
+require 'cdb/cdb_ext'
+require 'cdb/reader_util'
+require 'cdb/maker_util'

data/lib/cdb/maker_util.rb

@@ -0,0 +1,9 @@
+module CDB
+class CDBMaker
+  def self.fill(file)
+    maker = self.new(file)
+    yield maker
+    maker.finish!
+  end
+end
+end

data/lib/cdb/reader_util.rb

@@ -0,0 +1,13 @@
+require 'cdb/cdb_ext'
+
+module CDB
+class CDBReader
+  def values(key)
+    ret = Array.new
+    each_for_key(key) do |value|
+      ret << value 
+    end
+    ret
+  end
+end
+end

data/test/tc_maker.rb

@@ -0,0 +1,34 @@
+require 'cdb'
+require 'tempfile'
+require 'test/unit'
+
+require 'test_data'
+
+class TestCDBMaker < Test::Unit::TestCase
+  include ::CDB
+  include ::TestData
+
+  def setup
+    @tmpfile = Tempfile.new("cdb_maker_test")
+    @db = CDBMaker.new(@tmpfile.to_io)
+  end
+
+  def test_initialize
+    assert_raise(Errno::ESPIPE) do
+      CDBMaker.new($stdout)
+    end
+    assert_raise(TypeError) do
+      CDBMaker.new("test")
+    end
+  end
+
+  def test_store
+    Data.each do |key,values|
+      values.each do |value|
+        @db.store(key,value)
+      end
+    end
+    @db.finish!
+    assert(@db.finished?)
+  end
+end

data/test/tc_reader.rb

@@ -0,0 +1,121 @@
+#!/usr/bin/ruby
+require 'test/unit'
+require 'tempfile'
+require 'test_data'
+
+require 'cdb'
+
+class TestCDBReader < ::Test::Unit::TestCase
+  include ::TestData
+  class Dummy
+    def to_str
+      "lala"
+    end
+  end
+
+  class Dummy2
+    def to_str
+      "key1"
+    end
+  end
+
+  def self.cdb_format(key,value)
+    "+#{key.length.to_s},#{value.length.to_s}:#{key}->#{value}"
+  end
+
+  db = CDB::CDBMaker.new(file=Tempfile.new("test_cdb").to_io)
+
+  Data.each do |key,values|
+    values.each do |value|
+      db.store(key,value)
+    end
+  end
+  db.finish!
+  @@file_path = file.path
+  file.close
+
+  def setup
+    @db = CDB::CDBReader.new(@file=File.open(@@file_path))
+  end
+
+  def teardown
+    @file.close
+  end
+
+  def test_has_key?
+    Data.each do |pair|
+      key,value = pair
+      assert(@db.has_key?(key),"key: #{key} was not found!")
+    end
+    assert(!@db.has_key?("nonexistend"))
+    assert_raise(TypeError) do
+      assert(!@db.has_key?(1))
+    end
+    assert(!@db.has_key?(Dummy.new))
+    assert(@db.has_key?(Dummy2.new))
+  end
+
+  def test_each
+    tmp = Hash.new
+    Data.each do |key,value|
+      tmp[key] = value.dup
+    end
+    @db.each do |key,value|
+      assert(tmp.has_key?(key))
+      values = tmp.fetch(key)
+      assert(values.include?(value))
+      values.delete(value)
+      tmp.delete(key) if values.empty?
+    end
+    assert(tmp.empty?)
+  end
+
+  def test_each_key
+    tmp = Hash.new
+    @db.each_key do |key|
+      assert(Data.has_key?(key))
+      if tmp[key] 
+        tmp[key]+=1
+      else
+        tmp[key]=1
+      end
+    end
+    tmp.each do |key,count|
+      assert_equal(Data[key].length,count)
+    end
+  end
+
+  def test_each_value
+    values = Data.values.flatten
+    @db.each_value do |value|
+      assert(values.include?(value),"#{value} was not expected!")
+      values.delete(value)
+    end
+    assert(values.empty?)
+  end
+
+  def test_each_for_key
+    Data.each do |key,ovalue|
+      rvalue = Array.new
+      @db.each_for_key(key) do |x|
+        rvalue << x
+      end
+      assert_equal(ovalue,@db.values(key))
+      assert_equal(ovalue,rvalue)
+    end
+  end
+
+  def test_initialize
+    assert_raise(IOError) do
+      CDB::CDBReader.new($stdout)
+    end
+
+    assert_raise(TypeError) do 
+      CDB::CDBReader.new(1)
+    end
+
+    assert_nothing_raised do
+      CDB::CDBReader.new($stdin)
+    end
+  end
+end

data/test/test_data.rb

@@ -0,0 +1,27 @@
+module TestData
+  LARGE_KEY = "a"*1024
+  LARGE_VALUE = "b"*(1024*1024)
+  class Dummy
+    def to_str
+      "lala"
+    end
+  end
+
+  class Dummy2
+    def to_str
+      "key1"
+    end
+  end
+
+  Data = Hash.new
+
+  (1..10).each do |x|
+    key = "key#{x}"
+    values = Array.new
+    Data[key] = values
+    1.upto(x) do |i|
+      values << value = "value#{x}.#{i}"
+    end
+  end
+  Data[LARGE_KEY]=Array(LARGE_VALUE)
+end

data/test/ts_cdb.rb

@@ -0,0 +1,3 @@
+$: << File.dirname(__FILE__)
+require 'tc_maker'
+require 'tc_reader'

metadata

@@ -0,0 +1,56 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.4
+specification_version: 1
+name: cdb
+version: !ruby/object:Gem::Version 
+  version: 0.0.2
+date: 2008-01-13 00:00:00 +01:00
+summary: Reading and creating CDB Constant Databases
+require_paths: 
+- lib
+email: mbj@seonic.net
+homepage: http://mbj.seonic.net
+rubyforge_project: 
+description: 
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: false
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Markus Schirp
+files: 
+- README
+- lib/cdb
+- lib/cdb.rb
+- lib/cdb/maker_util.rb
+- lib/cdb/reader_util.rb
+- test/ts_cdb.rb
+- test/tc_reader.rb
+- test/test_data.rb
+- test/tc_maker.rb
+- ext/extconf.rb
+- ext/cdb_ext.c
+test_files: 
+- test/ts_cdb.rb
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: []
+
+extensions: 
+- ext/extconf.rb
+requirements: []
+
+dependencies: []
+