Ruby 2.6 BigDecimal initialization compatibility (#255)

Author: alxgsv

integration/datatype_utils.rb

@@ -64,7 +64,7 @@ def self.get_sample(datatype)
       when 'bigint' then 765438000
       when 'blob' then '0x626c6f62'
       when 'boolean' then true
-      when 'decimal' then ::BigDecimal.new('1313123123.234234234234234234123')
+      when 'decimal' then BigDecimal('1313123123.234234234234234234123')
       when 'double' then 3.141592653589793
       when 'float' then 1.25
       when 'inet' then ::IPAddr.new('200.199.198.197')

lib/cassandra/protocol/cql_byte_buffer.rb

@@ -58,7 +58,7 @@ def read_decimal(len = bytesize)
         if scale <= 0
           # Special case where the actual scale is positive; scale in the protocol is actually negative of
           # reality.
-          BigDecimal.new(number_string + '0' * -scale)
+          BigDecimal(number_string + '0' * -scale)
         else
           if number_string.length <= scale
             if number_string.start_with?(MINUS)
@@ -75,7 +75,7 @@ def read_decimal(len = bytesize)
             fraction_string <<
               number_string[number_string.length - scale, number_string.length]
           end
-          BigDecimal.new(fraction_string)
+          BigDecimal(fraction_string)
         end
       rescue Errors::DecodingError => e
         raise Errors::DecodingError, e.message, e.backtrace

lib/cassandra/types.rb

@@ -158,7 +158,7 @@ def assert_boolean(value, message, &block)
       end
 
       def new_decimal(value)
-        ::BigDecimal.new(value)
+        BigDecimal(value)
       end
 
       def assert_decimal(value, message, &block)

spec/cassandra/protocol/cql_byte_buffer_spec.rb

@@ -25,7 +25,7 @@ module Protocol
       let :buffer do
         described_class.new
       end
-      
+
       describe '#read_unsigned_byte' do
         let :buffer do
           described_class.new("\xab")
@@ -79,62 +79,62 @@ module Protocol
         end
 
         it 'decodes a decimal to a BigDecimal' do
-          buffer.read_decimal.should == BigDecimal.new('1042342234234.123423435647768234')
+          buffer.read_decimal.should == BigDecimal('1042342234234.123423435647768234')
         end
 
         it 'decodes a negative decimal' do
           buffer = described_class.new("\x00\x00\x00\x12\xF2\xD8\x02\xB6R\x7F\x99\xEE\x98#\x99\xA9V")
-          buffer.read_decimal.should == BigDecimal.new('-1042342234234.123423435647768234')
+          buffer.read_decimal.should == BigDecimal('-1042342234234.123423435647768234')
         end
 
         it 'decodes a positive decimal with only fractions' do
           buffer = described_class.new("\x00\x00\x00\x13*\xF8\xC4\xDF\xEB]o")
-          buffer.read_decimal.should == BigDecimal.new('0.0012095473475870063')
+          buffer.read_decimal.should == BigDecimal('0.0012095473475870063')
         end
 
         it 'decodes a negative decimal with only fractions' do
           buffer = described_class.new("\x00\x00\x00\x13\xD5\a;\x20\x14\xA2\x91")
-          buffer.read_decimal.should == BigDecimal.new('-0.0012095473475870063')
+          buffer.read_decimal.should == BigDecimal('-0.0012095473475870063')
         end
 
         it 'decodes a small negative decimal' do
           buffer = described_class.new("\x00\x00\x00\x12\x91z\xE1\xAF\x06c\x5A")
-          buffer.read_decimal.should == BigDecimal.new('-0.031108612692221094')
+          buffer.read_decimal.should == BigDecimal('-0.031108612692221094')
         end
 
         it 'decodes a decimal with negative scale' do
           buffer = described_class.new("\xff\xff\xff\xfa\x0a")
-          buffer.read_decimal.should == BigDecimal.new('10000000')
+          buffer.read_decimal.should == BigDecimal('10000000')
         end
 
         it 'decodes a negative decimal with negative scale' do
           buffer = described_class.new("\xff\xff\xff\xf9\xfd")
-          buffer.read_decimal.should == BigDecimal.new('-30000000')
+          buffer.read_decimal.should == BigDecimal('-30000000')
         end
 
         it 'decodes a decimal with zero scale' do
           buffer = described_class.new("\x00\x00\x00\x00\x0a")
-          buffer.read_decimal.should == BigDecimal.new('10')
+          buffer.read_decimal.should == BigDecimal('10')
         end
 
         it 'decodes a negative decimal with zero scale' do
           buffer = described_class.new("\x00\x00\x00\x00\xfe")
-          buffer.read_decimal.should == BigDecimal.new('-2')
+          buffer.read_decimal.should == BigDecimal('-2')
         end
 
         it 'decodes zero decimal with zero scale' do
           buffer = described_class.new("\x00\x00\x00\x00\x00")
-          buffer.read_decimal.should == BigDecimal.new('0')
+          buffer.read_decimal.should == BigDecimal('0')
         end
 
         it 'decodes zero decimal with negative scale' do
           buffer = described_class.new("\xff\xff\xff\xf9\x00")
-          buffer.read_decimal.should == BigDecimal.new('0')
+          buffer.read_decimal.should == BigDecimal('0')
         end
 
         it 'decodes zero decimal with positive scale' do
           buffer = described_class.new("\x00\x00\x00\x05\x00")
-          buffer.read_decimal.should == BigDecimal.new('0')
+          buffer.read_decimal.should == BigDecimal('0')
         end
 
         it 'consumes the bytes' do
@@ -326,7 +326,7 @@ module Protocol
         it 'decodes a UUID as a Cassandra::Uuid' do
           buffer.read_uuid.should == Uuid.new('a4a70900-24e1-11df-8924-001ff3591711')
         end
-        
+
         it 'decodes a UUID as a Cassandra::TimeUuid' do
           uuid = buffer.read_uuid(TimeUuid)
           uuid.should == TimeUuid.new('a4a70900-24e1-11df-8924-001ff3591711')
@@ -337,7 +337,7 @@ module Protocol
           buffer.read_uuid
           buffer.should be_empty
         end
-        
+
         it 'raises an error when there a not enough bytes in the buffer' do
           b = described_class.new(buffer.discard(2).read(5))
           expect { b.read_uuid }.to raise_error(Errors::DecodingError)
@@ -910,38 +910,38 @@ module Protocol
 
       describe '#append_decimal' do
         it 'encodes a BigDecimal as a decimal' do
-          buffer.append_decimal(BigDecimal.new('1042342234234.123423435647768234'))
+          buffer.append_decimal(BigDecimal('1042342234234.123423435647768234'))
           buffer.should eql_bytes("\x00\x00\x00\x12\r'\xFDI\xAD\x80f\x11g\xDCfV\xAA")
         end
 
         it 'encodes a 0.0 BigDecimal' do
-          buffer.append_decimal(BigDecimal.new('0.0'))
+          buffer.append_decimal(BigDecimal('0.0'))
           buffer.should eql_bytes("\x00\x00\x00\x01\x00")
         end
 
         it 'encodes a BigDecimal ending in .0' do
-          buffer.append_decimal(BigDecimal.new('1042342234234.0'))
+          buffer.append_decimal(BigDecimal('1042342234234.0'))
           buffer.should eql_bytes("\x00\x00\x00\x01\tz\xE4b\xD4\xC4")
         end
 
         it 'encodes a BigDecimal ending with 00.0' do
-          buffer.append_decimal(BigDecimal.new('12000.0'))
+          buffer.append_decimal(BigDecimal('12000.0'))
           buffer.should eql_bytes("\x00\x00\x00\x01\x01\xD4\xC0")
         end
 
         it 'encodes a BigDecimal with zero padding when sign bit is on' do
-          buffer.append_decimal(BigDecimal.new('25.0'))
+          buffer.append_decimal(BigDecimal('25.0'))
           buffer.should eql_bytes("\x00\x00\x00\x01\x00\xFA")
         end
 
         it 'appends to the buffer' do
           buffer << "\x99"
-          buffer.append_decimal(BigDecimal.new('1042342234234.123423435647768234'))
+          buffer.append_decimal(BigDecimal('1042342234234.123423435647768234'))
           buffer.read(1).should eql_bytes("\x99")
         end
 
         it 'returns the buffer' do
-          result = buffer.append_decimal(BigDecimal.new('3.14'))
+          result = buffer.append_decimal(BigDecimal('3.14'))
           result.should equal(buffer)
         end
       end

spec/cassandra/protocol/requests/execute_request_spec.rb

@@ -163,7 +163,7 @@ module Protocol
             [Types.blob, "\xab\xcd", "\xab\xcd"],
             [Types.boolean, false, "\x00"],
             [Types.boolean, true, "\x01"],
-            [Types.decimal, ::BigDecimal.new('1042342234234.123423435647768234'), "\x00\x00\x00\x12\r'\xFDI\xAD\x80f\x11g\xDCfV\xAA"],
+            [Types.decimal, BigDecimal('1042342234234.123423435647768234'), "\x00\x00\x00\x12\r'\xFDI\xAD\x80f\x11g\xDCfV\xAA"],
             [Types.double, 10000.123123123, "@\xC3\x88\x0F\xC2\x7F\x9DU"],
             [Types.float, 12.13, "AB\x14{"],
             [Types.inet, ::IPAddr.new('8.8.8.8'), "\x08\x08\x08\x08"],

spec/cassandra/protocol/requests/query_request_spec.rb

@@ -97,7 +97,7 @@ module Protocol
               [765438000, Types.bigint, "\x00\x00\x00\x08\x00\x00\x00\x00\x2d\x9f\xa8\x30"],
               [::Math::PI, Types.double, "\x00\x00\x00\x08\x40\x09\x21\xfb\x54\x44\x2d\x18"],
               [67890656781923123918798273492834712837198237, Types.varint, "\x00\x00\x00\x13\x03\x0b\x58\xb5\x74\x0a\xce\x65\x95\xb4\x03\x26\x7b\x6b\x6a\x6e\x08\x91\x9d"],
-              [::BigDecimal.new('1313123123.234234234234234234123'), Types.decimal, "\x00\x00\x00\x11\x00\x00\x00\x15\x10\x92\xed\xfd\x4b\x93\x4b\xd7\xa2\xc1\x0c\x65\x0b"],
+              [BigDecimal('1313123123.234234234234234234123'), Types.decimal, "\x00\x00\x00\x11\x00\x00\x00\x15\x10\x92\xed\xfd\x4b\x93\x4b\xd7\xa2\xc1\x0c\x65\x0b"],
               [true, Types.boolean, "\x00\x00\x00\x01\x01"],
               [nil, Types.varchar, "\xff\xff\xff\xff"],
               [Uuid.new('00b69180-d0e1-11e2-8b8b-0800200c9a66'), Types.uuid, "\x00\x00\x00\x10\x00\xb6\x91\x80\xd0\xe1\x11\xe2\x8b\x8b\x08\x00\x20\x0c\x9a\x66"],

spec/cassandra/util_spec.rb

@@ -27,7 +27,7 @@ module Cassandra
         [Types.bigint, 2**63],
         [Types.boolean, true],
         [Types.boolean, false],
-        [Types.decimal, ::BigDecimal.new('1042342234234.123423435647768234')],
+        [Types.decimal, BigDecimal('1042342234234.123423435647768234')],
         [Types.double, 10000.123123123],
         [Types.inet, ::IPAddr.new('8.8.8.8')],
         [Types.uuid, Uuid.new(::SecureRandom.hex)],