ruby: Kill garbage collection related cruft.

Let the user destroy objects that she wants explicitly.
It's not possible to specify the order objects are garbage collected.
See id:86y6f8v838.fsf@harikalardiyari.ev on ruby-talk for more
information.

12 files changed, 383 insertions, 662 deletions

diff --git a/bindings/ruby/database.c b/bindings/ruby/database.c
index fae5af28..e767819b 100644
--- a/bindings/ruby/database.c
+++ b/bindings/ruby/database.c
@@ -32,8 +32,8 @@ notmuch_rb_database_new(int argc, VALUE *argv, VALUE klass)
 {
     const char *path;
     int create, mode;
-    notmuch_rb_database_t *db;
-    VALUE modev, dbv;
+    notmuch_database_t *db;
+    VALUE modev;
 
 #if !defined(RSTRING_PTR)
 #define RSTRING_PTR(v) (RSTRING((v))->ptr)
@@ -70,12 +70,11 @@ notmuch_rb_database_new(int argc, VALUE *argv, VALUE klass)
         mode = NOTMUCH_DATABASE_MODE_READ_ONLY;
     }
 
-    dbv = Data_Make_Struct(klass, notmuch_rb_database_t, NULL, notmuch_rb_database_free, db);
-    db->nm_db = create ? notmuch_database_create(path) : notmuch_database_open(path, mode);
-    if (!db->nm_db)
+    db = create ? notmuch_database_create(path) : notmuch_database_open(path, mode);
+    if (!db)
         rb_raise(notmuch_rb_eDatabaseError, "failed to open database");
 
-    return dbv;
+    return Data_Wrap_Struct(klass, NULL, NULL, db);
 }
 
 /*
@@ -86,13 +85,10 @@ notmuch_rb_database_new(int argc, VALUE *argv, VALUE klass)
 VALUE
 notmuch_rb_database_close(VALUE self)
 {
-    notmuch_rb_database_t *db;
+    notmuch_database_t *db;
 
-    Data_Get_Struct(self, notmuch_rb_database_t, db);
-    if (db->nm_db) {
-        notmuch_database_close(db->nm_db);
-        db->nm_db = NULL;
-    }
+    Data_Get_Struct(self, notmuch_database_t, db);
+    notmuch_database_close(db);
 
     return Qnil;
 }
@@ -105,13 +101,11 @@ notmuch_rb_database_close(VALUE self)
 VALUE
 notmuch_rb_database_path(VALUE self)
 {
-    notmuch_rb_database_t *db;
+    notmuch_database_t *db;
 
-    Data_Get_Struct(self, notmuch_rb_database_t, db);
-    if (!db->nm_db)
-        rb_raise(rb_eRuntimeError, "Database closed");
+    Data_Get_Struct(self, notmuch_database_t, db);
 
-    return rb_str_new2(notmuch_database_get_path(db->nm_db));
+    return rb_str_new2(notmuch_database_get_path(db));
 }
 
 /*
@@ -122,13 +116,11 @@ notmuch_rb_database_path(VALUE self)
 VALUE
 notmuch_rb_database_version(VALUE self)
 {
-    notmuch_rb_database_t *db;
+    notmuch_database_t *db;
 
-    Data_Get_Struct(self, notmuch_rb_database_t, db);
-    if (!db->nm_db)
-        rb_raise(rb_eRuntimeError, "Database closed");
+    Data_Get_Struct(self, notmuch_database_t, db);
 
-    return INT2FIX(notmuch_database_get_version(db->nm_db));
+    return INT2FIX(notmuch_database_get_version(db));
 }
 
 /*
@@ -139,13 +131,11 @@ notmuch_rb_database_version(VALUE self)
 VALUE
 notmuch_rb_database_needs_upgrade(VALUE self)
 {
-    notmuch_rb_database_t *db;
+    notmuch_database_t *db;
 
-    Data_Get_Struct(self, notmuch_rb_database_t, db);
-    if (!db->nm_db)
-        rb_raise(rb_eRuntimeError, "Database closed");
+    Data_Get_Struct(self, notmuch_database_t, db);
 
-    return notmuch_database_needs_upgrade(db->nm_db) ? Qtrue : Qfalse;
+    return notmuch_database_needs_upgrade(db) ? Qtrue : Qfalse;
 }
 
 static void
@@ -168,12 +158,10 @@ notmuch_rb_database_upgrade(VALUE self)
 {
     notmuch_status_t ret;
     void (*pnotify) (void *closure, double progress);
-    notmuch_rb_database_t *db;
+    notmuch_database_t *db;
     VALUE block;
 
-    Data_Get_Struct(self, notmuch_rb_database_t, db);
-    if (!db->nm_db)
-        rb_raise(rb_eRuntimeError, "Database closed");
+    Data_Get_Struct(self, notmuch_database_t, db);
 
     if (rb_block_given_p()) {
         pnotify = notmuch_rb_upgrade_notify;
@@ -182,8 +170,9 @@ notmuch_rb_database_upgrade(VALUE self)
     else
         pnotify = NULL;
 
-    ret = notmuch_database_upgrade(db->nm_db, pnotify, pnotify ? &block : NULL);
+    ret = notmuch_database_upgrade(db, pnotify, pnotify ? &block : NULL);
     notmuch_rb_status_raise(ret);
+
     return Qtrue;
 }
 
@@ -196,13 +185,10 @@ VALUE
 notmuch_rb_database_get_directory(VALUE self, VALUE pathv)
 {
     const char *path;
-    notmuch_rb_directory_t *dir;
-    notmuch_rb_database_t *db;
-    VALUE dirv;
+    notmuch_directory_t *dir;
+    notmuch_database_t *db;
 
-    Data_Get_Struct(self, notmuch_rb_database_t, db);
-    if (!db->nm_db)
-        rb_raise(rb_eRuntimeError, "Database closed");
+    Data_Get_Struct(self, notmuch_database_t, db);
 
 #if !defined(RSTRING_PTR)
 #define RSTRING_PTR(v) (RSTRING((v))->ptr)
@@ -211,20 +197,18 @@ notmuch_rb_database_get_directory(VALUE self, VALUE pathv)
     SafeStringValue(pathv);
     path = RSTRING_PTR(pathv);
 
-    dirv = Data_Make_Struct(notmuch_rb_cDirectory, notmuch_rb_directory_t,
-            notmuch_rb_directory_mark, notmuch_rb_directory_free, dir);
-    dir->nm_dir = notmuch_database_get_directory(db->nm_db, path);
-    dir->db = self;
-    if (!dir->nm_dir)
+    dir = notmuch_database_get_directory(db, path);
+    if (!dir)
         rb_raise(notmuch_rb_eXapianError, "Xapian exception");
 
-    return dirv;
+    return Data_Wrap_Struct(notmuch_rb_cDirectory, NULL, NULL, dir);
 }
 
 /*
  * call-seq: DB.add_message(path) => MESSAGE, isdup
  *
- * Add a message to the database and return it
+ * Add a message to the database and return it.
+ *
  * +isdup+ is a boolean that specifies whether the added message was a
  * duplicate.
  */
@@ -233,13 +217,10 @@ notmuch_rb_database_add_message(VALUE self, VALUE pathv)
 {
     const char *path;
     notmuch_status_t ret;
-    notmuch_rb_message_t *message;
-    notmuch_rb_database_t *db;
-    VALUE messagev;
+    notmuch_message_t *message;
+    notmuch_database_t *db;
 
-    Data_Get_Struct(self, notmuch_rb_database_t, db);
-    if (!db->nm_db)
-        rb_raise(rb_eRuntimeError, "Database closed");
+    Data_Get_Struct(self, notmuch_database_t, db);
 
 #if !defined(RSTRING_PTR)
 #define RSTRING_PTR(v) (RSTRING((v))->ptr)
@@ -248,18 +229,17 @@ notmuch_rb_database_add_message(VALUE self, VALUE pathv)
     SafeStringValue(pathv);
     path = RSTRING_PTR(pathv);
 
-    messagev = Data_Make_Struct(notmuch_rb_cMessage, notmuch_rb_message_t,
-            notmuch_rb_message_mark, notmuch_rb_message_free, message);
-    ret = notmuch_database_add_message(db->nm_db, path, &message->nm_message);
-    message->parent = self;
+    ret = notmuch_database_add_message(db, path, &message);
     notmuch_rb_status_raise(ret);
-    return rb_assoc_new(messagev, (ret == NOTMUCH_STATUS_DUPLICATE_MESSAGE_ID) ? Qtrue : Qfalse);
+    return rb_assoc_new(Data_Wrap_Struct(notmuch_rb_cMessage, NULL, NULL, message),
+        (ret == NOTMUCH_STATUS_DUPLICATE_MESSAGE_ID) ? Qtrue : Qfalse);
 }
 
 /*
  * call-seq: DB.remove_message(path) => isdup
  *
  * Remove a message from the database.
+ *
  * +isdup+ is a boolean that specifies whether the removed message was a
  * duplicate.
  */
@@ -268,11 +248,9 @@ notmuch_rb_database_remove_message(VALUE self, VALUE pathv)
 {
     const char *path;
     notmuch_status_t ret;
-    notmuch_rb_database_t *db;
+    notmuch_database_t *db;
 
-    Data_Get_Struct(self, notmuch_rb_database_t, db);
-    if (!db->nm_db)
-        rb_raise(rb_eRuntimeError, "Database closed");
+    Data_Get_Struct(self, notmuch_database_t, db);
 
 #if !defined(RSTRING_PTR)
 #define RSTRING_PTR(v) (RSTRING((v))->ptr)
@@ -281,7 +259,7 @@ notmuch_rb_database_remove_message(VALUE self, VALUE pathv)
     SafeStringValue(pathv);
     path = RSTRING_PTR(pathv);
 
-    ret = notmuch_database_remove_message(db->nm_db, path);
+    ret = notmuch_database_remove_message(db, path);
     notmuch_rb_status_raise(ret);
     return (ret == NOTMUCH_STATUS_DUPLICATE_MESSAGE_ID) ? Qtrue : Qfalse;
 }
@@ -295,13 +273,10 @@ VALUE
 notmuch_rb_database_query_create(VALUE self, VALUE qstrv)
 {
     const char *qstr;
-    notmuch_rb_query_t *query;
-    notmuch_rb_database_t *db;
-    VALUE queryv;
+    notmuch_query_t *query;
+    notmuch_database_t *db;
 
-    Data_Get_Struct(self, notmuch_rb_database_t, db);
-    if (!db->nm_db)
-        rb_raise(rb_eRuntimeError, "Database closed");
+    Data_Get_Struct(self, notmuch_database_t, db);
 
 #if !defined(RSTRING_PTR)
 #define RSTRING_PTR(v) (RSTRING((v))->ptr)
@@ -310,12 +285,9 @@ notmuch_rb_database_query_create(VALUE self, VALUE qstrv)
     SafeStringValue(qstrv);
     qstr = RSTRING_PTR(qstrv);
 
-    queryv = Data_Make_Struct(notmuch_rb_cQuery, notmuch_rb_query_t,
-            notmuch_rb_query_mark, notmuch_rb_query_free, query);
-    query->nm_query = notmuch_query_create(db->nm_db, qstr);
-    query->db = self;
-    if (!query->nm_query)
+    query = notmuch_query_create(db, qstr);
+    if (!query)
         rb_raise(notmuch_rb_eMemoryError, "out of memory");
 
-    return queryv;
+    return Data_Wrap_Struct(notmuch_rb_cQuery, NULL, NULL, query);
 }
diff --git a/bindings/ruby/defs.h b/bindings/ruby/defs.h
index 1973d26e..f36b7227 100644
--- a/bindings/ruby/defs.h
+++ b/bindings/ruby/defs.h
@@ -49,106 +49,10 @@ ID ID_call;
 ID ID_db_create;
 ID ID_db_mode;
 
-typedef struct {
-    notmuch_database_t *nm_db;
-} notmuch_rb_database_t;
-
-typedef struct {
-    notmuch_directory_t *nm_dir;
-    VALUE db;
-} notmuch_rb_directory_t;
-
-typedef struct {
-    notmuch_filenames_t *nm_flist;
-    VALUE dir;
-} notmuch_rb_filenames_t;
-
-typedef struct {
-    notmuch_query_t *nm_query;
-    VALUE db;
-} notmuch_rb_query_t;
-
-typedef struct {
-    notmuch_threads_t *nm_threads;
-    VALUE query;
-} notmuch_rb_threads_t;
-
-typedef struct {
-    notmuch_messages_t *nm_messages;
-    VALUE parent;
-} notmuch_rb_messages_t;
-
-typedef struct {
-    notmuch_thread_t *nm_thread;
-    VALUE threads;
-} notmuch_rb_thread_t;
-
-typedef struct {
-    notmuch_message_t *nm_message;
-    VALUE parent;
-} notmuch_rb_message_t;
-
-typedef struct {
-    notmuch_tags_t *nm_tags;
-    VALUE parent;
-} notmuch_rb_tags_t;
-
 /* status.c */
 void
 notmuch_rb_status_raise(notmuch_status_t status);
 
-/* gc.c */
-void
-notmuch_rb_database_free(notmuch_rb_database_t *db);
-
-void
-notmuch_rb_directory_mark(notmuch_rb_directory_t *dir);
-
-void
-notmuch_rb_directory_free(notmuch_rb_directory_t *dir);
-
-void
-notmuch_rb_filenames_mark(notmuch_rb_filenames_t *flist);
-
-void
-notmuch_rb_filenames_free(notmuch_rb_filenames_t *flist);
-
-void
-notmuch_rb_query_mark(notmuch_rb_query_t *query);
-
-void
-notmuch_rb_query_free(notmuch_rb_query_t *query);
-
-void
-notmuch_rb_threads_mark(notmuch_rb_threads_t *threads);
-
-void
-notmuch_rb_threads_free(notmuch_rb_threads_t *threads);
-
-void
-notmuch_rb_messages_mark(notmuch_rb_messages_t *messages);
-
-void
-notmuch_rb_messages_free(notmuch_rb_messages_t *messages);
-
-void
-notmuch_rb_thread_mark(notmuch_rb_thread_t *thread);
-
-void
-notmuch_rb_thread_free(notmuch_rb_thread_t *thread);
-
-void
-notmuch_rb_message_mark(notmuch_rb_message_t *message);
-
-void
-notmuch_rb_message_free(notmuch_rb_message_t *message);
-
-void
-notmuch_rb_tags_mark(notmuch_rb_tags_t *tags);
-
-void
-notmuch_rb_tags_free(notmuch_rb_tags_t *tags);
-
 /* database.c */
 VALUE
 notmuch_rb_database_new(int argc, VALUE *argv, VALUE klass);
@@ -182,6 +86,9 @@ notmuch_rb_database_query_create(VALUE self, VALUE qstrv);
 
 /* directory.c */
 VALUE
+notmuch_rb_directory_destroy(VALUE self);
+
+VALUE
 notmuch_rb_directory_get_mtime(VALUE self);
 
 VALUE
@@ -195,10 +102,16 @@ notmuch_rb_directory_get_child_directories(VALUE self);
 
 /* filenames.c */
 VALUE
+notmuch_rb_filenames_destroy(VALUE self);
+
+VALUE
 notmuch_rb_filenames_each(VALUE self);
 
 /* query.c */
 VALUE
+notmuch_rb_query_destroy(VALUE self);
+
+VALUE
 notmuch_rb_query_set_sort(VALUE self, VALUE sortv);
 
 VALUE
@@ -209,10 +122,16 @@ notmuch_rb_query_search_messages(VALUE self);
 
 /* threads.c */
 VALUE
+notmuch_rb_threads_destroy(VALUE self);
+
+VALUE
 notmuch_rb_threads_each(VALUE self);
 
 /* messages.c */
 VALUE
+notmuch_rb_messages_destroy(VALUE self);
+
+VALUE
 notmuch_rb_messages_each(VALUE self);
 
 VALUE
@@ -220,6 +139,9 @@ notmuch_rb_messages_collect_tags(VALUE self);
 
 /* thread.c */
 VALUE
+notmuch_rb_thread_destroy(VALUE self);
+
+VALUE
 notmuch_rb_thread_get_thread_id(VALUE self);
 
 VALUE
@@ -248,6 +170,9 @@ notmuch_rb_thread_get_tags(VALUE self);
 
 /* message.c */
 VALUE
+notmuch_rb_message_destroy(VALUE self);
+
+VALUE
 notmuch_rb_message_get_message_id(VALUE self);
 
 VALUE
@@ -291,6 +216,9 @@ notmuch_rb_message_thaw(VALUE self);
 
 /* tags.c */
 VALUE
+notmuch_rb_tags_destroy(VALUE self);
+
+VALUE
 notmuch_rb_tags_each(VALUE self);
 
 /* init.c */
