bson 4.9.4 → 4.11.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9d770bbf52ee70915f3f04b3831de6ef57c90ae131fcde462bb1925df609119e
-  data.tar.gz: ea768461024fac1dabccae70d6a2b6a6d68c74be70eb581b5849c37d535b1fb3
+  metadata.gz: 6f2b7b7906a18c900a2cd45e1b884f3c84cf863234e703838ee752c6b87badcb
+  data.tar.gz: beb2dd92cc828d7db3084ff2095a8df28dcb6a18e89c699f2a6bd7b7d1acd376
 SHA512:
-  metadata.gz: c85b9d81f0f849fca1f59ee23c239de332107c4758673e60ee4f160fc8c0ba4089de905bdf8024d755b005c8828043f80f6158de0e780dba02d459c17550cc34
-  data.tar.gz: 9663f3b950a457c1143204ef24dd7aa418be6ea350c2a615fdf752b2d14482606133649d0b2d18549d5d9676f4df37f39d23a6b027b06365b1fbc7ebba3bfc8a
+  metadata.gz: 5e0359cf8b6632840e5ad9be71f5d350a53e0606d5fa5afa4706021f1083a9493a410bc8d9d5ecc24c6b3ba02f7ee482898db9dc190ff8620ad5dc9014441e90
+  data.tar.gz: beb107c6db4bd7f6ba32671d4d340f9593636fe490b69e6e60abc812c1698b4f203b800f2ea145af77a9c319b7c9f4dfa90bb22eea157d15828a09bc8fb388ae

checksums.yaml.gz.sig

@@ -1,2 +1,2 @@
-S�t�DCi�q<��E$��L?��)�t�
-�ɒ��[���E`�}��|$
�lP�/R�Ag��)�Q��P�ϼ�t�:���X�lFi��eoy/��u�HM���j!\���ISL��B�0������c[D�)�{n:��:Q�����Tm;�&�!�a�f�CÌd�%?ț����O�X���%��;<���.Y~�
_{��'����?�,0p<���9�H�����������q����L����#^�
+�Oi���a�H�V/ZH���L�aØ��+�<�.}�39X|7����yH��;Ңrs�A��y��/N�9�s��g-����6p{=��vJ1��{\3���쇮�E�����	��((�co)�~
+�vȿw�y�jR�Ҏ~�$N���P�����Ӿhr�����f�Yk��J�]υr�5�e�yA���NV�ў�H���#^2���Xg����޸	*_�ߌ��hQY6D������p�T�&�p�����?�

data/ext/bson/bson-native.h

@@ -76,6 +76,7 @@ VALUE rb_bson_byte_buffer_get_cstring(VALUE self);
 VALUE rb_bson_byte_buffer_get_decimal128_bytes(VALUE self);
 VALUE rb_bson_byte_buffer_get_double(VALUE self);
 VALUE rb_bson_byte_buffer_get_int32(VALUE self);
+VALUE rb_bson_byte_buffer_get_uint32(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(int argc, VALUE *argv, VALUE self);
@@ -86,6 +87,7 @@ VALUE rb_bson_byte_buffer_put_cstring(VALUE self, VALUE string);
 VALUE rb_bson_byte_buffer_put_decimal128(VALUE self, VALUE low, VALUE high);
 VALUE rb_bson_byte_buffer_put_double(VALUE self, VALUE f);
 VALUE rb_bson_byte_buffer_put_int32(VALUE self, VALUE i);
+VALUE rb_bson_byte_buffer_put_uint32(VALUE self, VALUE i);
 VALUE rb_bson_byte_buffer_put_int64(VALUE self, VALUE i);
 VALUE rb_bson_byte_buffer_put_string(VALUE self, VALUE string);
 VALUE rb_bson_byte_buffer_put_symbol(VALUE self, VALUE symbol);

data/ext/bson/init.c

@@ -56,6 +56,16 @@ void Init_bson_native()
 
   rb_define_alloc_func(rb_byte_buffer_class, rb_bson_byte_buffer_allocate);
   rb_define_method(rb_byte_buffer_class, "initialize", rb_bson_byte_buffer_initialize, -1);
+
+  /*
+   * call-seq:
+   *   buffer.length -> Fixnum
+   *
+   * Returns the number of bytes available to be read in the buffer.
+   *
+   * When a buffer is being written to, each added byte increases its length.
+   * When a buffer is being read from, each read byte decreases its length.
+   */
   rb_define_method(rb_byte_buffer_class, "length", rb_bson_byte_buffer_length, 0);
 
   /*
@@ -88,7 +98,7 @@ void Init_bson_native()
    * call-seq:
    *   buffer.get_array(**options) -> Array
    *
-   * Reads an array from the byte buffer..
+   * Reads an array from the byte buffer.
    *
    * @option options [ nil | :bson ] :mode Decoding mode to use.
    *
@@ -97,6 +107,18 @@ void Init_bson_native()
   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);
+  
+  /*
+   * call-seq:
+   *   buffer.get_uint32(buffer) -> Fixnum
+   *
+   * Reads an unsigned 32 bit number from the byte buffer.
+   *
+   * @return [ Fixnum ] The unsigned 32 bits integer from the buffer
+   *
+   * @api private
+   */
+  rb_define_method(rb_byte_buffer_class, "get_uint32", rb_bson_byte_buffer_get_uint32, 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);
 
@@ -202,6 +224,21 @@ void Init_bson_native()
    */
   rb_define_method(rb_byte_buffer_class, "put_int32", rb_bson_byte_buffer_put_int32, 1);
 
+  /*
+   * call-seq:
+   *   buffer.put_uint32(fixnum) -> ByteBuffer
+   *
+   * Writes an unsigned 32-bit integer value to the buffer.
+   *
+   * If the argument cannot be represented in 32 bits, raises RangeError.
+   *
+   * Returns the modified +self+.
+   *
+   * @api private
+   *
+   */
+  rb_define_method(rb_byte_buffer_class, "put_uint32", rb_bson_byte_buffer_put_uint32, 1);
+
   /*
    * call-seq:
    *   buffer.put_int64(fixnum) -> ByteBuffer
@@ -239,7 +276,7 @@ void Init_bson_native()
 
   /*
    * call-seq:
-   *   buffer.put_hash(hash) -> ByteBuffer
+   *   buffer.put_hash(hash, validating_keys) -> ByteBuffer
    *
    * Writes a Hash into the byte buffer.
    *
@@ -292,6 +329,10 @@ void Init_bson_native()
    *
    * Returns the contents of the buffer as a binary string.
    *
+   * If the buffer is used for reading, the returned contents is the data
+   * that was not yet read. If the buffer is used for writing, the returned
+   * contents is the complete data that has been written so far.
+   *
    * Note: this method copies the buffer's contents into a newly allocated
    * +String+ instance. It does not return a reference to the data stored in
    * the buffer itself.

data/ext/bson/read.c

@@ -21,6 +21,7 @@ static void pvt_raise_decode_error(volatile VALUE msg);
 static int32_t 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_uint32(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, const char *data_type);
@@ -41,12 +42,12 @@ void pvt_raise_decode_error(volatile VALUE msg) {
 int32_t pvt_validate_length(byte_buffer_t *b)
 {
   int32_t length;
-  
+
   ENSURE_BSON_READ(b, 4);
   memcpy(&length, READ_PTR(b), 4);
   length = BSON_UINT32_TO_LE(length);
 
-  /* minimum valid length is 4 (byte count) + 1 (terminating byte) */ 
+  /* minimum valid length is 4 (byte count) + 1 (terminating byte) */
   if(length >= 5){
     ENSURE_BSON_READ(b, length);
 
@@ -59,7 +60,7 @@ int32_t pvt_validate_length(byte_buffer_t *b)
   else{
     rb_raise(rb_eRangeError, "Buffer contained invalid length %d at %zu", length, b->read_position);
   }
-  
+
   return length;
 }
 
@@ -175,13 +176,13 @@ VALUE pvt_get_string(byte_buffer_t *b, const char *data_type)
   }
   ENSURE_BSON_READ(b, 4 + length);
   str_ptr = READ_PTR(b) + 4;
-  last_byte = *(READ_PTR(b) + 4 + length_le - 1);
+  last_byte = *(READ_PTR(b) + 4 + length - 1);
   if (last_byte != 0) {
     pvt_raise_decode_error(rb_sprintf("Last byte of the string is not null: 0x%x", (int) last_byte));
   }
   rb_bson_utf8_validate(str_ptr, length - 1, true, data_type);
   string = rb_enc_str_new(str_ptr, length - 1, rb_utf8_encoding());
-  b->read_position += 4 + length_le;
+  b->read_position += 4 + length;
   return string;
 }
 
@@ -205,7 +206,7 @@ VALUE pvt_get_symbol(byte_buffer_t *b, VALUE rb_buffer, int argc, VALUE *argv)
     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;
 }
@@ -259,6 +260,28 @@ VALUE pvt_get_int32(byte_buffer_t *b)
   return INT2NUM(BSON_UINT32_FROM_LE(i32));
 }
 
+/**
+ * Get an unsigned int32 from the buffer.
+ */
+VALUE rb_bson_byte_buffer_get_uint32(VALUE self)
+{
+  byte_buffer_t *b;
+
+  TypedData_Get_Struct(self, byte_buffer_t, &rb_byte_buffer_data_type, b);
+  return pvt_get_uint32(b);
+}
+
+VALUE pvt_get_uint32(byte_buffer_t *b)
+{
+  uint32_t i32;
+
+  ENSURE_BSON_READ(b, 4);
+  memcpy(&i32, READ_PTR(b), 4);
+  b->read_position += 4;
+  return UINT2NUM(BSON_UINT32_FROM_LE(i32));
+}
+
+
 /**
  * Get a int64 from the buffer.
  */
@@ -284,7 +307,7 @@ VALUE pvt_get_int64(byte_buffer_t *b, int argc, VALUE *argv)
   memcpy(&i64, READ_PTR(b), 8);
   b->read_position += 8;
   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);
@@ -293,7 +316,7 @@ VALUE pvt_get_int64(byte_buffer_t *b, int argc, VALUE *argv)
   } else {
     return num;
   }
-  
+
   RB_GC_GUARD(num);
 }
 
@@ -353,11 +376,11 @@ VALUE rb_bson_byte_buffer_get_hash(int argc, VALUE *argv, VALUE self){
     rb_hash_aset(doc, field, pvt_read_field(b, self, type, argc, argv));
     RB_GC_GUARD(field);
   }
-  
+
   if (READ_PTR(b) - start_ptr != length) {
     pvt_raise_decode_error(rb_sprintf("Expected to read %d bytes for the hash but read %ld bytes", length, READ_PTR(b) - start_ptr));
   }
-  
+
   return doc;
 }
 
@@ -379,10 +402,10 @@ VALUE rb_bson_byte_buffer_get_array(int argc, VALUE *argv, VALUE self){
     rb_ary_push(array,  pvt_read_field(b, self, type, argc, argv));
   }
   RB_GC_GUARD(array);
-  
+
   if (READ_PTR(b) - start_ptr != length) {
     pvt_raise_decode_error(rb_sprintf("Expected to read %d bytes for the hash but read %ld bytes", length, READ_PTR(b) - start_ptr));
   }
-  
+
   return array;
 }

data/ext/bson/write.c

@@ -27,6 +27,7 @@ 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_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);
@@ -390,6 +391,37 @@ void pvt_put_int32(byte_buffer_t *b, const int32_t i)
   b->write_position += 4;
 }
 
+/* The docstring is in init.c. */
+VALUE rb_bson_byte_buffer_put_uint32(VALUE self, VALUE i)
+{
+  byte_buffer_t *b;
+  int64_t temp;
+  uint32_t i32;
+
+  if (RB_TYPE_P(i, T_FLOAT)) {
+    rb_raise(rb_eArgError, "put_uint32: incorrect type: float, expected: integer");
+  }
+
+  temp = NUM2LL(i);
+  if (temp < 0 || temp > UINT32_MAX) {
+    rb_raise(rb_eRangeError, "Number %lld is out of range [0, 2^32)", (long long)temp);
+  }
+
+  i32 = NUM2UINT(i);
+
+  TypedData_Get_Struct(self, byte_buffer_t, &rb_byte_buffer_data_type, b);
+  pvt_put_uint32(b, i32);
+  return self;
+}
+
+void pvt_put_uint32(byte_buffer_t *b, const uint32_t i)
+{
+  const uint32_t i32 = BSON_UINT32_TO_LE(i);
+  ENSURE_BSON_WRITE(b, 4);
+  memcpy(WRITE_PTR(b), &i32, 4);
+  b->write_position += 4;
+}
+
 /* The docstring is in init.c. */
 VALUE rb_bson_byte_buffer_put_int64(VALUE self, VALUE i)
 {

data/lib/bson/date_time.rb

@@ -35,7 +35,7 @@ module BSON
     #
     # @since 2.1.0
     def to_bson(buffer = ByteBuffer.new, validating_keys = Config.validating_keys?)
-      to_time.to_bson(buffer)
+      gregorian.to_time.to_bson(buffer)
     end
   end
 

data/lib/bson/timestamp.rb

@@ -124,8 +124,8 @@ module BSON
     #
     # @since 2.0.0
     def to_bson(buffer = ByteBuffer.new, validating_keys = Config.validating_keys?)
-      buffer.put_int32(increment)
-      buffer.put_int32(seconds)
+      buffer.put_uint32(increment)
+      buffer.put_uint32(seconds)
     end
 
     # Deserialize timestamp from BSON.
@@ -140,8 +140,8 @@ module BSON
     #
     # @since 2.0.0
     def self.from_bson(buffer, **options)
-      increment = buffer.get_int32
-      seconds = buffer.get_int32
+      increment = buffer.get_uint32
+      seconds = buffer.get_uint32
       new(seconds, increment)
     end
 

data/lib/bson/version.rb

@@ -13,5 +13,5 @@
 # limitations under the License.
 
 module BSON
-  VERSION = "4.9.4".freeze
+  VERSION = "4.11.1".freeze
 end

data/spec/bson/byte_buffer_read_spec.rb

@@ -66,7 +66,7 @@ describe BSON::ByteBuffer do
   describe '#get_double' do
 
     let(:buffer) do
-      described_class.new("#{12.5.to_bson.to_s}")
+      described_class.new(12.5.to_bson.to_s)
     end
 
     let!(:double) do
@@ -85,7 +85,7 @@ describe BSON::ByteBuffer do
   describe '#get_int32' do
 
     let(:buffer) do
-      described_class.new("#{12.to_bson.to_s}")
+      described_class.new(12.to_bson.to_s)
     end
 
     let!(:int32) do
@@ -101,10 +101,66 @@ describe BSON::ByteBuffer do
     end
   end
 
+  describe '#get_uint32' do
+    context 'when using 2^32-1' do
+      let(:buffer) do
+        described_class.new(4294967295.to_bson.to_s)
+      end
+
+      let!(:int32) do
+        buffer.get_uint32
+      end
+
+      it 'gets the uint32 from the buffer' do
+        expect(int32).to eq(4294967295)
+      end
+
+      it 'increments the position by 4' do
+        expect(buffer.read_position).to eq(4)
+      end
+    end
+    
+    context 'when using 2^32-2' do
+      let(:buffer) do
+        described_class.new(4294967294.to_bson.to_s)
+      end
+
+      let!(:int32) do
+        buffer.get_uint32
+      end
+
+      it 'gets the uint32 from the buffer' do
+        expect(int32).to eq(4294967294)
+      end
+
+      it 'increments the position by 4' do
+        expect(buffer.read_position).to eq(4)
+      end
+    end
+
+    context 'when using 0' do
+      let(:buffer) do
+        described_class.new(0.to_bson.to_s)
+      end
+
+      let!(:int32) do
+        buffer.get_uint32
+      end
+
+      it 'gets the uint32 from the buffer' do
+        expect(int32).to eq(0)
+      end
+
+      it 'increments the position by 4' do
+        expect(buffer.read_position).to eq(4)
+      end
+    end
+  end
+
   describe '#get_int64' do
 
     let(:buffer) do
-      described_class.new("#{(Integer::MAX_64BIT - 1).to_bson.to_s}")
+      described_class.new((Integer::MAX_64BIT - 1).to_bson.to_s)
     end
 
     let!(:int64) do

data/spec/bson/byte_buffer_spec.rb

@@ -31,12 +31,14 @@ describe BSON::ByteBuffer do
         described_class.new
       end
 
-      before do
-        buffer.put_int32(5)
-      end
-
-      it 'returns the length of the buffer' do
-        expect(buffer.length).to eq(4)
+      context '#put_int32' do
+        before do
+          buffer.put_int32(5)
+        end
+
+        it 'returns the length of the buffer' do
+          expect(buffer.length).to eq(4)
+        end
       end
     end
 
@@ -50,6 +52,50 @@ describe BSON::ByteBuffer do
         expect(buffer.length).to eq(2)
       end
     end
+
+    context 'after the byte buffer was read from' do
+
+      let(:buffer) do
+        described_class.new({}.to_bson.to_s)
+      end
+
+      it 'returns the number of bytes remaining in the buffer' do
+        expect(buffer.length).to eq(5)
+        buffer.get_int32
+        expect(buffer.length).to eq(1)
+      end
+    end
+
+    context 'after the byte buffer was converted to string' do
+
+      shared_examples 'returns the total buffer length' do
+        it 'returns the total buffer length' do
+          expect(buffer.length).to eq(5)
+          buffer.to_s.length.should == 5
+          expect(buffer.length).to eq(5)
+        end
+      end
+
+      context 'read buffer' do
+
+        let(:buffer) do
+          described_class.new({}.to_bson.to_s)
+        end
+
+        include_examples 'returns the total buffer length'
+      end
+
+      context 'write buffer' do
+
+        let(:buffer) do
+          described_class.new.tap do |buffer|
+            buffer.put_bytes('hello')
+          end
+        end
+
+        include_examples 'returns the total buffer length'
+      end
+    end
   end
 
   describe '#rewind!' do
@@ -104,4 +150,81 @@ describe BSON::ByteBuffer do
       expect(buffer.write_position).to eq(1)
     end
   end
+
+  describe 'write followed by read' do
+    let(:buffer) do
+      described_class.new
+    end
+
+    context 'one cycle' do
+      it 'returns the written data' do
+        buffer.put_cstring('hello')
+        buffer.get_cstring.should == 'hello'
+      end
+    end
+
+    context 'two cycles' do
+      it 'returns the written data' do
+        buffer.put_cstring('hello')
+        buffer.get_cstring.should == 'hello'
+
+        buffer.put_cstring('world')
+        buffer.get_cstring.should == 'world'
+      end
+    end
+
+    context 'mixed cycles' do
+      it 'returns the written data' do
+        if BSON::Environment.jruby?
+          pending 'RUBY-2334'
+        end
+
+        buffer.put_int32(1)
+        buffer.put_int32(2)
+
+        buffer.get_int32.should == 1
+
+        buffer.put_int32(3)
+
+        buffer.get_int32.should == 2
+        buffer.get_int32.should == 3
+      end
+    end
+  end
+
+  describe '#to_s' do
+    context 'read buffer' do
+      let(:buffer) do
+        described_class.new("\x18\x00\x00\x00*\x00\x00\x00")
+      end
+
+      it 'returns the data' do
+        buffer.to_s.should == "\x18\x00\x00\x00*\x00\x00\x00"
+      end
+
+      it 'returns the remaining buffer contents after a read' do
+        buffer.to_s.should == "\x18\x00\x00\x00*\x00\x00\x00"
+        buffer.get_int32.should == 24
+        buffer.to_s.should == "*\x00\x00\x00"
+      end
+    end
+
+    context 'write buffer' do
+      let(:buffer) do
+        described_class.new.tap do |buffer|
+          buffer.put_int32(24)
+        end
+      end
+
+      it 'returns the data' do
+        buffer.to_s.should == "\x18\x00\x00\x00".force_encoding('binary')
+      end
+
+      it 'returns the complete buffer contents after a write' do
+        buffer.to_s.should == "\x18\x00\x00\x00".force_encoding('binary')
+        buffer.put_int32(42)
+        buffer.to_s.should == "\x18\x00\x00\x00*\x00\x00\x00".force_encoding('binary')
+      end
+    end
+  end
 end

data/spec/bson/byte_buffer_write_spec.rb

@@ -585,6 +585,102 @@ describe BSON::ByteBuffer do
     end
   end
 
+  describe '#put_uint32' do
+    context 'when argument is a float' do
+      it 'raises an Argument Error' do
+        expect{ buffer.put_uint32(4.934) }.to raise_error(ArgumentError, "put_uint32: incorrect type: float, expected: integer")
+      end
+    end
+    
+    context 'when number is in range' do 
+      let(:modified) do
+        buffer.put_uint32(5)
+      end
+
+      it 'returns gets the correct number from the buffer' do
+        expect(modified.get_uint32).to eq(5)
+      end
+
+      it 'returns the length of the buffer' do
+        expect(modified.length).to eq(4)
+      end
+    end
+
+    context 'when number is 0' do 
+      let(:modified) do
+        buffer.put_uint32(0)
+      end
+
+      it 'returns gets the correct number from the buffer' do
+        expect(modified.get_uint32).to eq(0)
+      end
+
+      it 'returns the length of the buffer' do
+        expect(modified.length).to eq(4)
+      end
+    end
+
+    context 'when number doesn\'t fit in signed int32' do 
+      let(:modified) do
+        buffer.put_uint32(4294967295)
+      end
+
+      let(:expected) do
+        [ 4294967295 ].pack(BSON::Int32::PACK)
+      end
+
+      it 'appends the int32 to the byte buffer' do
+        expect(modified.to_s).to eq(expected)
+      end
+
+      it 'get returns correct number' do
+        expect(modified.get_uint32).to eq(4294967295)
+      end
+
+      it 'returns the length of the buffer' do
+        expect(modified.length).to eq(4)
+      end
+    end
+
+    context 'when number is 2^31' do 
+      let(:modified) do
+        buffer.put_uint32(2147483648)
+      end
+
+      it 'returns gets the correct number from the buffer' do
+        expect(modified.get_uint32).to eq(2147483648)
+      end
+
+      it 'returns the length of the buffer' do
+        expect(modified.length).to eq(4)
+      end
+    end
+
+    context 'when number is 2^31-1' do 
+      let(:modified) do
+        buffer.put_uint32(2147483647)
+      end
+
+      it 'returns gets the correct number from the buffer' do
+        expect(modified.get_uint32).to eq(2147483647)
+      end
+
+      it 'returns the length of the buffer' do
+        expect(modified.length).to eq(4)
+      end
+    end
+
+    context 'when number is not in range' do 
+      it 'raises error on out of top range' do
+        expect{ buffer.put_uint32(4294967296) }.to raise_error(RangeError, "Number 4294967296 is out of range [0, 2^32)")
+      end
+
+      it 'raises error on out of bottom range' do
+        expect{ buffer.put_uint32(-1) }.to raise_error(RangeError, "Number -1 is out of range [0, 2^32)")
+      end
+    end
+  end
+
   describe '#put_int64' do
 
     context 'when the integer is 64 bit' do

data/spec/bson/date_time_spec.rb

@@ -35,5 +35,58 @@ describe DateTime do
 
       it_behaves_like "a serializable bson element"
     end
+
+    context "when the dates don't both use Gregorian" do
+      
+      let(:shakespeare_datetime) do 
+        DateTime.iso8601('1616-04-23', Date::ENGLAND)
+      end
+
+      let(:gregorian_datetime) do
+        DateTime.iso8601('1616-04-23', Date::GREGORIAN)
+      end
+
+      context "when putting to bson" do 
+        
+        let(:shakespeare) do
+          { a: shakespeare_datetime }.to_bson
+        end
+
+        let(:gregorian) do
+          { a: gregorian_datetime }.to_bson
+        end
+
+        it "does not equal each other" do 
+          expect(shakespeare.to_s).to_not eq(gregorian.to_s)
+        end
+
+        it "the english date is 10 days later" do 
+          expect(shakespeare.to_s).to eq({ a: DateTime.iso8601('1616-05-03', Date::GREGORIAN) }.to_bson.to_s)
+        end
+      end
+
+      context "when putting and receiving from bson" do 
+
+        let(:shakespeare) do
+          Hash.from_bson(BSON::ByteBuffer.new({ a: shakespeare_datetime }.to_bson.to_s))
+        end
+
+        let(:gregorian) do
+          Hash.from_bson(BSON::ByteBuffer.new({ a: gregorian_datetime }.to_bson.to_s))
+        end
+
+        it "does not equal each other" do
+          expect(shakespeare).to_not eq(gregorian)
+        end
+
+        it "the english date is 10 days later" do
+          expect(shakespeare[:a]).to eq(DateTime.iso8601('1616-05-03', Date::GREGORIAN).to_time)
+        end
+
+        it "the gregorian date is the same" do
+          expect(gregorian[:a]).to eq(DateTime.iso8601('1616-04-23', Date::GREGORIAN).to_time)
+        end
+      end
+    end
   end
 end

data/spec/bson/hash_spec.rb

@@ -244,6 +244,16 @@ describe Hash do
           /(Hash value for key 'foo'|Value) does not define its BSON serialized type:.*HashSpecUnserializableClass/)
       end
     end
+
+    context 'when reading from a byte buffer that was previously written to' do
+      let(:buffer) do
+        {foo: 42}.to_bson
+      end
+
+      it 'returns the original hash' do
+        expect(Hash.from_bson(buffer)).to eq('foo' => 42)
+      end
+    end
   end
 
   describe '#to_bson' do
@@ -310,4 +320,50 @@ describe Hash do
       end
     end
   end
+
+  describe '#from_bson' do
+    context 'when bson document has duplicate keys' do
+      let(:buf) do
+        buf = BSON::ByteBuffer.new
+        buf.put_int32(37)
+        buf.put_byte("\x02")
+        buf.put_cstring('foo')
+        buf.put_string('bar')
+        buf.put_byte("\x02")
+        buf.put_cstring('foo')
+        buf.put_string('overwrite')
+        buf.put_byte("\x00")
+
+        BSON::ByteBuffer.new(buf.to_s)
+      end
+
+      let(:doc) { Hash.from_bson(buf) }
+
+      it 'overwrites first value with second value' do
+        doc.should == {'foo' => 'overwrite'}
+      end
+    end
+
+    context 'when bson document has string and symbol keys of the same name' do
+      let(:buf) do
+        buf = BSON::ByteBuffer.new
+        buf.put_int32(31)
+        buf.put_byte("\x02")
+        buf.put_cstring('foo')
+        buf.put_string('bar')
+        buf.put_byte("\x0e")
+        buf.put_cstring('foo')
+        buf.put_string('bar')
+        buf.put_byte("\x00")
+
+        BSON::ByteBuffer.new(buf.to_s)
+      end
+
+      let(:doc) { Hash.from_bson(buf) }
+
+      it 'overwrites first value with second value' do
+        doc.should == {'foo' => :bar}
+      end
+    end
+  end
 end

data/spec/spec_tests/data/corpus/timestamp.json

@@ -13,6 +13,16 @@
             "canonical_bson": "100000001161002A00000015CD5B0700",
             "canonical_extjson": "{\"a\" : {\"$timestamp\" : {\"t\" : 123456789, \"i\" : 42} } }",
             "degenerate_extjson": "{\"a\" : {\"$timestamp\" : {\"i\" : 42, \"t\" : 123456789} } }"
+        },
+        {
+            "description": "Timestamp with high-order bit set on both seconds and increment",
+            "canonical_bson": "10000000116100FFFFFFFFFFFFFFFF00",
+            "canonical_extjson": "{\"a\" : {\"$timestamp\" : {\"t\" : 4294967295, \"i\" :  4294967295} } }"
+        },
+        {
+            "description": "Timestamp with high-order bit set on both seconds and increment (not UINT32_MAX)",
+            "canonical_bson": "1000000011610000286BEE00286BEE00", 
+            "canonical_extjson": "{\"a\" : {\"$timestamp\" : {\"t\" : 4000000000, \"i\" :  4000000000} } }"
         }
     ],
     "decodeErrors": [

data/spec/spec_tests/data/corpus/top.json

@@ -65,11 +65,11 @@
     "parseErrors": [
         {
             "description" : "Bad $regularExpression (extra field)",
-            "string" : "{\"a\" : \"$regularExpression\": {\"pattern\": \"abc\", \"options\": \"\", \"unrelated\": true}}}"
+            "string" : "{\"a\" : {\"$regularExpression\": {\"pattern\": \"abc\", \"options\": \"\", \"unrelated\": true}}}"
         },
         {
             "description" : "Bad $regularExpression (missing options field)",
-            "string" : "{\"a\" : \"$regularExpression\": {\"pattern\": \"abc\"}}}"
+            "string" : "{\"a\" : {\"$regularExpression\": {\"pattern\": \"abc\"}}}"
         },
         {
             "description": "Bad $regularExpression (pattern is number, not string)",
@@ -81,7 +81,7 @@
         },
         {
             "description" : "Bad $regularExpression (missing pattern field)",
-            "string" : "{\"a\" : \"$regularExpression\": {\"options\":\"ix\"}}}"
+            "string" : "{\"a\" : {\"$regularExpression\": {\"options\":\"ix\"}}}"
         },
         {
             "description": "Bad $oid (number, not string)",

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bson
 version: !ruby/object:Gem::Version
-  version: 4.9.4
+  version: 4.11.1
 platform: ruby
 authors:
 - Tyler Brock
@@ -33,7 +33,7 @@ cert_chain:
   gpvfPNWMwyBDlHaNS3GfO6cRRxBOvEG05GUCsvtTY4Bpe8yjE64wg1ymb47LMOnv
   Qb1lGORmf/opg45mluKUYl7pQNZHD0d3
   -----END CERTIFICATE-----
-date: 2020-06-29 00:00:00.000000000 Z
+date: 2020-11-04 00:00:00.000000000 Z
 dependencies: []
 description: A fully featured BSON specification implementation in Ruby
 email: