faststep 0.0.2 → 0.0.3

data/README.markdown

@@ -50,7 +50,6 @@ It's not nearly as smart as the mongo Ruby driver and it doesn't handle errors t
 
 * Connection pooling
 * Safe mode
-* Allow updates to *not* be multi (currently unconfigurable)
 * Master/slave
 * Replica sets
 

data/ext/faststep/bson_ruby_conversion.c

@@ -2,7 +2,7 @@
 #include "faststep_defines.h"
 
 bson* create_bson_from_ruby_hash(const VALUE hash) {
-  bson* document = bson_malloc(sizeof(bson));
+  bson* document = (bson*)bson_malloc(sizeof(bson));
 
   if(NIL_P(hash)) {
     bson_empty(document);
@@ -28,7 +28,7 @@ bson* bson_from_ruby_array(const VALUE array) {
     }
   }
 
-  create_bson_from_ruby_hash(hash);
+  return create_bson_from_ruby_hash(hash);
 }
 
 VALUE ruby_array_to_bson_ordered_hash(const VALUE array) {
@@ -48,11 +48,11 @@ 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_eFaststepOperationFailure, _invalid_command_description(document));
   }
+  return Qtrue;
 }
 
 static char* _invalid_command_description(const VALUE document) {
@@ -65,6 +65,6 @@ static char* _invalid_command_description(const VALUE document) {
 }
 
 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));
+  rb_funcall(hash, rb_intern("[]="), 2, rb_ary_entry(item, 0), rb_ary_entry(item, 1));
   return hash;
 }

data/ext/faststep/collection.c

@@ -2,6 +2,7 @@
 #include "connection.h"
 #include "bson_ruby_conversion.h"
 #include "faststep_defines.h"
+#include "utilities.h"
 #include <string.h>
 
 void faststep_collection_main() {
@@ -15,7 +16,7 @@ void faststep_collection_main() {
   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);
+  rb_define_method(rb_cFaststepCollection, "update",       faststep_collection_update, -1);
   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);
@@ -116,15 +117,30 @@ static VALUE faststep_collection_insert(const VALUE self, const VALUE documents)
   return Qtrue;
 }
 
