bson 4.2.2 → 4.12.1

data/lib/bson/time_with_zone.rb

@@ -0,0 +1,54 @@
+# Copyright (C) 2018-2020 MongoDB Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require "active_support/time_with_zone"
+
+module BSON
+
+  # Injects behaviour for encoding ActiveSupport::TimeWithZone values to
+  # raw bytes as specified by the BSON spec for time.
+  #
+  # @see http://bsonspec.org/#/specification
+  #
+  # @since 4.4.0
+  module TimeWithZone
+
+    # Get the ActiveSupport::TimeWithZone as encoded BSON.
+    #
+    # @example Get the ActiveSupport::TimeWithZone as encoded BSON.
+    #   Time.utc(2012, 12, 12, 0, 0, 0).in_time_zone("Pacific Time (US & Canada)").to_bson
+    #
+    # @return [ BSON::ByteBuffer ] The buffer with the encoded object.
+    #
+    # @see http://bsonspec.org/#/specification
+    #
+    # @since 4.4.0
+    def to_bson(buffer = ByteBuffer.new, validating_keys = Config.validating_keys?)
+      buffer.put_int64((to_i * 1000) + (usec / 1000))
+    end
+
+    # Get the BSON type for the ActiveSupport::TimeWithZone.
+    #
+    # As the ActiveSupport::TimeWithZone is converted to a time, this returns
+    # the BSON type for time.
+    def bson_type
+      ::Time::BSON_TYPE
+    end
+  end
+
+  # Enrich the ActiveSupport::TimeWithZone class with this module.
+  #
+  # @since 4.4.0
+  ActiveSupport::TimeWithZone.send(:include, TimeWithZone)
+end

data/lib/bson/timestamp.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2009-2014 MongoDB Inc.
+# Copyright (C) 2009-2020 MongoDB Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -21,12 +21,18 @@ module BSON
   # @since 2.0.0
   class Timestamp
     include JSON
+    include Comparable
 
     # A timestamp is type 0x11 in the BSON spec.
     #
     # @since 2.0.0
     BSON_TYPE = 17.chr.force_encoding(BINARY).freeze
 
+    # Error message if an object other than a Timestamp is compared with this object.
+    #
+    # @since 4.3.0
+    COMPARISON_ERROR_MESSAGE = 'comparison of %s with Timestamp failed'.freeze
+
     # @!attribute seconds
     #   @return [ Integer ] The number of seconds.
     #   @since 2.0.0
@@ -52,6 +58,24 @@ module BSON
       seconds == other.seconds && increment == other.increment
     end
 
+    # Determine if this timestamp is greater or less than another object.
+    #
+    # @example Compare the timestamp.
+    #   timestamp < other
+    #
+    # @param [ Object ] other The object to compare against.
+    #
+    # @return [ true, false ] The result of the comparison.
+    #
+    # @since 4.3.0
+    def <=>(other)
+      raise ArgumentError.new(COMPARISON_ERROR_MESSAGE % other.class) unless other.is_a?(Timestamp)
+      return 0 if self == other
+      a = [ seconds, increment ]
+      b = [ other.seconds, other.increment ]
+      [ a, b ].sort[0] == a ? -1 : 1
+    end
+
     # Get the timestamp as JSON hash data.
     #
     # @example Get the timestamp as a JSON hash.
@@ -60,7 +84,19 @@ module BSON
     # @return [ Hash ] The timestamp as a JSON hash.
     #
     # @since 2.0.0
+    # @deprecated Use as_extended_json instead.
     def as_json(*args)
+      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)
       { "$timestamp" => { "t" => seconds, "i" => increment } }
     end
 
@@ -88,22 +124,24 @@ 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.
     #
     # @param [ ByteBuffer ] buffer The byte buffer.
     #
+    # @option options [ nil | :bson ] :mode Decoding mode to use.
+    #
     # @return [ Timestamp ] The decoded timestamp.
     #
     # @see http://bsonspec.org/#/specification
     #
     # @since 2.0.0
-    def self.from_bson(buffer)
-      increment = buffer.get_int32
-      seconds = buffer.get_int32
+    def self.from_bson(buffer, **options)
+      increment = buffer.get_uint32
+      seconds = buffer.get_uint32
       new(seconds, increment)
     end
 

data/lib/bson/true_class.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2009-2014 MongoDB Inc.
+# Copyright (C) 2009-2020 MongoDB Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.

data/lib/bson/undefined.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2009-2014 MongoDB Inc.
+# Copyright (C) 2009-2020 MongoDB Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -41,6 +41,17 @@ module BSON
       self.class == other.class
     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)
