bson 4.13.0-java → 4.14.0-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ec2d89585c800c0c61b58f6902381b36273854a1c2a7f8064bfdc50b838cf123
-  data.tar.gz: be36daad51a87d3e7fd2d783c8a1e7b5d83ab2c4ea6fe515fd02012d5ad996ec
+  metadata.gz: a6f6b835c12a713aa18d8d1abeb460dc85fcb837bfefc13453dda3112be439dd
+  data.tar.gz: 8261ec5da2240e161132b2e8c47b5046b17e0d104b9d2c3ce5072b5fa235e0de
 SHA512:
-  metadata.gz: 79b8c0aa172f5fe850d6b8de145b2e0439a5b07544cfa994a22df322c8f6c88da09b6ca9db7352d0c01fbe9db03546bd9c34a7736a8305d06be992cd68508d9d
-  data.tar.gz: 64d250ddbf130ccc8db0405dd251f23277666bab3900a1b685f574757cf05788c88437d8de02d501e117dec951abec5a0a9d457a64209dbff1e0d8c9ab3519a9
+  metadata.gz: 5c77960c493303c90d8744694fca1fd3f8340533d6c4bc54ee2f614cab7fae29889ad3e6c458a83df8d7ea3eb8c3ad4d881c9c29cf58c3f005d95e343cf38228
+  data.tar.gz: 17e42012d096f348562df54bd63d5da2bce881f60be3e8e114dbd2c9e91da219e74aca7660c336aab2297105cb2f3e329e2c161abb3929a4e854c1e0d745f497

data/lib/bson/big_decimal.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+# Copyright (C) 2009-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.
+
+module BSON
+
+  # Injects behaviour for encoding and decoding BigDecimals
+  # to and from raw bytes as specified by the BSON spec.
+  #
+  # @see http://bsonspec.org/#/specification
+  module BigDecimal
+
+    # BigDecimals are serialized as Decimal128s under the hood. A Decimal128 
+    # is type 0x13 in the BSON spec.
+    BSON_TYPE = ::String.new(19.chr, encoding: BINARY).freeze
+
+    # Get the BigDecimal as encoded BSON.
+    #
+    # @example Get the BigDecimal as encoded BSON.
+    #   BigDecimal("1").to_bson
+    #
+    # @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?)
+      BSON::Decimal128.new(to_s).to_bson(buffer, validating_keys)
+    end
+
+    # Get the BSON type for BigDecimal. This is the same BSON type as
+    # BSON::Decimal128.
+    def bson_type
+      BSON_TYPE
+    end
+
+    module ClassMethods
+
+      # Deserialize the BigDecimal from raw BSON bytes.
+      #
+      # @example Get the BigDecimal from BSON.
+      #   BigDecimal.from_bson(bson)
+      #
+      # @param [ ByteBuffer ] buffer The byte buffer.
+      #
+      # @option options [ nil | :bson ] :mode Decoding mode to use.
+      #
+      # @return [ BigDecimal ] The decimal object.
+      def from_bson(buffer, **options)
+        Decimal128.from_bson(buffer, **options).to_big_decimal
+      end
+    end
+  end
+
+  # Enrich the core BigDecimal class with this module.
+  ::BigDecimal.send(:include, BigDecimal)
+  ::BigDecimal.send(:extend, BigDecimal::ClassMethods)
+end

data/lib/bson/decimal128/builder.rb

@@ -85,9 +85,13 @@ module BSON
       private
 
       def validate_range!(exponent, significand)
-        unless valid_significand?(significand) && valid_exponent?(exponent)
+        unless valid_exponent?(exponent)
           raise Decimal128::InvalidRange.new
         end
+
+        unless valid_significand?(significand)
+          raise Decimal128::UnrepresentablePrecision.new
+        end
       end
 
       def valid_significand?(significand)
@@ -302,11 +306,11 @@ module BSON
 
         def to_special_bits
           case @big_decimal.sign
-            when BigDecimal::SIGN_POSITIVE_INFINITE
+            when ::BigDecimal::SIGN_POSITIVE_INFINITE
               high = INFINITY_MASK
-            when BigDecimal::SIGN_NEGATIVE_INFINITE
+            when ::BigDecimal::SIGN_NEGATIVE_INFINITE
               high = INFINITY_MASK | SIGN_BIT_MASK
-            when BigDecimal::SIGN_NaN
+            when ::BigDecimal::SIGN_NaN
               high = NAN_MASK
           end
           [ 0, high ]
@@ -315,7 +319,7 @@ module BSON
         def to_bits
           sign, significand_str, base, exp = @big_decimal.split
           exponent = @big_decimal.zero? ? 0 : exp - significand_str.length
-          is_negative = (sign == BigDecimal::SIGN_NEGATIVE_FINITE || sign == BigDecimal::SIGN_NEGATIVE_ZERO)
+          is_negative = (sign == ::BigDecimal::SIGN_NEGATIVE_FINITE || sign == ::BigDecimal::SIGN_NEGATIVE_ZERO)
           Builder.parts_to_bits(significand_str.to_i,
                                 exponent,
                                 is_negative)

data/lib/bson/decimal128.rb

@@ -304,9 +304,7 @@ module BSON
       end
     end
 
