bson 4.15.0 → 5.0.2

data/ext/bson/util.c

@@ -21,6 +21,18 @@
  */
 static char rb_bson_machine_id_hash[HOST_NAME_HASH_MAX];
 
+/**
+ * Holds a reference to the SecureRandom module, or Qnil if the modle is
+ * not available.
+ */
+static VALUE pvt_SecureRandom = Qnil;
+
+/**
+ * Indicates whether or not the SecureRandom module responds to the
+ * `random_number` method (depends on Ruby version).
+ */
+static int pvt_has_random_number = 0;
+
 void rb_bson_generate_machine_id(VALUE rb_md5_class, char *rb_bson_machine_id)
 {
   VALUE digest = rb_funcall(rb_md5_class, rb_intern("digest"), 1, rb_str_new2(rb_bson_machine_id));
@@ -29,31 +41,69 @@ void rb_bson_generate_machine_id(VALUE rb_md5_class, char *rb_bson_machine_id)
 
 /**
  * Generate the next object id.
+ *
+ * Specification:
+ * https://github.com/mongodb/specifications/blob/master/source/bson-objectid/objectid.md
+ *
+ * The ObjectID BSON type is a 12-byte value consisting of three different portions (fields):
+ *   * a 4-byte value representing the seconds since the Unix epoch in the highest order bytes,
+ *   * a 5-byte random number unique to a machine and process,
+ *   * a 3-byte counter, starting with a random value.
  */
 VALUE rb_bson_object_id_generator_next(int argc, VALUE* args, VALUE self)
 {
   char bytes[12];
-  uint32_t t;
-  uint32_t c;
-  uint16_t pid = BSON_UINT16_TO_BE(getpid());
+  uint32_t time_component;
+  uint8_t* random_component;
+  uint32_t counter_component;
+  VALUE timestamp;
+  VALUE rb_bson_object_id_class;
 
-  if (argc == 0 || (argc == 1 && *args == Qnil)) {
-    t = BSON_UINT32_TO_BE((int) time(NULL));
-  }
-  else {
-    t = BSON_UINT32_TO_BE(NUM2ULONG(rb_funcall(*args, rb_intern("to_i"), 0)));
-  }
+  rb_bson_object_id_class = pvt_const_get_2("BSON", "ObjectId");
+
+  /* "Drivers SHOULD have an accessor method on an ObjectID class for
+   * obtaining the timestamp value." */
+
+  timestamp = rb_funcall(rb_bson_object_id_class, rb_intern("timestamp"), 0);
+  time_component = BSON_UINT32_TO_BE(NUM2UINT(timestamp));
+
+  /* "A 5-byte field consisting of a random value generated once per process.
+   * This random value is unique to the machine and process.
+   *
+   * "Drivers MUST NOT have an accessor method on an ObjectID class for
+   * obtaining this value."
+   */
 
-  c = BSON_UINT32_TO_BE(rb_bson_object_id_counter << 8);
+  random_component = pvt_get_object_id_random_value();
+
+  /* shift left 8 bits, so that the first three bytes of the result are
+   * the meaningful ones */
+  counter_component = BSON_UINT32_TO_BE(rb_bson_object_id_counter << 8);
+
+  memcpy(&bytes, &time_component, 4);
+  memcpy(&bytes[4], random_component, 5);
+  memcpy(&bytes[9], &counter_component, 3);
+
+  rb_bson_object_id_counter = (rb_bson_object_id_counter + 1) % 0x1000000;
 
-  memcpy(&bytes, &t, 4);
-  memcpy(&bytes[4], rb_bson_machine_id_hash, 3);
-  memcpy(&bytes[7], &pid, 2);
-  memcpy(&bytes[9], &c, 3);
-  rb_bson_object_id_counter++;
   return rb_str_new(bytes, 12);
 }
 
+/**
+ * Reset the counter. This is purely as an aid for testing.
+ *
+ * @param [ Integer ] i the value to set the counter to (default is 0)
+ */
+VALUE rb_bson_object_id_generator_reset_counter(int argc, VALUE* args, VALUE self) {
+  switch(argc) {
+    case 0: rb_bson_object_id_counter = 0; break;
+    case 1: rb_bson_object_id_counter = FIX2INT(args[0]); break;
+    default: rb_raise(rb_eArgError, "Expected 0 or 1 arguments, got %d", argc);
+  }
+
+  return T_NIL;
+}
+
 /**
  * Returns a Ruby constant nested one level, e.g. BSON::Document.
  */
@@ -77,7 +127,7 @@ VALUE pvt_const_get_3(const char *c1, const char *c2, const char *c3) {
 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;
@@ -93,3 +143,108 @@ int pvt_get_mode_option(int argc, VALUE *argv) {
     }
   }
 }
