bson 4.7.1 → 4.8.0

data/lib/bson/symbol.rb

@@ -89,19 +89,108 @@ module BSON
       to_s
     end
 
+    # Converts this object to a representation directly serializable to
+    # Extended JSON (https://github.com/mongodb/specifications/blob/master/source/extended-json.rst).
+    #
+    # @option options [ true | false ] :relaxed Whether to produce relaxed
+    #   extended JSON representation.
+    #
+    # @return [ Hash ] The extended json representation.
+    def as_extended_json(**options)
+      { "$symbol" => to_s }
+    end
+
+    class Raw
+      # Create a BSON Symbol
+      #
+      # @param [ String | Symbol ] str_or_sym The symbol represented by this
+      #   object. Can be specified as a Symbol or a String.
+      #
+      # @see http://bsonspec.org/#/specification
+      def initialize(str_or_sym)
+        unless str_or_sym.is_a?(String) || str_or_sym.is_a?(Symbol)
+          raise ArgumentError, "BSON::Symbol::Raw must be given a symbol or a string, not #{str_or_sym}"
+        end
+
+        @symbol = str_or_sym.to_sym
+      end
+
+      # Get the underlying symbol as a Ruby symbol.
+      #
+      # @return [ Symbol ] The symbol represented by this BSON object.
+      def to_sym
+        @symbol
+      end
+
+      # Get the underlying symbol as a Ruby string.
+      #
+      # @return [ String ] The symbol as a string.
+      def to_s
+        @symbol.to_s
+      end
+
+      # Check equality of the raw bson symbol against another.
+      #
+      # @param [ Object ] other The object to check against.
+      #
+      # @return [ true, false ] If the objects are equal.
+      def ==(other)
+        return false unless other.is_a?(Raw)
+        to_sym == other.to_sym
+      end
+      alias :eql? :==
+
+      # Get the symbol as encoded BSON.
+      #
+      # @raise [ EncodingError ] If the symbol is not UTF-8.
+      #
+      # @return [ BSON::ByteBuffer ] The buffer with the encoded object.
+      #
+      # @see http://bsonspec.org/#/specification
+      def to_bson(buffer = ByteBuffer.new, validating_keys = Config.validating_keys?)
+        buffer.put_string(to_s)
+      end
+
+      def bson_type
+        Symbol::BSON_TYPE
+      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 returns the integer value if relaxed representation is
+      # requested, otherwise a $numberLong hash.
+      #
+      # @option options [ true | false ] :relaxed Whether to produce relaxed
+      #   extended JSON representation.
+      #
+      # @return [ Hash | Integer ] The extended json representation.
+      def as_extended_json(**options)
+        {'$symbol' => to_s}
+      end
+    end
+
     module ClassMethods
 
       # Deserialize a symbol from BSON.
       #
       # @param [ ByteBuffer ] buffer The byte buffer.
       #
-      # @return [ Regexp ] The decoded symbol.
+      # @option options [ nil | :bson ] :mode Decoding mode to use.
+      #
+      # @return [ Symbol | BSON::Symbol::Raw ] The decoded symbol.
       #
       # @see http://bsonspec.org/#/specification
       #
       # @since 2.0.0
-      def from_bson(buffer)
-        buffer.get_string.intern
+      def from_bson(buffer, **options)
+        sym = buffer.get_string.intern
+
+        if options[:mode] == :bson
+          Raw.new(sym)
+        else
+          sym
+        end
       end
     end
 

data/lib/bson/time.rb

@@ -38,7 +38,30 @@ module BSON
     #
     # @since 2.0.0
     def to_bson(buffer = ByteBuffer.new, validating_keys = Config.validating_keys?)
-      buffer.put_int64((to_i * 1000) + (usec / 1000))
+      # A previous version of this method used the following implementation:
+      # buffer.put_int64((to_i * 1000) + (usec / 1000))
+      # Turns out, usec returned incorrect value - 999 for 1 millisecond.
+      buffer.put_int64((to_f * 1000).round)
+    end
+
+    # Converts this object to a representation directly serializable to
+    # Extended JSON (https://github.com/mongodb/specifications/blob/master/source/extended-json.rst).
+    #
+    # @option options [ true | false ] :relaxed Whether to produce relaxed
+    #   extended JSON representation.
+    #
+    # @return [ Hash ] The extended json representation.
+    def as_extended_json(**options)
+      utc_time = utc
+      if options[:mode] == :relaxed && (1970..9999).include?(utc_time.year)
+        if utc_time.usec != 0
+          {'$date' => utc_time.strftime('%Y-%m-%dT%H:%M:%S.%LZ')}
+        else
+          {'$date' => utc_time.strftime('%Y-%m-%dT%H:%M:%SZ')}
+        end
+      else
+        {'$date' => {'$numberLong' => (utc_time.to_f * 1000).round.to_s}}
+      end
     end
 
     module ClassMethods
@@ -47,13 +70,15 @@ module BSON
       #
       # @param [ ByteBuffer ] buffer The byte buffer.
       #
+      # @option options [ nil | :bson ] :mode Decoding mode to use.
+      #
       # @return [ Time ] The decoded UTC datetime.
       #
       # @see http://bsonspec.org/#/specification
       #
       # @since 2.0.0
-      def from_bson(buffer)
-        seconds, fragment = Int64.from_bson(buffer).divmod(1000)
+      def from_bson(buffer, **options)
+        seconds, fragment = Int64.from_bson(buffer, mode: nil).divmod(1000)
         at(seconds, fragment * 1000).utc
       end
     end

data/lib/bson/timestamp.rb

@@ -84,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
 
@@ -120,12 +132,14 @@ module 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)
+    def self.from_bson(buffer, **options)
       increment = buffer.get_int32
       seconds = buffer.get_int32
       new(seconds, increment)

data/lib/bson/undefined.rb

@@ -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

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

data/spec/bson/binary_spec.rb

@@ -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
 
@@ -126,12 +126,34 @@ describe BSON::Binary do
   end
 
   describe '#from_bson' do
-    let(:bson) { BSON::ByteBuffer.new("#{5.to_bson}#{0.chr}hello".force_encoding('BINARY')) }
-    let(:obj) { described_class.from_bson(bson) }
+    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
@@ -203,6 +225,14 @@ describe BSON::Binary do
       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') }

data/spec/bson/ext_json_parse_spec.rb