diff --git a/bindings/ruby/directory.c b/bindings/ruby/directory.c
index 46fe11cf..e73658c1 100644
--- a/bindings/ruby/directory.c
+++ b/bindings/ruby/directory.c
@@ -21,6 +21,23 @@
 #include "defs.h"
 
 /*
+ * call-seq: DIR.destroy => nil
+ *
+ * Destroys the directory, freeing all resources allocated for it.
+ */
+VALUE
+notmuch_rb_directory_destroy(VALUE self)
+{
+    notmuch_directory_t *dir;
+
+    Data_Get_Struct(self, notmuch_directory_t, dir);
+
+    notmuch_directory_destroy(dir);
+
+    return Qnil;
+}
+
+/*
  * call-seq: DIR.mtime => fixnum
  *
  * Returns the mtime of the directory or +0+ if no mtime has been previously
@@ -29,11 +46,11 @@
 VALUE
 notmuch_rb_directory_get_mtime(VALUE self)
 {
-    notmuch_rb_directory_t *dir;
+    notmuch_directory_t *dir;
 
-    Data_Get_Struct(self, notmuch_rb_directory_t, dir);
+    Data_Get_Struct(self, notmuch_directory_t, dir);
 
-    return UINT2NUM(notmuch_directory_get_mtime(dir->nm_dir));
+    return UINT2NUM(notmuch_directory_get_mtime(dir));
 }
 
 /*
@@ -45,15 +62,16 @@ VALUE
 notmuch_rb_directory_set_mtime(VALUE self, VALUE mtimev)
 {
     notmuch_status_t ret;
-    notmuch_rb_directory_t *dir;
+    notmuch_directory_t *dir;
 
-    Data_Get_Struct(self, notmuch_rb_directory_t, dir);
+    Data_Get_Struct(self, notmuch_directory_t, dir);
 
     if (!FIXNUM_P(mtimev))
         rb_raise(rb_eTypeError, "First argument not a fixnum");
 
-    ret = notmuch_directory_set_mtime(dir->nm_dir, FIX2UINT(mtimev));
+    ret = notmuch_directory_set_mtime(dir, FIX2UINT(mtimev));
     notmuch_rb_status_raise(ret);
+
     return Qtrue;
 }
 
@@ -66,18 +84,14 @@ notmuch_rb_directory_set_mtime(VALUE self, VALUE mtimev)
 VALUE
 notmuch_rb_directory_get_child_files(VALUE self)
 {
-    notmuch_rb_directory_t *dir;
-    notmuch_rb_filenames_t *flist;
-    VALUE flistv;
+    notmuch_directory_t *dir;
+    notmuch_filenames_t *fnames;
 
-    Data_Get_Struct(self, notmuch_rb_directory_t, dir);
+    Data_Get_Struct(self, notmuch_directory_t, dir);
 
-    flistv = Data_Make_Struct(notmuch_rb_cFileNames, notmuch_rb_filenames_t,
-            notmuch_rb_filenames_mark, notmuch_rb_filenames_free, flist);
-    flist->dir = self;
-    flist->nm_flist = notmuch_directory_get_child_files(dir->nm_dir);
+    fnames = notmuch_directory_get_child_files(dir);
 
-    return flistv;
+    return Data_Wrap_Struct(notmuch_rb_cFileNames, NULL, NULL, fnames);
 }
 
 /*
@@ -89,16 +103,12 @@ notmuch_rb_directory_get_child_files(VALUE self)
 VALUE
 notmuch_rb_directory_get_child_directories(VALUE self)
 {
-    notmuch_rb_directory_t *dir;
-    notmuch_rb_filenames_t *flist;
-    VALUE flistv;
+    notmuch_directory_t *dir;
+    notmuch_filenames_t *fnames;
 
-    Data_Get_Struct(self, notmuch_rb_directory_t, dir);
+    Data_Get_Struct(self, notmuch_directory_t, dir);
 
-    flistv = Data_Make_Struct(notmuch_rb_cFileNames, notmuch_rb_filenames_t,
-            notmuch_rb_filenames_mark, notmuch_rb_filenames_free, flist);
-    flist->dir = self;
-    flist->nm_flist = notmuch_directory_get_child_directories(dir->nm_dir);
+    fnames = notmuch_directory_get_child_directories(dir);
 
-    return flistv;
+    return Data_Wrap_Struct(notmuch_rb_cFileNames, NULL, NULL, fnames);
 }
diff --git a/bindings/ruby/filenames.c b/bindings/ruby/filenames.c
index 44a16522..23553ab1 100644
--- a/bindings/ruby/filenames.c
+++ b/bindings/ruby/filenames.c
@@ -21,6 +21,23 @@
 #include "defs.h"
 
 /*
+ * call-seq: FILENAMES.destroy => nil
+ *
+ * Destroys the filenames, freeing all resources allocated for it.
+ */
+VALUE
+notmuch_rb_filenames_destroy(VALUE self)
+{
+    notmuch_filenames_t *fnames;
+
+    Data_Get_Struct(self, notmuch_filenames_t, fnames);
+
+    notmuch_filenames_destroy(fnames);
+
+    return Qnil;
+}
+
+/*
  * call-seq: FILENAMES.each {|item| block } => FILENAMES
  *
  * Calls +block+ once for each element in +self+, passing that element as a
@@ -29,15 +46,14 @@
 VALUE
 notmuch_rb_filenames_each(VALUE self)
 {
-    notmuch_rb_filenames_t *flist;
+    notmuch_filenames_t *fnames;
 
-    Data_Get_Struct(self, notmuch_rb_filenames_t, flist);
-    if (!flist->nm_flist)
+    Data_Get_Struct(self, notmuch_filenames_t, fnames);
+    if (!fnames)
         return self;
 
-    for (; notmuch_filenames_valid(flist->nm_flist);
-            notmuch_filenames_move_to_next(flist->nm_flist))
-        rb_yield(rb_str_new2(notmuch_filenames_get(flist->nm_flist)));
+    for (; notmuch_filenames_valid(fnames); notmuch_filenames_move_to_next(fnames))
+        rb_yield(rb_str_new2(notmuch_filenames_get(fnames)));
 
     return self;
 }
diff --git a/bindings/ruby/gc.c b/bindings/ruby/gc.c
deleted file mode 100644
index 37b089f4..00000000
--- a/bindings/ruby/gc.c
+++ /dev/null
@@ -1,288 +0,0 @@
-/* The Ruby interface to the notmuch mail library
- *
- * Copyright © 2010 Ali Polatel
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program 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 General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see http://www.gnu.org/licenses/ .
- *
- * Author: Ali Polatel <alip@exherbo.org>
- */
-
-#include "defs.h"
-
-#include <stdlib.h>
-
-static notmuch_rb_database_t *
-_notmuch_rb_messages_db(notmuch_rb_messages_t *messages);
-
-static notmuch_rb_database_t *
-_notmuch_rb_message_db(notmuch_rb_message_t *message)
-{
-    notmuch_rb_messages_t *messages;
-    notmuch_rb_database_t *db;
-
-    if (rb_obj_is_instance_of(message->parent, notmuch_rb_cDatabase)) {
-        Data_Get_Struct(message->parent, notmuch_rb_database_t, db);
-    }
-    else if (rb_obj_is_instance_of(message->parent, notmuch_rb_cMessages)) {
-        Data_Get_Struct(message->parent, notmuch_rb_messages_t, messages);
-        db = _notmuch_rb_messages_db(messages);
-    }
-    else
-        db = NULL;
-
-    return db;
-}
-
-static notmuch_rb_database_t *
-_notmuch_rb_messages_db(notmuch_rb_messages_t *messages)
-{
-    notmuch_rb_query_t *query;
-    notmuch_rb_thread_t *thread;
-    notmuch_rb_message_t *message;
-    notmuch_rb_threads_t *threads;
-    notmuch_rb_database_t *db;
-
-    if (rb_obj_is_instance_of(messages->parent, notmuch_rb_cQuery)) {
-        Data_Get_Struct(messages->parent, notmuch_rb_query_t, query);
-        Data_Get_Struct(query->db, notmuch_rb_database_t, db);
-    }
-    else if (rb_obj_is_instance_of(messages->parent, notmuch_rb_cThread)) {
-        Data_Get_Struct(messages->parent, notmuch_rb_thread_t, thread);
-        Data_Get_Struct(thread->threads, notmuch_rb_threads_t, threads);
-        Data_Get_Struct(threads->query, notmuch_rb_query_t, query);
-        Data_Get_Struct(query->db, notmuch_rb_database_t, db);
-    }
-    else if (rb_obj_is_instance_of(messages->parent, notmuch_rb_cMessage)) {
-        Data_Get_Struct(messages->parent, notmuch_rb_message_t, message);
-        db = _notmuch_rb_message_db(message);
-    }
-    else
-        db = NULL;
-
-    return db;
-}
-
-static notmuch_rb_database_t *
-_notmuch_rb_thread_db(notmuch_rb_thread_t *thread)
-{
-    notmuch_rb_threads_t *threads;
-    notmuch_rb_query_t *query;
-    notmuch_rb_database_t *db;
-
-    Data_Get_Struct(thread->threads, notmuch_rb_threads_t, threads);
-    Data_Get_Struct(threads->query, notmuch_rb_query_t, query);
-    Data_Get_Struct(query->db, notmuch_rb_database_t, db);
-
-    return db;
-}
-
-void
-notmuch_rb_database_free(notmuch_rb_database_t *db)
-{
-    if (db->nm_db)
-        notmuch_database_close(db->nm_db);
-
-    free(db);
-}
-
-void
-notmuch_rb_directory_mark(notmuch_rb_directory_t *dir)
-{
-    rb_gc_mark(dir->db);
-}
-
-void
-notmuch_rb_directory_free(notmuch_rb_directory_t *dir)
-{
-    notmuch_rb_database_t *db;
-
-    if (rb_obj_is_instance_of(dir->db, notmuch_rb_cDatabase))
-        Data_Get_Struct(dir->db, notmuch_rb_database_t, db);
-    else
-        db = NULL;
-
-    if (db && db->nm_db && dir->nm_dir)
-        notmuch_directory_destroy(dir->nm_dir);
-
-    free(dir);
-}
-
-void
-notmuch_rb_filenames_mark(notmuch_rb_filenames_t *flist)
-{
-    rb_gc_mark(flist->dir);
-}
-
-void
-notmuch_rb_filenames_free(notmuch_rb_filenames_t *flist)
-{
-    notmuch_rb_directory_t *dir;
-    notmuch_rb_database_t *db;
-
-    if (rb_obj_is_instance_of(flist->dir, notmuch_rb_cDirectory)) {
-        Data_Get_Struct(flist->dir, notmuch_rb_directory_t, dir);
-        if (rb_obj_is_instance_of(dir->db, notmuch_rb_cDatabase))
-           Data_Get_Struct(dir->db, notmuch_rb_database_t, db);
-        else
-            db = NULL;
-    }
-    else
-        db = NULL;
-
-    if (db && db->nm_db && flist->nm_flist)
-        notmuch_filenames_destroy(flist->nm_flist);
-
-    free(flist);
-}
-
-void
-notmuch_rb_query_mark(notmuch_rb_query_t *query)
-{
-    rb_gc_mark(query->db);
-}
-
-void
-notmuch_rb_query_free(notmuch_rb_query_t *query)
-{
-    notmuch_rb_database_t *db;
-
-    if (rb_obj_is_instance_of(query->db, notmuch_rb_cDatabase))
-        Data_Get_Struct(query->db, notmuch_rb_database_t, db);
-    else
-        db = NULL;
-
-    if (db && db->nm_db && query->nm_query)
-        notmuch_query_destroy(query->nm_query);
-
-    free(query);
-}
-
-void
-notmuch_rb_threads_mark(notmuch_rb_threads_t *threads)
-{
-    rb_gc_mark(threads->query);
-}
-
-void
-notmuch_rb_threads_free(notmuch_rb_threads_t *threads)
-{
-    notmuch_rb_query_t *query;
-    notmuch_rb_database_t *db;
-
-    if (rb_obj_is_instance_of(threads->query, notmuch_rb_cQuery)) {
-        Data_Get_Struct(threads->query, notmuch_rb_query_t, query);
-        if (rb_obj_is_instance_of(query->db, notmuch_rb_cDatabase))
-            Data_Get_Struct(query->db, notmuch_rb_database_t, db);
-        else
-            db = NULL;
-    }
-    else
-        db = NULL;
-
-    if (db && db->nm_db && threads->nm_threads)
-        notmuch_threads_destroy(threads->nm_threads);
-
-    free(threads);
-}
-
-void
-notmuch_rb_messages_mark(notmuch_rb_messages_t *messages)
-{
-    rb_gc_mark(messages->parent);
-}
-
-void
-notmuch_rb_messages_free(notmuch_rb_messages_t *messages)
-{
-    notmuch_rb_database_t *db;
-
-    db = _notmuch_rb_messages_db(messages);
-
-    if (db && db->nm_db && messages->nm_messages)
-        notmuch_messages_destroy(messages->nm_messages);
-
-    free(messages);
-}
-
-void
-notmuch_rb_thread_mark(notmuch_rb_thread_t *thread)
-{
-    rb_gc_mark(thread->threads);
-}
-
-void
-notmuch_rb_thread_free(notmuch_rb_thread_t *thread)
-{
-    notmuch_rb_database_t *db;
-
-    db = _notmuch_rb_thread_db(thread);
-
-    if (db && db->nm_db && thread->nm_thread)
-        notmuch_thread_destroy(thread->nm_thread);
-
-    free(thread);
-}
-
-void
-notmuch_rb_message_mark(notmuch_rb_message_t *message)
-{
-    rb_gc_mark(message->parent);
-}
-
-void
-notmuch_rb_message_free(notmuch_rb_message_t *message)
-{
-    notmuch_rb_database_t *db;
-
-    db = _notmuch_rb_message_db(message);
-    if (db && db->nm_db && message->nm_message)
-        notmuch_message_destroy(message->nm_message);
-
-    free(message);
-}
-
-void
-notmuch_rb_tags_mark(notmuch_rb_tags_t *tags)
-{
-    rb_gc_mark(tags->parent);
-}
-
-void
-notmuch_rb_tags_free(notmuch_rb_tags_t *tags)
-{
-    notmuch_rb_message_t *message;
-    notmuch_rb_messages_t *messages;
-    notmuch_rb_thread_t *thread;
-    notmuch_rb_database_t *db;
-
-    if (rb_obj_is_instance_of(tags->parent, notmuch_rb_cThread)) {
-        Data_Get_Struct(tags->parent, notmuch_rb_thread_t, thread);
-        db = _notmuch_rb_thread_db(thread);
-    }
-    else if (rb_obj_is_instance_of(tags->parent, notmuch_rb_cMessage)) {
-        Data_Get_Struct(tags->parent, notmuch_rb_message_t, message);
-        db = _notmuch_rb_message_db(message);
-    }
-    else if (rb_obj_is_instance_of(tags->parent, notmuch_rb_cMessages)) {
-        Data_Get_Struct(tags->parent, notmuch_rb_messages_t, messages);
-        db = _notmuch_rb_messages_db(messages);
-    }
-    else
-        return;
-
-    if (db && db->nm_db && tags->nm_tags)
-        notmuch_tags_destroy(tags->nm_tags);
-
-    free(tags);
-}
diff --git a/bindings/ruby/init.c b/bindings/ruby/init.c
index 61077ccb..4fdd018c 100644
--- a/bindings/ruby/init.c
+++ b/bindings/ruby/init.c
@@ -207,6 +207,7 @@ Init_notmuch(void)
 
     notmuch_rb_cDirectory = rb_define_class_under(mod, "Directory", rb_cObject);
     rb_undef_method(notmuch_rb_cDirectory, "initialize");