+
+/**
+ * Returns the random number associated with this host and process. If the
+ * process ID changes (e.g. via fork), this will detect the change and
+ * generate another random number.
+ */
+uint8_t* pvt_get_object_id_random_value() {
+  static pid_t remembered_pid = 0;
+  static uint8_t remembered_value[BSON_OBJECT_ID_RANDOM_VALUE_LENGTH] = {0};
+  pid_t pid = getpid();
+
+  if (remembered_pid != pid) {
+    remembered_pid = pid;
+    pvt_rand_buf(remembered_value, BSON_OBJECT_ID_RANDOM_VALUE_LENGTH, pid);
+  }
+
+  return remembered_value;
+}
+
+/**
+ * Attempts to load the SecureRandom module
+ */
+VALUE pvt_load_secure_random(VALUE _arg) {
+  rb_require("securerandom");
+  pvt_SecureRandom = rb_const_get(rb_cObject, rb_intern("SecureRandom"));
+  pvt_has_random_number = rb_respond_to(pvt_SecureRandom, rb_intern("random_number"));
+
+  // mark SecureRandom so it does not get moved
+  rb_global_variable(&pvt_SecureRandom);
+
+  return Qnil;
+}
+
+/**
+ * The fallback, if loading `securerandom` fails.
+ */
+VALUE pvt_rescue_load_secure_random(VALUE _arg, VALUE _exception) {
+  pvt_SecureRandom = Qnil;
+
+  return Qnil;
+}
+
+/**
+ * Initializes the RNG.
+ */
+void pvt_init_rand() {
+  // SecureRandom may fail to load because it's not present (LoadError), or
+  // because it can't find a random device (NotImplementedError).
+  rb_rescue2(pvt_load_secure_random, Qnil, pvt_rescue_load_secure_random, Qnil,
+    rb_eLoadError, rb_eNotImpError, 0);
+}
+
+/**
+ * Fills the buffer with random bytes. It prefers to use SecureRandom for
+ * this, but in the very unlikely event that SecureRandom is not available,
+ * it will fall back to a much-less-ideal generator using srand/rand.
+ *
+ * The `pid` argument is only used by the fallback, if SecureRandom is not
+ * available.
+ */
+void pvt_rand_buf(uint8_t* bytes, int len, int pid) {
+  if (pvt_SecureRandom != Qnil) {
+    VALUE rb_bytes = rb_funcall(pvt_SecureRandom, rb_intern("bytes"), 1, INT2NUM(len));
+    memcpy(bytes, StringValuePtr(rb_bytes), len);
+
+  } else {
+    time_t t;
+    uint32_t seed;
+    int ofs = 0;
+
+    t = time(NULL);
+    seed = ((uint32_t)t << 16) + ((uint32_t)pid % 0xFFFF);
+    srand(seed);
+
+    while (ofs < len) {
+      int n = rand();
+      unsigned remaining = len - ofs;
+
+      if (remaining > sizeof(n)) remaining = sizeof(n);
+      memcpy(bytes+ofs, &n, remaining);
+
+      ofs += remaining;
+    }
+  }
+}
+
+/**
+ * Returns a random integer between 0 and INT_MAX.
+ */
+int pvt_rand() {
+  if (pvt_has_random_number) {
+    VALUE result = rb_funcall(pvt_SecureRandom, rb_intern("random_number"), 1, INT2NUM(INT_MAX));
+    return NUM2INT(result);
+
+  } else if (pvt_SecureRandom != Qnil) {
+    int result;
+    VALUE rb_result = rb_funcall(pvt_SecureRandom, rb_intern("bytes"), 1, INT2NUM(sizeof(result)));
+    memcpy(&result, StringValuePtr(rb_result), sizeof(result));
+    return result;
+
+  } else {
+    srand((unsigned)time(NULL));
+    return rand();
+  }
+}

data/ext/bson/write.c

@@ -20,18 +20,17 @@
 typedef struct{
   byte_buffer_t *b;
   VALUE buffer;
-  VALUE validating_keys;
 } put_hash_context;
 
 static void pvt_replace_int32(byte_buffer_t *b, int32_t position, int32_t newval);
-static void pvt_put_field(byte_buffer_t *b, VALUE rb_buffer, VALUE val, VALUE validating_keys);
+static void pvt_put_field(byte_buffer_t *b, VALUE rb_buffer, VALUE val);
 static void pvt_put_byte(byte_buffer_t *b, const char byte);
 static void pvt_put_int32(byte_buffer_t *b, const int32_t i32);
 static void pvt_put_uint32(byte_buffer_t *b, const uint32_t i32);
 static void pvt_put_int64(byte_buffer_t *b, const int64_t i);
 static void pvt_put_double(byte_buffer_t *b, double f);
 static void pvt_put_cstring(byte_buffer_t *b, const char *str, int32_t length, const char *data_type);
-static void pvt_put_bson_key(byte_buffer_t *b, VALUE string, VALUE validating_keys);
+static void pvt_put_bson_key(byte_buffer_t *b, VALUE string);
 static VALUE pvt_bson_byte_buffer_put_bson_partial_string(VALUE self, const char *str, int32_t length);
 static VALUE pvt_bson_byte_buffer_put_binary_string(VALUE self, const char *str, int32_t length);
 
@@ -39,7 +38,7 @@ static int fits_int32(int64_t i64){
   return i64 >= INT32_MIN && i64 <= INT32_MAX;
 }
 
