faststep 0.0.1

data/ext/faststep/bson.h

@@ -0,0 +1,225 @@
+/* bson.h */
+
+/*    Copyright 2009, 2010 10gen Inc.
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+
+#ifndef _BSON_H_
+#define _BSON_H_
+
+#include "platform_hacks.h"
+#include <time.h>
+
+MONGO_EXTERN_C_START
+
+typedef enum {
+    bson_eoo=0 ,
+    bson_double=1,
+    bson_string=2,
+    bson_object=3,
+    bson_array=4,
+    bson_bindata=5,
+    bson_undefined=6,
+    bson_oid=7,
+    bson_bool=8,
+    bson_date=9,
+    bson_null=10,
+    bson_regex=11,
+    bson_dbref=12, /* deprecated */
+    bson_code=13,
+    bson_symbol=14,
+    bson_codewscope=15,
+    bson_int = 16,
+    bson_timestamp = 17,
+    bson_long = 18
+} bson_type;
+
+typedef int bson_bool_t;
+
+typedef struct {
+    char * data;
+    bson_bool_t owned;
+} bson;
+
+typedef struct {
+    const char * cur;
+    bson_bool_t first;
+} bson_iterator;
+
+typedef struct {
+    char * buf;
+    char * cur;
+    int bufSize;
+    bson_bool_t finished;
+    int stack[32];
+    int stackPos;
+} bson_buffer;
+
+#pragma pack(1)
+typedef union{
+    char bytes[12];
+    int ints[3];
+} bson_oid_t;
+#pragma pack()
+
+typedef int64_t bson_date_t; /* milliseconds since epoch UTC */
+
+typedef struct {
+  int i; /* increment */
+  int t; /* time in seconds */
+} bson_timestamp_t;
+
+/* ----------------------------
+   READING
+   ------------------------------ */
+
+bson * bson_empty(bson * obj); /* returns pointer to static empty bson object */
+void bson_copy(bson* out, const bson* in); /* puts data in new buffer. NOOP if out==NULL */
+bson * bson_from_buffer(bson * b, bson_buffer * buf);
+bson * bson_init( bson * b , char * data , bson_bool_t mine );
+int bson_size(const bson * b );
+void bson_destroy( bson * b );
+
+void bson_print( bson * b );
+void bson_print_raw( const char * bson , int depth );
+
+/* advances iterator to named field */
+/* returns bson_eoo (which is false) if field not found */
+bson_type bson_find(bson_iterator* it, const bson* obj, const char* name);
+
+void bson_iterator_init( bson_iterator * i , const char * bson );
+
+/* more returns true for eoo. best to loop with bson_iterator_next(&it) */
+bson_bool_t bson_iterator_more( const bson_iterator * i );
+bson_type bson_iterator_next( bson_iterator * i );
+
+bson_type bson_iterator_type( const bson_iterator * i );
+const char * bson_iterator_key( const bson_iterator * i );
+const char * bson_iterator_value( const bson_iterator * i );
+
+/* these convert to the right type (return 0 if non-numeric) */
+double bson_iterator_double( const bson_iterator * i );
+int bson_iterator_int( const bson_iterator * i );
+int64_t bson_iterator_long( const bson_iterator * i );
+
+/* return the bson timestamp as a whole or in parts */
+bson_timestamp_t bson_iterator_timestamp( const bson_iterator * i );
+
+/* false: boolean false, 0 in any type, or null */
+/* true: anything else (even empty strings and objects) */
+bson_bool_t bson_iterator_bool( const bson_iterator * i );
+
+/* these assume you are using the right type */
+double bson_iterator_double_raw( const bson_iterator * i );
+int bson_iterator_int_raw( const bson_iterator * i );
+int64_t bson_iterator_long_raw( const bson_iterator * i );
+bson_bool_t bson_iterator_bool_raw( const bson_iterator * i );
+bson_oid_t* bson_iterator_oid( const bson_iterator * i );
+
+/* these can also be used with bson_code and bson_symbol*/
+const char * bson_iterator_string( const bson_iterator * i );
+int bson_iterator_string_len( const bson_iterator * i );
+
+/* works with bson_code, bson_codewscope, and bson_string */
+/* returns NULL for everything else */
+const char * bson_iterator_code(const bson_iterator * i);
+
+/* calls bson_empty on scope if not a bson_codewscope */
+void bson_iterator_code_scope(const bson_iterator * i, bson * scope);
+
+/* both of these only work with bson_date */
+bson_date_t bson_iterator_date(const bson_iterator * i);
+time_t bson_iterator_time_t(const bson_iterator * i);
+
+int bson_iterator_bin_len( const bson_iterator * i );
+char bson_iterator_bin_type( const bson_iterator * i );
+const char * bson_iterator_bin_data( const bson_iterator * i );
+
+const char * bson_iterator_regex( const bson_iterator * i );
+const char * bson_iterator_regex_opts( const bson_iterator * i );
+
+/* these work with bson_object and bson_array */
+void bson_iterator_subobject(const bson_iterator * i, bson * sub);
+void bson_iterator_subiterator(const bson_iterator * i, bson_iterator * sub);
+
+/* str must be at least 24 hex chars + null byte */
+void bson_oid_from_string(bson_oid_t* oid, const char* str);
+void bson_oid_to_string(const bson_oid_t* oid, char* str);
+void bson_oid_gen(bson_oid_t* oid);
+
+time_t bson_oid_generated_time(bson_oid_t* oid); /* Gives the time the OID was created */
+
+/* ----------------------------
+   BUILDING
+   ------------------------------ */
+
+bson_buffer * bson_buffer_init( bson_buffer * b );
+bson_buffer * bson_ensure_space( bson_buffer * b , const int bytesNeeded );
+
+/**
+ * @return the raw data.  you either should free this OR call bson_destroy not both
+ */
+char * bson_buffer_finish( bson_buffer * b );
+void bson_buffer_destroy( bson_buffer * b );
+
+bson_buffer * bson_append_oid( bson_buffer * b , const char * name , const bson_oid_t* oid );
+bson_buffer * bson_append_new_oid( bson_buffer * b , const char * name );
+bson_buffer * bson_append_int( bson_buffer * b , const char * name , const int i );
+bson_buffer * bson_append_long( bson_buffer * b , const char * name , const int64_t i );
+bson_buffer * bson_append_double( bson_buffer * b , const char * name , const double d );
+bson_buffer * bson_append_string( bson_buffer * b , const char * name , const char * str );
+bson_buffer * bson_append_symbol( bson_buffer * b , const char * name , const char * str );
+bson_buffer * bson_append_code( bson_buffer * b , const char * name , const char * str );
+bson_buffer * bson_append_code_w_scope( bson_buffer * b , const char * name , const char * code , const bson * scope);
+bson_buffer * bson_append_binary( bson_buffer * b, const char * name, char type, const char * str, int len );
+bson_buffer * bson_append_bool( bson_buffer * b , const char * name , const bson_bool_t v );
+bson_buffer * bson_append_null( bson_buffer * b , const char * name );
+bson_buffer * bson_append_undefined( bson_buffer * b , const char * name );
+bson_buffer * bson_append_regex( bson_buffer * b , const char * name , const char * pattern, const char * opts );
+bson_buffer * bson_append_bson( bson_buffer * b , const char * name , const bson* bson);
+bson_buffer * bson_append_element( bson_buffer * b, const char * name_or_null, const bson_iterator* elem);
+bson_buffer * bson_append_timestamp( bson_buffer * b, const char * name, bson_timestamp_t * ts );
+
+/* these both append a bson_date */
+bson_buffer * bson_append_date(bson_buffer * b, const char * name, bson_date_t millis);
+bson_buffer * bson_append_time_t(bson_buffer * b, const char * name, time_t secs);
+
+bson_buffer * bson_append_start_object( bson_buffer * b , const char * name );
+bson_buffer * bson_append_start_array( bson_buffer * b , const char * name );
+bson_buffer * bson_append_finish_object( bson_buffer * b );
+
+void bson_numstr(char* str, int i);
+void bson_incnumstr(char* str);
+
+
+/* ------------------------------
+   ERROR HANDLING - also used in mongo code
+   ------------------------------ */
+
+void * bson_malloc(int size); /* checks return value */
+void * bson_realloc(void * ptr, int size); /* checks return value */
+
+/* bson_err_handlers shouldn't return!!! */
+typedef void(*bson_err_handler)(const char* errmsg);
+
+/* returns old handler or NULL */
+/* default handler prints error then exits with failure*/
+bson_err_handler set_bson_err_handler(bson_err_handler func);
+
+/* does nothing is ok != 0 */
+void bson_fatal( int ok );
+void bson_fatal_msg( int ok, const char* msg );
+
+MONGO_EXTERN_C_END
+#endif

