bson 4.11.1 → 4.14.0

data/lib/bson/regexp.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 # Copyright (C) 2009-2020 MongoDB Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -26,34 +27,34 @@ module BSON
     # A regular expression is type 0x0B in the BSON spec.
     #
     # @since 2.0.0
-    BSON_TYPE = 11.chr.force_encoding(BINARY).freeze
+    BSON_TYPE = ::String.new(11.chr, encoding: BINARY).freeze
 
     # Extended value constant.
     #
     # @since 3.2.6
-    EXTENDED_VALUE = 'x'.freeze
+    EXTENDED_VALUE = 'x'
 
     # Ignore case constant.
     #
     # @since 3.2.6
-    IGNORECASE_VALUE = 'i'.freeze
+    IGNORECASE_VALUE = 'i'
 
     # Multiline constant.
     #
     # @since 3.2.6
-    MULTILINE_VALUE = 'm'.freeze
+    MULTILINE_VALUE = 'm'
 
     # Newline constant.
     #
     # @since 3.2.6
-    NEWLINE_VALUE = 's'.freeze
+    NEWLINE_VALUE = 's'
 
     # Ruby multiline constant.
     #
     # @since 3.2.6
     #
     # @deprecated Will be removed in 5.0
-    RUBY_MULTILINE_VALUE = 'ms'.freeze
+    RUBY_MULTILINE_VALUE = 'ms'
 
     # Get the regexp as JSON hash data.
     #
@@ -154,6 +155,16 @@ module BSON
       #
       # @since 3.0.0
       def initialize(pattern, options = '')
+        if pattern.include?(NULL_BYTE)
+          raise Error::InvalidRegexpPattern, "Regexp pattern cannot contain a null byte: #{pattern}"
+        elsif options.is_a?(String) || options.is_a?(Symbol)
+          if options.to_s.include?(NULL_BYTE)
+            raise Error::InvalidRegexpPattern, "Regexp options cannot contain a null byte: #{options}"
+          end
+        elsif !options.is_a?(Integer)
+          raise ArgumentError, "Regexp options must be a String, Symbol, or Integer"
+        end
+
         @pattern = pattern
         @options = options
       end

data/lib/bson/registry.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 # Copyright (C) 2009-2020 MongoDB Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");

data/lib/bson/specialized.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 # Copyright (C) 2009-2020 MongoDB Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");

data/lib/bson/string.rb

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*-
+# frozen_string_literal: true
 # Copyright (C) 2009-2020 MongoDB Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -26,12 +27,12 @@ module BSON
     # A string is type 0x02 in the BSON spec.
     #
     # @since 2.0.0
-    BSON_TYPE = 2.chr.force_encoding(BINARY).freeze
+    BSON_TYPE = ::String.new(2.chr, encoding: BINARY).freeze
 
     # Regex for matching illegal BSON keys.
     #
     # @since 4.1.0
-    ILLEGAL_KEY = /(\A[$])|(\.)/.freeze
+    ILLEGAL_KEY = /(\A[$])|(\.)/
 
     # Get the string as encoded BSON.
     #

data/lib/bson/symbol.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 # Copyright (C) 2009-2020 MongoDB Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -28,7 +29,7 @@ module BSON
     # A symbol is type 0x0E in the BSON spec.
     #
     # @since 2.0.0
-    BSON_TYPE = 14.chr.force_encoding(BINARY).freeze
+    BSON_TYPE = ::String.new(14.chr, encoding: BINARY).freeze
 
     # Symbols are serialized as strings as symbols are now removed from the
     # BSON specification. Therefore the bson_type when serializing must be a

data/lib/bson/time.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 # Copyright (C) 2009-2020 MongoDB Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -39,7 +40,7 @@ module BSON
     # A time is type 0x09 in the BSON spec.
     #
     # @since 2.0.0
-    BSON_TYPE = 9.chr.force_encoding(BINARY).freeze
+    BSON_TYPE = ::String.new(9.chr, encoding: BINARY).freeze
 
     # Get the time as encoded BSON.
     #
@@ -63,8 +64,8 @@ module BSON
     #
     # @note The time is floored to the nearest millisecond.
     #
-    # @option options [ true | false ] :relaxed Whether to produce relaxed
-    #   extended JSON representation.
+    # @option opts [ nil | :relaxed | :legacy ] :mode Serialization mode
+    #   (default is canonical extended JSON)
     #
     # @return [ Hash ] The extended json representation.
     def as_extended_json(**options)