@@ -0,0 +1,276 @@
+# Copyright (C) 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"
+
+describe "BSON::ExtJSON.parse" do
+
+  let(:parsed) { BSON::ExtJSON.parse_obj(input) }
+
+  context 'when input is true' do
+    let(:input) { true }
+
+    it 'returns true' do
+      parsed.should == true
+    end
+  end
+
+  context 'when input is false' do
+    let(:input) { false }
+
+    it 'returns false' do
+      parsed.should == false
+    end
+  end
+
+  context 'when input is nil' do
+    let(:input) { nil }
+
+    it 'returns nil' do
+      parsed.should be nil
+    end
+  end
+
+  context 'when input is a string' do
+    let(:input) { 'hello' }
+
+    it 'returns the string' do
+      parsed.should == 'hello'
+    end
+  end
+
+  context 'when input is a timestamp' do
+    let(:input) { {'$timestamp' => {'t' => 12345, 'i' => 42}} }
+
+    it 'returns a timestamp object' do
+      parsed.should == BSON::Timestamp.new(12345, 42)
+    end
+  end
+
+  context 'when input is an int32' do
+    let(:input) do
+      {'$numberInt' => '42'}
+    end
+
+    let(:parsed) { BSON::ExtJSON.parse_obj(input, mode: mode) }
+
+    context 'when :mode is nil' do
+      let(:mode) { nil }
+
+      it 'returns Integer instance' do
+        parsed.should be_a(Integer)
+        parsed.should == 42
+      end
+    end
+
+    context 'when :mode is :bson' do
+      let(:mode) { :bson }
+
+      it 'returns Integer instance' do
+        parsed.should be_a(Integer)
+        parsed.should == 42
+      end
+    end
+  end
+
+  context 'when input is an int64' do
+    let(:input) do
+      {'$numberLong' => '42'}
+    end
+
+    let(:parsed) { BSON::ExtJSON.parse_obj(input, mode: mode) }
+
+    context 'when :mode is nil' do
+      let(:mode) { nil }
+
+      it 'returns Integer instance' do
+        parsed.should be_a(Integer)
+        parsed.should == 42
+      end
+    end
+
+    context 'when :mode is :bson' do
+      let(:mode) { :bson }
+
+      it 'returns Int64 instance' do
+        parsed.should be_a(BSON::Int64)
+        parsed.value.should == 42
+      end
+    end
+  end
+
+  context 'when input is a hash' do
+    let(:input) do
+      {}
+    end
+
+    let(:parsed) { BSON::ExtJSON.parse_obj(input, mode: mode) }
+
+    context 'when mode is invalid' do
+      let(:mode) { :foo }
+
+      it 'raises an exception' do
+        lambda do
+          parsed
+        end.should raise_error(ArgumentError, /Invalid value for :mode option/)
+      end
+    end
+  end
+
+  context 'when input is a binary' do
+    let(:data) do
+      Base64.decode64("//8=")
+    end
+
+    context 'in current format' do
+      let(:input) do
+        { "$binary" => { "base64"=>"//8=", "subType"=>"00" } }
+      end
+
+      context 'when :mode is nil' do
+        let(:mode) { nil }
+
+        it 'returns BSON::Binary instance' do
+          parsed.should be_a(BSON::Binary)
+          parsed.data.should == data
+        end
+      end
+
+      context 'when mode is :bson' do
+        let(:mode) { :bson }
+
+        it 'returns BSON::Binary instance' do
+          parsed.should be_a(BSON::Binary)
+          parsed.data.should == data
+        end
+      end
+    end
+
+    context 'in legacy format' do
+      let(:input) do
+        { "$binary"=>"//8=", "$type"=>"00" }
+      end
+
+      context 'when :mode is nil' do
+        let(:mode) { nil }
+
+        it 'returns BSON::Binary instance' do
+          parsed.should be_a(BSON::Binary)
+          parsed.data.should == data
+        end
+      end
+
+      context 'when mode is :bson' do
+        let(:mode) { :bson }
+
+        it 'returns BSON::Binary instance' do
+          parsed.should be_a(BSON::Binary)
+          parsed.data.should == data
+        end
+      end
+    end
+  end
+
+  context 'when input is a regex' do
+    let(:pattern) { 'abc' }
+    let(:options) { 'im' }
+
+    context 'in current format' do
+      let(:input) do
+        { "$regularExpression" => { "pattern" => pattern, "options" => options } }
+      end
+
+      context 'when :mode is nil' do
+        let(:mode) { nil }
+
+        it 'returns a BSON::Regexp::Raw instance' do
+          parsed.should be_a(BSON::Regexp::Raw)
+          parsed.pattern.should == pattern
+          parsed.options.should == options
+        end
+      end
+
+      context 'when :mode is :bson' do
+        let(:mode) { :bson }
+
+        it 'returns a BSON::Regexp::Raw instance' do
+          parsed.should be_a(BSON::Regexp::Raw)
+          parsed.pattern.should == pattern
+          parsed.options.should == options
+        end
+      end
+    end
+
+    context 'in legacy format' do
+      let(:input) do
+        { "$regex" => pattern, "$options" => options }
+      end
+
+      context 'when :mode is nil' do
+        let(:mode) { nil }
+
+        it 'returns a BSON::Regexp::Raw instance' do
+          parsed.should be_a(BSON::Regexp::Raw)
+          parsed.pattern.should == pattern
+          parsed.options.should == options
+        end
+      end
+
+      context 'when :mode is :bson' do
+        let(:mode) { :bson }
+
+        it 'returns a BSON::Regexp::Raw instance' do
+          parsed.should be_a(BSON::Regexp::Raw)
+          parsed.pattern.should == pattern
+          parsed.options.should == options
+        end
+      end
+    end
+
+    context 'when $regularExpression is nested in $regex' do
+      context 'with options' do
+        let(:input) do
+          {
+            "$regex" => {
+              "$regularExpression" => { "pattern" => "foo*", "options" => "" },
+            },
+            "$options" => "ix",
+          }
+        end
+
+        it 'parses' do
+          parsed.should == {
+            '$regex' => BSON::Regexp::Raw.new('foo*'), '$options' => 'ix'
+          }
+        end
+      end
+
+      context 'without options' do
+        let(:input) do
+          {
+            "$regex" => {
+              "$regularExpression" => { "pattern" => "foo*", "options" => "" },
+            },
+          }
+        end
+
+        it 'parses' do
+          parsed.should == {
+            '$regex' => BSON::Regexp::Raw.new('foo*'),
+          }
+        end
+      end
+    end
+  end
+end