data/ext/faststep/bson_ruby_conversion.c

@@ -0,0 +1,44 @@
+#include "bson_ruby_conversion.h"
+#include "faststep_defines.h"
+
+bson* create_bson_from_ruby_hash(VALUE hash) {
+  bson* document = bson_malloc(sizeof(bson));
+
+  if(NIL_P(hash)) {
+    bson_empty(document);
+  } else {
+    VALUE byte_buffer = rb_funcall(rb_mBson, rb_intern("serialize"), 3, hash, Qfalse, Qfalse);
+    VALUE query = rb_funcall(byte_buffer, rb_intern("to_s"), 0);
+    bson* temp_bson = bson_malloc(sizeof(bson));
+    bson_init(temp_bson, RSTRING_PTR(query), 0);
+    bson_copy(document, temp_bson);
+    bson_destroy(temp_bson);
+  }
+
+  return document;
+}
+
+VALUE bool_to_ruby(bson_bool_t result) {
+  return result ? Qtrue : Qfalse;
+}
+
+VALUE ruby_hash_from_bson(bson* bson) {
+  VALUE bson_buf = rb_str_new(bson->data, bson_size(bson));
+
+  return rb_funcall(rb_mBson, rb_intern("deserialize"), 1, bson_buf);
+}
+
+VALUE ensure_document_ok(VALUE document) {
+  if(rb_funcall(rb_mFaststepSupport, rb_intern("ok?"), 1, document) == Qfalse) {
+    rb_raise(rb_cFaststepOperationFailure, _invalid_command_description(document));
+  }
+}
+
+static char* _invalid_command_description(VALUE document) {
+  VALUE message = rb_str_new2("Invalid command (");
+  rb_str_concat(message, rb_funcall(rb_hash_aref(document, rb_str_new2("bad cmd")), rb_intern("inspect"), 0));
+  rb_str_concat(message, rb_str_new2("): "));
+  rb_str_concat(message, rb_hash_aref(document, rb_str_new2("errmsg")));
+
+  return RSTRING_PTR(message);
+}

