mongodb-mongo_ext 0.1.1 → 0.3

data/Rakefile

@@ -11,6 +11,9 @@ end
 require 'rbconfig'
 include Config
 
+gem_command = "gem"
+gem_command = "gem1.9" if CONFIG["MAJOR"] == "1" && CONFIG["MINOR"] == "9"
+
 # NOTE: some of the tests assume Mongo is running
 Rake::TestTask.new do |t|
   t.test_files = FileList['tests/test*.rb']
@@ -18,8 +21,10 @@ end
 
 desc "Generate documentation"
 task :rdoc do
+  version = eval(File.read("mongo-ruby-driver.gemspec")).version
+  out = File.join('html', version.to_s)
   FileUtils.rm_rf('html')
-  system "rdoc --main README.rdoc --op html --inline-source --quiet README.rdoc `find lib -name '*.rb'`"
+  system "rdoc --main README.rdoc --op #{out} --inline-source --quiet README.rdoc `find lib -name '*.rb'`"
 end
 
 desc "Publish documentation to mongo.rubyforge.org"
@@ -33,8 +38,8 @@ namespace :gem do
   desc "Install the gem locally"
   task :install do
     sh <<EOS
-gem build mongo-ruby-driver.gemspec &&
-    sudo gem install mongo-*.gem &&
+#{gem_command} build mongo-ruby-driver.gemspec &&
+    sudo #{gem_command} install mongo-*.gem &&
     rm mongo-*.gem
 EOS
   end
@@ -42,8 +47,8 @@ EOS
   desc "Install the optional c extensions"
   task :install_extensions do
     sh <<EOS
-gem build mongo-extensions.gemspec &&
-    sudo gem install mongo_ext-*.gem &&
+#{gem_command} build mongo-extensions.gemspec &&
+    sudo #{gem_command} install mongo_ext-*.gem &&
     rm mongo_ext-*.gem
 EOS
   end

data/ext/cbson/cbson.c

@@ -24,6 +24,7 @@
 #include "st.h"
 #include "regex.h"
 #include <assert.h>
+#include <math.h>
 
 #define INITIAL_BUFFER_SIZE 256
 
@@ -36,6 +37,23 @@ static VALUE Code;
 static VALUE RegexpOfHolding;
 static VALUE OrderedHash;
 
+// this sucks. but for some reason these moved around between 1.8 and 1.9
+#ifdef ONIGURUMA_H
+#define IGNORECASE ONIG_OPTION_IGNORECASE
+#define MULTILINE ONIG_OPTION_MULTILINE
+#define EXTENDED ONIG_OPTION_EXTEND
+#else
+#define IGNORECASE RE_OPTION_IGNORECASE
+#define MULTILINE RE_OPTION_MULTILINE
+#define EXTENDED RE_OPTION_EXTENDED
+#endif
+
+// this sucks too.
+#ifndef RREGEXP_SRC_PTR
+#define RREGEXP_SRC_PTR(r) RREGEXP(r)->str
+#define RREGEXP_SRC_LEN(r) RREGEXP(r)->len
+#endif
+
 typedef struct {
     char* buffer;
     int size;
@@ -49,7 +67,7 @@ static int cmp_char(const void* a, const void* b) {
     return *(char*)a - *(char*)b;
 }
 
-static void write_doc(bson_buffer* buffer, VALUE hash);
+static void write_doc(bson_buffer* buffer, VALUE hash, VALUE check_keys);
 static int write_element(VALUE key, VALUE value, VALUE extra);
 static VALUE elements_to_hash(const char* buffer, int max);
 
@@ -109,14 +127,19 @@ static void buffer_write_bytes(bson_buffer* buffer, const char* bytes, int size)
     buffer->position += size;
 }
 
+static VALUE pack_extra(bson_buffer* buffer, VALUE check_keys) {
+    return rb_ary_new3(2, INT2NUM((int)buffer), check_keys);
+}
+
 static void write_name_and_type(bson_buffer* buffer, VALUE name, char type) {
     buffer_write_bytes(buffer, &type, 1);
-    buffer_write_bytes(buffer, RSTRING(name)->ptr, RSTRING(name)->len);
+    buffer_write_bytes(buffer, RSTRING_PTR(name), RSTRING_LEN(name));
     buffer_write_bytes(buffer, &zero, 1);
 }
 
 static int write_element_allow_id(VALUE key, VALUE value, VALUE extra, int allow_id) {
-    bson_buffer* buffer = (bson_buffer*)extra;
+    bson_buffer* buffer = (bson_buffer*)NUM2INT(rb_ary_entry(extra, 0));
+    VALUE check_keys = rb_ary_entry(extra, 1);
 
     if (TYPE(key) == T_SYMBOL) {
         // TODO better way to do this... ?
@@ -127,13 +150,29 @@ static int write_element_allow_id(VALUE key, VALUE value, VALUE extra, int allow
         rb_raise(rb_eTypeError, "keys must be strings or symbols");
     }
 
-    if (!allow_id && strcmp("_id", RSTRING(key)->ptr) == 0) {
+    if (!allow_id && strcmp("_id", RSTRING_PTR(key)) == 0) {
         return ST_CONTINUE;
     }
 
+    if (check_keys == Qtrue) {
+        if (RSTRING_LEN(key) > 0 && RSTRING_PTR(key)[0] == '$') {
+            rb_raise(rb_eRuntimeError, "key must not start with '$'");
+        }
+        int i;
+        for (i = 0; i < RSTRING_LEN(key); i++) {
+            if (RSTRING_PTR(key)[i] == '.') {
+                rb_raise(rb_eRuntimeError, "key must not contain '.'");
+            }
+        }
+    }
+
     switch(TYPE(value)) {
     case T_BIGNUM:
         {
+            if (rb_funcall(value, rb_intern(">"), 1, INT2NUM(2147483647)) == Qtrue ||
+                rb_funcall(value, rb_intern("<"), 1, INT2NUM(-2147483648)) == Qtrue) {
+                rb_raise(rb_eRangeError, "MongoDB can only handle 4-byte ints - try converting to a double before saving");
+            }
             write_name_and_type(buffer, key, 0x10);
             VALUE as_f = rb_funcall(value, rb_intern("to_f"), 0);
             int int_value = NUM2LL(as_f);
@@ -174,7 +213,7 @@ static int write_element_allow_id(VALUE key, VALUE value, VALUE extra, int allow
     case T_HASH:
         {
             write_name_and_type(buffer, key, 0x03);
-            write_doc(buffer, value);
+            write_doc(buffer, value, check_keys);
             break;
         }
     case T_ARRAY:
@@ -192,7 +231,7 @@ static int write_element_allow_id(VALUE key, VALUE value, VALUE extra, int allow
                 char* name;
                 asprintf(&name, "%d", i);
                 VALUE key = rb_str_new2(name);
-                write_element(key, values[i], (VALUE)buffer);
+                write_element(key, values[i], pack_extra(buffer, check_keys));
                 free(name);
             }
 
@@ -211,11 +250,11 @@ static int write_element_allow_id(VALUE key, VALUE value, VALUE extra, int allow
                 int start_position = buffer->position;
                 int length_location = buffer_save_bytes(buffer, 4);
 
-                int length = RSTRING(value)->len + 1;
+                int length = RSTRING_LEN(value) + 1;
                 buffer_write_bytes(buffer, (char*)&length, 4);
-                buffer_write_bytes(buffer, RSTRING(value)->ptr, length - 1);
+                buffer_write_bytes(buffer, RSTRING_PTR(value), length - 1);
                 buffer_write_bytes(buffer, &zero, 1);
-                write_doc(buffer, rb_funcall(value, rb_intern("scope"), 0));
+                write_doc(buffer, rb_funcall(value, rb_intern("scope"), 0), Qfalse);
 
                 int total_length = buffer->position - start_position;
                 memcpy(buffer->buffer + length_location, &total_length, 4);
@@ -223,9 +262,9 @@ static int write_element_allow_id(VALUE key, VALUE value, VALUE extra, int allow
                 break;
             } else {
                 write_name_and_type(buffer, key, 0x02);
-                int length = RSTRING(value)->len + 1;
+                int length = RSTRING_LEN(value) + 1;
                 buffer_write_bytes(buffer, (char*)&length, 4);
-                buffer_write_bytes(buffer, RSTRING(value)->ptr, length - 1);
+                buffer_write_bytes(buffer, RSTRING_PTR(value), length - 1);
                 buffer_write_bytes(buffer, &zero, 1);
                 break;
             }
@@ -249,7 +288,7 @@ static int write_element_allow_id(VALUE key, VALUE value, VALUE extra, int allow
                 const char subtype = strcmp(cls, "ByteBuffer") ?
                     (const char)FIX2INT(rb_funcall(value, rb_intern("subtype"), 0)) : 2;
                 VALUE string_data = rb_funcall(value, rb_intern("to_s"), 0);
-                int length = RSTRING(string_data)->len;
+                int length = RSTRING_LEN(string_data);
                 if (subtype == 2) {
                     const int other_length = length + 4;
                     buffer_write_bytes(buffer, (const char*)&other_length, 4);
@@ -259,7 +298,7 @@ static int write_element_allow_id(VALUE key, VALUE value, VALUE extra, int allow
                 if (subtype != 2) {
                     buffer_write_bytes(buffer, &subtype, 1);
                 }
-                buffer_write_bytes(buffer, RSTRING(string_data)->ptr, length);
+                buffer_write_bytes(buffer, RSTRING_PTR(string_data), length);
                 break;
             }
             if (strcmp(cls, "XGen::Mongo::Driver::ObjectID") == 0) {
@@ -267,7 +306,7 @@ static int write_element_allow_id(VALUE key, VALUE value, VALUE extra, int allow
                 VALUE as_array = rb_funcall(value, rb_intern("to_a"), 0);
                 int i;
                 for (i = 0; i < 12; i++) {
-                    char byte = (char)FIX2INT(RARRAY(as_array)->ptr[i]);
+                    char byte = (char)FIX2INT(RARRAY_PTR(as_array)[i]);
                     buffer_write_bytes(buffer, &byte, 1);
                 }
                 break;
@@ -281,9 +320,9 @@ static int write_element_allow_id(VALUE key, VALUE value, VALUE extra, int allow
                 int length_location = buffer_save_bytes(buffer, 4);
 
                 VALUE ns = rb_funcall(value, rb_intern("namespace"), 0);
-                write_element(rb_str_new2("$ref"), ns, (VALUE)buffer);
+                write_element(rb_str_new2("$ref"), ns, pack_extra(buffer, Qfalse));
                 VALUE oid = rb_funcall(value, rb_intern("object_id"), 0);
-                write_element(rb_str_new2("$id"), oid, (VALUE)buffer);
+                write_element(rb_str_new2("$id"), oid, pack_extra(buffer, Qfalse));
 
                 // write null byte and fill in length
                 buffer_write_bytes(buffer, &zero, 1);
@@ -303,7 +342,7 @@ static int write_element_allow_id(VALUE key, VALUE value, VALUE extra, int allow
             if (strcmp(cls, "Time") == 0) {
                 write_name_and_type(buffer, key, 0x09);
                 double t = NUM2DBL(rb_funcall(value, rb_intern("to_f"), 0));
-                long long time_since_epoch = (long long)(t * 1000);
+                long long time_since_epoch = (long long)round(t * 1000);
                 buffer_write_bytes(buffer, (const char*)&time_since_epoch, 8);
                 break;
             }
@@ -312,21 +351,21 @@ static int write_element_allow_id(VALUE key, VALUE value, VALUE extra, int allow
         {
             write_name_and_type(buffer, key, 0x0B);
 
-            int length = RREGEXP(value)->len;
-            char* pattern = RREGEXP(value)->str;
+            int length = RREGEXP_SRC_LEN(value);
+            char* pattern = (char*)RREGEXP_SRC_PTR(value);
             buffer_write_bytes(buffer, pattern, length);
             buffer_write_bytes(buffer, &zero, 1);
 
             long flags = RREGEXP(value)->ptr->options;
-            if (flags & RE_OPTION_IGNORECASE) {
+            if (flags & IGNORECASE) {
                 char ignorecase = 'i';
                 buffer_write_bytes(buffer, &ignorecase, 1);
             }
-            if (flags & RE_OPTION_MULTILINE) {
+            if (flags & MULTILINE) {
                 char multiline = 'm';
                 buffer_write_bytes(buffer, &multiline, 1);
             }
-            if (flags & RE_OPTION_EXTENDED) {
+            if (flags & EXTENDED) {
                 char extended = 'x';
                 buffer_write_bytes(buffer, &extended, 1);
             }
@@ -335,8 +374,8 @@ static int write_element_allow_id(VALUE key, VALUE value, VALUE extra, int allow
             if (TYPE(has_extra) == T_TRUE) {
                 VALUE extra = rb_funcall(value, rb_intern("extra_options_str"), 0);
                 int old_position = buffer->position;
-                buffer_write_bytes(buffer, RSTRING(extra)->ptr, RSTRING(extra)->len);
-                qsort(buffer->buffer + old_position, RSTRING(extra)->len, sizeof(char), cmp_char);
+                buffer_write_bytes(buffer, RSTRING_PTR(extra), RSTRING_LEN(extra));
+                qsort(buffer->buffer + old_position, RSTRING_LEN(extra), sizeof(char), cmp_char);
             }
             buffer_write_bytes(buffer, &zero, 1);
 
@@ -355,33 +394,33 @@ static int write_element(VALUE key, VALUE value, VALUE extra) {
     return write_element_allow_id(key, value, extra, 0);
 }
 
-static void write_doc(bson_buffer* buffer, VALUE hash) {
+static void write_doc(bson_buffer* buffer, VALUE hash, VALUE check_keys) {
     int start_position = buffer->position;
     int length_location = buffer_save_bytes(buffer, 4);
 
     VALUE key = rb_str_new2("_id");
-    VALUE id = rb_hash_aref(hash, key);
-    if (TYPE(id) != T_NIL) {
-        write_element_allow_id(key, id, (VALUE)buffer, 1);
+    if (rb_funcall(hash, rb_intern("has_key?"), 1, key) == Qtrue) {
+        VALUE id = rb_hash_aref(hash, key);
+        write_element_allow_id(key, id, pack_extra(buffer, check_keys), 1);
     }
     key = ID2SYM(rb_intern("_id"));
-    id = rb_hash_aref(hash, key);
-    if (TYPE(id) != T_NIL) {
-        write_element_allow_id(key, id, (VALUE)buffer, 1);
+    if (rb_funcall(hash, rb_intern("has_key?"), 1, key) == Qtrue) {
+        VALUE id = rb_hash_aref(hash, key);
+        write_element_allow_id(key, id, pack_extra(buffer, check_keys), 1);
     }
 
-
     // we have to check for an OrderedHash and handle that specially
     if (strcmp(rb_class2name(RBASIC(hash)->klass), "OrderedHash") == 0) {
         VALUE keys = rb_funcall(hash, rb_intern("keys"), 0);
         int i;
-        for(i = 0; i < RARRAY(keys)->len; i++) {
-            VALUE key = RARRAY(keys)->ptr[i];
+        for(i = 0; i < RARRAY_LEN(keys); i++) {
+            VALUE key = RARRAY_PTR(keys)[i];
             VALUE value = rb_hash_aref(hash, key);
-            write_element(key, value, (VALUE)buffer);
+
+            write_element(key, value, pack_extra(buffer, check_keys));
         }
     } else {
-        rb_hash_foreach(hash, write_element, (VALUE)buffer);
+        rb_hash_foreach(hash, write_element, pack_extra(buffer, check_keys));
     }
 
     // write null byte and fill in length
@@ -390,11 +429,11 @@ static void write_doc(bson_buffer* buffer, VALUE hash) {
     memcpy(buffer->buffer + length_location, &length, 4);
 }
 
-static VALUE method_serialize(VALUE self, VALUE doc) {
+static VALUE method_serialize(VALUE self, VALUE doc, VALUE check_keys) {
     bson_buffer* buffer = buffer_new();
     assert(buffer);
 
-    write_doc(buffer, doc);
+    write_doc(buffer, doc, check_keys);
 
     VALUE result = rb_str_new(buffer->buffer, buffer->position);
     buffer_free(buffer);
@@ -525,13 +564,13 @@ static VALUE get_value(const char* buffer, int* position, int type) {
             for (i = 0; i < flags_length; i++) {
                 char flag = buffer[*position + i];
                 if (flag == 'i') {
-                    flags |= RE_OPTION_IGNORECASE;
+                    flags |= IGNORECASE;
                 }
                 else if (flag == 'm') {
-                    flags |= RE_OPTION_MULTILINE;
+                    flags |= MULTILINE;
                 }
                 else if (flag == 'x') {
-                    flags |= RE_OPTION_EXTENDED;
+                    flags |= EXTENDED;
                 }
                 else if (strlen(extra) < 9) {
                     strncat(extra, &flag, 1);
@@ -594,6 +633,16 @@ static VALUE get_value(const char* buffer, int* position, int type) {
             *position += 4;
             break;
         }
+    case 17:
+        {
+            int i;
+            int j;
+            memcpy(&i, buffer + *position, 4);
+            memcpy(&j, buffer + *position + 4, 4);
+            value = rb_ary_new3(2, LL2NUM(i), LL2NUM(j));
+            *position += 8;
+            break;
+        }
     default:
         {
             rb_raise(rb_eTypeError, "no c decoder for this type yet (%d)", type);
@@ -618,8 +667,8 @@ static VALUE elements_to_hash(const char* buffer, int max) {
 }
 
 static VALUE method_deserialize(VALUE self, VALUE bson) {
-    const char* buffer = RSTRING(bson)->ptr;
-    int remaining = RSTRING(bson)->len;
+    const char* buffer = RSTRING_PTR(bson);
+    int remaining = RSTRING_LEN(bson);
 
     // NOTE we just swallow the size and end byte here
     buffer += 4;
@@ -651,6 +700,6 @@ void Init_cbson() {
     OrderedHash = rb_const_get(rb_cObject, rb_intern("OrderedHash"));
 
     VALUE CBson = rb_define_module("CBson");
-    rb_define_module_function(CBson, "serialize", method_serialize, 1);
+    rb_define_module_function(CBson, "serialize", method_serialize, 2);
     rb_define_module_function(CBson, "deserialize", method_deserialize, 1);
 }

data/ext/cbson/extconf.rb

@@ -1,4 +1,6 @@
 require 'mkmf'
 
+find_header("st.h")
+find_header("regex.h")
 dir_config('cbson')
 create_makefile('mongo_ext/cbson')

data/mongo-extensions.gemspec

@@ -7,7 +7,7 @@ TEST_FILES = []
 
 Gem::Specification.new do |s|
   s.name = 'mongo_ext'
-  s.version = '0.1.1'
+  s.version = '0.3'
   s.platform = Gem::Platform::RUBY
   s.summary = 'C extensions for the MongoDB Ruby driver'
   s.description = 'C extensions to accelerate the MondoDB Ruby driver. For more information about Mongo, see http://www.mongodb.org.'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: mongodb-mongo_ext
 version: !ruby/object:Gem::Version 
-  version: 0.1.1
+  version: "0.3"
 platform: ruby
 authors: 
 - Mike Dirolf
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-02-25 00:00:00 -08:00
+date: 2009-05-16 00:00:00 -07:00
 default_executable: 
 dependencies: []