+    rb_define_method(notmuch_rb_cDirectory, "destroy", notmuch_rb_directory_destroy, 0);
     rb_define_method(notmuch_rb_cDirectory, "mtime", notmuch_rb_directory_get_mtime, 0);
     rb_define_method(notmuch_rb_cDirectory, "mtime=", notmuch_rb_directory_set_mtime, 1);
     rb_define_method(notmuch_rb_cDirectory, "child_files", notmuch_rb_directory_get_child_files, 0);
@@ -214,28 +215,33 @@ Init_notmuch(void)
 
     notmuch_rb_cFileNames = rb_define_class_under(mod, "FileNames", rb_cObject);
     rb_undef_method(notmuch_rb_cFileNames, "initialize");
+    rb_define_method(notmuch_rb_cFileNames, "destroy", notmuch_rb_filenames_destroy, 0);
     rb_define_method(notmuch_rb_cFileNames, "each", notmuch_rb_filenames_each, 0);
     rb_include_module(notmuch_rb_cFileNames, rb_mEnumerable);
 
     notmuch_rb_cQuery = rb_define_class_under(mod, "Query", rb_cObject);
     rb_undef_method(notmuch_rb_cQuery, "initialize");
+    rb_define_method(notmuch_rb_cQuery, "destroy", notmuch_rb_query_destroy, 0);
     rb_define_method(notmuch_rb_cQuery, "sort=", notmuch_rb_query_set_sort, 1);
     rb_define_method(notmuch_rb_cQuery, "search_threads", notmuch_rb_query_search_threads, 0);
     rb_define_method(notmuch_rb_cQuery, "search_messages", notmuch_rb_query_search_messages, 0);
 
     notmuch_rb_cThreads = rb_define_class_under(mod, "Threads", rb_cObject);
     rb_undef_method(notmuch_rb_cThreads, "initialize");
+    rb_define_method(notmuch_rb_cThreads, "destroy", notmuch_rb_threads_destroy, 0);
     rb_define_method(notmuch_rb_cThreads, "each", notmuch_rb_threads_each, 0);
     rb_include_module(notmuch_rb_cThreads, rb_mEnumerable);
 
     notmuch_rb_cMessages = rb_define_class_under(mod, "Messages", rb_cObject);
     rb_undef_method(notmuch_rb_cMessages, "initialize");
+    rb_define_method(notmuch_rb_cMessages, "destroy", notmuch_rb_messages_destroy, 0);
     rb_define_method(notmuch_rb_cMessages, "each", notmuch_rb_messages_each, 0);
     rb_define_method(notmuch_rb_cMessages, "tags", notmuch_rb_messages_collect_tags, 0);
     rb_include_module(notmuch_rb_cMessages, rb_mEnumerable);
 
     notmuch_rb_cThread = rb_define_class_under(mod, "Thread", rb_cObject);
     rb_undef_method(notmuch_rb_cThread, "initialize");
+    rb_define_method(notmuch_rb_cThread, "destroy", notmuch_rb_thread_destroy, 0);
     rb_define_method(notmuch_rb_cThread, "thread_id", notmuch_rb_thread_get_thread_id, 0);
     rb_define_method(notmuch_rb_cThread, "total_messages", notmuch_rb_thread_get_total_messages, 0);
     rb_define_method(notmuch_rb_cThread, "toplevel_messages", notmuch_rb_thread_get_toplevel_messages, 0);
@@ -248,6 +254,7 @@ Init_notmuch(void)
 
     notmuch_rb_cMessage = rb_define_class_under(mod, "Message", rb_cObject);
     rb_undef_method(notmuch_rb_cMessage, "initialize");
+    rb_define_method(notmuch_rb_cMessage, "destroy", notmuch_rb_message_destroy, 0);
     rb_define_method(notmuch_rb_cMessage, "message_id", notmuch_rb_message_get_message_id, 0);
     rb_define_method(notmuch_rb_cMessage, "thread_id", notmuch_rb_message_get_thread_id, 0);
     rb_define_method(notmuch_rb_cMessage, "replies", notmuch_rb_message_get_replies, 0);
@@ -267,6 +274,7 @@ Init_notmuch(void)
 
     notmuch_rb_cTags = rb_define_class_under(mod, "Tags", rb_cObject);
     rb_undef_method(notmuch_rb_cTags, "initialize");
+    rb_define_method(notmuch_rb_cTags, "destroy", notmuch_rb_tags_destroy, 0);
     rb_define_method(notmuch_rb_cTags, "each", notmuch_rb_tags_each, 0);
     rb_include_module(notmuch_rb_cTags, rb_mEnumerable);
 }