data/ext/faststep/bson_ruby_conversion.h

@@ -0,0 +1,10 @@
+#ifndef BSON_RUBY_CONVERSION_H
+#include <ruby.h>
+#include "bson.h"
+#define BSON_RUBY_CONVERSION_H
+bson* create_bson_from_ruby_hash(VALUE);
+VALUE ruby_hash_from_bson(bson*);
+VALUE ensure_document_ok(VALUE);
+VALUE bool_to_ruby(bson_bool_t);
+static char* _invalid_command_description(VALUE);
+#endif

data/ext/faststep/collection.c

@@ -0,0 +1,187 @@
+#include "collection.h"
+#include "connection.h"
+#include "bson_ruby_conversion.h"
+#include "faststep_defines.h"
+#include <string.h>
+
+void faststep_collection_main() {
+  rb_cFaststepCollection = rb_define_class_under(rb_mFaststep, "Collection", rb_cObject);
+
+  rb_define_attr(rb_cFaststepCollection, "name", 1, 0);
+
+  rb_define_method(rb_cFaststepCollection, "initialize",   faststep_collection_init, 2);
+  rb_define_method(rb_cFaststepCollection, "ns",           faststep_collection_ns, 0);
+  rb_define_method(rb_cFaststepCollection, "count",        faststep_collection_count, -1);
+  rb_define_method(rb_cFaststepCollection, "insert",       faststep_collection_insert, 1);
+  rb_define_method(rb_cFaststepCollection, "update",       faststep_collection_update, 2);
+  rb_define_method(rb_cFaststepCollection, "remove",       faststep_collection_remove, -1);
+  rb_define_method(rb_cFaststepCollection, "drop",         faststep_collection_drop, 0);
+  rb_define_method(rb_cFaststepCollection, "create_index", faststep_collection_create_index, 1);
+  return;
+}
+
+static VALUE faststep_collection_init(VALUE self, VALUE name, VALUE database) {
+  rb_iv_set(self, "@name", name);
+  rb_iv_set(self, "@db", database);
+
+  return self;
+}
+
+VALUE faststep_collection_ns(VALUE self) {
+  VALUE db = rb_iv_get(self, "@db");
+
+  char ns[255] = "";
+  build_collection_ns(ns, _ivar_name(db), _ivar_name(self));
+
+  return rb_str_new2(ns);
+}
+
+static VALUE faststep_collection_count(int argc, VALUE* argv, VALUE self) {
+  VALUE query;
+  rb_scan_args(argc, argv, "01", &query);
+
+  bson* bson_query = create_bson_from_ruby_hash(query);
+
+  int64_t count = mongo_count(GetFaststepConnectionForCollection(self),
+                              _ivar_name(rb_iv_get(self, "@db")),
+                              _ivar_name(self),
+                              bson_query);
+
+  bson_destroy(bson_query);
+  return ULL2NUM(count);
+}
+
+void build_collection_ns(char* ns, char* database, char* collection) {
+  strcat(ns, database);
+  strcat(ns, ".");
+  strcat(ns, collection);
+
+  return;
+}
+
+static VALUE faststep_collection_insert(VALUE self, VALUE documents) {
+  mongo_connection* conn = GetFaststepConnectionForCollection(self);
+
+  VALUE ns = faststep_collection_ns(self);
+
+  if(TYPE(documents) == T_ARRAY) {
+    _faststep_collection_insert_batch(conn, RSTRING_PTR(ns), documents);
+  } else {
+    _faststep_collection_insert_one(conn, RSTRING_PTR(ns), documents);
+  }
+
+  return Qtrue;
+}
+
+static VALUE faststep_collection_update(VALUE self, VALUE query, VALUE operations) {
+  bson* bson_query      = create_bson_from_ruby_hash(query);
+  bson* bson_operations = create_bson_from_ruby_hash(operations);
+
+  mongo_update(GetFaststepConnectionForCollection(self),
+               RSTRING_PTR(faststep_collection_ns(self)),
+               bson_query,
+               bson_operations,
+               MONGO_UPDATE_MULTI);
+
+  bson_destroy(bson_query);
+  bson_destroy(bson_operations);
+
+  return Qtrue;
+}
+
+static VALUE faststep_collection_remove(int argc, VALUE* argv, VALUE self) {
+  VALUE query;
+  rb_scan_args(argc, argv, "01", &query);
+
+  bson* bson_query = create_bson_from_ruby_hash(query);
+
+  mongo_remove(GetFaststepConnectionForCollection(self),
+               RSTRING_PTR(faststep_collection_ns(self)),
+               bson_query);
+  bson_destroy(bson_query);
+  return Qnil;
+}
+
+static VALUE faststep_collection_drop(VALUE self) {
+  bson_bool_t result = mongo_cmd_drop_collection(GetFaststepConnectionForCollection(self),
+                                                 _ivar_name(rb_iv_get(self, "@db")),
+                                                 _ivar_name(self),
+                                                 NULL);
+
+  return bool_to_ruby(result);
+}
+
+static VALUE faststep_collection_create_index(VALUE self, VALUE indexes) {
+  bson* bson_indexes = create_bson_from_ruby_hash(indexes);
+
+  bson_bool_t result = mongo_create_index(GetFaststepConnectionForCollection(self),
+                                          RSTRING_PTR(faststep_collection_ns(self)),
+                                          bson_indexes,
+                                          0,
+                                          NULL);
+  bson_destroy(bson_indexes);
+
+  return bool_to_ruby(result);
+}
+
+static void _faststep_collection_insert_one(mongo_connection* conn, char* ns, VALUE document) {
+  bson* bson_document = create_bson_from_ruby_hash(document);
+  mongo_insert(conn, ns, bson_document);
+  bson_destroy(bson_document);
+}
+
+static void _faststep_collection_insert_batch(mongo_connection* conn, char* ns, VALUE documents) {
+  int total_document_count = RARRAY_LEN(documents);
+  bson** bson_documents = (bson**)malloc(sizeof(bson*) * total_document_count);
+
+  int chunk_size = 1024*1024*16;
+  int sent_document_count    = 0,
+      current_bson_size      = 0,
+      current_document_count = 0,
+      iterator;
+
+  for(iterator = 0; iterator < total_document_count; iterator++) {
+    int current_document_array_index = sent_document_count + current_document_count;
+    bson* document = create_bson_from_ruby_hash(rb_ary_entry(documents, current_document_array_index));
+
+    if(bson_size(document) + current_bson_size > chunk_size) {
+      mongo_insert_batch(conn, ns, bson_documents, current_document_count);
+      _faststep_collection_destroy(bson_documents, current_document_count);
+
+      sent_document_count += current_document_count;
+      total_document_count -= current_document_count;
+
+      current_bson_size = 0;
+      current_document_count = 0;
+      iterator = 0;
+    }
+
+    bson_documents[iterator] = document;
+    current_document_count += 1;
+    current_bson_size += bson_size(document);
+  }
+
+  if(current_document_count > 0) {
+    mongo_insert_batch(conn, ns, bson_documents, current_document_count);
+    _faststep_collection_destroy(bson_documents, current_document_count);
+  }
+}
+
+static void _faststep_collection_destroy(bson** bson_documents, int document_count) {
+  int iterator;
+  for(iterator = 0; iterator < document_count; iterator++) {
+    bson_destroy(bson_documents[iterator]);
+  }
+  return;
+}
+
+static char* _ivar_name(VALUE obj) {
+  return RSTRING_PTR(rb_iv_get(obj, "@name"));
+}
+
+mongo_connection* GetFaststepConnectionForCollection(VALUE collection) {
+  VALUE db         = rb_iv_get(collection, "@db");
+  VALUE connection = rb_iv_get(db, "@connection");
+
+  return GetFaststepConnection(connection);
+}