+      { "$undefined" => true }
+    end
+
     # Register this type when the module is loaded.
     #
     # @since 2.0.0

data/lib/bson/version.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2009-2016 MongoDB Inc.
+# Copyright (C) 2009-2020 MongoDB Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -13,5 +13,5 @@
 # limitations under the License.
 
 module BSON
-  VERSION = "4.2.2".freeze
+  VERSION = "4.12.1".freeze
 end

data/spec/bson/array_spec.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2009-2014 MongoDB Inc.
+# Copyright (C) 2009-2020 MongoDB Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -132,6 +132,23 @@ describe Array do
         end
       end
     end
+
+    context 'when array contains value of an unserializable class' do
+      class ArraySpecUnserializableClass
+      end
+
+      let(:obj) do
+        [ArraySpecUnserializableClass.new]
+      end
+
+      it 'raises UnserializableClass' do
+        lambda do
+          obj.to_bson
+        end.should raise_error(BSON::Error::UnserializableClass,
+          # C extension does not provide element position in the exception message.
+          /(Array element at position 0|Value) does not define its BSON serialized type:.*ArraySpecUnserializableClass/)
+      end
+    end
   end
 
   describe "#to_bson_normalized_value" do

data/spec/bson/binary_spec.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2009-2014 MongoDB Inc.
+# Copyright (C) 2009-2020 MongoDB Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -63,7 +63,7 @@ describe BSON::Binary do
 
     it "returns the binary data plus type" do
       expect(object.as_json).to eq(
-        { "$binary" => Base64.encode64("testing"), "$type" => :user }
+        { "$binary" => {'base64' => Base64.encode64("testing").strip, "subType" => '80' }}
       )
     end
 
@@ -72,6 +72,14 @@ describe BSON::Binary do
 
   describe "#initialize" do
 
+    context 'when type is not given' do
+      let(:obj) { described_class.new('foo') }
+
+      it 'defaults to generic type' do
+        expect(obj.type).to eq(:generic)
+      end
+    end
+
     context "when he type is invalid" do
 
       it "raises an error" do
@@ -105,7 +113,11 @@ describe BSON::Binary do
         expect(object.inspect).to eq("<BSON::Binary:0x#{object.object_id} type=user data=0x1f8b08000c787055...>")
       end
 
-      it 'is not different from default encoding' do
+      it 'is not binary' do
+        # As long as the default Ruby encoding is not binary, the inspected
+        # string should also not be in the binary encoding (it should be
+        # in one of the text encodings, but which one could depend on
+        # the Ruby runtime environment).
         expect(object.inspect.encoding).not_to eq(Encoding::BINARY)
       end
 
@@ -113,6 +125,37 @@ describe BSON::Binary do
 
   end
 
+  describe '#from_bson' do
+    let(:buffer) { BSON::ByteBuffer.new(bson) }
+    let(:obj) { described_class.from_bson(buffer) }
+
+    let(:bson) { "#{5.to_bson}#{0.chr}hello".force_encoding('BINARY') }
+
+    it 'sets data encoding to binary' do
+      expect(obj.data.encoding).to eq(Encoding.find('BINARY'))
+    end
+
+    context 'when binary subtype is supported' do
+      let(:bson) { [3, 0, 0, 0, 1].map(&:chr).join.force_encoding('BINARY') + 'foo' }
+
+      it 'works' do
+        obj.should be_a(described_class)
+        obj.type.should be :function
+      end
+    end
+
+    context 'when binary subtype is not supported' do
+      let(:bson) { [3, 0, 0, 0, 16].map(&:chr).join.force_encoding('BINARY') + 'foo' }
+
+      it 'raises an exception' do
+        lambda do
+          obj
+        end.should raise_error(BSON::Error::UnsupportedBinarySubtype,
+          /BSON data contains unsupported binary subtype 0x10/)
+      end
+    end
+  end
+
   describe "#to_bson/#from_bson" do
 
     let(:type) { 5.chr }
@@ -181,5 +224,59 @@ describe BSON::Binary do
       it_behaves_like "a serializable bson element"
       it_behaves_like "a deserializable bson element"
     end
+
+    context "when the type is :cyphertext" do
+      let(:obj)  { described_class.new("testing", :ciphertext) }
+      let(:bson) { "#{7.to_bson}#{6.chr}testing" }
+
+      it_behaves_like "a serializable bson element"
+      it_behaves_like "a deserializable bson element"
+    end
+
+    context 'when given binary string' do
+      let(:obj) { described_class.new("\x00\xfe\xff".force_encoding('BINARY')) }
+      let(:bson) { "#{3.to_bson}#{0.chr}\x00\xfe\xff".force_encoding('BINARY') }
+
+      it_behaves_like "a serializable bson element"
+      it_behaves_like "a deserializable bson element"
+    end
+
+    context 'when given a frozen string' do
+      let(:str) { "\x00\xfe\xff".force_encoding('BINARY').freeze }
+      let(:obj) { described_class.new(str) }
+      let(:bson) { "#{3.to_bson}#{0.chr}\x00\xfe\xff".force_encoding('BINARY') }
+
+      it_behaves_like "a serializable bson element"
+      it_behaves_like "a deserializable bson element"
+    end
+  end
+
+  describe '#to_uuid' do
+    let(:obj) { described_class.new("\x00" * 16, :uuid) }
+
+    it 'accepts symbol representation' do
+      expect(obj.to_uuid(:standard)).to eq('00000000-0000-0000-0000-000000000000')
+    end
+
+    it 'rejects string representation' do
+      expect do
+        obj.to_uuid('standard')
+      end.to raise_error(ArgumentError, /Representation must be given as a symbol/)
+    end
+  end
+
+  describe '#from_uuid' do
+    let(:uuid) { '00000000-0000-0000-0000000000000000' }
+
+    it 'accepts symbol representation' do
+      obj = described_class.from_uuid(uuid, :standard)
+      expect(obj.data).to eq("\x00" * 16)
+    end
+
+    it 'rejects string representation' do
+      expect do
+        described_class.from_uuid(uuid, 'standard')
+      end.to raise_error(ArgumentError, /Representation must be given as a symbol/)
+    end
   end
 end

data/spec/bson/binary_uuid_spec.rb

