bson 4.9.4-java → 4.11.1-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eedbe4346e9f1ededbe02d7ce67e4e078c415caaa4b5e17fc1504a194ea48b3b
-  data.tar.gz: 0c3dbcdc8aa4593631b43e8df5db90b12fbf63ec5b3bcd85388f5c440a939eeb
+  metadata.gz: 725cd0cbc7f1ffe6b21db7a0bba75f06004cfe840bdc960ec3e800017b655bcd
+  data.tar.gz: ded62238e5d764555a8325e22832383413923fd794f5f342bc908d97868e1676
 SHA512:
-  metadata.gz: cd040870d55f7e7021ebe5d89a8737fe877f21bbfd8d96893d4c7972c312bedded6c787d67fe4647e241be84966ef9749de13b259416bbe9622ecc2de883a5a6
-  data.tar.gz: 7d595857065631624cf580220d8b0c83590e050a6c0bdfd420a886a18fac8ceb1a54702521aab6f3352d2de341e39059ea0ac372ebed7a7b410b80207e8445ff
+  metadata.gz: 6d0b0a456f5bf8ac39396cceb105f7ef0f28cf17694583e4da3d9fb4385e8852151b1408ea15e77a27154013602f317f67ab8b2be83cae195fe579c34723ce0b
+  data.tar.gz: c21d38cb8696363b1ddbc87c781e2109b236ba99de9dfb86e9daa8cabacf230b83d84f06d68bbebbe7aafa6598358d77a395a6ee2426fc337b5cbaa07510b10c

data.tar.gz.sig

@@ -1,3 +1 @@
-X�M���>�:s��R
-�#�Cy�b���.}^�}_�wOJ������e�x��y ����'�?�3�H��τ�I��Isz�nc	�c��hm�
E�ǝl~Jn������V��+z�%g�L���(˘;��Ep�7L*v�!�(�J��,f^�Hssh��1իy�ܫ��Y�`�ǣ[�8�$P��R����ۄ_�F��	�E�����Y�q�ʊ;LƇ�������(�u������Y̳
-A�kn�
+`�]m1���I�+��d���]�B�����0�EO%p��H�G�-!�D¿����\�6%�!�H�z�?�ѩ�5W�o�ud��gdT(o�)}g2ސM'7씳_J�x͌q%:�pm(�qh.�a4+'3�[+�(s�s�{R�

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: java
 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: