faststep 0.0.4 → 0.0.5

data/README.markdown

@@ -35,7 +35,7 @@ Have some fun!
     >> 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
+    => true
     >> db["users"].count(:name => /0$/)
     => 0
     >> db["users"].count
@@ -47,13 +47,13 @@ Have some fun!
 
 ### 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.
+This is under heavy development (what gem isn't?) but there's a lot of stuff to be implemented still.
 It's not nearly as smart as the mongo Ruby driver and it doesn't handle errors that well.
 
 ### Todo
 
 * Connection pooling
-* Safe mode
+* Safe mode (per database or connection)
 * Master/slave
 * Replica sets
 

data/ext/faststep/bson_ruby_conversion.c

@@ -56,10 +56,19 @@ VALUE ensure_document_ok(const VALUE document) {
 }
 
 static char* _invalid_command_description(const VALUE document) {
-  VALUE message = rb_str_new2("Invalid command (");
-  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")));
+  VALUE message = rb_str_new2("");
+
+  if(RTEST(rb_hash_aref(document, rb_str_new2("bad cmd")))) {
+    rb_str_concat(message, rb_str_new2("Invalid command ("));
+    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")));
+  } else {
+    rb_str_concat(message, rb_str_new2("Error ("));
+    rb_str_concat(message, rb_inspect(rb_hash_aref(document, rb_str_new2("code"))));
+    rb_str_concat(message, rb_str_new2("): "));
+    rb_str_concat(message, rb_hash_aref(document, rb_str_new2("err")));
+  }
 
   return RSTRING_PTR(message);
 }

data/ext/faststep/collection.c

@@ -15,7 +15,7 @@ void faststep_collection_main() {
   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, "insert",       faststep_collection_insert, -1);
   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);
@@ -103,9 +103,12 @@ void build_collection_ns(char* ns, const char* database, const char* collection)
   return;
 }
 
-static VALUE faststep_collection_insert(const VALUE self, const VALUE documents) {
+static VALUE faststep_collection_insert(int argc, VALUE* argv, const VALUE self) {
   mongo_connection* conn = GetFaststepConnectionForCollection(self);
 
+  VALUE documents, options;
+  rb_scan_args(argc, argv, "11", &documents, &options);
+
   VALUE ns = faststep_collection_ns(self);
 
   if(TYPE(documents) == T_ARRAY) {
@@ -114,7 +117,7 @@ static VALUE faststep_collection_insert(const VALUE self, const VALUE documents)
     _faststep_collection_insert_one(conn, RSTRING_PTR(ns), documents);
   }
 
-  return Qtrue;
+  return _faststep_safe_operation(self, options);
 }
 
 static VALUE faststep_collection_update(int argc, VALUE* argv, VALUE self) {
@@ -145,12 +148,12 @@ static VALUE faststep_collection_update(int argc, VALUE* argv, VALUE self) {
   bson_destroy(bson_query);
   bson_destroy(bson_operations);
 
-  return Qtrue;
+  return _faststep_safe_operation(self, options);
 }
 
 static VALUE faststep_collection_remove(int argc, VALUE* argv, VALUE self) {
-  VALUE query;
-  rb_scan_args(argc, argv, "01", &query);
+  VALUE query, options;
+  rb_scan_args(argc, argv, "02", &query, &options);
 
   bson* bson_query = create_bson_from_ruby_hash(query);
 
@@ -158,7 +161,8 @@ static VALUE faststep_collection_remove(int argc, VALUE* argv, VALUE self) {
                RSTRING_PTR(faststep_collection_ns(self)),
                bson_query);
   bson_destroy(bson_query);
-  return Qnil;
+
+  return _faststep_safe_operation(self, options);
 }
 
 static VALUE faststep_collection_drop(const VALUE self) {
@@ -244,3 +248,21 @@ mongo_connection* GetFaststepConnectionForCollection(const VALUE collection) {
 
   return GetFaststepConnection(connection);
 }
+
+static VALUE _faststep_safe_operation(const VALUE self, const VALUE options) {
+  int safe_mode = 0;
+
+  if(TYPE(options) == T_HASH) {
+    if(rb_indiff_hash_aref(options, rb_str_new2("safe")) == Qtrue) {
+      safe_mode = 1;
+    }
+  }
+
+  if(safe_mode) {
+    VALUE document = rb_funcall(rb_iv_get(self, "@db"), rb_intern("get_last_error"), 0);
+    ensure_document_ok(document);
+    return document;
+  } else {
+    return Qtrue;
+  }
+}

data/ext/faststep/collection.h

@@ -9,7 +9,7 @@ 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(const VALUE, const VALUE);
+static VALUE faststep_collection_insert(int, 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);
@@ -20,6 +20,7 @@ static void _faststep_collection_insert_one(mongo_connection*, const char*, cons
 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);
+static VALUE _faststep_safe_operation(const VALUE, const VALUE);
 
 void build_collection_ns(char*, const char*, const char*);
 static char* _ivar_name(const VALUE);

data/ext/faststep/support.c

@@ -8,13 +8,10 @@ void faststep_support_main() {
 }
 
 static VALUE faststep_support_ok(VALUE self, VALUE document) {
-  VALUE ok_value = rb_hash_aref(document, rb_str_new2("ok"));
-
-  bson_bool_t result = 0;
-
-  switch(TYPE(ok_value)) {
-    case T_FLOAT: result = FIX2INT(ok_value); break;
-    case T_TRUE:  result = 1; break;
+  bson_bool_t result = 1;
+  if(RTEST(rb_hash_aref(document, rb_str_new2("err"))) ||
+      RTEST(rb_hash_aref(document, rb_str_new2("errmsg")))) {
+    result = 0;
   }
 
   return bool_to_ruby(result);

data/lib/faststep/version.rb

@@ -1,3 +1,3 @@
 module Faststep
-  VERSION = "0.0.4"
+  VERSION = "0.0.5"
 end

data/spec/collection_spec.rb

@@ -17,16 +17,6 @@ describe Faststep::Collection do
     db["something"].find_one(BSON::ObjectId.new).should be_nil
   end
 
-  it "removes documents" do
-    db["something"].insert(5.times.map { {:foo => "bar", :something => "fun"} })
-    db["something"].insert(:foo => "bar", :baz => "what!")
-
-    db["something"].remove(:baz => "what!")
-    db["something"].count.should == 5
-    db["something"].remove
-    db["something"].count.should be_zero
-  end
-
   it "drops collections" do
     db["something"].insert(:foo => "bar")
     db["something"].drop
@@ -105,6 +95,20 @@ describe Faststep::Collection, "#insert" do
     db["another.thing"].count(:baz => "qux").should == 1
   end
 
+  it "inserts documents in safe mode" do
+    document_id = BSON::ObjectId.new
+    db["something"].insert({ :_id => document_id, :something => "great" }, { :safe => true })
+
+    expect {
+      db["something"].insert({ :_id => document_id, :something => "great" })
+    }.to_not raise_error
+
+    expect {
+      db["something"].insert({ :_id => document_id, :something => "great" },
+                             { :safe => true })
+    }.to raise_error(Faststep::OperationFailure, /Error \(11000\): .*duplicate key error index/)
+  end
+
   it "supports batch inserting" do
     db["something"].insert([small_document] * document_count)
     db["something"].count("foo" => "bar").should == document_count
@@ -144,4 +148,33 @@ describe Faststep::Collection, "#update" do
     db["something"].count.should == 1
     db["something"].find_one["count"].should == 2
   end
+
+  it "updates documents in safe mode" do
+    expect {
+      db["something"].update({},
+                             { "$set" => { "invalid." => 1 } },
+                             { :safe => true })
+    }.to raise_error(Faststep::OperationFailure, /Error \(10149\): Invalid mod field name/)
+  end
+end
+
+describe Faststep::Collection, "#remove" do
+  let(:db) { $faststep_test_db }
+
+  before do
+    db["something"].insert(5.times.map { {:foo => "bar", :something => "fun"} })
+    db["something"].insert(:foo => "bar", :baz => "what!")
+
+  end
+
+  it "removes documents" do
+    db["something"].remove(:baz => "what!")
+    db["something"].count.should == 5
+    db["something"].remove
+    db["something"].count.should be_zero
+  end
+
+  it "removes documents in safe mode" do
+    db["something"].remove({}, { :safe => true })["n"].should == 6
+  end
 end

data/spec/connection_spec.rb

@@ -28,8 +28,7 @@ describe Faststep::Connection, "getting a database" do
   subject { Faststep::Connection.new }
 
   it "uses a database" do
-    subject[$faststep_test_db.name]["something"].insert(:foo => "bar")
-    $faststep_test_db["something"].count.should == 1
+    subject[$faststep_test_db.name].should be_a(Faststep::Db)
   end
 end
 

data/spec/db_spec.rb

@@ -13,7 +13,10 @@ describe Faststep::Db do
 
   it "runs specific commands" do
     expect { subject.command(:dbstats => 1) }.to_not raise_error
-    expect { subject.command(:totally_bogus => 1) }.to raise_error(Faststep::OperationFailure)
+    expect {
+      subject.command(:totally_bogus => 1)
+    }.to raise_error(Faststep::OperationFailure,
+                     %{Invalid command ({"totally_bogus"=>1}): no such cmd: totally_bogus})
   end
 
   it "drops the database" do

data/spec/support_spec.rb

@@ -1,14 +1,13 @@
 require "spec_helper"
 
 describe Faststep::Support, "ok?" do
-  it "returns true when response is ok" do
+  it "returns true when no err or errmsg key is present" do
     Faststep::Support.ok?({ "ok" => true }).should be_true
     Faststep::Support.ok?({ "ok" => 1.0 }).should be_true
   end
 
   it "returns false when response is not ok" do
-    Faststep::Support.ok?({ "ok" => false }).should be_false
-    Faststep::Support.ok?({ "ok" => 0.0 }).should be_false
-    Faststep::Support.ok?({ "ok" => nil }).should be_false
+    Faststep::Support.ok?({ "err" => "something broke" }).should be_false
+    Faststep::Support.ok?({ "errmsg" => "something else broke" }).should be_false
   end
 end

metadata

@@ -2,7 +2,7 @@
 name: faststep
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.0.4
+  version: 0.0.5
 platform: ruby
 authors: 
 - Josh Clayton
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-04-18 00:00:00 -04:00
+date: 2011-04-23 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency