bson_ext 1.1.5 → 1.2.rc0

data/bson_ext.gemspec

@@ -1,6 +1,6 @@
 require './lib/bson'
 VERSION_HEADER = File.open(File.join(File.dirname(__FILE__), 'ext', 'cbson', 'version.h'), "r")
-VERSION        = VERSION_HEADER.read.scan(/VERSION\s+"(\d+\.\d+(\.\d+\w*)?)\"/)[0][0]
+VERSION        = VERSION_HEADER.read.scan(/VERSION\s+"(\d+\.\d+(\.[\w\d]+\w*)?)\"/)[0][0]
 Gem::Specification.new do |s|
   s.name = 'bson_ext'
 

data/ext/cbson/cbson.c

@@ -30,10 +30,16 @@
 #ifndef RSTRING_LEN
 #  define RSTRING_LEN(v) RSTRING(v)->len
 #endif
+#ifndef RSTRING_LENINT
+#  define RSTRING_LENINT(v) (int)(RSTRING_LEN(v))
+#endif
 
 #ifndef RARRAY_LEN
 #  define RARRAY_LEN(v) RARRAY(v)->len
 #endif
+#ifndef RARRAY_LENINT
+#  define RARRAY_LENINT(v) (int)(RARRAY_LEN(v))
+#endif
 
 #if HAVE_RUBY_ST_H
 #include "ruby/st.h"
@@ -88,6 +94,8 @@ static VALUE InvalidDocument;
 static VALUE DigestMD5;
 static VALUE RB_HASH;
 
+static int max_bson_size;
+
 #if HAVE_RUBY_ENCODING_H
 #include "ruby/encoding.h"
 #define STR_NEW(p,n)                                                    \
@@ -102,13 +110,13 @@ static VALUE RB_HASH;
 /* MUST call TO_UTF8 before calling write_utf8. */
 #define TO_UTF8(string) rb_str_export_to_enc((string), rb_utf8_encoding())
 static void write_utf8(buffer_t buffer, VALUE string, char check_null) {
-    result_t status = check_string(RSTRING_PTR(string), RSTRING_LEN(string),
+    result_t status = check_string(RSTRING_PTR(string), RSTRING_LENINT(string),
                                    0, check_null);
     if (status == HAS_NULL) {
         buffer_free(buffer);
         rb_raise(InvalidDocument, "Key names / regex patterns must not contain the NULL byte");
     }
-    SAFE_WRITE(buffer, RSTRING_PTR(string), RSTRING_LEN(string));
+    SAFE_WRITE(buffer, RSTRING_PTR(string), RSTRING_LENINT(string));
 }
 #else
 #define STR_NEW(p,n) rb_str_new((p), (n))
@@ -147,7 +155,7 @@ static void write_utf8(buffer_t buffer, VALUE string, char check_null) {
  * either use _scprintf and _snprintf on for Windows or
  * use snprintf for solaris. */
 #ifndef HAVE_ASPRINTF
-#ifdef _MSC_VER
+#ifdef _WIN32 || _MSC_VER
 #define INT2STRING(buffer, i)                   \
     {                                           \
         int vslength = _scprintf("%d", i) + 1;  \
@@ -255,7 +263,7 @@ static int write_element(VALUE key, VALUE value, VALUE extra, int allow_id) {
             } else {
                 int int_value;
                 write_name_and_type(buffer, key, 0x10);
-                int_value = ll_value;
+                int_value = (int)ll_value;
                 SAFE_WRITE(buffer, (char*)&int_value, 4);
             }
             break;
@@ -305,7 +313,7 @@ static int write_element(VALUE key, VALUE value, VALUE extra, int allow_id) {
                 rb_raise(rb_eNoMemError, "failed to allocate memory in buffer.c");
             }
 
-            items = RARRAY_LEN(value);
+            items = RARRAY_LENINT(value);
             for(i = 0; i < items; i++) {
                 char* name;
                 VALUE key;
@@ -326,7 +334,7 @@ static int write_element(VALUE key, VALUE value, VALUE extra, int allow_id) {
             int length;
             write_name_and_type(buffer, key, 0x02);
             value = TO_UTF8(value);
-            length = RSTRING_LEN(value) + 1;
+            length = RSTRING_LENINT(value) + 1;
             SAFE_WRITE(buffer, (char*)&length, 4);
             write_utf8(buffer, value, 0);
             SAFE_WRITE(buffer, &zero, 1);
@@ -335,7 +343,7 @@ static int write_element(VALUE key, VALUE value, VALUE extra, int allow_id) {
     case T_SYMBOL:
         {
             const char* str_value = rb_id2name(SYM2ID(value));
-            int length = strlen(str_value) + 1;
+            int length = (int)strlen(str_value) + 1;
             write_name_and_type(buffer, key, 0x0E);
             SAFE_WRITE(buffer, (char*)&length, 4);
             SAFE_WRITE(buffer, str_value, length);
@@ -350,7 +358,7 @@ static int write_element(VALUE key, VALUE value, VALUE extra, int allow_id) {
                 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_LEN(string_data);
+                int length = RSTRING_LENINT(string_data);
                 write_name_and_type(buffer, key, 0x05);
                 if (subtype == 2) {
                     const int other_length = length + 4;
@@ -401,6 +409,7 @@ static int write_element(VALUE key, VALUE value, VALUE extra, int allow_id) {
             if (strcmp(cls, "BSON::Code") == 0) {
                 buffer_position length_location, start_position, total_length;
                 int length;
+                VALUE code_str;
                 write_name_and_type(buffer, key, 0x0F);
 
                 start_position = buffer_get_position(buffer);
@@ -409,8 +418,8 @@ static int write_element(VALUE key, VALUE value, VALUE extra, int allow_id) {
                     rb_raise(rb_eNoMemError, "failed to allocate memory in buffer.c");
                 }
 
-                VALUE code_str = rb_funcall(value, rb_intern("code"), 0);
-                length = RSTRING_LEN(code_str) + 1;
+                code_str = rb_funcall(value, rb_intern("code"), 0);
+                length = RSTRING_LENINT(code_str) + 1;
                 SAFE_WRITE(buffer, (char*)&length, 4);
                 SAFE_WRITE(buffer, RSTRING_PTR(code_str), length - 1);
                 SAFE_WRITE(buffer, &zero, 1);
@@ -490,7 +499,7 @@ static int write_element(VALUE key, VALUE value, VALUE extra, int allow_id) {
             if (TYPE(has_extra) == T_TRUE) {
                 VALUE extra = rb_funcall(value, rb_intern("extra_options_str"), 0);
                 buffer_position old_position = buffer_get_position(buffer);
-                SAFE_WRITE(buffer, RSTRING_PTR(extra), RSTRING_LEN(extra));
+                SAFE_WRITE(buffer, RSTRING_PTR(extra), RSTRING_LENINT(extra));
                 qsort(buffer_get_buffer(buffer) + old_position, RSTRING_LEN(extra), sizeof(char), cmp_char);
             }
             SAFE_WRITE(buffer, &zero, 1);
@@ -573,8 +582,7 @@ static void write_doc(buffer_t buffer, VALUE hash, VALUE check_keys, VALUE move_
         rb_hash_foreach(hash, write_function, pack_extra(buffer, check_keys));
     } else {
         buffer_free(buffer);
-        char* cls = rb_obj_classname(hash);
-        rb_raise(InvalidDocument, "BSON.serialize takes a Hash but got a %s", cls);
+        rb_raise(InvalidDocument, "BSON.serialize takes a Hash but got a %s", rb_obj_classname(hash));
     }
 
     // write null byte and fill in length
@@ -582,9 +590,9 @@ static void write_doc(buffer_t buffer, VALUE hash, VALUE check_keys, VALUE move_
     length = buffer_get_position(buffer) - start_position;
 
     // make sure that length doesn't exceed 4MB
-    if (length > 4 * 1024 * 1024) {
+    if (length > max_bson_size) {
       buffer_free(buffer);
-      rb_raise(InvalidDocument, "Document too large: BSON documents are limited to 4MB.");
+      rb_raise(InvalidDocument, "Document too large: BSON documents are limited to %d bytes.", max_bson_size);
       return;
     }
     SAFE_WRITE_AT_POS(buffer, length_location, (const char*)&length, 4);
@@ -665,7 +673,7 @@ static VALUE get_value(const char* buffer, int* position, int type) {
             value = rb_ary_new();
             while (*position < end) {
                 int type = (int)buffer[(*position)++];
-                int key_size = strlen(buffer + *position);
+                int key_size = (int)strlen(buffer + *position);
                 VALUE to_append;
 
                 *position += key_size + 1; // just skip the key, they're in order.
@@ -729,13 +737,13 @@ static VALUE get_value(const char* buffer, int* position, int type) {
         }
     case 11:
         {
-            int pattern_length = strlen(buffer + *position);
+            int pattern_length = (int)strlen(buffer + *position);
             VALUE pattern = STR_NEW(buffer + *position, pattern_length);
             int flags_length, flags = 0, i = 0;
             VALUE argv[3];
             *position += pattern_length + 1;
 
-            flags_length = strlen(buffer + *position);
+            flags_length = (int)strlen(buffer + *position);
             for (i = 0; i < flags_length; i++) {
                 char flag = buffer[*position + i];
                 if (flag == 'i') {
@@ -845,7 +853,7 @@ static VALUE elements_to_hash(const char* buffer, int max) {
     int position = 0;
     while (position < max) {
         int type = (int)buffer[position++];
-        int name_length = strlen(buffer + position);
+        int name_length = (int)strlen(buffer + position);
         VALUE name = STR_NEW(buffer + position, name_length);
         VALUE value;
         position += name_length + 1;
@@ -857,7 +865,7 @@ static VALUE elements_to_hash(const char* buffer, int max) {
 
 static VALUE method_deserialize(VALUE self, VALUE bson) {
     const char* buffer = RSTRING_PTR(bson);
-    int remaining = RSTRING_LEN(bson);
+    int remaining = RSTRING_LENINT(bson);
 
     // NOTE we just swallow the size and end byte here
     buffer += 4;
@@ -874,7 +882,7 @@ static VALUE objectid_generate(VALUE self)
     unsigned short pid;
     int i;
 
-    t = htonl(time(NULL));
+    t = htonl((int)time(NULL));
     MEMCPY(&oid_bytes, &t, unsigned char, 4);
 
     MEMCPY(&oid_bytes[4], hostname_digest, unsigned char, 3);
@@ -902,11 +910,19 @@ static VALUE objectid_generate(VALUE self)
     return oid;
 }
 
+static VALUE method_update_max_bson_size(VALUE self, VALUE connection) {
+    max_bson_size = FIX2INT(rb_funcall(connection, rb_intern("max_bson_size"), 0));
+    return INT2FIX(max_bson_size);
+}
+
+static VALUE method_max_bson_size(VALUE self) {
+    return INT2FIX(max_bson_size);
+}
 
 void Init_cbson() {
     VALUE bson, CBson, Digest, ext_version, digest;
     static char hostname[MAX_HOSTNAME_LENGTH];
-    
+
     element_assignment_method = rb_intern("[]=");
     unpack_method = rb_intern("unpack");
     utc_method = rb_intern("utc");
@@ -939,6 +955,8 @@ void Init_cbson() {
     rb_define_const(CBson, "VERSION", ext_version);
     rb_define_module_function(CBson, "serialize", method_serialize, 3);
     rb_define_module_function(CBson, "deserialize", method_deserialize, 1);
+    rb_define_module_function(CBson, "max_bson_size", method_max_bson_size, 0);
+    rb_define_module_function(CBson, "update_max_bson_size", method_update_max_bson_size, 1);
 
     rb_require("digest/md5");
     Digest = rb_const_get(rb_cObject, rb_intern("Digest"));
@@ -953,4 +971,6 @@ void Init_cbson() {
         rb_str_new2(hostname));
     memcpy(hostname_digest, RSTRING_PTR(digest), 16);
     hostname_digest[16] = '\0';
+
+    max_bson_size = 4 * 1024 * 1024;
 }

data/ext/cbson/version.h

@@ -14,4 +14,4 @@
  * limitations under the License.
  */
 
-#define VERSION "1.1.5"
+#define VERSION "1.2.rc0"

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: bson_ext
 version: !ruby/object:Gem::Version 
-  hash: 25
-  prerelease: false
+  hash: 977940448
+  prerelease: true
   segments: 
   - 1
-  - 1
-  - 5
-  version: 1.1.5
+  - 2
+  - rc0
+  version: 1.2.rc0
 platform: ruby
 authors: 
 - Mike Dirolf
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-12-15 00:00:00 -05:00
+date: 2011-01-05 00:00:00 -05:00
 default_executable: 
 dependencies: []
 
@@ -37,7 +37,7 @@ files:
 - ext/cbson/encoding_helpers.h
 - ext/cbson/version.h
 - ext/cbson/buffer.h
-has_rdoc: true
+has_rdoc: false
 homepage: http://www.mongodb.org
 licenses: []
 
@@ -58,12 +58,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version 
-      hash: 3
+      hash: 25
       segments: 
-      - 0
-      version: "0"
+      - 1
+      - 3
+      - 1
+      version: 1.3.1
 requirements: []
 
 rubyforge_project: