bson 4.7.1 → 4.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b8a3b9746ff3d1a260ea84b199e2d0f5633dd64a2f35cd0b25f5c6e04fe7087d
-  data.tar.gz: cfa985f7f17d689484240c54756b3a0248f0a8c97573cbfc1af0fbc037835e3d
+  metadata.gz: c37081fa823c2700f07a23ca6ecbec6fc67cffbf7915b4a21e59940b332b678d
+  data.tar.gz: 16d483a311c4252f4ef1463be2f86240450b82294a972d8bb5bb2bb332fd7b17
 SHA512:
-  metadata.gz: bde5c1c92fd57f6e9ed5ad0cec9957521949022141a98a7fd47c551cdb313380c56607dd6946575cbfe20413170ff009cb6d8d165f674ed3f82e7ce63576c8e9
-  data.tar.gz: c857d6e12472340748ebb2c31da5ddc637510fbf07248d4a8ce9277967acfd74bca0bb065cbc1369c75e14d1994fa099ce8a40c4e468003376b92304a7883029
+  metadata.gz: 1618b74348d155c904b2f24739d7b9403bc0b1c23e67cc6ce89a92ac19070dd5965dc1fccc6353c2eefb82993bf5fec30702bccaaf6bb8171777421253832cce
+  data.tar.gz: 1362710c9b36348437bf266a52c18347c1228ddd92231b520e6b068b1742f42895c2108a64cdff2487c5b874c12e3af5ce4d4435c00cebad942b83f1ea9e17ab

checksums.yaml.gz.sig

@@ -1,2 +1,2 @@
-�}(� v�+�͎z�5�s�n�:���@�;�vL��Y��<T���BE8$�n�O;�@��y�y��ۆ�\#�;+9�S#r���A���\~JdJt��X �&H�R/j`U��.����Ռ=���W&W��������$l������C�b>gCՍ]P���Ԓ&�M�K&[��,�6�+V��+��Z֦�iE62~���S��hQ�Sd���v���}�f������/"�'
-��)�ɎI��
+�}
+O��t���9�a���2)����=%Zf{ms	3VeB�L)¡o�crp�e��r��@�K�~�

data/README.md