data/ext/faststep/collection.h

@@ -0,0 +1,24 @@
+#ifndef COLLECTION_H
+#include <ruby.h>
+#include "mongo.h"
+#include "bson.h"
+#define COLLECTION_H
+
+void  faststep_collection_main();
+static VALUE faststep_collection_init(VALUE, VALUE, VALUE);
+static VALUE faststep_collection_count(int, VALUE*, VALUE);
+static VALUE faststep_collection_insert(VALUE, VALUE);
+static VALUE faststep_collection_update(VALUE, VALUE, VALUE);
+static VALUE faststep_collection_remove(int, VALUE*, VALUE);
+static VALUE faststep_collection_drop(VALUE);
+static VALUE faststep_collection_create_index(VALUE, VALUE);
+VALUE faststep_collection_ns(VALUE);
+
+static void _faststep_collection_insert_one(mongo_connection*, char*, VALUE);
+static void _faststep_collection_insert_batch(mongo_connection*, char*, VALUE);
+mongo_connection* GetFaststepConnectionForCollection(VALUE);
+static void _faststep_collection_destroy(bson**, int);
+
+void build_collection_ns(char*, char*, char*);
+static char* _ivar_name(VALUE);
+#endif

data/ext/faststep/connection.c

@@ -0,0 +1,85 @@
+#include "connection.h"
+#include "faststep_defines.h"
+#include "bson_ruby_conversion.h"
+
+void faststep_connection_main() {
+  rb_cFaststepConnection = rb_define_class_under(rb_mFaststep, "Connection", rb_cObject);
+
+  rb_define_attr(rb_cFaststepConnection, "host", 1, 0);
+  rb_define_attr(rb_cFaststepConnection, "port", 1, 0);
+
+  rb_define_singleton_method(rb_cFaststepConnection, "new", faststep_connection_new, 2);
+
+  rb_define_method(rb_cFaststepConnection, "initialize",  faststep_connection_init, 2);
+  rb_define_method(rb_cFaststepConnection, "connect!",    faststep_connection_connect, 0);
+  rb_define_method(rb_cFaststepConnection, "disconnect!", faststep_connection_disconnect, 0);
+  rb_define_method(rb_cFaststepConnection, "connected?",  faststep_connection_connected, 0);
+  rb_define_method(rb_cFaststepConnection, "master?",     faststep_connection_master, 0);
+
+  return;
+}
+
+static VALUE faststep_connection_init(VALUE self, VALUE host, VALUE port) {
+  rb_iv_set(self, "@host", host);
+  rb_iv_set(self, "@port", port);
+
+  faststep_connection_connect(self);
+
+  return self;
+}
+
+static VALUE faststep_connection_new(VALUE class, VALUE host, VALUE port) {
+  mongo_connection* conn = bson_malloc(sizeof(mongo_connection));
+
+  VALUE tdata = Data_Wrap_Struct(class, NULL, mongo_destroy, conn);
+
+  VALUE argv[2];
+  argv[0] = host;
+  argv[1] = port;
+
+  rb_obj_call_init(tdata, 2, argv);
+
+  return tdata;
+}
+
+static VALUE faststep_connection_connect(VALUE self) {
+  mongo_connection_options* options = bson_malloc(sizeof(mongo_connection_options));
+
+  strcpy(options->host, RSTRING_PTR(rb_iv_get(self, "@host")));
+  options->port = NUM2INT(rb_iv_get(self, "@port"));
+
+  _faststep_connect_or_raise(GetFaststepConnection(self), options);
+
+  return Qnil;
+}
+
+static VALUE faststep_connection_disconnect(VALUE self) {
+  mongo_disconnect(GetFaststepConnection(self));
+
+  return Qnil;
+}
+
+static VALUE faststep_connection_connected(VALUE self) {
+  return bool_to_ruby(GetFaststepConnection(self)->connected);
+}
+
+static VALUE faststep_connection_master(VALUE self) {
+  return bool_to_ruby(mongo_cmd_ismaster(GetFaststepConnection(self), NULL));
+}
+
+static void _faststep_connect_or_raise(mongo_connection* conn, mongo_connection_options* options) {
+  mongo_connect(conn, options);
+
+  if(conn->connected == 0) {
+    mongo_destroy(conn);
+    rb_raise(rb_cFaststepConnectionFailure, "unable to connect to Mongo");
+  }
+
+  return;
+}
+
+mongo_connection* GetFaststepConnection(VALUE object) {
+  mongo_connection* conn;
+  Data_Get_Struct(object, mongo_connection, conn);
+  return conn;
+}