-static VALUE faststep_collection_update(const VALUE self, const VALUE query, const VALUE operations) {
+static VALUE faststep_collection_update(int argc, VALUE* argv, VALUE self) {
+  VALUE query, operations, options;
+  rb_scan_args(argc, argv, "21", &query, &operations, &options);
+
   bson* bson_query      = create_bson_from_ruby_hash(query);
   bson* bson_operations = create_bson_from_ruby_hash(operations);
 
+  int update_flags = 0;
+
+  if(TYPE(options) == T_HASH) {
+    if(rb_indiff_hash_aref(options, rb_str_new2("multi")) == Qtrue) {
+      update_flags |= MONGO_UPDATE_MULTI;
+    }
+
+    if(rb_indiff_hash_aref(options, rb_str_new2("upsert")) == Qtrue) {
+      update_flags |= MONGO_UPDATE_UPSERT;
+    }
+  }
+
   mongo_update(GetFaststepConnectionForCollection(self),
                RSTRING_PTR(faststep_collection_ns(self)),
                bson_query,
                bson_operations,
-               MONGO_UPDATE_MULTI);
+               update_flags);
 
   bson_destroy(bson_query);
   bson_destroy(bson_operations);

data/ext/faststep/collection.h

@@ -10,7 +10,7 @@ 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(const VALUE, const VALUE);
-static VALUE faststep_collection_update(const VALUE, const VALUE, const VALUE);
+static VALUE faststep_collection_update(int, VALUE*, const VALUE);
 static VALUE faststep_collection_remove(int, VALUE*, VALUE);
 static VALUE faststep_collection_drop(const VALUE);
 static VALUE faststep_collection_create_index(const VALUE, const VALUE);

data/ext/faststep/connection.c

@@ -31,7 +31,7 @@ static VALUE faststep_connection_init(VALUE self, const VALUE host, const VALUE
 }
 
 static VALUE faststep_connection_new(VALUE class, const VALUE host, const VALUE port) {
-  mongo_connection* conn = bson_malloc(sizeof(mongo_connection));
+  mongo_connection* conn = (mongo_connection*)bson_malloc(sizeof(mongo_connection));
 
   VALUE tdata = Data_Wrap_Struct(class, NULL, mongo_destroy, conn);
 
@@ -45,7 +45,7 @@ static VALUE faststep_connection_new(VALUE class, const VALUE host, const VALUE
 }
 
 static VALUE faststep_connection_connect(VALUE self) {
-  mongo_connection_options* options = bson_malloc(sizeof(mongo_connection_options));
+  mongo_connection_options* options = (mongo_connection_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"));

data/ext/faststep/cursor.c

@@ -9,6 +9,8 @@ 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, -1);
+
   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);
@@ -42,11 +44,28 @@ static VALUE faststep_cursor_init(int argc, VALUE* argv, VALUE self) {
   return self;
 }
 
+static VALUE faststep_cursor_new(int argc, VALUE* argv, VALUE class) {
+  faststep_cursor* fs_cursor = (faststep_cursor*)bson_malloc(sizeof(faststep_cursor));
+  mongo_cursor* cursor = (mongo_cursor*)bson_malloc(sizeof(mongo_cursor));
+
+  fs_cursor->cursor = cursor;
+  fs_cursor->initialized = 0;
+
+  VALUE tdata = Data_Wrap_Struct(class, NULL, _faststep_destroy_cursor, fs_cursor);
+
+  rb_obj_call_init(tdata, argc, argv);
+  return tdata;
+}
+
 static VALUE faststep_cursor_each(const VALUE self) {
-  mongo_cursor* cursor = _faststep_build_mongo_cursor(self);
+  faststep_cursor* fs_cursor;
+  Data_Get_Struct(self, faststep_cursor, fs_cursor);
 
-  while(mongo_cursor_next(cursor)) {
-    rb_yield(ruby_hash_from_bson(&cursor->current));
+  fs_cursor->cursor      = _faststep_build_mongo_cursor(self);
+  fs_cursor->initialized = 1;
+
+  while(mongo_cursor_next(fs_cursor->cursor)) {
+    rb_yield(ruby_hash_from_bson(&fs_cursor->cursor->current));
   }
 }
 
@@ -85,15 +104,13 @@ 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 limit = 0,
+      skip  = 0;
+  VALUE limit_value = rb_iv_get(self, "@limit"),
+        skip_value  = rb_iv_get(self, "@skip");
 
-  int skip = 0;
-  if(RTEST(rb_iv_get(self, "@skip"))) {
-    skip = FIX2INT(rb_iv_get(self, "@skip"));
-  }
+  if(RTEST(limit_value)) { limit = -1*FIX2INT(limit_value); }
+  if(RTEST(skip_value))  { skip  = FIX2INT(skip_value); }
 
   VALUE collection = rb_iv_get(self, "@collection");
 
@@ -110,15 +127,30 @@ static mongo_cursor* _faststep_build_mongo_cursor(VALUE self) {
 }
 
 static VALUE _faststep_build_full_query(VALUE self) {
-  if(RTEST(rb_iv_get(self, "@explain")) || RTEST(rb_iv_get(self, "@order"))) {
+  VALUE order_value    = rb_iv_get(self, "@order"),
+        explain_value  = rb_iv_get(self, "@explain"),
+        selector_value = rb_iv_get(self, "@selector");
+
+  if(RTEST(explain_value) || RTEST(order_value)) {
     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"));
+    rb_hash_aset(full_query, rb_str_new2("$query"), selector_value);
+    rb_hash_aset(full_query, rb_str_new2("$explain"), explain_value);
+    if(RTEST(order_value)) {
+      rb_hash_aset(full_query, rb_str_new2("$orderby"), order_value);
     }
     return full_query;
   } else {
-    return rb_iv_get(self, "@selector");
+    return selector_value;
+  }
+}
+
+static void _faststep_destroy_cursor(faststep_cursor* cursor) {
+  if(cursor->initialized == 1) {
+    mongo_cursor_destroy(cursor->cursor);
+    cursor->initialized = 0;
   }
+
+  free(cursor);
+
+  return;
 }

data/ext/faststep/cursor.h

@@ -2,8 +2,15 @@
 #include <ruby.h>
 #include "mongo.h"
 #define CURSOR_h
+
+typedef struct {
+  mongo_cursor* cursor;
+  int initialized;
+} faststep_cursor;
+
 void  faststep_cursor_main();
 static VALUE faststep_cursor_init(int, VALUE*, VALUE);
+static VALUE faststep_cursor_new(int, VALUE*, VALUE);
 static VALUE faststep_cursor_each(const VALUE);
 static VALUE faststep_cursor_explain(VALUE);
 static VALUE faststep_cursor_skip(VALUE, const VALUE);
@@ -12,4 +19,6 @@ 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);
+static void  _faststep_destroy_cursor(faststep_cursor*);
+
 #endif

data/ext/faststep/db.c

@@ -14,9 +14,10 @@ void faststep_db_main() {
 
   rb_define_alias(rb_cFaststepDb, "[]", "collection");
 
-  rb_define_method(rb_cFaststepDb, "initialize", faststep_db_init, 2);
-  rb_define_method(rb_cFaststepDb, "drop",       faststep_db_drop, 0);
-  rb_define_method(rb_cFaststepDb, "command",    faststep_db_command, 1);
+  rb_define_method(rb_cFaststepDb, "initialize",     faststep_db_init, 2);
+  rb_define_method(rb_cFaststepDb, "drop",           faststep_db_drop, 0);
+  rb_define_method(rb_cFaststepDb, "command",        faststep_db_command, 1);
+  rb_define_method(rb_cFaststepDb, "get_last_error", faststep_db_get_last_error, 0);
 }
 
 static VALUE faststep_db_init(VALUE self, VALUE name, VALUE connection) {
@@ -33,24 +34,37 @@ static VALUE faststep_db_drop(VALUE self) {
 }
 
 static VALUE faststep_db_command(VALUE self, VALUE command) {
-  mongo_connection* conn = GetFaststepConnection(rb_iv_get(self, "@connection"));
-
-  bson* result = bson_malloc(sizeof(bson));
-  bson_init(result, "", 1);
-
+  bson* result       = (bson*)bson_malloc(sizeof(bson));
   bson* bson_command = create_bson_from_ruby_hash(command);
 
   char ns[500] = "";
   build_collection_ns(ns, RSTRING_PTR(rb_iv_get(self, "@name")), "$cmd");
 
-  mongo_find_one(conn, ns, bson_command, NULL, result);
-
-  bson_destroy(bson_command);
+  mongo_find_one(GetFaststepConnection(rb_iv_get(self, "@connection")),
+                 ns,
+                 bson_command,
+                 NULL,
+                 result);
 
   VALUE hash = ruby_hash_from_bson(result);
+
   bson_destroy(result);
+  bson_destroy(bson_command);
 
   ensure_document_ok(hash);
 
   return hash;
 }
+
+static VALUE faststep_db_get_last_error(VALUE self) {
+  bson* result = (bson*)bson_malloc(sizeof(bson));
+
+  mongo_cmd_get_last_error(GetFaststepConnection(rb_iv_get(self, "@connection")),
+                           RSTRING_PTR(rb_iv_get(self, "@name")),
+                           result);
+
+  VALUE last_error = ruby_hash_from_bson(result);
+  bson_destroy(result);
+
+  return last_error;
+}

data/ext/faststep/db.h

@@ -5,4 +5,5 @@ void  faststep_db_main();
 static VALUE faststep_db_init(VALUE, VALUE, VALUE);
 static VALUE faststep_db_drop(VALUE);
 static VALUE faststep_db_command(VALUE, VALUE);
+static VALUE faststep_db_get_last_error(VALUE);
 #endif

data/ext/faststep/faststep.c

@@ -22,8 +22,6 @@ VALUE rb_eFaststepOperationFailure;
 
 void Init_faststep() {
   rb_mFaststep = rb_define_module("Faststep");
-  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"));

data/ext/faststep/utilities.c

@@ -0,0 +1,17 @@
+#include "utilities.h"
+
+VALUE rb_str_to_sym(const VALUE str) {
+  return ID2SYM(rb_intern(RSTRING_PTR(str)));
+}
+
+VALUE rb_indiff_hash_aref(const VALUE hash, const VALUE key) {
+  VALUE string_key, symbol_key;
+
+  if(RTEST(string_key = rb_hash_aref(hash, key))) {
+    return string_key;
+  } else if(RTEST(symbol_key = rb_hash_aref(hash, rb_str_to_sym(key)))) {
+    return symbol_key;
+  } else {
+    return Qnil;
+  }
+}

data/ext/faststep/utilities.h

@@ -0,0 +1,6 @@
+#ifndef UTILITIES_H
+#include <ruby.h>
+#define UTILITIES_H
+VALUE rb_indiff_hash_aref(const VALUE, const VALUE);
+VALUE rb_str_to_sym(const VALUE);
+#endif

data/lib/faststep/version.rb

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

data/lib/faststep.rb

@@ -1,6 +1,8 @@
 require "bson"
 
 module Faststep
+  ASCENDING  =  1
+  DESCENDING = -1
   autoload :Db,         "faststep/db"
   autoload :Connection, "faststep/connection"
   autoload :Cursor,     "faststep/cursor"

data/spec/collection_spec.rb

@@ -3,23 +3,6 @@ require "spec_helper"
 describe Faststep::Collection do
   let(:db) { $faststep_test_db }
 
-  it "inserts the correct documents" do
-    db["something"].insert(:foo => "bar")
-    db["another.thing"].insert(:baz => "qux")
-
-    db["something"].count(:foo => "bar").should == 1
-    db["something"].count(:baz => "qux").should == 0
-    db["another.thing"].count(:foo => "bar").should == 0
-    db["another.thing"].count(:foo => true).should == 0
-    db["another.thing"].count(:baz => "qux").should == 1
-  end
-
-  it "supports batch inserting" do
-    db["something"].insert([{:foo => "bar"}, {:baz => "qux"}])
-    db["something"].count.should == 2
-    db["something"].count(:foo => "bar").should == 1
-  end
-
   it "finds documents" do
     db["something"].insert(:foo => "bar")
     db["another.thing"].insert(:baz => "qux")
@@ -34,13 +17,6 @@ describe Faststep::Collection do
     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" } })
-
-    db["something"].find({}).first["foo"].should == "awesome"
-  end
-
   it "removes documents" do
     db["something"].insert(5.times.map { {:foo => "bar", :something => "fun"} })
     db["something"].insert(:foo => "bar", :baz => "what!")
@@ -90,7 +66,11 @@ describe Faststep::Collection, "queries" do
 end
 
 describe Faststep::Collection, "#insert" do
-  let(:large) {
+  let(:small_document) {
+    { "foo" => "bar" }
+  }
+
+  let(:large_document) {
     {
       'base_url' => 'http://www.example.com/test-me',
       'total_word_count' => 6743,
@@ -114,9 +94,54 @@ describe Faststep::Collection, "#insert" do
   let(:db) { $faststep_test_db }
   let(:document_count) { 50 }
 
+  it "inserts the correct documents" do
+    db["something"].insert(:foo => "bar")
+    db["another.thing"].insert(:baz => "qux")
+
+    db["something"].count(:foo => "bar").should == 1
+    db["something"].count(:baz => "qux").should == 0
+    db["another.thing"].count(:foo => "bar").should == 0
+    db["another.thing"].count(:foo => true).should == 0
+    db["another.thing"].count(:baz => "qux").should == 1
+  end
+
+  it "supports batch inserting" do
+    db["something"].insert([small_document] * document_count)
+    db["something"].count("foo" => "bar").should == document_count
+  end
+
   it "batch inserts multiple large documents" do
-    db["something"].insert([large] * document_count)
+    db["something"].insert([large_document] * document_count)
     db["something"].count.should == document_count
-    db["something"].count("base_url" => large["base_url"]).should == document_count
+    db["something"].count("base_url" => large_document["base_url"]).should == document_count
+  end
+end
+
+describe Faststep::Collection, "#update" do
+  let(:db) { $faststep_test_db }
+
+  it "updates documents" do
+    2.times { db["something"].insert(:foo => "bar", :something => "fun") }
+
+    db["something"].update({ :something => "fun" }, { "$set" => { :foo => "awesome" } })
+    db["something"].count(:foo => "awesome").should == 1
+    db["something"].count(:foo => "bar").should == 1
+  end
+
+  it "multi-updates documents" do
+    2.times { db["something"].insert(:foo => "bar", :something => "fun") }
+
+    db["something"].update({ :something => "fun" }, { "$set" => { :foo => "awesome" } }, :multi => true)
+    db["something"].count(:foo => "awesome").should == 2
+    db["something"].count(:foo => "bar").should be_zero
+  end
+
+  it "upserts documents" do
+    2.times do
+      db["something"].update({ "email" => "john@example.com" }, { "$inc" => { "count" => 1 } }, :upsert => true)
+    end
+
+    db["something"].count.should == 1
+    db["something"].find_one["count"].should == 2
   end
 end

data/spec/db_spec.rb

@@ -25,4 +25,13 @@ describe Faststep::Db do
     subject["something"].count.should be_zero
     subject["another.thing"].count.should be_zero
   end
+
+  it "gets the last error" do
+    subject["something"].insert(:foo => "bar")
+    subject.get_last_error.tap do |result|
+      result.should have_key("ok")
+      result.should have_key("n")
+      result.should have_key("err")
+    end
+  end
 end

metadata

@@ -2,7 +2,7 @@
 name: faststep
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors: 
 - Josh Clayton
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-03-20 00:00:00 -04:00
+date: 2011-03-25 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -102,6 +102,8 @@ files:
 - ext/faststep/platform_hacks.h
 - ext/faststep/support.c
 - ext/faststep/support.h
+- ext/faststep/utilities.c
+- ext/faststep/utilities.h
 - faststep.gemspec
 - lib/faststep.rb
 - lib/faststep/connection.rb