rbcddb 0.0.2

data/ext/cddb_disc.c

@@ -0,0 +1,497 @@
+#include<ruby.h>
+#include<cddb/cddb.h>
+
+#include "cddb_conn.h"
+#include "cddb_disc.h"
+#include "cddb_track.h"
+
+#include "usage.h"
+
+VALUE cddb_disc_rb;
+
+static void crb_disc_free(void *p) {
+  cddb_disc_destroy(p);
+  decLibUsage();
+}
+
+static VALUE crb_to_string(const char* str) {
+  if (str)
+    return rb_str_new2(str);
+  else
+    return Qnil;
+}
+
+cddb_disc_t *get_cddb_disc_from_Value(VALUE self) {
+  cddb_disc_t *disc = NULL;
+  Data_Get_Struct(self,cddb_disc_t,disc);
+  return disc;
+}
+
+VALUE makeValueFrom_cddb_disc_t(cddb_disc_t *disc) {
+  VALUE obj=Qnil;
+  if (disc) {
+    incLibUsage();
+    obj=Data_Wrap_Struct(cddb_disc_rb,0,crb_disc_free,disc);
+  }
+  return obj;
+}
+
+VALUE _makeValueFrom_cddb_disc_t(cddb_disc_t *disc) {
+  VALUE obj=Qnil;
+  if (disc) {
+    obj=Data_Wrap_Struct(cddb_disc_rb,0,0,disc);
+  }
+  return obj;
+}
+
+
+static VALUE crb_disc_alloc(VALUE klass)
+{
+  VALUE obj;
+  cddb_disc_t *disc = NULL;
+  incLibUsage();
+  disc = cddb_disc_new();
+  if (disc == NULL) {
+    rb_sys_fail("out of memory, "
+		"unable to create cddb_disc structure");
+  }
+  obj=Data_Wrap_Struct(klass,0,crb_disc_free,disc);
+  return obj;
+}
+
+
+/*
+ * call-seq:
+ * clone -> CDDB_Disc
+ *
+ *  Makes an object with the same content as the current object
+ *
+ */
+static VALUE crb_cddb_disc_clone(VALUE self) {
+  cddb_disc_t *disc=get_cddb_disc_from_Value(self);
+  return makeValueFrom_cddb_disc_t(cddb_disc_clone(disc));
+}
+
+
+/*
+ * call-seq:
+ * add_track(CDDB_Track)
+ * 
+ *  Adds a clone of a CDDB_Track object to the object
+ *
+ */
+static VALUE crb_cddb_disc_add_track(VALUE self,VALUE rtrack) {
+  cddb_disc_t *disc=get_cddb_disc_from_Value(self);
+  cddb_track_t *track=get_cddb_track_from_Value(rtrack);
+  cddb_disc_add_track(disc,cddb_track_clone(track));
+  return self;
+}
+
+/*
+ * call-seq:
+ * get_track(number) -> CDDB_Track
+ *
+ *  Gets the specified track (not a clone)
+ *  since it was already cloned when adding
+ *
+ */
+static VALUE crb_cddb_disc_get_track(VALUE self,VALUE track_no) {
+  cddb_disc_t *disc=get_cddb_disc_from_Value(self);
+  cddb_track_t *track=cddb_disc_get_track(disc,NUM2INT(track_no));
+  return _makeValueFrom_cddb_track_t(track);
+}
+
+/*
+ * call-seq:
+ * track_first -> CDDB_Track
+ * 
+ * returns the first track 
+ */
+static VALUE crb_cddb_disc_get_track_first(VALUE self) {
+  cddb_disc_t *disc=get_cddb_disc_from_Value(self);
+  cddb_track_t *track=cddb_disc_get_track_first(disc);
+  return _makeValueFrom_cddb_track_t(track);
+}
+
+/*
+ * call-seq:
+ * track_next -> CDDB_Track
+ * 
+ * returns the next track or a nil object 
+ */
+static VALUE crb_cddb_disc_get_track_next(VALUE self) {
+  cddb_disc_t *disc=get_cddb_disc_from_Value(self);
+  cddb_track_t *track=cddb_disc_get_track_next(disc);
+  return _makeValueFrom_cddb_track_t(track);
+}
+
+
+/*
+ * call-seq:
+ * disc_id -> number
+ * 
+ * returns the number of the disc
+ */
+static VALUE crb_cddb_disc_get_discid(VALUE self) {
+  cddb_disc_t *disc=get_cddb_disc_from_Value(self);
+  return UINT2NUM(cddb_disc_get_discid(disc));
+}
+
+/*
+ * call-seq:
+ * disc_id= number
+ * 
+ * returns the number of the disc based on other values
+ */
+static VALUE crb_cddb_disc_set_discid(VALUE self,VALUE id) {
+  cddb_disc_t *disc=get_cddb_disc_from_Value(self);
+  cddb_disc_set_discid(disc,NUM2UINT(id));
+  return self;
+}
+
+
+/*
+ * call-seq:
+ * category_str -> string
+ * 
+ * returns a string that represents the category of the disc
+ */
+static VALUE crb_cddb_disc_get_category_str(VALUE self) {
+  cddb_disc_t *disc=get_cddb_disc_from_Value(self);
+  return crb_to_string(cddb_disc_get_category_str(disc));
+}
+
+/*
+ * call-seq:
+ * category_str= string
+ * 
+ * set category of the disc
+ */
+static VALUE crb_cddb_disc_set_category_str(VALUE self,VALUE cat) {
+  cddb_disc_t *disc=get_cddb_disc_from_Value(self);
+  cddb_disc_set_category_str(disc,STR2CSTR(cat));
+  return self;
+}
+
+
+/*
+ * call-seq:
+ * genre-> Rb_CDDB::CAT_xxx
+ *
+ * compare with the CAT_xx constants from Rb_CDDB
+ */
+static VALUE crb_cddb_disc_get_genre(VALUE self) {
+  cddb_disc_t *disc=get_cddb_disc_from_Value(self);
+  return crb_to_string(cddb_disc_get_category_str(disc));
+}
+
+/*
+ * call-seq:
+ * genre= Rb_CDDB::CAT_xxx
+ *
+ * use the CAT_xx constants from Rb_CDDB
+ */
+static VALUE crb_cddb_disc_set_genre(VALUE self,VALUE gen) {
+  cddb_disc_t *disc=get_cddb_disc_from_Value(self);
+  cddb_disc_set_category_str(disc,STR2CSTR(gen));
+  return self;
+}
+
+
+/*
+ * call-seq:
+ * length -> number
+ *
+ * get the length field of the disc in seconds
+ */
+static VALUE crb_cddb_disc_get_length(VALUE self) {
+  cddb_disc_t *disc=get_cddb_disc_from_Value(self);
+  return INT2NUM(cddb_disc_get_length(disc));
+}
+
+/*
+ * call-seq:
+ * length= number
+ *
+ * set the length field of the disc in seconds
+ *
+ */
+static VALUE crb_cddb_disc_set_length(VALUE self,VALUE len) {
+  cddb_disc_t *disc=get_cddb_disc_from_Value(self);
+  cddb_disc_set_length(disc,NUM2INT(len));
+  return self;
+}
+
+
+/*
+ * call-seq:
+ * length_by_offset= number
+ * 
+ * set the length field of the disc in frames
+ * to get this with rbcdio use the frameoffset (lba) 
+ * of the leadout
+ */
+static VALUE crb_cddb_disc_set_length_by_offset(VALUE self,VALUE len) {
+  cddb_disc_t *disc=get_cddb_disc_from_Value(self);
+  cddb_disc_set_length(disc,FRAMES_TO_SECONDS(NUM2INT(len)));
+  return self;
+}
+
+/*
+ * call-seq:
+ * year -> number
+ *
+ * year of the disc
+ */
+static VALUE crb_cddb_disc_get_year(VALUE self) {
+  cddb_disc_t *disc=get_cddb_disc_from_Value(self);
+  return INT2NUM(cddb_disc_get_year(disc));
+}
+
+/*
+ * call-seq:
+ * year= number
+ * 
+ * sets the year
+ */
+static VALUE crb_cddb_disc_set_year(VALUE self,VALUE year) {
+  cddb_disc_t *disc=get_cddb_disc_from_Value(self);
+  cddb_disc_set_year(disc,NUM2INT(year));
+  return self;
+}
+
+/*
+ * call-seq:
+ * track_count -> number
+ * the number of tracks
+ */
+static VALUE crb_cddb_disc_get_track_count(VALUE self) {
+  cddb_disc_t *disc=get_cddb_disc_from_Value(self);
+  return INT2NUM(cddb_disc_get_track_count(disc));
+}
+
+
+/*
+ * call-seq:
+ * title -> string
+ *
+ * get the title of the disc
+ */
+static VALUE crb_cddb_disc_get_title(VALUE self) {
+  cddb_disc_t *disc=get_cddb_disc_from_Value(self);
+  return crb_to_string(cddb_disc_get_title(disc));
+}
+
+/*
+ * call-seq:
+ * title= string
+ *
+ * set the title of the disc
+ */
+static VALUE crb_cddb_disc_set_title(VALUE self,VALUE title) {
+  cddb_disc_t *disc=get_cddb_disc_from_Value(self);
+  cddb_disc_set_title(disc,STR2CSTR(title));
+  return self;
+}
+
+
+/*
+ * call-seq:
+ * artist -> string
+ * get the artist of the disc 
+ *
+ */
+
+static VALUE crb_cddb_disc_get_artist(VALUE self) {
+  cddb_disc_t *disc=get_cddb_disc_from_Value(self);
+  return crb_to_string(cddb_disc_get_artist(disc));
+}
+
+/*
+ * call-seq:
+ * artist= string
+ * set the artist of the disc (tracks can have a different one)
+ */
+static VALUE crb_cddb_disc_set_artist(VALUE self,VALUE artist) {
+  cddb_disc_t *disc=get_cddb_disc_from_Value(self);
+  cddb_disc_set_artist(disc,STR2CSTR(artist));
+  return self;
+}
+
+/*
+ * call-seq:
+ * ext_data -> string
+ * get the extra data of the disc 
+ */
+static VALUE crb_cddb_disc_get_ext_data(VALUE self) {
+  cddb_disc_t *disc=get_cddb_disc_from_Value(self);
+  return crb_to_string(cddb_disc_get_ext_data(disc));
+}
+
+/*
+ * call-seq:
+ * ext= string
+ * set the extra data the disc 
+ */
+static VALUE crb_cddb_disc_set_ext_data(VALUE self,VALUE ext_data) {
+  cddb_disc_t *disc=get_cddb_disc_from_Value(self);
+  cddb_disc_set_ext_data(disc,STR2CSTR(ext_data));
+  return self;
+}
+
+
+/*
+ * call-seq:
+ * calc_discid -> number
+ * calculate the discid and return this value
+ */
+static VALUE crb_cddb_calc_discid(VALUE self) {
+  cddb_disc_t *disc=get_cddb_disc_from_Value(self);
+  cddb_disc_calc_discid(disc);
+  return UINT2NUM(cddb_disc_get_discid(disc));
+}
+
+/*
+ * call-seq:
+ * print
+ *
+ * a debug method from the libcddb, it dumps the content
+ * to the STDOUT for a quick inspection, the to_hash method
+ * will be more useful in most cases
+ */
+static VALUE crb_cddb_print(VALUE self) {
+  cddb_disc_t *disc=get_cddb_disc_from_Value(self);
+  cddb_disc_print(disc);
+  return self;
+}
+
+
+/* 
+ * call-seq:
+ * to_hash -> Hash
+ *
+ *   Gets all the fields together as a ruby Hash
+ * 
+ * def to_hash
+ *   return {
+ *     'disc_id' => self.disc_id,
+ *     'title' => self.title,
+ *     'artist' => self.artist,
+ *     'category_str' => self.category_str,
+ *     'genre' => self.genre,
+ *     'length' => self.length,
+ *     'year' => self.year,
+ *     'ext_data' => self.ext_data,
+ *     'track_count'=> self.track_count,
+ *   }
+ * end
+ * 
+ */
+ static VALUE crb_cddb_disc_to_hash(VALUE self) {
+  VALUE hash=rb_hash_new();
+
+  rb_hash_aset(hash,	rb_str_new2("disc_id"),
+	       crb_cddb_disc_get_discid(self));
+
+  rb_hash_aset(hash,	rb_str_new2("title"),
+	       crb_cddb_disc_get_title(self));
+
+  rb_hash_aset(hash,	rb_str_new2("artist"),
+	       crb_cddb_disc_get_artist(self));
+
+  rb_hash_aset(hash, rb_str_new2("category_str"),
+	       crb_cddb_disc_get_category_str(self));
+
+  rb_hash_aset(hash, rb_str_new2("genre"),
+	       crb_cddb_disc_get_genre(self));
+
+  rb_hash_aset(hash, rb_str_new2("length"),
+	       crb_cddb_disc_get_length(self));
+
+  rb_hash_aset(hash, rb_str_new2("year"),
+	       crb_cddb_disc_get_year(self));
+ 
+  rb_hash_aset(hash, rb_str_new2("ext_data"),
+	      crb_cddb_disc_get_ext_data(self));
+
+  rb_hash_aset(hash, rb_str_new2("track_count"),
+	       crb_cddb_disc_get_track_count(self));
+
+  return hash;
+}
+
+
+
+/*
+ * The copy from will copy all the content from another CDDB_Disc
+ * object
+ */
+static VALUE crb_cddb_disc_copy_from(VALUE self,VALUE source) {
+  cddb_disc_t *dst=get_cddb_disc_from_Value(self);
+  cddb_disc_t *src=get_cddb_disc_from_Value(source);
+  cddb_disc_copy(dst,src);
+  return self;
+}
+
+
+
+
+
+
+/*
+ * Class +CDDB_Disc+  represent a disc and can contain 
+ * +CDDB_Track+ object
+ */
+
+void init_cddb_disc() {
+  cddb_disc_rb=rb_define_class("CDDB_Disc",rb_cObject);
+  rb_define_alloc_func(cddb_disc_rb,crb_disc_alloc);
+  rb_define_method(cddb_disc_rb,"clone",
+		   crb_cddb_disc_clone,1);
+  rb_define_method(cddb_disc_rb,"add_track",
+		   crb_cddb_disc_add_track,1);
+  rb_define_method(cddb_disc_rb,"track",
+		   crb_cddb_disc_get_track,1);
+  rb_define_method(cddb_disc_rb,"track_first",  
+		   crb_cddb_disc_get_track_first,0);
+  rb_define_method(cddb_disc_rb,"track_next",   
+		   crb_cddb_disc_get_track_next,0);
+  rb_define_method(cddb_disc_rb,"discid",  
+		   crb_cddb_disc_get_discid,0);
+  rb_define_method(cddb_disc_rb,"discid=",  
+		   crb_cddb_disc_set_discid,1);
+  rb_define_method(cddb_disc_rb,"category_str",  
+		   crb_cddb_disc_get_category_str,0);
+  rb_define_method(cddb_disc_rb,"category_str=",  
+		   crb_cddb_disc_set_category_str,1);
+  rb_define_method(cddb_disc_rb,"genre",  
+		   crb_cddb_disc_get_genre,0);
+  rb_define_method(cddb_disc_rb,"genre=",  
+		   crb_cddb_disc_set_genre,1);
+  rb_define_method(cddb_disc_rb,"length",  
+		   crb_cddb_disc_get_length,0);
+  rb_define_method(cddb_disc_rb,"length=",  
+		   crb_cddb_disc_set_length,1);
+  rb_define_method(cddb_disc_rb,"last_frame_offset=",  
+		   crb_cddb_disc_set_length_by_offset,1);
+  rb_define_method(cddb_disc_rb,"year",  
+		   crb_cddb_disc_get_year,0);
+  rb_define_method(cddb_disc_rb,"year=",  
+		   crb_cddb_disc_set_year,1);
+  rb_define_method(cddb_disc_rb,"track_count" ,  
+		   crb_cddb_disc_get_track_count,0);
+  rb_define_method(cddb_disc_rb,"title",  
+		   crb_cddb_disc_get_title,0);
+  rb_define_method(cddb_disc_rb,"title=",  
+		   crb_cddb_disc_set_title,1);
+  rb_define_method(cddb_disc_rb,"ext_data" ,  
+		   crb_cddb_disc_get_ext_data,0);
+  rb_define_method(cddb_disc_rb,"ext_data=", crb_cddb_disc_set_ext_data,1);
+  rb_define_method(cddb_disc_rb,"copy_from", crb_cddb_disc_copy_from,1);
+  rb_define_method(cddb_disc_rb,"calc_discid", 
+		   crb_cddb_calc_discid,0);
+  rb_define_method(cddb_disc_rb,"to_hash",  
+		   crb_cddb_disc_to_hash,0);
+  rb_define_method(cddb_disc_rb,"print", 
+		   crb_cddb_print,0);
+}