diff --git a/bindings/ruby/message.c b/bindings/ruby/message.c
index 6c7a0391..2babfd04 100644
--- a/bindings/ruby/message.c
+++ b/bindings/ruby/message.c
@@ -21,6 +21,23 @@
 #include "defs.h"
 
 /*
+ * call-seq: MESSAGE.destroy => nil
+ *
+ * Destroys the message, freeing all resources allocated for it.
+ */
+VALUE
+notmuch_rb_message_destroy(VALUE self)
+{
+    notmuch_message_t *message;
+
+    Data_Get_Struct(self, notmuch_message_t, message);
+
+    notmuch_message_destroy(message);
+
+    return Qnil;
+}
+
+/*
  * call-seq: MESSAGE.message_id => String
  *
  * Get the message ID of 'message'.
@@ -29,12 +46,13 @@ VALUE
 notmuch_rb_message_get_message_id(VALUE self)
 {
     const char *msgid;
-    notmuch_rb_message_t *message;
+    notmuch_message_t *message;
+
+    Data_Get_Struct(self, notmuch_message_t, message);
 
-    Data_Get_Struct(self, notmuch_rb_message_t, message);
+    msgid = notmuch_message_get_message_id(message);
 
-    msgid = notmuch_message_get_message_id(message->nm_message);
-    return msgid ? rb_str_new2(msgid) : Qnil;
+    return rb_str_new2(msgid);
 }
 
 /*
@@ -46,12 +64,13 @@ VALUE
 notmuch_rb_message_get_thread_id(VALUE self)
 {
     const char *tid;
-    notmuch_rb_message_t *message;
+    notmuch_message_t *message;
+
+    Data_Get_Struct(self, notmuch_message_t, message);
 
-    Data_Get_Struct(self, notmuch_rb_message_t, message);
+    tid = notmuch_message_get_thread_id(message);
 
-    tid = notmuch_message_get_thread_id(message->nm_message);
-    return tid ? rb_str_new2(tid) : Qnil;
+    return rb_str_new2(tid);
 }
 
 /*
@@ -62,18 +81,14 @@ notmuch_rb_message_get_thread_id(VALUE self)
 VALUE
 notmuch_rb_message_get_replies(VALUE self)
 {
-    notmuch_rb_messages_t *messages;
-    notmuch_rb_message_t *message;
-    VALUE messagesv;
+    notmuch_messages_t *messages;
+    notmuch_message_t *message;
 
-    Data_Get_Struct(self, notmuch_rb_message_t, message);
+    Data_Get_Struct(self, notmuch_message_t, message);
 
-    messagesv = Data_Make_Struct(notmuch_rb_cMessages, notmuch_rb_messages_t,
-            notmuch_rb_messages_mark, notmuch_rb_messages_free, messages);
-    messages->nm_messages = notmuch_message_get_replies(message->nm_message);
-    messages->parent = self;
+    messages = notmuch_message_get_replies(message);
 
-    return messages->nm_messages ? messagesv : Qnil;
+    return Data_Wrap_Struct(notmuch_rb_cMessages, NULL, NULL, messages);
 }
 
 /*
@@ -85,12 +100,13 @@ VALUE
 notmuch_rb_message_get_filename(VALUE self)
 {
     const char *fname;
-    notmuch_rb_message_t *message;
+    notmuch_message_t *message;
 
-    Data_Get_Struct(self, notmuch_rb_message_t, message);
+    Data_Get_Struct(self, notmuch_message_t, message);
 
-    fname = notmuch_message_get_filename(message->nm_message);
-    return fname ? rb_str_new2(fname) : Qnil;
+    fname = notmuch_message_get_filename(message);
+
+    return rb_str_new2(fname);
 }
 
 /*
@@ -101,14 +117,14 @@ notmuch_rb_message_get_filename(VALUE self)
 VALUE
 notmuch_rb_message_get_flag(VALUE self, VALUE flagv)
 {
-    notmuch_rb_message_t *message;
+    notmuch_message_t *message;
 
-    Data_Get_Struct(self, notmuch_rb_message_t, message);
+    Data_Get_Struct(self, notmuch_message_t, message);
 
     if (!FIXNUM_P(flagv))
         rb_raise(rb_eTypeError, "Flag not a Fixnum");
 
-    return notmuch_message_get_flag(message->nm_message, FIX2INT(flagv)) ? Qtrue : Qfalse;
+    return notmuch_message_get_flag(message, FIX2INT(flagv)) ? Qtrue : Qfalse;
 }
 
 /*
@@ -119,14 +135,15 @@ notmuch_rb_message_get_flag(VALUE self, VALUE flagv)
 VALUE
 notmuch_rb_message_set_flag(VALUE self, VALUE flagv, VALUE valuev)
 {
-    notmuch_rb_message_t *message;
+    notmuch_message_t *message;
 
-    Data_Get_Struct(self, notmuch_rb_message_t, message);
+    Data_Get_Struct(self, notmuch_message_t, message);
 
     if (!FIXNUM_P(flagv))
         rb_raise(rb_eTypeError, "Flag not a Fixnum");
 
-    notmuch_message_set_flag(message->nm_message, FIX2INT(flagv), RTEST(valuev));
+    notmuch_message_set_flag(message, FIX2INT(flagv), RTEST(valuev));
+
     return Qnil;
 }
 
@@ -138,11 +155,11 @@ notmuch_rb_message_set_flag(VALUE self, VALUE flagv, VALUE valuev)
 VALUE
 notmuch_rb_message_get_date(VALUE self)
 {
-    notmuch_rb_message_t *message;
+    notmuch_message_t *message;
 
-    Data_Get_Struct(self, notmuch_rb_message_t, message);
+    Data_Get_Struct(self, notmuch_message_t, message);
 
-    return UINT2NUM(notmuch_message_get_date(message->nm_message));
+    return UINT2NUM(notmuch_message_get_date(message));
 }
 
 /*
@@ -154,9 +171,9 @@ VALUE
 notmuch_rb_message_get_header(VALUE self, VALUE headerv)
 {
     const char *header, *value;
-    notmuch_rb_message_t *message;
+    notmuch_message_t *message;
 
-    Data_Get_Struct(self, notmuch_rb_message_t, message);
+    Data_Get_Struct(self, notmuch_message_t, message);
 
 #if !defined(RSTRING_PTR)
 #define RSTRING_PTR(v) (RSTRING((v))->ptr)
@@ -165,9 +182,9 @@ notmuch_rb_message_get_header(VALUE self, VALUE headerv)
     SafeStringValue(headerv);
     header = RSTRING_PTR(headerv);
 
-    value = notmuch_message_get_header(message->nm_message, header);
+    value = notmuch_message_get_header(message, header);
     if (!value)
-        rb_raise(notmuch_rb_eMemoryError, "out of memory");
+        rb_raise(notmuch_rb_eMemoryError, "Out of memory");
 
     return rb_str_new2(value);
 }
@@ -180,20 +197,16 @@ notmuch_rb_message_get_header(VALUE self, VALUE headerv)
 VALUE
 notmuch_rb_message_get_tags(VALUE self)
 {
-    notmuch_rb_message_t *message;
-    notmuch_rb_tags_t *tags;
-    VALUE tagsv;
+    notmuch_message_t *message;
+    notmuch_tags_t *tags;
 
-    Data_Get_Struct(self, notmuch_rb_message_t, message);
+    Data_Get_Struct(self, notmuch_message_t, message);
 
-    tagsv = Data_Make_Struct(notmuch_rb_cTags, notmuch_rb_tags_t,
-            notmuch_rb_tags_mark, notmuch_rb_tags_free, tags);
-    tags->nm_tags = notmuch_message_get_tags(message->nm_message);
-    tags->parent = self;
-    if (!tags->nm_tags)
-        rb_raise(notmuch_rb_eMemoryError, "out of memory");
+    tags = notmuch_message_get_tags(message);
+    if (!tags)
+        rb_raise(notmuch_rb_eMemoryError, "Out of memory");
 
-    return tagsv;
+    return Data_Wrap_Struct(notmuch_rb_cTags, NULL, NULL, tags);
 }
 
 /*
@@ -206,9 +219,9 @@ notmuch_rb_message_add_tag(VALUE self, VALUE tagv)
 {
     const char *tag;
     notmuch_status_t ret;
-    notmuch_rb_message_t *message;
+    notmuch_message_t *message;
 
-    Data_Get_Struct(self, notmuch_rb_message_t, message);
+    Data_Get_Struct(self, notmuch_message_t, message);
 
 #if !defined(RSTRING_PTR)
 #define RSTRING_PTR(v) (RSTRING((v))->ptr)
@@ -217,8 +230,9 @@ notmuch_rb_message_add_tag(VALUE self, VALUE tagv)
     SafeStringValue(tagv);
     tag = RSTRING_PTR(tagv);
 
-    ret = notmuch_message_add_tag(message->nm_message, tag);
+    ret = notmuch_message_add_tag(message, tag);
     notmuch_rb_status_raise(ret);
+
     return Qtrue;
 }
 
@@ -232,9 +246,9 @@ notmuch_rb_message_remove_tag(VALUE self, VALUE tagv)
 {
     const char *tag;
     notmuch_status_t ret;
-    notmuch_rb_message_t *message;
+    notmuch_message_t *message;
 
-    Data_Get_Struct(self, notmuch_rb_message_t, message);
+    Data_Get_Struct(self, notmuch_message_t, message);
 
 #if !defined(RSTRING_PTR)
 #define RSTRING_PTR(v) (RSTRING((v))->ptr)
@@ -243,8 +257,9 @@ notmuch_rb_message_remove_tag(VALUE self, VALUE tagv)
     SafeStringValue(tagv);
     tag = RSTRING_PTR(tagv);
 
-    ret = notmuch_message_remove_tag(message->nm_message, tag);
+    ret = notmuch_message_remove_tag(message, tag);
     notmuch_rb_status_raise(ret);
+
     return Qtrue;
 }
 
@@ -257,12 +272,13 @@ VALUE
 notmuch_rb_message_remove_all_tags(VALUE self)
 {
     notmuch_status_t ret;
-    notmuch_rb_message_t *message;
+    notmuch_message_t *message;
 
-    Data_Get_Struct(self, notmuch_rb_message_t, message);
+    Data_Get_Struct(self, notmuch_message_t, message);
 
-    ret = notmuch_message_remove_all_tags(message->nm_message);
+    ret = notmuch_message_remove_all_tags(message);
     notmuch_rb_status_raise(ret);
+
     return Qtrue;
 }
 
@@ -275,12 +291,13 @@ VALUE
 notmuch_rb_message_freeze(VALUE self)
 {
     notmuch_status_t ret;
-    notmuch_rb_message_t *message;
+    notmuch_message_t *message;
 
-    Data_Get_Struct(self, notmuch_rb_message_t, message);
+    Data_Get_Struct(self, notmuch_message_t, message);
 
-    ret = notmuch_message_freeze(message->nm_message);
+    ret = notmuch_message_freeze(message);
     notmuch_rb_status_raise(ret);
+
     return Qtrue;
 }
 
@@ -293,11 +310,12 @@ VALUE
 notmuch_rb_message_thaw(VALUE self)
 {
     notmuch_status_t ret;
-    notmuch_rb_message_t *message;
+    notmuch_message_t *message;
 
-    Data_Get_Struct(self, notmuch_rb_message_t, message);
+    Data_Get_Struct(self, notmuch_message_t, message);
 
-    ret = notmuch_message_thaw(message->nm_message);
+    ret = notmuch_message_thaw(message);
     notmuch_rb_status_raise(ret);
+
     return Qtrue;
 }
diff --git a/bindings/ruby/messages.c b/bindings/ruby/messages.c
index 6b296b32..94b0b0da 100644
--- a/bindings/ruby/messages.c
+++ b/bindings/ruby/messages.c
@@ -20,6 +20,23 @@
 
 #include "defs.h"
 
+/*
+ * call-seq: MESSAGES.destroy => nil
+ *
+ * Destroys the messages, freeing all resources allocated for it.
+ */
+VALUE
+notmuch_rb_messages_destroy(VALUE self)
+{
+    notmuch_messages_t *fnames;
+
+    Data_Get_Struct(self, notmuch_messages_t, fnames);
+
+    notmuch_messages_destroy(fnames);
+
+    return Qnil;
+}
+
 /* call-seq: MESSAGES.each {|item| block } => MESSAGES
  *
  * Calls +block+ once for each message in +self+, passing that element as a
@@ -28,22 +45,16 @@
 VALUE
 notmuch_rb_messages_each(VALUE self)
 {
-    notmuch_rb_message_t *message;
-    notmuch_rb_messages_t *messages;
-    VALUE messagev;
+    notmuch_message_t *message;
+    notmuch_messages_t *messages;
 
-    Data_Get_Struct(self, notmuch_rb_messages_t, messages);
-    if (!messages->nm_messages)
+    Data_Get_Struct(self, notmuch_messages_t, messages);
+    if (!messages)
         return self;
 
-    for (; notmuch_messages_valid(messages->nm_messages);
-            notmuch_messages_move_to_next(messages->nm_messages))
-    {
-        messagev = Data_Make_Struct(notmuch_rb_cMessage, notmuch_rb_message_t,
-                notmuch_rb_message_mark, notmuch_rb_message_free, message);
-        message->nm_message = notmuch_messages_get(messages->nm_messages);
-        message->parent = self;
-        rb_yield(messagev);
+    for (; notmuch_messages_valid(messages); notmuch_messages_move_to_next(messages)) {
+        message = notmuch_messages_get(messages);
+        rb_yield(Data_Wrap_Struct(notmuch_rb_cMessage, NULL, NULL, message));
     }
 
     return self;
@@ -57,18 +68,14 @@ notmuch_rb_messages_each(VALUE self)
 VALUE
 notmuch_rb_messages_collect_tags(VALUE self)
 {
-    notmuch_rb_tags_t *tags;
-    notmuch_rb_messages_t *messages;
-    VALUE tagsv;
+    notmuch_tags_t *tags;
+    notmuch_messages_t *messages;
 
-    Data_Get_Struct(self, notmuch_rb_messages_t, messages);
+    Data_Get_Struct(self, notmuch_messages_t, messages);
 
-    tagsv = Data_Make_Struct(notmuch_rb_cTags, notmuch_rb_tags_t,
-            notmuch_rb_tags_mark, notmuch_rb_tags_free, tags);
-    tags->nm_tags = notmuch_messages_collect_tags(messages->nm_messages);
-    tags->parent = self;
-    if (!tags->nm_tags)
-        rb_raise(notmuch_rb_eMemoryError, "out of memory");
+    tags = notmuch_messages_collect_tags(messages);
+    if (!tags)
+        rb_raise(notmuch_rb_eMemoryError, "Out of memory");
 
-    return tagsv;
+    return Data_Wrap_Struct(notmuch_rb_cTags, NULL, NULL, tags);
 }
diff --git a/bindings/ruby/query.c b/bindings/ruby/query.c
index 50edf170..5140c008 100644
--- a/bindings/ruby/query.c
+++ b/bindings/ruby/query.c
@@ -21,6 +21,23 @@
 #include "defs.h"
 
 /*
+ * call-seq: QUERY.destroy => nil
+ *
+ * Destroys the query, freeing all resources allocated for it.
+ */
+VALUE
+notmuch_rb_query_destroy(VALUE self)
+{
+    notmuch_query_t *query;
+
+    Data_Get_Struct(self, notmuch_query_t, query);
+
+    notmuch_query_destroy(query);
+
+    return Qnil;
+}
+
+/*
  * call-seq: QUERY.sort=(fixnum) => nil
  *
  * Set sort type of the +QUERY+
@@ -28,14 +45,15 @@
 VALUE
 notmuch_rb_query_set_sort(VALUE self, VALUE sortv)
 {
-    notmuch_rb_query_t *query;
+    notmuch_query_t *query;
 
-    Data_Get_Struct(self, notmuch_rb_query_t, query);
+    Data_Get_Struct(self, notmuch_query_t, query);
 
     if (!FIXNUM_P(sortv))
         rb_raise(rb_eTypeError, "Not a fixnum");
 
-    notmuch_query_set_sort(query->nm_query, FIX2UINT(sortv));
+    notmuch_query_set_sort(query, FIX2UINT(sortv));
+
     return Qnil;
 }
 
@@ -47,20 +65,16 @@ notmuch_rb_query_set_sort(VALUE self, VALUE sortv)
 VALUE
 notmuch_rb_query_search_threads(VALUE self)
 {
-    notmuch_rb_query_t *query;
-    notmuch_rb_threads_t *threads;
-    VALUE threadsv;
+    notmuch_query_t *query;
+    notmuch_threads_t *threads;
 
-    Data_Get_Struct(self, notmuch_rb_query_t, query);
+    Data_Get_Struct(self, notmuch_query_t, query);
 
-    threadsv = Data_Make_Struct(notmuch_rb_cThreads, notmuch_rb_threads_t,
-            notmuch_rb_threads_mark, notmuch_rb_threads_free, threads);
-    threads->nm_threads = notmuch_query_search_threads(query->nm_query);
-    threads->query = self;
-    if (!threads->nm_threads)
-        rb_raise(notmuch_rb_eMemoryError, "out of memory");
+    threads = notmuch_query_search_threads(query);
+    if (!threads)
+        rb_raise(notmuch_rb_eMemoryError, "Out of memory");
 
-    return threadsv;
+    return Data_Wrap_Struct(notmuch_rb_cThreads, NULL, NULL, threads);
 }
 
 /*
@@ -71,18 +85,14 @@ notmuch_rb_query_search_threads(VALUE self)
 VALUE
 notmuch_rb_query_search_messages(VALUE self)
 {
-    notmuch_rb_query_t *query;
-    notmuch_rb_messages_t *messages;
-    VALUE messagesv;
+    notmuch_query_t *query;
+    notmuch_messages_t *messages;
 
-    Data_Get_Struct(self, notmuch_rb_query_t, query);
+    Data_Get_Struct(self, notmuch_query_t, query);
 
-    messagesv = Data_Make_Struct(notmuch_rb_cMessages, notmuch_rb_messages_t,
-            notmuch_rb_messages_mark, notmuch_rb_messages_free, messages);
-    messages->nm_messages = notmuch_query_search_messages(query->nm_query);
-    messages->parent = self;
-    if (!messages->nm_messages)
-        rb_raise(notmuch_rb_eMemoryError, "out of memory");
+    messages = notmuch_query_search_messages(query);
+    if (!messages)
+        rb_raise(notmuch_rb_eMemoryError, "Out of memory");
 
-    return messagesv;
+    return Data_Wrap_Struct(notmuch_rb_cMessages, NULL, NULL, messages);
 }
diff --git a/bindings/ruby/tags.c b/bindings/ruby/tags.c
index d0a5054a..7ca03b6f 100644
--- a/bindings/ruby/tags.c
+++ b/bindings/ruby/tags.c
@@ -21,6 +21,23 @@
 #include "defs.h"
 
 /*
+ * call-seq: tags.destroy => nil
+ *
+ * Destroys the tags, freeing all resources allocated for it.
+ */
+VALUE
+notmuch_rb_tags_destroy(VALUE self)
+{
+    notmuch_tags_t *tags;
+
+    Data_Get_Struct(self, notmuch_tags_t, tags);
+
+    notmuch_tags_destroy(tags);
+
+    return Qnil;
+}
+
+/*
  * call-seq: TAGS.each {|item| block } => TAGS
  *
  * Calls +block+ once for each element in +self+, passing that element as a
@@ -30,16 +47,15 @@ VALUE
 notmuch_rb_tags_each(VALUE self)
 {
     const char *tag;
-    notmuch_rb_tags_t *tags;
+    notmuch_tags_t *tags;
 
-    Data_Get_Struct(self, notmuch_rb_tags_t, tags);
-    if (!tags->nm_tags)
+    Data_Get_Struct(self, notmuch_tags_t, tags);
+    if (!tags)
         return self;
 
-    for (; notmuch_tags_valid(tags->nm_tags);
-            notmuch_tags_move_to_next(tags->nm_tags)) {
-        tag = notmuch_tags_get(tags->nm_tags);
-        rb_yield(tag ? rb_str_new2(tag) : Qnil);
+    for (; notmuch_tags_valid(tags); notmuch_tags_move_to_next(tags)) {
+        tag = notmuch_tags_get(tags);
+        rb_yield(rb_str_new2(tag));
     }
 
     return self;
diff --git a/bindings/ruby/thread.c b/bindings/ruby/thread.c
index 72a86b8f..5534fe3f 100644
--- a/bindings/ruby/thread.c
+++ b/bindings/ruby/thread.c
@@ -21,6 +21,23 @@
 #include "defs.h"
 
 /*
+ * call-seq: THREAD.destroy => nil
+ *
+ * Destroys the thread, freeing all resources allocated for it.
+ */
+VALUE
+notmuch_rb_thread_destroy(VALUE self)
+{
+    notmuch_thread_t *thread;
+
+    Data_Get_Struct(self, notmuch_thread_t, thread);
+
+    notmuch_thread_destroy(thread);
+
+    return Qnil;
+}
+
+/*
  * call-seq: THREAD.thread_id => String
  *
  * Returns the thread id
@@ -29,12 +46,13 @@ VALUE
 notmuch_rb_thread_get_thread_id(VALUE self)
 {
     const char *tid;
-    notmuch_rb_thread_t *thread;
+    notmuch_thread_t *thread;
 
-    Data_Get_Struct(self, notmuch_rb_thread_t, thread);
+    Data_Get_Struct(self, notmuch_thread_t, thread);
 
-    tid = notmuch_thread_get_thread_id(thread->nm_thread);
-    return tid ? rb_str_new2(tid) : Qnil;
+    tid = notmuch_thread_get_thread_id(thread);
+
+    return rb_str_new2(tid);
 }
 
 /*
@@ -45,11 +63,11 @@ notmuch_rb_thread_get_thread_id(VALUE self)
 VALUE
 notmuch_rb_thread_get_total_messages(VALUE self)
 {
-    notmuch_rb_thread_t *thread;
+    notmuch_thread_t *thread;
 
-    Data_Get_Struct(self, notmuch_rb_thread_t, thread);
+    Data_Get_Struct(self, notmuch_thread_t, thread);
 
-    return INT2FIX(notmuch_thread_get_total_messages(thread->nm_thread));
+    return INT2FIX(notmuch_thread_get_total_messages(thread));
 }
 
 /*
@@ -60,20 +78,16 @@ notmuch_rb_thread_get_total_messages(VALUE self)
 VALUE
 notmuch_rb_thread_get_toplevel_messages(VALUE self)
 {
-    notmuch_rb_messages_t *messages;
-    notmuch_rb_thread_t *thread;
-    VALUE messagesv;
+    notmuch_messages_t *messages;
+    notmuch_thread_t *thread;
 
-    Data_Get_Struct(self, notmuch_rb_thread_t, thread);
+    Data_Get_Struct(self, notmuch_thread_t, thread);
 
-    messagesv = Data_Make_Struct(notmuch_rb_cMessages, notmuch_rb_messages_t,
-            notmuch_rb_messages_mark, notmuch_rb_messages_free, messages);
-    messages->nm_messages = notmuch_thread_get_toplevel_messages(thread->nm_thread);
-    messages->parent = self;
-    if (!messages->nm_messages)
-        rb_raise(notmuch_rb_eMemoryError, "out of memory");
+    messages = notmuch_thread_get_toplevel_messages(thread);
+    if (!messages)
+        rb_raise(notmuch_rb_eMemoryError, "Out of memory");
 
-    return messagesv;
+    return Data_Wrap_Struct(notmuch_rb_cMessages, NULL, NULL, messages);
 }
 
 /*
@@ -84,11 +98,11 @@ notmuch_rb_thread_get_toplevel_messages(VALUE self)
 VALUE
 notmuch_rb_thread_get_matched_messages(VALUE self)
 {
-    notmuch_rb_thread_t *thread;
+    notmuch_thread_t *thread;
 
-    Data_Get_Struct(self, notmuch_rb_thread_t, thread);
+    Data_Get_Struct(self, notmuch_thread_t, thread);
 
-    return INT2FIX(notmuch_thread_get_matched_messages(thread->nm_thread));
+    return INT2FIX(notmuch_thread_get_matched_messages(thread));
 }
 
 /*
@@ -100,12 +114,13 @@ VALUE
 notmuch_rb_thread_get_authors(VALUE self)
 {
     const char *authors;
-    notmuch_rb_thread_t *thread;
+    notmuch_thread_t *thread;
+
+    Data_Get_Struct(self, notmuch_thread_t, thread);
 
-    Data_Get_Struct(self, notmuch_rb_thread_t, thread);
+    authors = notmuch_thread_get_authors(thread);
 
-    authors = notmuch_thread_get_authors(thread->nm_thread);
-    return authors ? rb_str_new2(authors) : Qnil;
+    return rb_str_new2(authors);
 }
 
 /*
@@ -117,12 +132,13 @@ VALUE
 notmuch_rb_thread_get_subject(VALUE self)
 {
     const char *subject;
-    notmuch_rb_thread_t *thread;
+    notmuch_thread_t *thread;
+
+    Data_Get_Struct(self, notmuch_thread_t, thread);
 
-    Data_Get_Struct(self, notmuch_rb_thread_t, thread);
+    subject = notmuch_thread_get_subject(thread);
 
-    subject = notmuch_thread_get_subject(thread->nm_thread);
-    return subject ? rb_str_new2(subject) : Qnil;
+    return rb_str_new2(subject);
 }
 
 /*
@@ -133,11 +149,11 @@ notmuch_rb_thread_get_subject(VALUE self)
 VALUE
 notmuch_rb_thread_get_oldest_date(VALUE self)
 {
-    notmuch_rb_thread_t *thread;
+    notmuch_thread_t *thread;
 
-    Data_Get_Struct(self, notmuch_rb_thread_t, thread);
+    Data_Get_Struct(self, notmuch_thread_t, thread);
 
-    return UINT2NUM(notmuch_thread_get_oldest_date(thread->nm_thread));
+    return UINT2NUM(notmuch_thread_get_oldest_date(thread));
 }
 
 /*
@@ -148,11 +164,11 @@ notmuch_rb_thread_get_oldest_date(VALUE self)
 VALUE
 notmuch_rb_thread_get_newest_date(VALUE self)
 {
-    notmuch_rb_thread_t *thread;
+    notmuch_thread_t *thread;
 
-    Data_Get_Struct(self, notmuch_rb_thread_t, thread);
+    Data_Get_Struct(self, notmuch_thread_t, thread);
 
-    return UINT2NUM(notmuch_thread_get_newest_date(thread->nm_thread));
+    return UINT2NUM(notmuch_thread_get_newest_date(thread));
 }
 
 /*
@@ -163,18 +179,14 @@ notmuch_rb_thread_get_newest_date(VALUE self)
 VALUE
 notmuch_rb_thread_get_tags(VALUE self)
 {
-    notmuch_rb_thread_t *thread;
-    notmuch_rb_tags_t *tags;
-    VALUE tagsv;
+    notmuch_thread_t *thread;
+    notmuch_tags_t *tags;
 
-    Data_Get_Struct(self, notmuch_rb_thread_t, thread);
+    Data_Get_Struct(self, notmuch_thread_t, thread);
 
-    tagsv = Data_Make_Struct(notmuch_rb_cTags, notmuch_rb_tags_t,
-            notmuch_rb_tags_mark, notmuch_rb_tags_free, tags);
-    tags->nm_tags = notmuch_thread_get_tags(thread->nm_thread);
-    tags->parent = self;
-    if (!tags->nm_tags)
-        rb_raise(notmuch_rb_eMemoryError, "out of memory");
+    tags = notmuch_thread_get_tags(thread);
+    if (!tags)
+        rb_raise(notmuch_rb_eMemoryError, "Out of memory");
 
-    return tagsv;
+    return Data_Wrap_Struct(notmuch_rb_cTags, NULL, NULL, tags);
 }
diff --git a/bindings/ruby/threads.c b/bindings/ruby/threads.c
index cee6afbe..09906975 100644
--- a/bindings/ruby/threads.c
+++ b/bindings/ruby/threads.c
@@ -20,6 +20,24 @@
 
 #include "defs.h"
 
+/*
+ * call-seq: THREADS.destroy => nil
+ *
+ * Destroys the threads, freeing all resources allocated for it.
+ */
+VALUE
+notmuch_rb_threads_destroy(VALUE self)
+{
+    notmuch_threads_t *threads;
+
+    Data_Get_Struct(self, notmuch_threads_t, threads);
+
+    notmuch_threads_destroy(threads);
+
+    return Qnil;
+}
+
+
 /* call-seq: THREADS.each {|item| block } => THREADS
  *
  * Calls +block+ once for each thread in +self+, passing that element as a
@@ -28,22 +46,16 @@
 VALUE
 notmuch_rb_threads_each(VALUE self)
 {
-    notmuch_rb_thread_t *thread;
-    notmuch_rb_threads_t *threads;
-    VALUE threadv;
+    notmuch_thread_t *thread;
+    notmuch_threads_t *threads;
 
-    Data_Get_Struct(self, notmuch_rb_threads_t, threads);
-    if (!threads->nm_threads)
+    Data_Get_Struct(self, notmuch_threads_t, threads);
+    if (!threads)
         return self;
 
-    for (; notmuch_threads_valid(threads->nm_threads);
-            notmuch_threads_move_to_next(threads->nm_threads))
-    {
-        threadv = Data_Make_Struct(notmuch_rb_cThread, notmuch_rb_thread_t,
-                notmuch_rb_thread_mark, notmuch_rb_thread_free, thread);
-        thread->nm_thread = notmuch_threads_get(threads->nm_threads);
-        thread->threads = self;
-        rb_yield(threadv);
+    for (; notmuch_threads_valid(threads); notmuch_threads_move_to_next(threads)) {
+        thread = notmuch_threads_get(threads);
+        rb_yield(Data_Wrap_Struct(notmuch_rb_cThread, NULL, NULL, thread));
     }
 
     return self;