-void pvt_put_field(byte_buffer_t *b, VALUE rb_buffer, VALUE val, VALUE validating_keys){
+void pvt_put_field(byte_buffer_t *b, VALUE rb_buffer, VALUE val){
   switch(TYPE(val)){
     case T_BIGNUM:
     case T_FIXNUM:{
@@ -55,7 +54,7 @@ void pvt_put_field(byte_buffer_t *b, VALUE rb_buffer, VALUE val, VALUE validatin
       pvt_put_double(b, NUM2DBL(val));
       break;
     case T_ARRAY:
-      rb_bson_byte_buffer_put_array(rb_buffer, val, validating_keys);
+      rb_bson_byte_buffer_put_array(rb_buffer, val);
       break;
     case T_TRUE:
       pvt_put_byte(b, 1);
@@ -64,10 +63,10 @@ void pvt_put_field(byte_buffer_t *b, VALUE rb_buffer, VALUE val, VALUE validatin
       pvt_put_byte(b, 0);
       break;
     case T_HASH:
-      rb_bson_byte_buffer_put_hash(rb_buffer, val, validating_keys);
+      rb_bson_byte_buffer_put_hash(rb_buffer, val);
       break;
     default:{
-      rb_funcall(val, rb_intern("to_bson"), 2, rb_buffer, validating_keys);
+      rb_funcall(val, rb_intern("to_bson"), 1, rb_buffer);
       break;
     }
   }
@@ -93,7 +92,7 @@ VALUE rb_bson_byte_buffer_put_byte(VALUE self, VALUE byte)
 
   str = RSTRING_PTR(byte);
   length = RSTRING_LEN(byte);
-  
+
   if (length != 1) {
     rb_raise(rb_eArgError, "put_byte requires a string of length 1");
   }
@@ -129,7 +128,7 @@ VALUE rb_bson_byte_buffer_put_bytes(VALUE self, VALUE bytes)
 /* write the byte denoting the BSON type for the passed object */
 void pvt_put_type_byte(byte_buffer_t *b, VALUE val){
   char type_byte;
-  
+
   switch (TYPE(val)){
     case T_BIGNUM:
     case T_FIXNUM:
@@ -169,7 +168,7 @@ void pvt_put_type_byte(byte_buffer_t *b, VALUE val){
       break;
     }
   }
-  
+
   pvt_put_byte(b, type_byte);
 }
 
@@ -213,24 +212,24 @@ static VALUE pvt_bson_encode_to_utf8(VALUE string) {
   VALUE utf8_string;
   const char *str;
   int32_t length;
-  
+
   existing_encoding_name = rb_funcall(
     rb_funcall(string, rb_intern("encoding"), 0),
     rb_intern("name"), 0);
-  
+
   if (strcmp(RSTRING_PTR(existing_encoding_name), "UTF-8") == 0) {
     utf8_string = string;
-  
+
     str = RSTRING_PTR(utf8_string);
     length = RSTRING_LEN(utf8_string);
-    
+
     rb_bson_utf8_validate(str, length, true, "String");
   } else {
     encoding = rb_enc_str_new_cstr("UTF-8", rb_utf8_encoding());
     utf8_string = rb_funcall(string, rb_intern("encode"), 1, encoding);
     RB_GC_GUARD(encoding);
   }
-  
+
   return utf8_string;
 }
 
@@ -240,15 +239,15 @@ VALUE rb_bson_byte_buffer_put_string(VALUE self, VALUE string)
   VALUE utf8_string;
   const char *str;
   int32_t length;
-  
+
   utf8_string = pvt_bson_encode_to_utf8(string);
   /* At this point utf8_string contains valid utf-8 byte sequences only */
-  
+
   str = RSTRING_PTR(utf8_string);
   length = RSTRING_LEN(utf8_string);
 
   RB_GC_GUARD(utf8_string);
-  
+
   return pvt_bson_byte_buffer_put_binary_string(self, str, length);
 }
 
@@ -287,7 +286,7 @@ VALUE rb_bson_byte_buffer_put_cstring(VALUE self, VALUE obj)
   default:
     rb_raise(rb_eTypeError, "Invalid type for put_cstring");
   }
-  
+
   str = RSTRING_PTR(string);
   length = RSTRING_LEN(string);
   RB_GC_GUARD(string);
@@ -327,15 +326,9 @@ VALUE rb_bson_byte_buffer_put_symbol(VALUE self, VALUE symbol)
 /**
  * Write a hash key to the byte buffer, validating it if requested
  */
-void pvt_put_bson_key(byte_buffer_t *b, VALUE string, VALUE validating_keys){
+void pvt_put_bson_key(byte_buffer_t *b, VALUE string){
   char *c_str = RSTRING_PTR(string);
   size_t length = RSTRING_LEN(string);
-  
-  if (RTEST(validating_keys)) {
-    if (length > 0 && (c_str[0] == '$' || memchr(c_str, '.', length))) {
-      rb_exc_raise(rb_funcall(rb_bson_illegal_key, rb_intern("new"), 1, string));
-    }
-  }
 
   pvt_put_cstring(b, c_str, length, "Key");
 }
@@ -351,18 +344,18 @@ VALUE rb_bson_byte_buffer_replace_int32(VALUE self, VALUE position, VALUE newval
 {
   byte_buffer_t *b;
   long _position;
-  
+
   _position = NUM2LONG(position);
   if (_position < 0) {
     rb_raise(rb_eArgError, "Position given to replace_int32 cannot be negative: %ld", _position);
   }
-  
+
   TypedData_Get_Struct(self, byte_buffer_t, &rb_byte_buffer_data_type, b);
-  
+
   if (b->write_position < 4) {
     rb_raise(rb_eArgError, "Buffer does not have enough data to use replace_int32");
   }
-  
+
   if ((size_t) _position > b->write_position - 4) {
     rb_raise(rb_eArgError, "Position given to replace_int32 is out of bounds: %ld", _position);
   }
@@ -481,7 +474,6 @@ VALUE rb_bson_byte_buffer_put_decimal128(VALUE self, VALUE low, VALUE high)
 
 static int put_hash_callback(VALUE key, VALUE val, VALUE context){
   VALUE buffer = ((put_hash_context*)context)->buffer;
-  VALUE validating_keys = ((put_hash_context*)context)->validating_keys;
   byte_buffer_t *b = ((put_hash_context*)context)->b;
   VALUE key_str;
 
@@ -489,23 +481,23 @@ static int put_hash_callback(VALUE key, VALUE val, VALUE context){
 
   switch(TYPE(key)){
     case T_STRING:
-      pvt_put_bson_key(b, key, validating_keys);
+      pvt_put_bson_key(b, key);
       break;
     case T_SYMBOL:
       key_str = rb_sym_to_s(key);
       RB_GC_GUARD(key_str);
-      pvt_put_bson_key(b, key_str, validating_keys);
+      pvt_put_bson_key(b, key_str);
       break;
     default:
-      rb_bson_byte_buffer_put_cstring(buffer, rb_funcall(key, rb_intern("to_bson_key"), 1, validating_keys));
+      rb_bson_byte_buffer_put_cstring(buffer, rb_funcall(key, rb_intern("to_bson_key"), 0));
   }
 
-  pvt_put_field(b, buffer, val, validating_keys);
+  pvt_put_field(b, buffer, val);
   return ST_CONTINUE;
 }
 
 /* The docstring is in init.c. */
-VALUE rb_bson_byte_buffer_put_hash(VALUE self, VALUE hash, VALUE validating_keys){
+VALUE rb_bson_byte_buffer_put_hash(VALUE self, VALUE hash){
   byte_buffer_t *b = NULL;
   put_hash_context context = { NULL };
   size_t position = 0;
@@ -520,7 +512,6 @@ VALUE rb_bson_byte_buffer_put_hash(VALUE self, VALUE hash, VALUE validating_keys
   /* insert length placeholder */
   pvt_put_int32(b, 0);
   context.buffer = self;
-  context.validating_keys = validating_keys;
   context.b = b;
 
   rb_hash_foreach(hash, put_hash_callback, (VALUE)&context);
@@ -642,6 +633,10 @@ void pvt_put_array_index(byte_buffer_t *b, int32_t index)
     c_str = buffer;
     snprintf(buffer, sizeof(buffer), "%d", index);
   }
+  // strlen is a potential vector for out-of-bounds errors, but
+  // the only way for that to happen here, specifically, is if `index`
+  // is greater than 10e16 - 1, which is far beyond the domain of an
+  // int32.
   length = strlen(c_str) + 1;
   ENSURE_BSON_WRITE(b, length);
   memcpy(WRITE_PTR(b), c_str, length);
@@ -649,7 +644,7 @@ void pvt_put_array_index(byte_buffer_t *b, int32_t index)
 }
 
 /* The docstring is in init.c. */
-VALUE rb_bson_byte_buffer_put_array(VALUE self, VALUE array, VALUE validating_keys){
+VALUE rb_bson_byte_buffer_put_array(VALUE self, VALUE array){
   byte_buffer_t *b = NULL;
   size_t new_position = 0;
   int32_t new_length = 0;
@@ -667,7 +662,7 @@ VALUE rb_bson_byte_buffer_put_array(VALUE self, VALUE array, VALUE validating_ke
   for(int32_t index=0; index < RARRAY_LEN(array); index++, array_element++){
     pvt_put_type_byte(b, *array_element);
     pvt_put_array_index(b, index);
-    pvt_put_field(b, self, *array_element, validating_keys);
+    pvt_put_field(b, self, *array_element);
   }
   pvt_put_byte(b, 0);
 

data/lib/bson/active_support.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# rubocop:todo all
 # Copyright (C) 2018-2020 MongoDB Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");

data/lib/bson/array.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 # Copyright (C) 2009-2020 MongoDB Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -13,8 +14,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+# The top-level BSON module.
 module BSON
-
   # Injects behaviour for encoding and decoding arrays to
   # and from raw bytes as specified by the BSON spec.
   #
@@ -22,7 +23,6 @@ module BSON
   #
   # @since 2.0.0
   module Array
-
     # An array is type 0x04 in the BSON spec.
     #
     # @since 2.0.0
@@ -41,19 +41,21 @@ module BSON
     # @see http://bsonspec.org/#/specification
     #
     # @since 2.0.0
-    def to_bson(buffer = ByteBuffer.new, validating_keys = Config.validating_keys?)
+    def to_bson(buffer = ByteBuffer.new)
       if buffer.respond_to?(:put_array)
-        buffer.put_array(self, validating_keys)
+        buffer.put_array(self)
       else
         position = buffer.length
         buffer.put_int32(0)
         each_with_index do |value, index|
           unless value.respond_to?(:bson_type)
-            raise Error::UnserializableClass, "Array element at position #{index} does not define its BSON serialized type: #{value}"
+            raise Error::UnserializableClass,
+                  "Array element at position #{index} does not define its BSON serialized type: #{value}"
           end
+
           buffer.put_byte(value.bson_type)
           buffer.put_cstring(index.to_s)
-          value.to_bson(buffer, validating_keys)
+          value.to_bson(buffer)
         end
         buffer.put_byte(NULL_BYTE)
         buffer.replace_int32(position, buffer.length - position)
@@ -68,13 +70,13 @@ module BSON
     #
     # @note This is used for repairing legacy bson data.
     #
-    # @raise [ BSON::ObjectId::Invalid ] If the array is not 12 elements.
+    # @raise [ BSON::Error::InvalidObjectId ] If the array is not 12 elements.
     #
     # @return [ String ] The raw object id bytes.
     #
     # @since 2.0.0
     def to_bson_object_id
-      ObjectId.repair(self) { pack("C*") }
+      ObjectId.repair(self) { pack('C*') }
     end
 
     # Converts the array to a normalized value in a BSON document.
@@ -86,11 +88,11 @@ module BSON
     #
     # @since 3.0.0
     def to_bson_normalized_value
-      map { |value| value.to_bson_normalized_value }
+      map(&: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).
+    # Extended JSON (https://github.com/mongodb/specifications/blob/master/source/extended-json/extended-json.md).
     #
     # This method recursively invokes +as_extended_json+ with the provided
     # options on each array element.
@@ -105,10 +107,15 @@ module BSON
       end
     end
 
+    # Class-level methods to be added to the Array class.
     module ClassMethods
-
       # Deserialize the array from BSON.
       #
+      # @note If the argument cannot be parsed, an exception will be raised
+      #   and the argument will be left in an undefined state. The caller
+      #   must explicitly call `rewind` on the buffer before trying to parse
+      #   it again.
+      #
       # @param [ ByteBuffer ] buffer The byte buffer.
       #
       # @option options [ nil | :bson ] :mode Decoding mode to use.
@@ -116,43 +123,62 @@ module BSON
       # @return [ Array ] The decoded array.
       #
       # @see http://bsonspec.org/#/specification
-      #
-      # @since 2.0.0
       def from_bson(buffer, **options)
         if buffer.respond_to?(:get_array)
           buffer.get_array(**options)
         else
-          array = new
+          parse_array_from_buffer(buffer, **options)
+        end
+      end
+
+      private
+
+      # Parse an array from the buffer.
+      #
+      # @param [ ByteBuf ] buffer the buffer to read from
+      # @param [ Hash ] options the optional keyword arguments
+      #
+      # @return [ Array ] the array that was parsed
+      #
+      # @raise [ BSON::Error::BSONDecodeError ] if the expected number of
+      #   bytes were not read from the buffer
+      def parse_array_from_buffer(buffer, **options)
+        new.tap do |array|
           start_position = buffer.read_position
           expected_byte_size = buffer.get_int32
-          while (type = buffer.get_byte) != NULL_BYTE
-            buffer.get_cstring
-            cls = BSON::Registry.get(type)
-            value = if options.empty?
-              cls.from_bson(buffer)
-            else
-              cls.from_bson(buffer, **options)
-            end
-            array << value
-          end
+          parse_array_elements_from_buffer(array, buffer, **options)
           actual_byte_size = buffer.read_position - start_position
           if actual_byte_size != expected_byte_size
-            raise Error::BSONDecodeError, "Expected array to take #{expected_byte_size} bytes but it took #{actual_byte_size} bytes"
+            raise Error::BSONDecodeError,
+                  "Expected array to take #{expected_byte_size} bytes but it took #{actual_byte_size} bytes"
           end
-          array
+        end
+      end
+
+      # Parse a sequence of array elements from the buffer.
+      #
+      # @param [ Array ] array the array to populate
+      # @param [ ByteBuf ] buffer the buffer to read from
+      # @param [ Hash ] options the optional keyword arguments
+      def parse_array_elements_from_buffer(array, buffer, **options)
+        while (type = buffer.get_byte) != NULL_BYTE
+          buffer.get_cstring
+          cls = BSON::Registry.get(type)
+          value = if options.empty?
+                    cls.from_bson(buffer)
+                  else
+                    cls.from_bson(buffer, **options)
+                  end
+          array << value
         end
       end
     end
 
     # Register this type when the module is loaded.
-    #
-    # @since 2.0.0
     Registry.register(BSON_TYPE, ::Array)
   end
 
   # Enrich the core Array class with this module.
-  #
-  # @since 2.0.0
-  ::Array.send(:include, Array)
-  ::Array.send(:extend, Array::ClassMethods)
+  ::Array.include Array
+  ::Array.extend Array::ClassMethods
 end