@@ -0,0 +1,189 @@
+# Copyright (C) 2019-2020 MongoDB Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require "spec_helper"
+require "base64"
+
+describe "BSON::Binary - UUID spec tests" do
+  def make_binary(uuid_hex_str, type)
+    uuid_binary_str = uuid_hex_str.scan(/../).map(&:hex).map(&:chr).join
+    BSON::Binary.new(uuid_binary_str, type)
+  end
+
+  describe 'explicit encoding' do
+    let(:uuid_str) { '00112233-4455-6677-8899-aabbccddeeff' }
+
+    shared_examples_for 'creates binary' do
+      it 'creates subtype 4 binary' do
+        expect(binary.type).to eq(expected_type)
+      end
+
+      it 'creates binary with correct value' do
+        expect(binary.data).to eq(expected_hex_value.scan(/../).map(&:hex).map(&:chr).join)
+      end
+    end
+
+    context 'no representation' do
+      let(:binary) { BSON::Binary.from_uuid(uuid_str) }
+      let(:expected_type) { :uuid }
+      let(:expected_hex_value) { '00112233445566778899AABBCCDDEEFF' }
+
+      it_behaves_like 'creates binary'
+    end
+
+    context 'standard representation' do
+      let(:binary) { BSON::Binary.from_uuid(uuid_str, :standard) }
+      let(:expected_type) { :uuid }
+      let(:expected_hex_value) { '00112233445566778899AABBCCDDEEFF' }
+
+      it_behaves_like 'creates binary'
+    end
+
+    context 'csharp legacy representation' do
+      let(:binary) { BSON::Binary.from_uuid(uuid_str, :csharp_legacy) }
+      let(:expected_type) { :uuid_old }
+      let(:expected_hex_value) { '33221100554477668899AABBCCDDEEFF' }
+
+      it_behaves_like 'creates binary'
+    end
+
+    context 'java legacy representation' do
+      let(:binary) { BSON::Binary.from_uuid(uuid_str, :java_legacy) }
+      let(:expected_type) { :uuid_old }
+      let(:expected_hex_value) { '7766554433221100FFEEDDCCBBAA9988' }
+
+      it_behaves_like 'creates binary'
+    end
+
+    context 'python legacy representation' do
+      let(:binary) { BSON::Binary.from_uuid(uuid_str, :python_legacy) }
+      let(:expected_type) { :uuid_old }
+      let(:expected_hex_value) { '00112233445566778899AABBCCDDEEFF' }
+
+      it_behaves_like 'creates binary'
+    end
+  end
+
+  describe 'explicit decoding' do
+    context ':uuid, standard encoded' do
+      let(:binary) { make_binary("00112233445566778899AABBCCDDEEFF", :uuid) }
+
+      it 'decodes without arguments' do
+        expect(binary.to_uuid.gsub('-', '').upcase).to eq("00112233445566778899AABBCCDDEEFF")
+      end
+
+      it 'decodes as standard' do
+        expect(binary.to_uuid(:standard).gsub('-', '').upcase).to eq("00112233445566778899AABBCCDDEEFF")
+      end
+
+      it 'does not decode as csharp legacy' do
+        expect do
+          binary.to_uuid(:csharp_legacy)
+        end.to raise_error(ArgumentError, /Binary of type :uuid can only be stringified to :standard representation/)
+      end
+
+      it 'does not decode as java legacy' do
+        expect do
+          binary.to_uuid(:java_legacy)
+        end.to raise_error(ArgumentError, /Binary of type :uuid can only be stringified to :standard representation/)
+      end
+
+      it 'does not decode as python legacy' do
+        expect do
+          binary.to_uuid(:python_legacy)
+        end.to raise_error(ArgumentError, /Binary of type :uuid can only be stringified to :standard representation/)
+      end
+    end
+
+    shared_examples_for 'a legacy uuid' do
+      it 'does not decode without arguments' do
+        expect do
+          binary.to_uuid
+        end.to raise_error(ArgumentError, /Representation must be specified for BSON::Binary objects of type :uuid_old/)
+      end
+
+      it 'does not decode as standard' do
+        expect do
+          binary.to_uuid(:standard)
+        end.to raise_error(ArgumentError, /BSON::Binary objects of type :uuid_old cannot be stringified to :standard representation/)
+      end
+    end
+
+    context ':uuid_old, csharp legacy encoded' do
+      let(:binary) { make_binary("33221100554477668899AABBCCDDEEFF", :uuid_old) }
+
+      it_behaves_like 'a legacy uuid'
+
+      it 'decodes as csharp legacy' do
+        expect(binary.to_uuid(:csharp_legacy).gsub('-', '').upcase).to eq("00112233445566778899AABBCCDDEEFF")
+      end
+
+      it 'decodes as java legacy' do
+        expect(binary.to_uuid(:java_legacy).gsub('-', '').upcase).not_to eq("00112233445566778899AABBCCDDEEFF")
+      end
+
+      it 'decodes as python legacy' do
+        expect(binary.to_uuid(:python_legacy).gsub('-', '').upcase).not_to eq("00112233445566778899AABBCCDDEEFF")
+      end
+
+      it 'expects four dashes when output as String' do
+        expect(binary.to_uuid(:csharp_legacy)).to eq("00112233-4455-6677-8899-aabbccddeeff")
+      end
+    end
+
+    context ':uuid_old, java legacy encoded' do
+      let(:binary) { make_binary("7766554433221100FFEEDDCCBBAA9988", :uuid_old) }
+
+      it_behaves_like 'a legacy uuid'
+
+      it 'decodes as csharp legacy' do
+        expect(binary.to_uuid(:csharp_legacy).gsub('-', '').upcase).not_to eq("00112233445566778899AABBCCDDEEFF")
+      end
+
+      it 'decodes as java legacy' do
+        expect(binary.to_uuid(:java_legacy).gsub('-', '').upcase).to eq("00112233445566778899AABBCCDDEEFF")
+      end
+
+      it 'decodes as python legacy' do
+        expect(binary.to_uuid(:python_legacy).gsub('-', '').upcase).not_to eq("00112233445566778899AABBCCDDEEFF")
+      end
+
+      it 'expects four dashes when output as String' do
+        expect(binary.to_uuid(:java_legacy)).to eq("00112233-4455-6677-8899-aabbccddeeff")
+      end
+    end
+
+    context ':uuid_old, python legacy encoded' do
+      let(:binary) { make_binary("00112233445566778899AABBCCDDEEFF", :uuid_old) }
+
+      it_behaves_like 'a legacy uuid'
+
+      it 'decodes as csharp legacy' do
+        expect(binary.to_uuid(:csharp_legacy).gsub('-', '').upcase).not_to eq("00112233445566778899AABBCCDDEEFF")
+      end
+
+      it 'decodes as java legacy' do
+        expect(binary.to_uuid(:java_legacy).gsub('-', '').upcase).not_to eq("00112233445566778899AABBCCDDEEFF")
+      end
+
+      it 'decodes as python legacy' do
+        expect(binary.to_uuid(:python_legacy).gsub('-', '').upcase).to eq("00112233445566778899AABBCCDDEEFF")
+      end
+
+      it 'expects four dashes when output as String' do
+        expect(binary.to_uuid(:python_legacy)).to eq("00112233-4455-6677-8899-aabbccddeeff")
+      end
+    end
+  end
+end