@@ -1,4 +1,8 @@
-BSON [![Build Status](https://secure.travis-ci.org/mongodb/bson-ruby.png?branch=master&.png)](http://travis-ci.org/mongodb/bson-ruby)  [![Code Climate](https://codeclimate.com/github/mongodb/bson-ruby.png)](https://codeclimate.com/github/mongodb/bson-ruby) [![Coverage Status](https://coveralls.io/repos/mongodb/bson-ruby/badge.png?branch=master)](https://coveralls.io/r/mongodb/bson-ruby?branch=master) [![Inline docs](http://inch-ci.org/github/mongodb/bson-ruby.svg?branch=master)](http://inch-ci.org/github/mongodb/bson-ruby)
+BSON [![Build Status](https://secure.travis-ci.org/mongodb/bson-ruby.svg?branch=master)](http://travis-ci.org/mongodb/bson-ruby)
+[![Build status Windows](https://ci.appveyor.com/api/projects/status/p5aqko7umsx351nm?svg=true)](https://ci.appveyor.com/project/p-mongo/bson-ruby/branch/master)
+[![Code Climate](https://codeclimate.com/github/mongodb/bson-ruby.svg)](https://codeclimate.com/github/mongodb/bson-ruby)
+[![Coverage Status](https://coveralls.io/repos/mongodb/bson-ruby/badge.svg?branch=master)](https://coveralls.io/r/mongodb/bson-ruby?branch=master)
+[![Inline docs](http://inch-ci.org/github/mongodb/bson-ruby.svg?branch=master)](http://inch-ci.org/github/mongodb/bson-ruby)
 ====
 
 An implementation of the BSON specification in Ruby.

data/ext/bson/bson-native.h

@@ -33,13 +33,15 @@ rb_bson_utf8_validate (const char *utf8, /* IN */
 #define HOST_NAME_HASH_MAX 256
 #endif
 
+/* See the type list in http://bsonspec.org/spec.html. */
 #define BSON_TYPE_DOUBLE        1
 #define BSON_TYPE_STRING        2
 #define BSON_TYPE_DOCUMENT      3
 #define BSON_TYPE_ARRAY         4
 #define BSON_TYPE_BOOLEAN       8
-#define BSON_TYPE_INT32         16
-#define BSON_TYPE_INT64         18
+#define BSON_TYPE_SYMBOL        0x0E
+#define BSON_TYPE_INT32         0x10
+#define BSON_TYPE_INT64         0x12
 
 typedef struct {
   size_t size;
@@ -76,8 +78,8 @@ VALUE rb_bson_byte_buffer_get_double(VALUE self);
 VALUE rb_bson_byte_buffer_get_int32(VALUE self);
 VALUE rb_bson_byte_buffer_get_int64(VALUE self);
 VALUE rb_bson_byte_buffer_get_string(VALUE self);
-VALUE rb_bson_byte_buffer_get_hash(VALUE self);
-VALUE rb_bson_byte_buffer_get_array(VALUE self);
+VALUE rb_bson_byte_buffer_get_hash(int argc, VALUE *argv, VALUE self);
+VALUE rb_bson_byte_buffer_get_array(int argc, VALUE *argv, VALUE self);
 VALUE rb_bson_byte_buffer_put_byte(VALUE self, VALUE byte);
 VALUE rb_bson_byte_buffer_put_bytes(VALUE self, VALUE bytes);
 VALUE rb_bson_byte_buffer_put_cstring(VALUE self, VALUE string);
@@ -101,6 +103,14 @@ void rb_bson_byte_buffer_free(void *ptr);
 void rb_bson_expand_buffer(byte_buffer_t* buffer_ptr, size_t length);
 void rb_bson_generate_machine_id(VALUE rb_md5_class, char *rb_bson_machine_id);
 
+VALUE pvt_const_get_2(const char *c1, const char *c2);
+VALUE pvt_const_get_3(const char *c1, const char *c2, const char *c3);
+
+#define BSON_MODE_DEFAULT       0
+#define BSON_MODE_BSON          1
+
+int pvt_get_mode_option(int argc, VALUE *argv);
+
 /**
  * The counter for incrementing object ids.
  */

data/ext/bson/init.c

@@ -70,8 +70,31 @@ void Init_bson_native()
   rb_define_method(rb_byte_buffer_class, "get_cstring", rb_bson_byte_buffer_get_cstring, 0);
   rb_define_method(rb_byte_buffer_class, "get_decimal128_bytes", rb_bson_byte_buffer_get_decimal128_bytes, 0);
   rb_define_method(rb_byte_buffer_class, "get_double", rb_bson_byte_buffer_get_double, 0);
-  rb_define_method(rb_byte_buffer_class, "get_hash", rb_bson_byte_buffer_get_hash, 0);
-  rb_define_method(rb_byte_buffer_class, "get_array", rb_bson_byte_buffer_get_array, 0);
+  
+  /*
+   * call-seq:
+   *   buffer.get_hash(**options) -> Hash
+   *
+   * Reads a document from the byte buffer and returns it as a BSON::Document.
+   *
+   * @option options [ nil | :bson ] :mode Decoding mode to use.
+   *
+   * @return [ BSON::Document ] The decoded document.
+   */
+  rb_define_method(rb_byte_buffer_class, "get_hash", rb_bson_byte_buffer_get_hash, -1);
+  
+  /*
+   * call-seq:
+   *   buffer.get_array(**options) -> Array
+   *
+   * Reads an array from the byte buffer..
+   *
+   * @option options [ nil | :bson ] :mode Decoding mode to use.
+   *
+   * @return [ Array ] The decoded array.
+   */
+  rb_define_method(rb_byte_buffer_class, "get_array", rb_bson_byte_buffer_get_array, -1);
+  
   rb_define_method(rb_byte_buffer_class, "get_int32", rb_bson_byte_buffer_get_int32, 0);
   rb_define_method(rb_byte_buffer_class, "get_int64", rb_bson_byte_buffer_get_int64, 0);
   rb_define_method(rb_byte_buffer_class, "get_string", rb_bson_byte_buffer_get_string, 0);

data/ext/bson/read.c

@@ -20,11 +20,12 @@
 static void pvt_validate_length(byte_buffer_t *b);
 static uint8_t pvt_get_type_byte(byte_buffer_t *b);
 static VALUE pvt_get_int32(byte_buffer_t *b);
-static VALUE pvt_get_int64(byte_buffer_t *b);
+static VALUE pvt_get_int64(byte_buffer_t *b, int argc, VALUE *argv);
 static VALUE pvt_get_double(byte_buffer_t *b);
 static VALUE pvt_get_string(byte_buffer_t *b);
+static VALUE pvt_get_symbol(byte_buffer_t *b, VALUE rb_buffer, int argc, VALUE *argv);
 static VALUE pvt_get_boolean(byte_buffer_t *b);
-static VALUE pvt_read_field(byte_buffer_t *b, VALUE rb_buffer, uint8_t type);
+static VALUE pvt_read_field(byte_buffer_t *b, VALUE rb_buffer, uint8_t type, int argc, VALUE *argv);
 static void pvt_skip_cstring(byte_buffer_t *b);
 
 /**
@@ -57,14 +58,16 @@ void pvt_validate_length(byte_buffer_t *b)
 /**
  * Read a single field from a hash or array
  */
-VALUE pvt_read_field(byte_buffer_t *b, VALUE rb_buffer, uint8_t type){
+VALUE pvt_read_field(byte_buffer_t *b, VALUE rb_buffer, uint8_t type, int argc, VALUE *argv)
+{
   switch(type) {
     case BSON_TYPE_INT32: return pvt_get_int32(b);
-    case BSON_TYPE_INT64: return pvt_get_int64(b);
+    case BSON_TYPE_INT64: return pvt_get_int64(b, argc, argv);
     case BSON_TYPE_DOUBLE: return pvt_get_double(b);
     case BSON_TYPE_STRING: return pvt_get_string(b);
-    case BSON_TYPE_ARRAY: return rb_bson_byte_buffer_get_array(rb_buffer);
-    case BSON_TYPE_DOCUMENT: return rb_bson_byte_buffer_get_hash(rb_buffer);
+    case BSON_TYPE_SYMBOL: return pvt_get_symbol(b, rb_buffer, argc, argv);
+    case BSON_TYPE_ARRAY: return rb_bson_byte_buffer_get_array(argc, argv, rb_buffer);
+    case BSON_TYPE_DOCUMENT: return rb_bson_byte_buffer_get_hash(argc, argv, rb_buffer);
     case BSON_TYPE_BOOLEAN: return pvt_get_boolean(b);
     default:
     {
@@ -150,6 +153,31 @@ VALUE pvt_get_string(byte_buffer_t *b)
   return string;
 }
 
+/**
+ * Reads a UTF-8 string out of the byte buffer. If the argc/argv arguments
+ * have a :mode option with the value of :bson, wraps the string in a
+ * BSON::Symbol::Raw. Otherwise consults the BSON registry to determine
+ * which class to instantiate (String in bson-ruby, overridden to Symbol by
+ * the Ruby driver). Returns either a BSON::Symbol::Raw, Symbol or String
+ * value.
+ */
+VALUE pvt_get_symbol(byte_buffer_t *b, VALUE rb_buffer, int argc, VALUE *argv)
+{
+  VALUE value, klass;
+
+  if (pvt_get_mode_option(argc, argv) == BSON_MODE_BSON) {
+    value = pvt_get_string(b);
+    klass = pvt_const_get_3("BSON", "Symbol", "Raw");
+    value = rb_funcall(klass, rb_intern("new"), 1, value);
+  } else {
+    klass = rb_funcall(rb_bson_registry, rb_intern("get"), 1, INT2FIX(BSON_TYPE_SYMBOL));
+    value = rb_funcall(klass, rb_intern("from_bson"), 1, rb_buffer);
+  }
+  
+  RB_GC_GUARD(klass);
+  return value;
+}
+
 /**
  * Get a cstring from the buffer.
  */
@@ -206,17 +234,35 @@ VALUE rb_bson_byte_buffer_get_int64(VALUE self)
 {
   byte_buffer_t *b;
   TypedData_Get_Struct(self, byte_buffer_t, &rb_byte_buffer_data_type, b);
-  return pvt_get_int64(b);
+  return pvt_get_int64(b, 0, NULL);
 }
 
-VALUE pvt_get_int64(byte_buffer_t *b)
+/**
+ * Reads a 64-bit integer out of the byte buffer into a Ruby Integer instance.
+ * If the argc/argv arguments have a :mode option with the value of :bson,
+ * wraps the integer in a BSON::Int64. Returns either the Integer or the
+ * BSON::Int64 instance.
+ */
+VALUE pvt_get_int64(byte_buffer_t *b, int argc, VALUE *argv)
 {
   int64_t i64;
+  VALUE num;
 
   ENSURE_BSON_READ(b, 8);
   memcpy(&i64, READ_PTR(b), 8);
   b->read_position += 8;
-  return LL2NUM(BSON_UINT64_FROM_LE(i64));
+  num = LL2NUM(BSON_UINT64_FROM_LE(i64));
+  
+  if (pvt_get_mode_option(argc, argv) == BSON_MODE_BSON) {
+    VALUE klass = rb_funcall(rb_bson_registry,rb_intern("get"),1, INT2FIX(BSON_TYPE_INT64));
+    VALUE value = rb_funcall(klass, rb_intern("new"), 1, num);
+    RB_GC_GUARD(klass);
+    return value;
+  } else {
+    return num;
+  }
+  
+  RB_GC_GUARD(num);
 }
 
 /**
@@ -255,27 +301,27 @@ VALUE rb_bson_byte_buffer_get_decimal128_bytes(VALUE self)
   return bytes;
 }
 
-VALUE rb_bson_byte_buffer_get_hash(VALUE self){
+VALUE rb_bson_byte_buffer_get_hash(int argc, VALUE *argv, VALUE self){
   VALUE doc = Qnil;
   byte_buffer_t *b = NULL;
   uint8_t type;
-  VALUE cDocument = rb_const_get(rb_const_get(rb_cObject, rb_intern("BSON")), rb_intern("Document"));
+  VALUE cDocument = pvt_const_get_2("BSON", "Document");
 
   TypedData_Get_Struct(self, byte_buffer_t, &rb_byte_buffer_data_type, b);
 
   pvt_validate_length(b);
 
-  doc = rb_funcall(cDocument, rb_intern("allocate"),0);
+  doc = rb_funcall(cDocument, rb_intern("allocate"), 0);
 
   while((type = pvt_get_type_byte(b)) != 0){
     VALUE field = rb_bson_byte_buffer_get_cstring(self);
+    rb_hash_aset(doc, field, pvt_read_field(b, self, type, argc, argv));
     RB_GC_GUARD(field);
-    rb_hash_aset(doc, field, pvt_read_field(b, self, type));
   }
   return doc;
 }
 
-VALUE rb_bson_byte_buffer_get_array(VALUE self){
+VALUE rb_bson_byte_buffer_get_array(int argc, VALUE *argv, VALUE self){
   byte_buffer_t *b;
   VALUE array = Qnil;
   uint8_t type;
@@ -287,7 +333,7 @@ VALUE rb_bson_byte_buffer_get_array(VALUE self){
   array = rb_ary_new();
   while((type = pvt_get_type_byte(b)) != 0){
     pvt_skip_cstring(b);
-    rb_ary_push(array,  pvt_read_field(b, self, type));
+    rb_ary_push(array,  pvt_read_field(b, self, type, argc, argv));
   }
   RB_GC_GUARD(array);
   return array;

data/ext/bson/util.c

@@ -53,3 +53,43 @@ VALUE rb_bson_object_id_generator_next(int argc, VALUE* args, VALUE self)
   rb_bson_object_id_counter++;
   return rb_str_new(bytes, 12);
 }
+
+/**
+ * Returns a Ruby constant nested one level, e.g. BSON::Document.
+ */
+VALUE pvt_const_get_2(const char *c1, const char *c2) {
+  return rb_const_get(rb_const_get(rb_cObject, rb_intern(c1)), rb_intern(c2));
+}
+
+/**
+ * Returns a Ruby constant nested two levels, e.g. BSON::Regexp::Raw.
+ */
+VALUE pvt_const_get_3(const char *c1, const char *c2, const char *c3) {
+  return rb_const_get(pvt_const_get_2(c1, c2), rb_intern(c3));
+}
+
+/**
+ * Returns the value of the :mode option, or the default if the option is not
+ * specified. Raises ArgumentError if the value is not one of nil or :bson.
+ * A future version of bson-ruby is expected to also support :ruby and :ruby!
+ * values. Returns one of the BSON_MODE_* values.
+ */
+int pvt_get_mode_option(int argc, VALUE *argv) {
+  VALUE opts;
+  VALUE mode;
+  
+  rb_scan_args(argc, argv, ":", &opts);
+  if (NIL_P(opts)) {
+    return BSON_MODE_DEFAULT;
+  } else {
+    mode = rb_hash_lookup(opts, ID2SYM(rb_intern("mode")));
+    if (mode == Qnil) {
+      return BSON_MODE_DEFAULT;
+    } else if (mode == ID2SYM(rb_intern("bson"))) {
+      return BSON_MODE_BSON;
+    } else {
+      rb_raise(rb_eArgError, "Invalid value for :mode option: %s",
+        RSTRING_PTR(rb_funcall(mode, rb_intern("inspect"), 0)));
+    }
+  }
+}

data/ext/bson/write.c

@@ -125,40 +125,44 @@ VALUE rb_bson_byte_buffer_put_bytes(VALUE self, VALUE bytes)
   return self;
 }
 
-/* write the byte denoting the BSON type for the passed object*/
+/* write the byte denoting the BSON type for the passed object */
 void pvt_put_type_byte(byte_buffer_t *b, VALUE val){
-  switch(TYPE(val)){
+  char type_byte;
+  
+  switch (TYPE(val)){
     case T_BIGNUM:
     case T_FIXNUM:
-      if(fits_int32(NUM2LL(val))){
-        pvt_put_byte(b, BSON_TYPE_INT32);
-      }else{
-        pvt_put_byte(b, BSON_TYPE_INT64);
+      if (fits_int32(NUM2LL(val))) {
+        type_byte = BSON_TYPE_INT32;
+      } else {
+        type_byte = BSON_TYPE_INT64;
       }
       break;
     case T_STRING:
-      pvt_put_byte(b, BSON_TYPE_STRING);
+      type_byte = BSON_TYPE_STRING;
       break;
     case T_ARRAY:
-      pvt_put_byte(b, BSON_TYPE_ARRAY);
+      type_byte = BSON_TYPE_ARRAY;
       break;
     case T_TRUE:
     case T_FALSE:
-      pvt_put_byte(b, BSON_TYPE_BOOLEAN);
+      type_byte = BSON_TYPE_BOOLEAN;
       break;
     case T_HASH:
-      pvt_put_byte(b, BSON_TYPE_DOCUMENT);
+      type_byte = BSON_TYPE_DOCUMENT;
       break;
     case T_FLOAT:
-      pvt_put_byte(b, BSON_TYPE_DOUBLE);
+      type_byte = BSON_TYPE_DOUBLE;
       break;
     default:{
-      VALUE type = rb_funcall(val, rb_intern("bson_type"),0);
+      VALUE type = rb_funcall(val, rb_intern("bson_type"), 0);
+      type_byte = *RSTRING_PTR(type);
       RB_GC_GUARD(type);
-      pvt_put_byte(b, *RSTRING_PTR(type));
       break;
     }
   }
+  
+  pvt_put_byte(b, type_byte);
 }
 
 /**

data/lib/bson.rb

@@ -57,6 +57,7 @@ module BSON
 end
 
 require "bson/config"
+require "bson/error"
 require "bson/registry"
 require "bson/specialized"
 require "bson/json"
@@ -70,8 +71,10 @@ require "bson/code"
 require "bson/code_with_scope"
 require "bson/date"
 require "bson/date_time"
+require "bson/db_pointer"
 require "bson/decimal128"
 require "bson/document"
+require "bson/ext_json"
 require "bson/false_class"
 require "bson/float"
 require "bson/hash"

data/lib/bson/array.rb

@@ -85,26 +85,44 @@ module BSON
       map { |value| value.to_bson_normalized_value }
     end
 
+    # Converts this object to a representation directly serializable to
+    # Extended JSON (https://github.com/mongodb/specifications/blob/master/source/extended-json.rst).
+    #
+    # This method recursively invokes +as_extended_json+ with the provided
+    # options on each array element.
+    #
+    # @option opts [ nil | :relaxed | :legacy ] :mode Serialization mode
+    #   (default is canonical extended JSON)
+    #
+    # @return [ Array ] This array converted to extended json representation.
+    def as_extended_json(**options)
+      map do |item|
+        item.as_extended_json(**options)
+      end
+    end
+
     module ClassMethods
 
       # Deserialize the array from BSON.
       #
       # @param [ ByteBuffer ] buffer The byte buffer.
       #
+      # @option options [ nil | :bson ] :mode Decoding mode to use.
+      #
       # @return [ Array ] The decoded array.
       #
       # @see http://bsonspec.org/#/specification
       #
       # @since 2.0.0
-      def from_bson(buffer)
+      def from_bson(buffer, **options)
         if buffer.respond_to?(:get_array)
-          buffer.get_array
+          buffer.get_array(**options)
         else
           array = new
           buffer.get_int32 # throw away the length
           while (type = buffer.get_byte) != NULL_BYTE
             buffer.get_cstring
-            array << BSON::Registry.get(type).from_bson(buffer)
+            array << BSON::Registry.get(type).from_bson(buffer, **options)
           end
           array
         end

data/lib/bson/binary.rb

@@ -31,6 +31,12 @@ module BSON
 
     # The mappings of subtypes to their single byte identifiers.
     #
+    # @note subtype 6 (ciphertext) is used for the Client-Side Encryption
+    #   feature. Data represented by this subtype is often encrypted, but
+    #   may also be plaintext. All instances of this subtype necessary for
+    #   Client-Side Encryption will be created internally by the Ruby driver.
+    #   An application should not create new BSON::Binary objects of this subtype.
+    #
     # @since 2.0.0
     SUBTYPES = {
       :generic => 0.chr,
@@ -39,6 +45,7 @@ module BSON
       :uuid_old => 3.chr,
       :uuid => 4.chr,
       :md5 => 5.chr,
+      :ciphertext => 6.chr,
       :user => 128.chr
     }.freeze
 
@@ -94,8 +101,31 @@ module BSON
     # @return [ Hash ] The binary as a JSON hash.
     #
     # @since 2.0.0
+    # @deprecated Use as_extended_json instead.
     def as_json(*args)
-      { "$binary" => Base64.encode64(data), "$type" => type }
+      as_extended_json
+    end
+
+    # Converts this object to a representation directly serializable to
+    # Extended JSON (https://github.com/mongodb/specifications/blob/master/source/extended-json.rst).
+    #
+    # @option opts [ nil | :relaxed | :legacy ] :mode Serialization mode
+    #   (default is canonical extended JSON)
+    #
+    # @return [ Hash ] The extended json representation.
+    def as_extended_json(**options)
+      subtype = SUBTYPES[type].each_byte.map { |c| c.to_s(16) }.join
+      if subtype.length == 1
+        subtype = "0#{subtype}"
+      end
+
+      value = Base64.encode64(data).strip
+
+      if options[:mode] == :legacy
+        { "$binary" => value, "$type" => subtype }
+      else
+        { "$binary" => {'base64' => value, "subType" => subtype }}
+      end
     end
 
     # Instantiate the new binary object.
@@ -228,14 +258,22 @@ module BSON
     #
     # @param [ ByteBuffer ] buffer The byte buffer.
     #
+    # @option options [ nil | :bson ] :mode Decoding mode to use.
+    #
     # @return [ Binary ] The decoded binary data.
     #
     # @see http://bsonspec.org/#/specification
     #
     # @since 2.0.0
-    def self.from_bson(buffer)
+    def self.from_bson(buffer, **options)
       length = buffer.get_int32
-      type = TYPES[buffer.get_byte]
+      type_byte = buffer.get_byte
+      type = TYPES[type_byte]
+      if type.nil?
+        raise Error::UnsupportedBinarySubtype,
+          "BSON data contains unsupported binary subtype #{'0x%02x' % type_byte.ord}"
+      end
+
       length = buffer.get_int32 if type == :old
       data = buffer.get_bytes(length)
       new(data, type)