faststep 0.0.1 → 0.0.2

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2011 Josh Clayton
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

data/README.markdown

@@ -0,0 +1,84 @@
+# Faststep
+
+## Mongo on Speed
+
+### Install
+
+Add to your Gemfile and `bundle`; otherwise,
+
+    gem install faststep
+
+### Usage
+
+Connect to mongo:
+
+    >> conn = Faststep::Connection.new("127.0.0.1", 27017)
+
+Pick a database:
+
+    >> db = conn.db("awesome_development")
+
+Have some fun!
+
+    >> db["users"].count
+    => 0
+    >> db["users"].insert(10000.times.map {|i| { :name => "Person #{i}" } }
+    => true
+    >> db["users"].count
+    => 10000
+    >> db["users"].count(:name => /0$/)
+    => 1000
+    >> db["users"].find(:name => /0$/).to_a
+    => [{"_id"=>BSON::ObjectId('4d83c53555ca381d572c1cf7'), "name"=>"Person 0"}, {"_id"=>BSON::ObjectId('4d83c53555ca381d572c1d01'), "name"=>"Person 10"}, ...]
+    >> db["users"].remove(:name => /0$/)
+    => nil
+    >> db["users"].count(:name => /0$/)
+    => 0
+    >> db["users"].count
+    => 9000
+    >> db["users"].drop
+    => true
+    >> db.drop
+    => true
+
+### Caveats
+
+This is under heavy development (what gem isn't?) but there's a lot of stuff to be implemented still. Some methods return nil (remove, for example) when they shouldn't.
+It's not nearly as smart as the mongo Ruby driver and it doesn't handle errors that well.
+
+### Todo
+
+* Connection pooling
+* Safe mode
+* Allow updates to *not* be multi (currently unconfigurable)
+* Master/slave
+* Replica sets
+
+Basically, most of http://www.mongodb.org/display/DOCS/Feature+Checklist+for+Mongo+Drivers
+
+### About
+
+This is a C extension that uses the [Mongo C driver](https://github.com/mongodb/mongo-c-driver).
+As of right now, I haven't modified any of the code provided in that driver in here.
+That code's Apache license still applies, and since it's not a derivative work (I haven't
+changed any of the source), I'm using an MIT license for Faststep.
+
+I've basically copied the benchmark from the [Mongo Ruby driver](https://github.com/mongodb/mongo-ruby-driver)
+to test Faststep's speed, and all operations are anywhere between 10% (finding ranges on large docs)
+and 120% faster (inserting small/medium indexed documents and inserting small/medium documents in batches).
+See https://gist.github.com/870297 for benchmarks.
+
+I started writing this driver for a project I'm working on called [Crowdtap](http://crowdtap.com),
+which uses Mongo as its primary data store. I'd dabbled in C extensions before and
+figured I could leverage this knowledge to speed up certain operations we were doing.
+If it wasn't for them and their belief that I could get something usable in a short time,
+this project probably wouldn't exist; thanks guys!
+
+### License
+
+The Mongo C driver code has retained its Apache license; I've released faststep under an MIT license (see
+LICENSE for details).
+
+### Author
+
+Written 2011 by Josh Clayton.

data/ext/faststep/bson_ruby_conversion.c

@@ -1,7 +1,7 @@
 #include "bson_ruby_conversion.h"
 #include "faststep_defines.h"
 
-bson* create_bson_from_ruby_hash(VALUE hash) {
+bson* create_bson_from_ruby_hash(const VALUE hash) {
   bson* document = bson_malloc(sizeof(bson));
 
   if(NIL_P(hash)) {
@@ -18,27 +18,53 @@ bson* create_bson_from_ruby_hash(VALUE hash) {
   return document;
 }
 
-VALUE bool_to_ruby(bson_bool_t result) {
-  return result ? Qtrue : Qfalse;
+bson* bson_from_ruby_array(const VALUE array) {
+  VALUE hash = rb_hash_new();
+
+  if(RTEST(array)) {
+    int iterator;
+    for(iterator = 0; iterator < RARRAY_LEN(array); iterator++) {
+      rb_hash_aset(hash, rb_ary_entry(array, iterator), INT2NUM(1));
+    }
+  }
+
+  create_bson_from_ruby_hash(hash);
+}
+
+VALUE ruby_array_to_bson_ordered_hash(const VALUE array) {
+  VALUE order_as_ordered_hash = rb_funcall(rb_cBsonOrderedHash, rb_intern("new"), 0);
+  rb_iterate(rb_each, array, _map_assoc_ary_to_key_value_pair, order_as_ordered_hash);
+
+  return order_as_ordered_hash;
 }
 
-VALUE ruby_hash_from_bson(bson* bson) {
+VALUE ruby_hash_from_bson(const 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) {
+VALUE bool_to_ruby(const bson_bool_t result) {
+  return result ? Qtrue : Qfalse;
+}
+
+
+VALUE ensure_document_ok(const VALUE document) {
   if(rb_funcall(rb_mFaststepSupport, rb_intern("ok?"), 1, document) == Qfalse) {
-    rb_raise(rb_cFaststepOperationFailure, _invalid_command_description(document));
+    rb_raise(rb_eFaststepOperationFailure, _invalid_command_description(document));
   }
 }
 
-static char* _invalid_command_description(VALUE document) {
+static char* _invalid_command_description(const 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_inspect(rb_hash_aref(document, rb_str_new2("bad cmd"))));
   rb_str_concat(message, rb_str_new2("): "));
   rb_str_concat(message, rb_hash_aref(document, rb_str_new2("errmsg")));
 
   return RSTRING_PTR(message);
 }
+
+static VALUE _map_assoc_ary_to_key_value_pair(const VALUE item, VALUE hash) {
+  rb_hash_aset(hash, rb_ary_entry(item, 0), rb_ary_entry(item, 1));
+  return hash;
+}

data/ext/faststep/bson_ruby_conversion.h

@@ -2,9 +2,12 @@
 #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);
+bson* create_bson_from_ruby_hash(const VALUE);
+bson* bson_from_ruby_array(const VALUE);
+VALUE ruby_array_to_bson_ordered_hash(const VALUE);
+VALUE ruby_hash_from_bson(const bson*);
+VALUE bool_to_ruby(const bson_bool_t);
+VALUE ensure_document_ok(const VALUE);
+static char* _invalid_command_description(const VALUE);
+static VALUE _map_assoc_ary_to_key_value_pair(const VALUE, VALUE);
 #endif

data/ext/faststep/collection.c

@@ -11,6 +11,8 @@ void faststep_collection_main() {
 
   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, "find",         faststep_collection_find, -1);
+  rb_define_method(rb_cFaststepCollection, "find_one",     faststep_collection_find_one, -1);
   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);
@@ -20,14 +22,14 @@ void faststep_collection_main() {
   return;
 }
 
-static VALUE faststep_collection_init(VALUE self, VALUE name, VALUE database) {
+static VALUE faststep_collection_init(VALUE self, const VALUE name, const VALUE database) {
   rb_iv_set(self, "@name", name);
   rb_iv_set(self, "@db", database);
 
   return self;
 }
 
-VALUE faststep_collection_ns(VALUE self) {
+VALUE faststep_collection_ns(const VALUE self) {
   VALUE db = rb_iv_get(self, "@db");
 
   char ns[255] = "";
@@ -51,7 +53,48 @@ static VALUE faststep_collection_count(int argc, VALUE* argv, VALUE self) {
   return ULL2NUM(count);
 }
 
-void build_collection_ns(char* ns, char* database, char* collection) {
+static VALUE faststep_collection_find(int argc, VALUE* argv, VALUE self) {
+  VALUE selector, options;
+  rb_scan_args(argc, argv, "02", &selector, &options);
+  if(!RTEST(selector)) { selector = rb_hash_new(); }
+  if(!RTEST(options))  { options  = rb_hash_new(); }
+
+  VALUE full_query = rb_hash_new();
+  rb_hash_aset(full_query, rb_str_new2("selector"), selector);
+  rb_funcall(full_query, rb_intern("merge"), 1, options);
+
+  return rb_funcall(rb_cFaststepCursor, rb_intern("new"), 2, self, full_query);
+}
+
+static VALUE faststep_collection_find_one(int argc, VALUE* argv, VALUE self) {
+  VALUE selector, options;
+  rb_scan_args(argc, argv, "02", &selector, &options);
+
+  if(!RTEST(options)) { options = rb_hash_new(); }
+
+  VALUE full_query = rb_hash_new();
+
+  if(RTEST(rb_funcall(selector, rb_intern("is_a?"), 1, rb_cBsonObjectId))) {
+    rb_hash_aset(full_query, rb_str_new2("_id"), selector);
+  } else {
+    switch(TYPE(selector)) {
+      case T_NIL:
+        break;
+      case T_HASH:
+        full_query = selector;
+        break;
+      default:
+        rb_raise(rb_eTypeError, "selector must be an instance of BSON::ObjectId, Hash, or nil");
+    }
+  }
+
+  rb_hash_aset(options, rb_str_new2("limit"), INT2NUM(-1));
+
+  VALUE result = rb_funcall(self, rb_intern("find"), 2, full_query, options);
+  return rb_funcall(result, rb_intern("first"), 0);
+}
+
+void build_collection_ns(char* ns, const char* database, const char* collection) {
   strcat(ns, database);
   strcat(ns, ".");
   strcat(ns, collection);
@@ -59,7 +102,7 @@ void build_collection_ns(char* ns, char* database, char* collection) {
   return;
 }
 
-static VALUE faststep_collection_insert(VALUE self, VALUE documents) {
+static VALUE faststep_collection_insert(const VALUE self, const VALUE documents) {
   mongo_connection* conn = GetFaststepConnectionForCollection(self);
 
   VALUE ns = faststep_collection_ns(self);
@@ -73,7 +116,7 @@ static VALUE faststep_collection_insert(VALUE self, VALUE documents) {
   return Qtrue;
 }
 
-static VALUE faststep_collection_update(VALUE self, VALUE query, VALUE operations) {
+static VALUE faststep_collection_update(const VALUE self, const VALUE query, const VALUE operations) {
   bson* bson_query      = create_bson_from_ruby_hash(query);
   bson* bson_operations = create_bson_from_ruby_hash(operations);
 
@@ -102,7 +145,7 @@ static VALUE faststep_collection_remove(int argc, VALUE* argv, VALUE self) {
   return Qnil;
 }
 
-static VALUE faststep_collection_drop(VALUE self) {
+static VALUE faststep_collection_drop(const VALUE self) {
   bson_bool_t result = mongo_cmd_drop_collection(GetFaststepConnectionForCollection(self),
                                                  _ivar_name(rb_iv_get(self, "@db")),
                                                  _ivar_name(self),
@@ -111,7 +154,7 @@ static VALUE faststep_collection_drop(VALUE self) {
   return bool_to_ruby(result);
 }
 
-static VALUE faststep_collection_create_index(VALUE self, VALUE indexes) {
+static VALUE faststep_collection_create_index(const VALUE self, const VALUE indexes) {
   bson* bson_indexes = create_bson_from_ruby_hash(indexes);
 
   bson_bool_t result = mongo_create_index(GetFaststepConnectionForCollection(self),
@@ -124,13 +167,13 @@ static VALUE faststep_collection_create_index(VALUE self, VALUE indexes) {
   return bool_to_ruby(result);
 }
 
-static void _faststep_collection_insert_one(mongo_connection* conn, char* ns, VALUE document) {
+static void _faststep_collection_insert_one(mongo_connection* conn, const char* ns, const 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) {
+static void _faststep_collection_insert_batch(mongo_connection* conn, const char* ns, const VALUE documents) {
   int total_document_count = RARRAY_LEN(documents);
   bson** bson_documents = (bson**)malloc(sizeof(bson*) * total_document_count);
 
@@ -167,7 +210,7 @@ static void _faststep_collection_insert_batch(mongo_connection* conn, char* ns,
   }
 }
 
-static void _faststep_collection_destroy(bson** bson_documents, int document_count) {
+static void _faststep_collection_destroy(bson** bson_documents, const int document_count) {
   int iterator;
   for(iterator = 0; iterator < document_count; iterator++) {
     bson_destroy(bson_documents[iterator]);
@@ -175,11 +218,11 @@ static void _faststep_collection_destroy(bson** bson_documents, int document_cou
   return;
 }
 
-static char* _ivar_name(VALUE obj) {
-  return RSTRING_PTR(rb_iv_get(obj, "@name"));
+static char* _ivar_name(const VALUE object) {
+  return RSTRING_PTR(rb_iv_get(object, "@name"));
 }
 
-mongo_connection* GetFaststepConnectionForCollection(VALUE collection) {
+mongo_connection* GetFaststepConnectionForCollection(const VALUE collection) {
   VALUE db         = rb_iv_get(collection, "@db");
   VALUE connection = rb_iv_get(db, "@connection");
 

data/ext/faststep/collection.h

@@ -5,20 +5,22 @@
 #define COLLECTION_H
 
 void  faststep_collection_main();
-static VALUE faststep_collection_init(VALUE, VALUE, VALUE);
+static VALUE faststep_collection_init(VALUE, const VALUE, const VALUE);
+static VALUE faststep_collection_find(int, VALUE*, const VALUE);
+static VALUE faststep_collection_find_one(int, VALUE*, const 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_insert(const VALUE, const VALUE);
+static VALUE faststep_collection_update(const VALUE, const VALUE, const 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 VALUE faststep_collection_drop(const VALUE);
+static VALUE faststep_collection_create_index(const VALUE, const VALUE);
+VALUE faststep_collection_ns(const 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);
+static void _faststep_collection_insert_one(mongo_connection*, const char*, const VALUE);
+static void _faststep_collection_insert_batch(mongo_connection*, const char*, const VALUE);
+mongo_connection* GetFaststepConnectionForCollection(const VALUE);
+static void _faststep_collection_destroy(bson**, const int);
 
-void build_collection_ns(char*, char*, char*);
-static char* _ivar_name(VALUE);
+void build_collection_ns(char*, const char*, const char*);
+static char* _ivar_name(const VALUE);
 #endif

data/ext/faststep/connection.c

@@ -4,6 +4,7 @@
 
 void faststep_connection_main() {
   rb_cFaststepConnection = rb_define_class_under(rb_mFaststep, "Connection", rb_cObject);
+  rb_define_const(rb_cFaststepConnection, "DEFAULT_PORT", INT2FIX(27017));
 
   rb_define_attr(rb_cFaststepConnection, "host", 1, 0);
   rb_define_attr(rb_cFaststepConnection, "port", 1, 0);
@@ -15,11 +16,12 @@ void faststep_connection_main() {
   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);
+  rb_define_method(rb_cFaststepConnection, "db",          faststep_connection_db, 1);
 
   return;
 }
 
-static VALUE faststep_connection_init(VALUE self, VALUE host, VALUE port) {
+static VALUE faststep_connection_init(VALUE self, const VALUE host, const VALUE port) {
   rb_iv_set(self, "@host", host);
   rb_iv_set(self, "@port", port);
 
@@ -28,7 +30,7 @@ static VALUE faststep_connection_init(VALUE self, VALUE host, VALUE port) {
   return self;
 }
 
-static VALUE faststep_connection_new(VALUE class, VALUE host, VALUE port) {
+static VALUE faststep_connection_new(VALUE class, const VALUE host, const VALUE port) {
   mongo_connection* conn = bson_malloc(sizeof(mongo_connection));
 
   VALUE tdata = Data_Wrap_Struct(class, NULL, mongo_destroy, conn);
@@ -53,32 +55,36 @@ static VALUE faststep_connection_connect(VALUE self) {
   return Qnil;
 }
 
-static VALUE faststep_connection_disconnect(VALUE self) {
+static VALUE faststep_connection_disconnect(const VALUE self) {
   mongo_disconnect(GetFaststepConnection(self));
 
   return Qnil;
 }
 
-static VALUE faststep_connection_connected(VALUE self) {
+static VALUE faststep_connection_connected(const VALUE self) {
   return bool_to_ruby(GetFaststepConnection(self)->connected);
 }
 
-static VALUE faststep_connection_master(VALUE self) {
+static VALUE faststep_connection_master(const VALUE self) {
   return bool_to_ruby(mongo_cmd_ismaster(GetFaststepConnection(self), NULL));
 }
 
+static VALUE faststep_connection_db(const VALUE self, const VALUE database_name) {
+  return rb_funcall(rb_cFaststepDb, rb_intern("new"), 2, database_name, self);
+}
+
 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");
+    rb_raise(rb_eFaststepConnectionFailure, "unable to connect to Mongo");
   }
 
   return;
 }
 
-mongo_connection* GetFaststepConnection(VALUE object) {
+mongo_connection* GetFaststepConnection(const VALUE object) {
   mongo_connection* conn;
   Data_Get_Struct(object, mongo_connection, conn);
   return conn;

data/ext/faststep/connection.h

@@ -4,14 +4,15 @@
 #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_init(VALUE, const VALUE, const VALUE);
+static VALUE faststep_connection_new(VALUE, const VALUE, const 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);
+static VALUE faststep_connection_disconnect(const VALUE);
+static VALUE faststep_connection_connected(const VALUE);
+static VALUE faststep_connection_master(const VALUE);
+static VALUE faststep_connection_db(const VALUE, const VALUE);
 
-mongo_connection* GetFaststepConnection(VALUE);
+mongo_connection* GetFaststepConnection(const VALUE);
 
 static void _faststep_connect_or_raise(mongo_connection*, mongo_connection_options*);
 #endif

data/ext/faststep/cursor.c

@@ -9,53 +9,116 @@ void faststep_cursor_main() {
   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);
+  rb_define_method(rb_cFaststepCursor, "initialize", faststep_cursor_init, -1);
+  rb_define_method(rb_cFaststepCursor, "explain",    faststep_cursor_explain, 0);
+  rb_define_method(rb_cFaststepCursor, "skip",       faststep_cursor_skip, 1);
+  rb_define_method(rb_cFaststepCursor, "limit",      faststep_cursor_limit, 1);
+  rb_define_method(rb_cFaststepCursor, "fields",     faststep_cursor_fields, 1);
+  rb_define_method(rb_cFaststepCursor, "order",      faststep_cursor_order, 1);
+  rb_define_method(rb_cFaststepCursor, "each",       faststep_cursor_each, 0);
 
   return;
 }
 
-static VALUE faststep_cursor_init(VALUE self, VALUE collection, VALUE options) {
+static VALUE faststep_cursor_init(int argc, VALUE* argv, VALUE self) {
+  VALUE collection, options;
+  rb_scan_args(argc, argv, "11", &collection, &options);
+
   rb_iv_set(self, "@collection", collection);
 
+  VALUE selector = rb_hash_aref(options, rb_str_new2("selector"));
+  if(NIL_P(selector)) { selector = rb_hash_new(); }
+  if(RTEST(rb_hash_aref(selector, rb_str_new2("$query")))) {
+    rb_iv_set(self, "@selector", rb_hash_aref(selector, rb_str_new2("$query")));
+  } else {
+    rb_iv_set(self, "@selector", selector);
+  }
+
+  rb_iv_set(self, "@explain", Qfalse);
+  rb_iv_set(self, "@fields",  rb_hash_aref(options, rb_str_new2("fields")));
+  rb_iv_set(self, "@skip",    rb_hash_aref(options, rb_str_new2("skip")));
+  rb_iv_set(self, "@limit",   rb_hash_aref(options, rb_str_new2("limit")));
+
   return self;
 }
 
-static VALUE faststep_cursor_new(VALUE class, VALUE collection, VALUE options) {
-  mongo_cursor* cursor = _faststep_build_mongo_cursor(collection, options);
+static VALUE faststep_cursor_each(const VALUE self) {
+  mongo_cursor* cursor = _faststep_build_mongo_cursor(self);
 
-  VALUE tdata = Data_Wrap_Struct(class, NULL, mongo_cursor_destroy, cursor);
+  while(mongo_cursor_next(cursor)) {
+    rb_yield(ruby_hash_from_bson(&cursor->current));
+  }
+}
 
-  VALUE argv[2];
-  argv[0] = collection;
-  argv[1] = options;
+static VALUE faststep_cursor_explain(VALUE self) {
+  rb_iv_set(self, "@explain", Qtrue);
 
-  rb_obj_call_init(tdata, 2, argv);
+  mongo_cursor* cursor = _faststep_build_mongo_cursor(self);
+  mongo_cursor_next(cursor);
 
-  return tdata;
+  VALUE result = ruby_hash_from_bson(&cursor->current);
+  mongo_cursor_destroy(cursor);
+  return result;
 }
 
-static VALUE faststep_cursor_each(VALUE self) {
-  mongo_cursor* cursor;
-  Data_Get_Struct(self, mongo_cursor, cursor);
+static VALUE faststep_cursor_skip(VALUE self, const VALUE skip_count) {
+  rb_iv_set(self, "@skip", skip_count);
+  return self;
+}
 
-  while(mongo_cursor_next(cursor)) {
-    rb_yield(ruby_hash_from_bson(&cursor->current));
-  }
+static VALUE faststep_cursor_limit(VALUE self, const VALUE limit_count) {
+  rb_iv_set(self, "@limit", limit_count);
+  return self;
+}
+
+static VALUE faststep_cursor_fields(VALUE self, const VALUE fields) {
+  rb_iv_set(self, "@fields", fields);
+  return self;
 }
 
-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")));
+static VALUE faststep_cursor_order(VALUE self, const VALUE order) {
+  rb_iv_set(self, "@order", ruby_array_to_bson_ordered_hash(order));
+  return self;
+}
+
+static mongo_cursor* _faststep_build_mongo_cursor(VALUE self) {
+  bson* selector = create_bson_from_ruby_hash(_faststep_build_full_query(self));
+  bson* fields   = bson_from_ruby_array(rb_iv_get(self, "@fields"));
+
+  int limit = 0;
+  if(RTEST(rb_iv_get(self, "@limit"))) {
+    limit = -1*FIX2INT(rb_iv_get(self, "@limit"));
+  }
+
+  int skip = 0;
+  if(RTEST(rb_iv_get(self, "@skip"))) {
+    skip = FIX2INT(rb_iv_get(self, "@skip"));
+  }
+
+  VALUE collection = rb_iv_get(self, "@collection");
 
   mongo_cursor* result = mongo_find(GetFaststepConnectionForCollection(collection),
                                     RSTRING_PTR(rb_funcall(collection, rb_intern("ns"), 0)),
                                     selector,
-                                    NULL,
-                                    0, 0, 0);
+                                    fields,
+                                    limit, skip, 0);
 
   bson_destroy(selector);
+  bson_destroy(fields);
 
   return result;
 }
+
+static VALUE _faststep_build_full_query(VALUE self) {
+  if(RTEST(rb_iv_get(self, "@explain")) || RTEST(rb_iv_get(self, "@order"))) {
+    VALUE full_query = rb_hash_new();
+    rb_hash_aset(full_query, rb_str_new2("$query"),   rb_iv_get(self, "@selector"));
+    rb_hash_aset(full_query, rb_str_new2("$explain"), rb_iv_get(self, "@explain"));
+    if(RTEST(rb_iv_get(self, "@order"))) {
+      rb_hash_aset(full_query, rb_str_new2("$orderby"), rb_iv_get(self, "@order"));
+    }
+    return full_query;
+  } else {
+    return rb_iv_get(self, "@selector");
+  }
+}

data/ext/faststep/cursor.h

@@ -3,8 +3,13 @@
 #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);
+static VALUE faststep_cursor_init(int, VALUE*, VALUE);
+static VALUE faststep_cursor_each(const VALUE);
+static VALUE faststep_cursor_explain(VALUE);
+static VALUE faststep_cursor_skip(VALUE, const VALUE);
+static VALUE faststep_cursor_limit(VALUE, const VALUE);
+static VALUE faststep_cursor_fields(VALUE, const VALUE);
+static VALUE faststep_cursor_order(VALUE, const VALUE);
+static mongo_cursor* _faststep_build_mongo_cursor(VALUE);
+static VALUE _faststep_build_full_query(VALUE);
 #endif

data/ext/faststep/exceptions.c

@@ -2,6 +2,6 @@
 #include "faststep_defines.h"
 
 void faststep_exceptions_main() {
-  rb_cFaststepConnectionFailure = rb_define_class_under(rb_mFaststep, "ConnectionFailure", rb_eStandardError);
-  rb_cFaststepOperationFailure  = rb_define_class_under(rb_mFaststep, "OperationFailure", rb_eStandardError);
+  rb_eFaststepConnectionFailure = rb_define_class_under(rb_mFaststep, "ConnectionFailure", rb_eStandardError);
+  rb_eFaststepOperationFailure  = rb_define_class_under(rb_mFaststep, "OperationFailure",  rb_eStandardError);
 }

data/ext/faststep/faststep.c

@@ -7,6 +7,9 @@
 #include "support.h"
 
 VALUE rb_mBson;
+VALUE rb_cBsonOrderedHash;
+VALUE rb_cBsonObjectId;
+
 VALUE rb_mFaststep;
 VALUE rb_cFaststepConnection;
 VALUE rb_cFaststepDb;
@@ -14,12 +17,17 @@ VALUE rb_cFaststepCollection;
 VALUE rb_cFaststepCursor;
 VALUE rb_mFaststepSupport;
 
-VALUE rb_cFaststepConnectionFailure;
-VALUE rb_cFaststepOperationFailure;
+VALUE rb_eFaststepConnectionFailure;
+VALUE rb_eFaststepOperationFailure;
 
 void Init_faststep() {
   rb_mFaststep = rb_define_module("Faststep");
-  rb_mBson     = rb_const_get(rb_cObject, rb_intern("BSON"));
+  rb_define_const(rb_mFaststep, "DESCENDING", NUM2INT(-1));
+  rb_define_const(rb_mFaststep, "ASCENDING",  NUM2INT(1));
+
+  rb_mBson            = rb_const_get(rb_cObject, rb_intern("BSON"));
+  rb_cBsonOrderedHash = rb_const_get(rb_mBson, rb_intern("OrderedHash"));
+  rb_cBsonObjectId    = rb_const_get(rb_mBson, rb_intern("ObjectId"));
 
   faststep_connection_main();
   faststep_db_main();

data/ext/faststep/faststep_defines.h

@@ -5,7 +5,9 @@ RUBY_EXTERN VALUE rb_cFaststepDb;
 RUBY_EXTERN VALUE rb_cFaststepCollection;
 RUBY_EXTERN VALUE rb_cFaststepCursor;
 
-RUBY_EXTERN VALUE rb_cFaststepConnectionFailure;
-RUBY_EXTERN VALUE rb_cFaststepOperationFailure;
+RUBY_EXTERN VALUE rb_eFaststepConnectionFailure;
+RUBY_EXTERN VALUE rb_eFaststepOperationFailure;
 
 RUBY_EXTERN VALUE rb_mBson;
+RUBY_EXTERN VALUE rb_cBsonOrderedHash;
+RUBY_EXTERN VALUE rb_cBsonObjectId;

data/lib/faststep/connection.rb

@@ -1,13 +1,7 @@
 module Faststep
   class Connection
-    DEFAULT_PORT = 27017
-
-    def db(database_name)
-      Db.new(database_name, self)
-    end
-
     def drop_database(database_name)
-      Db.new(database_name, self).drop
+      db(database_name).drop
     end
   end
 end

data/lib/faststep/version.rb

@@ -1,3 +1,3 @@
 module Faststep
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/lib/faststep.rb

@@ -3,7 +3,6 @@ require "bson"
 module Faststep
   autoload :Db,         "faststep/db"
   autoload :Connection, "faststep/connection"
-  autoload :Collection, "faststep/collection"
   autoload :Cursor,     "faststep/cursor"
 end
 

data/spec/collection_spec.rb

@@ -28,6 +28,12 @@ describe Faststep::Collection do
     db["another.thing"].find({}).first["baz"].should == "qux"
   end
 
+  it "finds single documents" do
+    10.times { db["something"].insert(:foo => "bar") }
+    db["something"].find_one({:foo => "bar"})["foo"].should == "bar"
+    db["something"].find_one(BSON::ObjectId.new).should be_nil
+  end
+
   it "updates documents" do
     db["something"].insert(:foo => "bar", :something => "fun")
     db["something"].update({ :something => "fun" }, { "$set" => { :foo => "awesome" } })

data/spec/cursor_spec.rb

@@ -10,15 +10,69 @@ describe Faststep::Cursor do
     cursor = Faststep::Cursor.new(collection, {})
     cursor.to_a.length.should_not == 0
     cursor.each do |doc|
-      doc[:foo].should == "bar"
+      doc["foo"].should == "bar"
     end
   end
 
-  it "caches documents" do
-    10.times { collection.insert(:foo => "bar") }
+  it "finds specific fields for a document" do
+    collection.insert(:name => "John Doe", :age => 25, :gender => "Male",   :postal_code => "02108")
+    collection.insert(:name => "Jane Doe", :age => 22, :gender => "Female", :postal_code => "02108")
 
-    cursor = Faststep::Cursor.new(collection, {})
-    cursor.to_a.length.should == 10
-    cursor.to_a.length.should == 10
+    documents = collection.find.fields(%w(name age)).to_a
+
+    documents.each do |document|
+      document.has_key?("name").should be_true
+      document.has_key?("age").should be_true
+      document.has_key?("_id").should be_true
+      document.has_key?("gender").should be_false
+      document.has_key?("postal_code").should be_false
+    end
+  end
+
+  it "limits documents" do
+    10.times.map { |i| collection.insert(:name => "Person #{i}") }
+
+    documents = collection.find.limit(2).to_a
+    documents.map {|doc| doc["name"] }.should == ["Person 0", "Person 1"]
+
+    documents = collection.find({}).limit(1).to_a
+    documents.length.should == 1
+    documents.first["name"].should == "Person 0"
+  end
+
+  it "skips documents" do
+    collection.insert(:name => "John Doe",   :age => 25, :gender => "Male",   :postal_code => "02108")
+    collection.insert(:name => "Jane Doe",   :age => 22, :gender => "Female", :postal_code => "02108")
+    collection.insert(:name => "John Smith", :age => 40, :gender => "Male",   :postal_code => "02108")
+
+    documents = collection.find.skip(1).to_a
+    documents.length.should == 2
+    documents[0]["name"].should == "Jane Doe"
+    documents[1]["name"].should == "John Smith"
+  end
+
+  it "orders documents" do
+    10.times.map { |i| collection.insert(:name => "Person #{i}", :age => 24) }
+    collection.insert(:name => "Person 9", :age => 20)
+    collection.find.order([[:name, Faststep::DESCENDING], [:age, Faststep::ASCENDING]]).to_a.tap do |documents|
+      documents.first["name"].should == "Person 9"
+      documents.first["age"].should  == 20
+    end
+
+    collection.find.order([[:age, Faststep::DESCENDING], [:name, Faststep::ASCENDING]]).to_a.tap do |documents|
+      documents.first["name"].should == "Person 0"
+    end
+
+    collection.find.order([[:age, Faststep::DESCENDING], [:name, Faststep::DESCENDING]]).to_a.tap do |documents|
+      documents.first["name"].should == "Person 9"
+      documents.first["age"].should  == 24
+    end
+  end
+
+  it "explains queries" do
+    result = collection.find.explain
+    result.should have_key("cursor")
+    result.should have_key("nscanned")
+    result.should have_key("n")
   end
 end

metadata

@@ -1,13 +1,8 @@
 --- !ruby/object:Gem::Specification 
 name: faststep
 version: !ruby/object:Gem::Version 
-  hash: 29
   prerelease: 
-  segments: 
-  - 0
-  - 0
-  - 1
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors: 
 - Josh Clayton
@@ -15,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-03-18 00:00:00 -04:00
+date: 2011-03-20 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -26,11 +21,6 @@ dependencies:
     requirements: 
     - - "="
       - !ruby/object:Gem::Version 
-        hash: 15
-        segments: 
-        - 0
-        - 7
-        - 6
         version: 0.7.6
   type: :runtime
   version_requirements: *id001
@@ -42,11 +32,6 @@ dependencies:
     requirements: 
     - - "="
       - !ruby/object:Gem::Version 
-        hash: 23
-        segments: 
-        - 1
-        - 2
-        - 4
         version: 1.2.4
   type: :runtime
   version_requirements: *id002
@@ -58,11 +43,6 @@ dependencies:
     requirements: 
     - - "="
       - !ruby/object:Gem::Version 
-        hash: 23
-        segments: 
-        - 1
-        - 2
-        - 4
         version: 1.2.4
   type: :runtime
   version_requirements: *id003
@@ -74,11 +54,6 @@ dependencies:
     requirements: 
     - - "="
       - !ruby/object:Gem::Version 
-        hash: 27
-        segments: 
-        - 2
-        - 5
-        - 0
         version: 2.5.0
   type: :development
   version_requirements: *id004
@@ -94,6 +69,8 @@ extra_rdoc_files: []
 files: 
 - .gitignore
 - Gemfile
+- LICENSE
+- README.markdown
 - Rakefile
 - bench/standard_benchmark
 - ext/faststep/bson.c
@@ -127,7 +104,6 @@ files:
 - ext/faststep/support.h
 - faststep.gemspec
 - lib/faststep.rb
-- lib/faststep/collection.rb
 - lib/faststep/connection.rb
 - lib/faststep/cursor.rb
 - lib/faststep/db.rb
@@ -152,23 +128,17 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
       version: "0"
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.4.2
+rubygems_version: 1.6.2
 signing_key: 
 specification_version: 3
 summary: Mongo on Speed

data/lib/faststep/collection.rb

@@ -1,21 +0,0 @@
-module Faststep
-  class Collection
-    def find(selector = {}, options = {})
-      Cursor.new(self, "selector" => selector)
-    end
-
-    def find_one(spec_or_object_id=nil, opts={})
-      spec = case spec_or_object_id
-             when nil
-               {}
-             when BSON::ObjectId
-               {:_id => spec_or_object_id}
-             when Hash
-               spec_or_object_id
-             else
-               raise TypeError, "spec_or_object_id must be an instance of ObjectId or Hash, or nil"
-             end
-      find(spec, opts.merge(:limit => -1)).first
-    end
-  end
-end