data/lib/bson/time_with_zone.rb

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

data/lib/bson/timestamp.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 # Copyright (C) 2009-2020 MongoDB Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -26,12 +27,12 @@ module BSON
     # A timestamp is type 0x11 in the BSON spec.
     #
     # @since 2.0.0
-    BSON_TYPE = 17.chr.force_encoding(BINARY).freeze
+    BSON_TYPE = ::String.new(17.chr, 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
+    COMPARISON_ERROR_MESSAGE = 'comparison of %s with Timestamp failed'
 
     # @!attribute seconds
     #   @return [ Integer ] The number of seconds.

data/lib/bson/true_class.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 # Copyright (C) 2009-2020 MongoDB Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -25,7 +26,7 @@ module BSON
     # A true value in the BSON spec is 0x01.
     #
     # @since 2.0.0
-    TRUE_BYTE = 1.chr.force_encoding(BINARY).freeze
+    TRUE_BYTE = ::String.new(1.chr, encoding: BINARY).freeze
 
     # The BSON type for true values is the general boolean type of 0x08.
     #

data/lib/bson/undefined.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 # Copyright (C) 2009-2020 MongoDB Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -25,7 +26,7 @@ module BSON
     # Undefined is type 0x06 in the BSON spec.
     #
     # @since 2.0.0
-    BSON_TYPE = 6.chr.force_encoding(BINARY).freeze
+    BSON_TYPE = ::String.new(6.chr, encoding: BINARY).freeze
 
     # Determine if undefined is equal to another object.
     #

data/lib/bson/version.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 # Copyright (C) 2009-2020 MongoDB Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -13,5 +14,5 @@
 # limitations under the License.
 
 module BSON
-  VERSION = "4.11.1".freeze
+  VERSION = "4.14.0"
 end

data/lib/bson.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 # Copyright (C) 2009-2020 MongoDB Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -38,22 +39,22 @@ module BSON
   # Constant for binary string encoding.
   #
   # @since 2.0.0
-  BINARY = "BINARY".freeze
+  BINARY = "BINARY"
 
   # Constant for bson types that don't actually serialize a value.
   #
   # @since 2.0.0
-  NO_VALUE = "".force_encoding(BINARY).freeze
+  NO_VALUE = ::String.new(encoding: BINARY).freeze
 
   # Constant for a null byte (0x00).
   #
   # @since 2.0.0
-  NULL_BYTE = 0.chr.force_encoding(BINARY).freeze
+  NULL_BYTE = ::String.new(0.chr, encoding: BINARY).freeze
 
   # Constant for UTF-8 string encoding.
   #
   # @since 2.0.0
-  UTF8 = "UTF-8".freeze
+  UTF8 = "UTF-8"
 end
 
 require "bson/config"
@@ -73,11 +74,13 @@ require "bson/date"
 require "bson/date_time"
 require "bson/db_pointer"
 require "bson/decimal128"
+require "bson/big_decimal"
 require "bson/document"
 require "bson/ext_json"
 require "bson/false_class"
 require "bson/float"
 require "bson/hash"
+require "bson/dbref"
 require "bson/open_struct"
 require "bson/max_key"
 require "bson/min_key"
@@ -100,7 +103,7 @@ require "bson/version"
 begin
   if BSON::Environment.jruby?
     require "bson-ruby.jar"
-    org.bson.NativeService.new.basicLoad(JRuby.runtime)
+    JRuby::Util.load_ext("org.bson.NativeService")
   else
     require "bson_native"
   end

data/spec/README.md

@@ -0,0 +1,14 @@
+# Running BSON Ruby Tests
+
+## Quick Start
+
+The test suite requires shared tooling that is stored in a separate repository
+and is referenced as a submodule. After checking out the desired bson-ruby
+branch, check out the matching submodules:
+
+    git submodule init
+    git submodule update
+
+Then, to run the test suite:
+
+    rake

data/spec/bson/big_decimal_spec.rb

@@ -0,0 +1,316 @@
+# Copyright (C) 2016-2021 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::BigDecimal do
+
+  describe '#from_bson' do
+    shared_examples_for 'a BSON::BigDecimal deserializer' do
+
+      let(:decimal128) do
+        BSON::Decimal128.new(argument)
+      end
+
+      let(:deserialized_big_decimal) do
+        BigDecimal.from_bson(decimal128.to_bson)
+      end
+
+      let(:deserialized_decimal128) do
+        BSON::Decimal128.from_bson(decimal128.to_bson)
+      end
+
+      it 'deserializes Decimal128 encoded bson correctly' do
+        if deserialized_decimal128.to_s == "NaN"
+          expect(deserialized_big_decimal.nan?).to be true
+        else
+          expect(deserialized_big_decimal).to eq(deserialized_decimal128.to_big_decimal)
+        end
+      end
+    end
+
+    context 'when Infinity is passed' do
+
+      let(:argument) { "Infinity" }
+
+      it_behaves_like 'a BSON::BigDecimal deserializer'
+    end
+
+    context 'when -Infinity is passed' do
+
+      let(:argument) { "-Infinity" }
+
+      it_behaves_like 'a BSON::BigDecimal deserializer'
+    end
+
+    context 'when NaN is passed' do
+
+      let(:argument) { "NaN" }
+
+      it_behaves_like 'a BSON::BigDecimal deserializer'
+    end
+
+    context 'when -NaN is passed' do
+      let(:argument) { "-NaN" }
+
+      it_behaves_like 'a BSON::BigDecimal deserializer'
+    end
+
+    context 'when SNaN is passed' do
+      let(:argument) { "SNaN" }
+
+      it_behaves_like 'a BSON::BigDecimal deserializer'
+    end
+
+    context 'when -SNaN is passed' do
+      let(:argument) { "SNaN" }
+
+      it_behaves_like 'a BSON::BigDecimal deserializer'
+    end
+
+    context 'when -0 is passed' do
+      let(:argument) { "-0" }
+
+      it_behaves_like 'a BSON::BigDecimal deserializer'
+    end
+
+    context 'when a positive integer is passed' do
+      let(:argument) { "12" }
+
+      it_behaves_like 'a BSON::BigDecimal deserializer'
+    end
+
+    context 'when a negative integer is passed' do
+      let(:argument) { "-12" }
+
+      it_behaves_like 'a BSON::BigDecimal deserializer'
+    end
+
+    context 'when a positive float is passed' do
+      let(:argument) { "0.12345" }
+
+      it_behaves_like 'a BSON::BigDecimal deserializer'
+    end
+
+    context 'when a negative float is passed' do
+      let(:argument) { "-0.12345" }
+
+      it_behaves_like 'a BSON::BigDecimal deserializer'
+    end
+
+    context 'when a large positive integer is passed' do
+      let(:argument) { "1234567890123456789012345678901234" }
+
+      it_behaves_like 'a BSON::BigDecimal deserializer'
+    end
+
+    context 'when a large negative integer is passed' do
+      let(:argument) { "-1234567890123456789012345678901234" }
+
+      it_behaves_like 'a BSON::BigDecimal deserializer'
+    end
+  end
+
+  describe "#to_bson" do
+    shared_examples_for 'a BSON::BigDecimal serializer' do
+
+      let(:decimal128) do
+        BSON::Decimal128.new(BigDecimal(argument).to_s)
+      end
+
+      let(:decimal_128_bson) do
+        decimal128.to_bson
+      end
+
+      let(:big_decimal_bson) do
+        BigDecimal(argument).to_bson
+      end
+
+      it 'serializes BigDecimals correctly' do
+        expect(decimal_128_bson.to_s).to eq(big_decimal_bson.to_s)
+      end
+    end
+
+    context 'when Infinity is passed' do
+
+      let(:argument) { "Infinity" }
+
+      it_behaves_like 'a BSON::BigDecimal serializer'
+    end
+
+    context 'when -Infinity is passed' do
+
+      let(:argument) { "-Infinity" }
+
+      it_behaves_like 'a BSON::BigDecimal serializer'
+    end
+
+    context 'when NaN is passed' do
+
+      let(:argument) { "NaN" }
+
+      it_behaves_like 'a BSON::BigDecimal serializer'
+    end
+
+    context 'when -0 is passed' do
+      let(:argument) { "-0" }
+
+      it_behaves_like 'a BSON::BigDecimal serializer'
+    end
+
+    context 'when a positive integer is passed' do
+      let(:argument) { "12" }
+
+      it_behaves_like 'a BSON::BigDecimal serializer'
+    end
+
+    context 'when a negative integer is passed' do
+      let(:argument) { "-12" }
+
+      it_behaves_like 'a BSON::BigDecimal serializer'
+    end
+
+    context 'when a positive float is passed' do
+      let(:argument) { "0.12345" }
+
+      it_behaves_like 'a BSON::BigDecimal serializer'
+    end
+
+    context 'when a negative float is passed' do
+      let(:argument) { "-0.12345" }
+
+      it_behaves_like 'a BSON::BigDecimal serializer'
+    end
+
+    context 'when a large positive integer is passed' do
+      let(:argument) { "1234567890123456789012345678901234" }
+
+      it_behaves_like 'a BSON::BigDecimal serializer'
+    end
+
+    context 'when a large negative integer is passed' do
+      let(:argument) { "-1234567890123456789012345678901234" }
+
+      it_behaves_like 'a BSON::BigDecimal serializer'
+    end
+
+    context "when passing an out of range Decimal128" do
+      let(:argument) { "1E1000000" }
+
+      it "raises an error" do
+        expect do
+          BigDecimal(argument).to_bson
+        end.to raise_error(BSON::Decimal128::InvalidRange)
+      end
+    end
+
+    context "when passing a number with too much precision for Decimal128" do
+      let(:argument) { "1.000000000000000000000000000000000000000000000000001" }
+
+      it "raises an error" do
+        expect do
+          BigDecimal(argument).to_bson
+        end.to raise_error(BSON::Decimal128::UnrepresentablePrecision)
+      end
+    end
+  end
+
+  describe "#from_bson/#to_bson" do
+    shared_examples_for 'a BSON::BigDecimal round trip' do
+
+      let(:big_decimal) do
+        BigDecimal(argument)
+      end
+
+      let(:big_decimal_bson) do
+        big_decimal.to_bson
+      end
+
+      let(:deserialized_big_decimal) do
+        BigDecimal.from_bson(big_decimal_bson)
+      end
+
+      it 'serializes BigDecimals correctly' do
+        if big_decimal.nan?
+          expect(deserialized_big_decimal.nan?).to be true
+        else
+          expect(deserialized_big_decimal).to eq(big_decimal)
+        end
+      end
+    end
+
+    context 'when Infinity is passed' do
+
+      let(:argument) { "Infinity" }
+
+      it_behaves_like 'a BSON::BigDecimal round trip'
+    end
+
+    context 'when -Infinity is passed' do
+
+      let(:argument) { "-Infinity" }
+
+      it_behaves_like 'a BSON::BigDecimal round trip'
+    end
+
+    context 'when NaN is passed' do
+
+      let(:argument) { "NaN" }
+
+      it_behaves_like 'a BSON::BigDecimal round trip'
+    end
+
+    context 'when -0 is passed' do
+      let(:argument) { "-0" }
+
+      it_behaves_like 'a BSON::BigDecimal round trip'
+    end
+
+    context 'when a positive integer is passed' do
+      let(:argument) { "12" }
+
+      it_behaves_like 'a BSON::BigDecimal round trip'
+    end
+
+    context 'when a negative integer is passed' do
+      let(:argument) { "-12" }
+
+      it_behaves_like 'a BSON::BigDecimal round trip'
+    end
+
+    context 'when a positive float is passed' do
+      let(:argument) { "0.12345" }
+
+      it_behaves_like 'a BSON::BigDecimal round trip'
+    end
+
+    context 'when a negative float is passed' do
+      let(:argument) { "-0.12345" }
+
+      it_behaves_like 'a BSON::BigDecimal round trip'
+    end
+
+    context 'when a large positive integer is passed' do
+      let(:argument) { "1234567890123456789012345678901234" }
+
+      it_behaves_like 'a BSON::BigDecimal round trip'
+    end
+
+    context 'when a large negative integer is passed' do
+      let(:argument) { "-1234567890123456789012345678901234" }
+
+      it_behaves_like 'a BSON::BigDecimal round trip'
+    end
+  end
+end

data/spec/bson/binary_spec.rb

@@ -255,7 +255,7 @@ describe BSON::Binary do
     let(:obj) { described_class.new("\x00" * 16, :uuid) }
 
     it 'accepts symbol representation' do
-      expect(obj.to_uuid(:standard)).to eq('00000000-0000-0000-0000000000000000')
+      expect(obj.to_uuid(:standard)).to eq('00000000-0000-0000-0000-000000000000')
     end
 
     it 'rejects string representation' do

data/spec/bson/binary_uuid_spec.rb

@@ -136,6 +136,10 @@ describe "BSON::Binary - UUID spec tests" do
       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
@@ -154,6 +158,10 @@ describe "BSON::Binary - UUID spec tests" do
       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
@@ -172,6 +180,10 @@ describe "BSON::Binary - UUID spec tests" do
       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