bson 4.13.0 → 4.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f6a42388fd836eb9cd8caee93899ca84eea84d14a0eb79346d7c96deba08b0d1
-  data.tar.gz: d0d20e09019369dea160278abee5929ea89f91efcdbd0523f68dd83fa0d2b30f
+  metadata.gz: 542c675ad88650d665d5e077de9a3c7bcbd566647fc1f08f1d3441948d646c1c
+  data.tar.gz: b9f41c2f216e982dcdcd2c83c17a4dd59f8e062406023eb6bd1932afa8338698
 SHA512:
-  metadata.gz: 3210c3ef66059b6b44e4286755df4ed8508e4c367c20b6ff89698d21dd89151c4aee54e4a31cc92c5b09db3b7d33ec8ece2dc17372920885d9808aa13d5eed09
-  data.tar.gz: '0086253724f6b26a1e1a40ee89d9c434c5005bbfbdcf28b11aa40b1f5742eb4a030d4ca26c331b71cfabfb911e9a8200719c72e4327cad3e6d825a8e3de5d346'
+  metadata.gz: 3a084a08fb6cd5601e6b0095b7086348e602aa42e5b52069531f107879d4a67a7a982ce1938d4ef4bedb4b559648a0139b3c85ab011b5f65fa415300dadef079
+  data.tar.gz: 3dde4070b315b1a3da605c11fa6571a9fb641dcdc77ed2edb7aec0e3799a2765af68342ac9a4fb839e0c0a84ad4a10f1641948a76857f649c9680a521aec90bd

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

data/spec/shared/bin/s3-upload

@@ -0,0 +1,69 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require 'aws-sdk-s3'
+
+options = {}
+OptionParser.new do |opts|
+  opts.banner = "Usage: s3-upload 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 S3 upload") do |v|
+    options[:params] ||= {}
+    k, v = v.split('=', 2)
+    options[:params][k.to_sym] = v
+  end
+
+  opts.on("-f", "--file=PATH", "Path to the file to upload, - to upload standard input") do |v|
+    options[:file] = v
+  end
+
+  opts.on("-w", "--write=BUCKET:PATH", "Bucket name and key (or path) to upload to") do |v|
+    options[:write] = v
+  end
+
+  opts.on("-c", "--copy=BUCKET:PATH", "Bucket name and key (or path) to copy to (may be specified more than once)") do |v|
+    options[:copy] ||= []
+    options[:copy] << v
+  end
+end.parse!
+
+ENV['AWS_REGION'] ||= options[:region] || 'us-east-1'
+
+def upload(f, options)
+  s3 = Aws::S3::Client.new
+  write = options.fetch(:write)
+  STDERR.puts "Writing #{write}"
+  bucket, key = write.split(':', 2)
+  s3.put_object(
+    body: f.read,
+    bucket: bucket,
+    key: key,
+    **options[:params] || {},
+  )
+  if copy = options[:copy]
+    copy.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
+  end
+end
+
+if options[:file] == '-'
+  upload(STDIN, options)
+elsif options[:file]
+  File.open(options[:file]) do |f|
+    upload(f, options)
+  end
+else
+  upload(STDIN, options)
+end