data/ext/cddb_disc.h

@@ -0,0 +1,16 @@
+#ifndef DISC_HEADER
+#define DISC_HEADER
+
+#include<ruby.h>
+#include<cddb/cddb.h>
+
+
+extern VALUE cddb_disc_rbclass;
+
+cddb_disc_t *get_cddb_disc_from_Value(VALUE self);
+
+VALUE makeValueFrom_cddb_disc_t(cddb_disc_t *disc);
+
+void init_cddb_disc();
+
+#endif

data/ext/cddb_mod.c

@@ -0,0 +1,134 @@
+#include<ruby.h>
+#include<cddb/cddb.h>
+
+
+VALUE cddb_mod_rb;
+
+/*
+ * call-seq:
+ *  Rb_CDDB.log_level= 
+ *
+ * sets the log level to one of the Rb_CDDB::LOG_xxx values
+ */
+static VALUE crb_cddb_set_log_level(VALUE self,VALUE serverport) {
+  cddb_log_set_level(NUM2INT(serverport));
+  return self;
+}
+
+/*
+ * call-seq:
+ * frame2sec(number) -> number
+ *
+ * convert the number of frames to seconds
+ */
+static VALUE crb_cddb_frame2sec(VALUE self,VALUE frames) {
+  return INT2NUM(FRAMES_TO_SECONDS(NUM2INT(frames)));
+}
+
+/*
+ * call-seq:
+ * sec2frame(number) -> number
+ *
+ * convert a number of seconds to a number of frames
+ */
+
+static VALUE crb_cddb_sec2frame(VALUE self,VALUE frames) {
+  return INT2NUM(TO_SECONDS_TO_FRAMES(NUM2INT(frames)));
+}
+
+/*
+ * call-seq:
+ * searchcat(number) -> number
+ *
+ * convert a number (Rb_CDDB::CAT_xxx values) to a value
+ * which can be ORed for the CDDB_Connection#search_categories= method
+ * 
+ */
+static VALUE crb_cddb_searchcat(VALUE self,VALUE cat) {
+  return INT2NUM(SEARCHCAT(NUM2INT(cat)));
+}
+
+
+
+/*
+ * +Rb_CDDB+ contrains several constants and a few methods
+ *  that control the entire libcddb like for instance logging
+ *
+ * the genres can be set with these constants
+ *  - Rb_CDDB::CAT_DATA
+ *  - Rb_CDDB::CAT_FOLK
+ *  - Rb_CDDB::CAT_JAZZ
+ *  - Rb_CDDB::CAT_MISC   
+ *  - Rb_CDDB::CAT_ROCK  
+ *  - Rb_CDDB::CAT_COUNTRY  
+ *  - Rb_CDDB::CAT_BLUES
+ *  - Rb_CDDB::CAT_NEWAGE    
+ *  - Rb_CDDB::CAT_REGGAE   
+ *  - Rb_CDDB::CAT_CLASSICAL   
+ *  - Rb_CDDB::CAT_SOUNDTRACK   
+ *  - Rb_CDDB::CAT_INVALID   
+ *  - Rb_CDDB::CAT_LAST
+ *
+ *  These values can be use to specify the log_level
+ *  - Rb_CDDB::LOG_DEBUG
+ *  - Rb_CDDB::LOG_INFO
+ *  - Rb_CDDB::LOG_WARN
+ *  - Rb_CDDB::LOG_ERROR
+ *  - Rb_CDDB::LOG_CRITICAL
+ *  - Rb_CDDB::LOG_NONE
+ *
+ *  The search values can be used 
+ *  for CDDB_Connection#search_fields=
+ *  - Rb_CDDB::SEARCH_NONE
+ *  - Rb_CDDB::SEARCH_ARTIST
+ *  - Rb_CDDB::SEARCH_TITLE
+ *  - Rb_CDDB::SEARCH_TRACK
+ *  - Rb_CDDB::SEARCH_OTHER
+ *  - Rb_CDDB::SEARCH_ALL
+ *
+ */
+void init_cddb_mod() {
+  cddb_mod_rb=rb_define_module("Rb_CDDB");
+
+  rb_define_module_function(cddb_mod_rb, "log_level=",
+			    crb_cddb_set_log_level,1);
+  rb_define_const(cddb_mod_rb,"CAT_DATA"    ,INT2NUM(CDDB_CAT_DATA));
+  rb_define_const(cddb_mod_rb,"CAT_FOLK"    ,INT2NUM(CDDB_CAT_FOLK));
+  rb_define_const(cddb_mod_rb,"CAT_JAZZ"    ,INT2NUM(CDDB_CAT_JAZZ));
+  rb_define_const(cddb_mod_rb,"CAT_MISC"    ,INT2NUM(CDDB_CAT_MISC));
+  rb_define_const(cddb_mod_rb,"CAT_ROCK"    ,INT2NUM(CDDB_CAT_ROCK));
+  rb_define_const(cddb_mod_rb,"CAT_COUNTRY" ,INT2NUM(CDDB_CAT_COUNTRY));
+  rb_define_const(cddb_mod_rb,"CAT_BLUES"   ,INT2NUM(CDDB_CAT_BLUES));
+  rb_define_const(cddb_mod_rb,"CAT_NEWAGE"  ,INT2NUM(CDDB_CAT_NEWAGE));
+  rb_define_const(cddb_mod_rb,"CAT_REGGAE"  ,INT2NUM(CDDB_CAT_REGGAE));
+  rb_define_const(cddb_mod_rb,"CAT_CLASSICAL" ,INT2NUM(CDDB_CAT_CLASSICAL));
+  rb_define_const(cddb_mod_rb,"CAT_SOUNDTRACK" ,INT2NUM(CDDB_CAT_SOUNDTRACK));
+  rb_define_const(cddb_mod_rb,"CAT_INVALID" ,INT2NUM(CDDB_CAT_INVALID));
+  rb_define_const(cddb_mod_rb,"CAT_LAST" ,INT2NUM(CDDB_CAT_LAST));
+
+
+  rb_define_const(cddb_mod_rb,"LOG_DEBUG"    ,INT2NUM(CDDB_LOG_DEBUG));
+  rb_define_const(cddb_mod_rb,"LOG_INFO"     ,INT2NUM(CDDB_LOG_INFO));
+  rb_define_const(cddb_mod_rb,"LOG_WARN"     ,INT2NUM(CDDB_LOG_WARN));
+  rb_define_const(cddb_mod_rb,"LOG_ERROR"    ,INT2NUM(CDDB_LOG_ERROR));
+  rb_define_const(cddb_mod_rb,"LOG_CRITICAL" ,INT2NUM(CDDB_LOG_CRITICAL));
+  rb_define_const(cddb_mod_rb,"LOG_NONE"     ,INT2NUM(CDDB_LOG_NONE));
+
+  rb_define_const(cddb_mod_rb,"CACHE_OFF"   ,INT2NUM(CACHE_OFF));
+  rb_define_const(cddb_mod_rb,"CACHE_ON"    ,INT2NUM(CACHE_ON));
+  rb_define_const(cddb_mod_rb,"CACHE_ONLY"  ,INT2NUM(CACHE_ONLY));
+
+  rb_define_const(cddb_mod_rb,"SEARCH_NONE"   ,INT2NUM(SEARCH_NONE));
+  rb_define_const(cddb_mod_rb,"SEARCH_ARTIST" ,INT2NUM(SEARCH_ARTIST));
+  rb_define_const(cddb_mod_rb,"SEARCH_TITLE"  ,INT2NUM(SEARCH_TITLE));
+  rb_define_const(cddb_mod_rb,"SEARCH_TRACK"  ,INT2NUM(SEARCH_TRACK));
+  rb_define_const(cddb_mod_rb,"SEARCH_OTHER"  ,INT2NUM(SEARCH_OTHER));
+  rb_define_const(cddb_mod_rb,"SEARCH_ALL"    ,INT2NUM(SEARCH_ALL));
+
+
+
+  rb_define_global_function("frame2sec",crb_cddb_frame2sec,1);
+  rb_define_global_function("sec2frame",crb_cddb_sec2frame,1); 
+  rb_define_global_function("searchcat",crb_cddb_searchcat,1); 
+
+}

data/ext/cddb_mod.h

@@ -0,0 +1,11 @@
+#ifndef CONN_HEADER
+#define CONN_HEADER
+
+#include<ruby.h>
+#include<cddb/cddb.h>
+
+extern VALUE cddb_mod_rb;
+
+void init_cddb_mod();
+
+#endif

data/ext/cddb_rb.c

@@ -0,0 +1,15 @@
+#include<ruby.h>
+
+#include "cddb_mod.h"
+#include "cddb_conn.h"
+#include "cddb_disc.h"
+#include "cddb_track.h"
+#include "cddb_mod.h"
+
+void Init_rbcddb() {
+  init_cddb_conn();
+  init_cddb_disc();
+  init_cddb_track();
+  init_cddb_mod();
+
+}