data/ext/faststep/connection.h

@@ -0,0 +1,17 @@
+#ifndef CONNECTION_H
+#include <ruby.h>
+#include "mongo.h"
+#define CONNECTION_H
+void faststep_connection_main();
+
+static VALUE faststep_connection_init(VALUE, VALUE, VALUE);
+static VALUE faststep_connection_new(VALUE, VALUE, VALUE);
+static VALUE faststep_connection_connect(VALUE);
+static VALUE faststep_connection_disconnect(VALUE);
+static VALUE faststep_connection_connected(VALUE);
+static VALUE faststep_connection_master(VALUE);
+
+mongo_connection* GetFaststepConnection(VALUE);
+
+static void _faststep_connect_or_raise(mongo_connection*, mongo_connection_options*);
+#endif

data/ext/faststep/cursor.c

@@ -0,0 +1,61 @@
+#include "cursor.h"
+#include "bson_ruby_conversion.h"
+#include "collection.h"
+#include "faststep_defines.h"
+
+void faststep_cursor_main() {
+  rb_cFaststepCursor = rb_define_class_under(rb_mFaststep, "Cursor", rb_cObject);
+
+  rb_define_attr(rb_cFaststepCursor, "collection", 1, 0);
+  rb_include_module(rb_cFaststepCursor, rb_mEnumerable);
+
+  rb_define_singleton_method(rb_cFaststepCursor, "new", faststep_cursor_new, 2);
+
+  rb_define_method(rb_cFaststepCursor, "initialize", faststep_cursor_init, 2);
+  rb_define_method(rb_cFaststepCursor, "each", faststep_cursor_each, 0);
+
+  return;
+}
+
+static VALUE faststep_cursor_init(VALUE self, VALUE collection, VALUE options) {
+  rb_iv_set(self, "@collection", collection);
+
+  return self;
+}
+
+static VALUE faststep_cursor_new(VALUE class, VALUE collection, VALUE options) {
+  mongo_cursor* cursor = _faststep_build_mongo_cursor(collection, options);
+
+  VALUE tdata = Data_Wrap_Struct(class, NULL, mongo_cursor_destroy, cursor);
+
+  VALUE argv[2];
+  argv[0] = collection;
+  argv[1] = options;
+
+  rb_obj_call_init(tdata, 2, argv);
+
+  return tdata;
+}
+
+static VALUE faststep_cursor_each(VALUE self) {
+  mongo_cursor* cursor;
+  Data_Get_Struct(self, mongo_cursor, cursor);
+
+  while(mongo_cursor_next(cursor)) {
+    rb_yield(ruby_hash_from_bson(&cursor->current));
+  }
+}
+
+static mongo_cursor* _faststep_build_mongo_cursor(VALUE collection, VALUE options) {
+  bson* selector = create_bson_from_ruby_hash(rb_hash_aref(options, rb_str_new2("selector")));
+
+  mongo_cursor* result = mongo_find(GetFaststepConnectionForCollection(collection),
+                                    RSTRING_PTR(rb_funcall(collection, rb_intern("ns"), 0)),
+                                    selector,
+                                    NULL,
+                                    0, 0, 0);
+
+  bson_destroy(selector);
+
+  return result;
+}

data/ext/faststep/cursor.h

@@ -0,0 +1,10 @@
+#ifndef CURSOR_H
+#include <ruby.h>
+#include "mongo.h"
+#define CURSOR_h
+void  faststep_cursor_main();
+static VALUE faststep_cursor_init(VALUE, VALUE, VALUE);
+static VALUE faststep_cursor_new(VALUE, VALUE, VALUE);
+static VALUE faststep_cursor_each(VALUE);
+static mongo_cursor* _faststep_build_mongo_cursor(VALUE, VALUE);
+#endif