-    # Raised when the exponent or significand provided is outside the valid range.
-    #
-    # @api private
+    # Raised when the exponent is outside the valid range.
     #
     # @since 4.2.0
     class InvalidRange < RuntimeError
@@ -314,6 +312,7 @@ module BSON
       # The custom error message for this error.
       #
       # @since 4.2.0
+      # @deprecated
       MESSAGE = 'Value out of range for Decimal128 representation.'
 
       # Get the custom error message for the exception.
@@ -329,6 +328,21 @@ module BSON
       end
     end
 
+    # Raised when the significand provided is outside the valid range.
+    #
+    # @note This class derives from InvalidRange for backwards compatibility,
+    #   however when RUBY-1806 is implemented it should be changed to derive
+    #   from the base BSON exception class.
+    class UnrepresentablePrecision < InvalidRange
+
+      # Get the custom error message for the exception.
+      #
+      # @return [ String ] The error message.
+      def message
+        'The value contains too much precision for Decimal128 representation'
+      end
+    end
+
     Registry.register(BSON_TYPE, self)
   end
 end

data/lib/bson/float.rb

@@ -16,7 +16,7 @@
 module BSON
 
   # Injects behaviour for encoding and decoding floating point values
-  # to and from # raw bytes as specified by the BSON spec.
+  # to and from raw bytes as specified by the BSON spec.
   #
   # @see http://bsonspec.org/#/specification
   #

data/lib/bson/version.rb

@@ -14,5 +14,5 @@
 # limitations under the License.
 
 module BSON
-  VERSION = "4.13.0"
+  VERSION = "4.14.0"
 end

data/lib/bson.rb

@@ -74,6 +74,7 @@ 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"
@@ -102,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/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/decimal128_spec.rb

@@ -309,6 +309,22 @@ describe BSON::Decimal128 do
         it_behaves_like 'an initialized BSON::Decimal128'
       end
     end
+
+    context 'when range is exceeded' do
+      it 'raises InvalidRange' do
+        lambda do
+          described_class.new('1e10000')
+        end.should raise_error(BSON::Decimal128::InvalidRange, /Value out of range/)
+      end
+    end
+
+    context 'when precision is exceeded' do
+      it 'raises UnrepresentablePrecision' do
+        lambda do
+          described_class.new('1.000000000000000000000000000000000000000000000000001')
+        end.should raise_error(BSON::Decimal128::UnrepresentablePrecision, /The value contains too much precision/)
+      end
+    end
   end
 
   context 'when deserializing' do

data/spec/bson/hash_spec.rb

@@ -254,6 +254,26 @@ describe Hash do
         expect(Hash.from_bson(buffer)).to eq('foo' => 42)
       end
     end
+
+    context 'when round-tripping a BigDecimal' do
+      let(:to_bson) do
+        {"x" => BigDecimal('1')}.to_bson
+      end
+
+      let(:from_bson) do
+        Hash.from_bson(to_bson)
+      end
+
+      it 'doesn\'t raise on serialization' do
+        expect do
+          to_bson
+        end.to_not raise_error
+      end
+
+      it 'deserializes as a BSON::Decimal128' do
+        expect(from_bson).to eq({"x" => BSON::Decimal128.new('1')})
+      end
+    end
   end
 
   describe '#to_bson' do
@@ -319,6 +339,18 @@ describe Hash do
         end.not_to raise_error
       end
     end
+
+    context 'when serializing a hash with a BigDecimal' do
+      let(:hash) do
+        {'foo' => BigDecimal('1')}
+      end
+
+      it 'works' do
+        expect do
+          hash.to_bson
+        end.not_to raise_error
+      end
+    end
   end
 
   describe '#from_bson' do

data/spec/shared/bin/s3-copy

@@ -0,0 +1,45 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require 'aws-sdk-s3'
+
+options = {}
+OptionParser.new do |opts|
+  opts.banner = "Usage: s3-copy options"
+
+  opts.on("-r", "--region=REGION", "AWS region to use (default us-east-1)") do |v|
+    options[:region] = v
+  end
+
+  opts.on("-p", "--param=KEY=VALUE", "Specify parameter for new files") do |v|
+    options[:params] ||= {}
+    k, v = v.split('=', 2)
+    options[:params][k.to_sym] = v
+  end
+
+  opts.on("-f", "--from=BUCKET:PATH", "Bucket name and key (or path) to copy from") do |v|
+    options[:from] = v
+  end
+
+  opts.on("-t", "--to=BUCKET:PATH", "Bucket name and key (or path) to write to (may be specified more than once)") do |v|
+    options[:to] ||= []
+    options[:to] << v
+  end
+end.parse!
+
+ENV['AWS_REGION'] ||= options[:region] || 'us-east-1'
+
+bucket, key = options.fetch(:from).split(':', 2)
+
+s3 = Aws::S3::Client.new
+
+options.fetch(:to).each do |dest|
+  STDERR.puts "Copying to #{dest}"
+  dbucket, dkey = dest.split(':', 2)
+  s3.copy_object(
+    bucket: dbucket,
+    key: dkey,
+    copy_source: "/#{bucket}/#{key}",
+    **options[:params] || {},
+  )
+end