RUBY-3117 remove all references to BSON::Config.validating_keys?

neilshweky · neilshweky · commit 71b4e22579e0 · 2022-09-13T14:06:03.000-04:00
diff --git a/lib/mongo/grid/file/chunk.rb b/lib/mongo/grid/file/chunk.rb
@@ -133,11 +133,12 @@ def initialize(document)
         #
         # @param [ BSON::ByteBuffer ] buffer The encoded BSON buffer to append to.
         # @param [ true, false ] validating_keys Whether keys should be validated when serializing.
+        #   This option is deprecated and will not be used. It will removed in version 3.0.
         #
         # @return [ String ] The raw BSON data.
         #
         # @since 2.0.0
-        def to_bson(buffer = BSON::ByteBuffer.new, validating_keys = BSON::Config.validating_keys?)
+        def to_bson(buffer = BSON::ByteBuffer.new, validating_keys = nil)
           document.to_bson(buffer)
         end
 
diff --git a/lib/mongo/grid/file/info.rb b/lib/mongo/grid/file/info.rb
@@ -228,11 +228,12 @@ def update_md5(bytes)
         #
         # @param [ BSON::ByteBuffer ] buffer The encoded BSON buffer to append to.
         # @param [ true, false ] validating_keys Whether keys should be validated when serializing.
+        #   This option is deprecated and will not be used. It will removed in version 3.0.
         #
         # @return [ String ] The raw BSON data.
         #
         # @since 2.0.0
-        def to_bson(buffer = BSON::ByteBuffer.new, validating_keys = BSON::Config.validating_keys?)
+        def to_bson(buffer = BSON::ByteBuffer.new, validating_keys = nil)
           if @client_md5 && !document[:md5]
             document[:md5] = @client_md5.hexdigest
           end
diff --git a/lib/mongo/protocol/bit_vector.rb b/lib/mongo/protocol/bit_vector.rb
@@ -39,9 +39,11 @@ def initialize(layout)
         #
         # @param buffer [ String ] Buffer to receive the serialized vector
         # @param value [ Array<Symbol> ] Array of flags to encode
+        # @param [ true, false ] validating_keys Whether keys should be validated when serializing.
+        #   This option is deprecated and will not be used. It will removed in version 3.0.
         #
         # @return [ String ] Buffer that received the serialized vector
-        def serialize(buffer, value, validating_keys = BSON::Config.validating_keys?)
+        def serialize(buffer, value, validating_keys = nil)
           bits = 0
           value.each { |flag| bits |= (@masks[flag] || 0) }
           buffer.put_int32(bits)
diff --git a/lib/mongo/protocol/caching_hash.rb b/lib/mongo/protocol/caching_hash.rb
@@ -38,32 +38,15 @@ def bson_type
       #
       # @param [ BSON::ByteBuffer ] buffer The encoded BSON buffer to append to.
       # @param [ true, false ] validating_keys Whether keys should be validated when serializing.
+      #   This option is deprecated and will not be used. It will removed in version 3.0.
       #
       # @return [ BSON::ByteBuffer ] The buffer with the encoded object.
-      def to_bson(buffer = BSON::ByteBuffer.new, validating_keys = BSON::Config.validating_keys?)
+      def to_bson(buffer = BSON::ByteBuffer.new, validating_keys = nil)
         if !@bytes
-          @bytes = @hash.to_bson(BSON::ByteBuffer.new, validating_keys).to_s
-        elsif needs_validation?(validating_keys)
-          @validated = true
-          return @hash.to_bson(buffer, validating_keys)
+          @bytes = @hash.to_bson(BSON::ByteBuffer.new).to_s
         end
-        @validated ||= validating_keys
         buffer.put_bytes(@bytes)
       end
-
-      private
-
-      # Checks the current value for validating keys, and whether or not this
-      # bson has been validated in the past, and decides if we need to recalculate
-      # the to_bson to check the validations.
-      #
-      # @param [ true, false ] validating_keys Whether keys should be validated when serializing.
-      #
-      # @return [ true, false ] Whether or not the bson needs to be recalculated
-      #   with validation.
-      def needs_validation?(validating_keys)
-        !@validated && validating_keys
-      end
     end
   end
 end
diff --git a/lib/mongo/protocol/message.rb b/lib/mongo/protocol/message.rb
@@ -354,16 +354,16 @@ def serialize_fields(buffer, max_bson_size = nil)
           if field[:multi]
             value.each do |item|
               if field[:type].respond_to?(:size_limited?)
-                field[:type].serialize(buffer, item, max_bson_size, validating_keys?)
+                field[:type].serialize(buffer, item, max_bson_size)
               else
-                field[:type].serialize(buffer, item, validating_keys?)
+                field[:type].serialize(buffer, item)
               end
             end
           else
             if field[:type].respond_to?(:size_limited?)
-              field[:type].serialize(buffer, value, max_bson_size, validating_keys?)
+              field[:type].serialize(buffer, value, max_bson_size)
             else
-              field[:type].serialize(buffer, value, validating_keys?)
+              field[:type].serialize(buffer, value)
             end
           end
         end
@@ -456,10 +456,6 @@ def self.deserialize_field(message, io, field, options = {})
           field[:type].deserialize(io, options)
         )
       end
-
-      def validating_keys?
-        @options[:validating_keys] if @options
-      end
     end
   end
 end
diff --git a/lib/mongo/protocol/msg.rb b/lib/mongo/protocol/msg.rb
@@ -58,6 +58,7 @@ class Msg < Message
       # @option options [ true, false ] validating_keys Whether keys should be
       #   validated for being valid document keys (i.e. not begin with $ and
       #   not contain dots).
+      #   This option is deprecated and will not be used. It will removed in version 3.0.
       #
       # @api private
       #
diff --git a/lib/mongo/protocol/serializers.rb b/lib/mongo/protocol/serializers.rb
@@ -51,9 +51,11 @@ module Header
         #
         # @param buffer [ String ] Buffer to receive the serialized value.
         # @param value [ String ] Header value to be serialized.
+        # @param [ true, false ] validating_keys Whether keys should be validated when serializing.
+        #   This option is deprecated and will not be used. It will removed in version 3.0.
         #
         # @return [ String ] Buffer with serialized value.
-        def self.serialize(buffer, value, validating_keys = BSON::Config.validating_keys?)
+        def self.serialize(buffer, value, validating_keys = nil)
           buffer.put_bytes(value.pack(HEADER_PACK))
         end
 
@@ -80,7 +82,7 @@ module CString
         # @param value [ String ] The string to be serialized.
         #
         # @return [ String ] Buffer with serialized value.
-        def self.serialize(buffer, value, validating_keys = BSON::Config.validating_keys?)
+        def self.serialize(buffer, value, validating_keys = nil)
           buffer.put_cstring(value)
         end
       end
@@ -96,7 +98,7 @@ module Zero
         # @param value [ Fixnum ] Ignored value.
         #
         # @return [ String ] Buffer with serialized value.
-        def self.serialize(buffer, value, validating_keys = BSON::Config.validating_keys?)
+        def self.serialize(buffer, value, validating_keys = nil)
           buffer.put_int32(ZERO)
         end
       end
@@ -112,7 +114,7 @@ module Int32
         # @param value [ Integer | BSON::Int32 ] 32-bit integer to be serialized.
         #
         # @return [String] Buffer with serialized value.
-        def self.serialize(buffer, value, validating_keys = BSON::Config.validating_keys?)
+        def self.serialize(buffer, value, validating_keys = nil)
           if value.is_a?(BSON::Int32)
             if value.respond_to?(:value)
               # bson-ruby >= 4.6.0
@@ -146,7 +148,7 @@ module Int64
         # @param value [ Integer | BSON::Int64 ] 64-bit integer to be serialized.
         #
         # @return [ String ] Buffer with serialized value.
-        def self.serialize(buffer, value, validating_keys = BSON::Config.validating_keys?)
+        def self.serialize(buffer, value, validating_keys = nil)
           if value.is_a?(BSON::Int64)
             if value.respond_to?(:value)
               # bson-ruby >= 4.6.0
@@ -182,19 +184,20 @@ module Sections
         # @param [ Array<Hash, BSON::Document> ] value The sections to be serialized.
         # @param [ Fixnum ] max_bson_size The max bson size of documents in the sections.
         # @param [ true, false ] validating_keys Whether to validate document keys.
+        #   This option is deprecated and will not be used. It will removed in version 3.0.
         #
         # @return [ BSON::ByteBuffer ] Buffer with serialized value.
         #
         # @since 2.5.0
-        def self.serialize(buffer, value, max_bson_size = nil, validating_keys = BSON::Config.validating_keys?)
+        def self.serialize(buffer, value, max_bson_size = nil, validating_keys = nil)
           value.each do |section|
             case section[:type]
             when PayloadZero::TYPE
-              PayloadZero.serialize(buffer, section[:payload], max_bson_size, false)
+              PayloadZero.serialize(buffer, section[:payload], max_bson_size)
             when nil
-              PayloadZero.serialize(buffer, section[:payload], max_bson_size, false)
+              PayloadZero.serialize(buffer, section[:payload], max_bson_size)
             when PayloadOne::TYPE
-              PayloadOne.serialize(buffer, section[:payload], max_bson_size, validating_keys)
+              PayloadOne.serialize(buffer, section[:payload], max_bson_size)
             else
               raise Error::UnknownPayloadType.new(section[:type])
             end
@@ -259,13 +262,14 @@ module PayloadZero
           # @param [ BSON::Document, Hash ] value The object to serialize.
           # @param [ Fixnum ] max_bson_size The max bson size of documents in the section.
           # @param [ true, false ] validating_keys Whether to validate document keys.
+          #   This option is deprecated and will not be used. It will removed in version 3.0.
           #
           # @return [ BSON::ByteBuffer ] Buffer with serialized value.
           #
           # @since 2.5.0
-          def self.serialize(buffer, value, max_bson_size = nil, validating_keys = BSON::Config.validating_keys?)
+          def self.serialize(buffer, value, max_bson_size = nil, validating_keys = nil)
             buffer.put_byte(TYPE_BYTE)
-            Serializers::Document.serialize(buffer, value, max_bson_size, validating_keys)
+            Serializers::Document.serialize(buffer, value, max_bson_size)
           end
 
           # Deserializes a section of payload type 0 of an OP_MSG from the IO stream.
@@ -307,17 +311,18 @@ module PayloadOne
           # @param [ BSON::Document, Hash ] value The object to serialize.
           # @param [ Fixnum ] max_bson_size The max bson size of documents in the section.
           # @param [ true, false ] validating_keys Whether to validate document keys.
+          #   This option is deprecated and will not be used. It will removed in version 3.0.
           #
           # @return [ BSON::ByteBuffer ] Buffer with serialized value.
           #
           # @since 2.5.0
-          def self.serialize(buffer, value, max_bson_size = nil, validating_keys = BSON::Config.validating_keys?)
+          def self.serialize(buffer, value, max_bson_size = nil, validating_keys = nil)
             buffer.put_byte(TYPE_BYTE)
             start = buffer.length
             buffer.put_int32(0) # hold for size
             buffer.put_cstring(value[:identifier])
             value[:sequence].each do |document|
-              Document.serialize(buffer, document, max_bson_size, validating_keys)
+              Document.serialize(buffer, document, max_bson_size)
             end
             buffer.replace_int32(start, buffer.length - start)
           end
@@ -356,9 +361,9 @@ module Document
         # @param value [ Hash ] Document to serialize as BSON.
         #
         # @return [ String ] Buffer with serialized value.
-        def self.serialize(buffer, value, max_bson_size = nil, validating_keys = BSON::Config.validating_keys?)
+        def self.serialize(buffer, value, max_bson_size = nil, validating_keys = nil)
           start_size = buffer.length
-          value.to_bson(buffer, validating_keys)
+          value.to_bson(buffer)
           serialized_size = buffer.length - start_size
           if max_bson_size && serialized_size > max_bson_size
             raise Error::MaxBSONSize,
@@ -401,11 +406,12 @@ module Byte
         # @param [ BSON::ByteBuffer ] buffer Buffer to receive the single byte.
         # @param [ String ] value The byte to write to the buffer.
         # @param [ true, false ] validating_keys Whether to validate keys.
+        #   This option is deprecated and will not be used. It will removed in version 3.0.
         #
         # @return [ BSON::ByteBuffer ] Buffer with serialized value.
         #
         # @since 2.5.0
-        def self.serialize(buffer, value, validating_keys = BSON::Config.validating_keys?)
+        def self.serialize(buffer, value, validating_keys = nil)
           buffer.put_byte(value)
         end
 
@@ -432,11 +438,12 @@ module Bytes
         # @param [ BSON::ByteBuffer ] buffer Buffer to receive the bytes.
         # @param [ String ] value The bytes to write to the buffer.
         # @param [ true, false ] validating_keys Whether to validate keys.
+        #   This option is deprecated and will not be used. It will removed in version 3.0.
         #
         # @return [ BSON::ByteBuffer ] Buffer with serialized value.
         #
         # @since 2.5.0
-        def self.serialize(buffer, value, validating_keys = BSON::Config.validating_keys?)
+        def self.serialize(buffer, value, validating_keys = nil)
           buffer.put_bytes(value)
         end
 
diff --git a/spec/mongo/protocol/caching_hash_spec.rb b/spec/mongo/protocol/caching_hash_spec.rb
@@ -34,50 +34,4 @@
       end
     end
   end
-
-  describe "#needs_validation?" do
-    max_bson_version "4.99.99"
-
-    before do
-      hash.to_bson(BSON::ByteBuffer.new, validation)
-    end
-
-    let(:needs_validation?) do
-      hash.send(:needs_validation?, validating_keys)
-    end
-
-    context "when calling to_bson without validation" do
-      let(:validation) { false }
-
-      context "validating_keys is true" do
-        let(:validating_keys) { true }
-
-        it "is true" do
-          expect(needs_validation?).to be true
-        end
-      end
-
-      context "validating_keys is false" do
-        let(:validating_keys) { false }
-
-        it "is false" do
-          expect(needs_validation?).to be false
-        end
-      end
-    end
-
-    context "when calling to_bson with validation" do
-      let(:validation) { true }
-
-      [true, false].each do |b|
-        context "validating_keys is #{b}" do
-          let(:validating_keys) { b }
-
-          it "is false" do
-            expect(needs_validation?).to be false
-          end
-        end
-      end
-    end
-  end
 end
diff --git a/spec/mongo/protocol/msg_spec.rb b/spec/mongo/protocol/msg_spec.rb
@@ -404,10 +404,8 @@
         { validating_keys: true }
       end
 
-      it 'checks the sequence document keys' do
-        expect {
-          message.serialize
-        }.to raise_exception(BSON::String::IllegalKey)
+      it 'does not check the sequence document keys' do
+        expect(message.serialize).to be_a(BSON::ByteBuffer)
       end
     end
 

Original file line number	Diff line number	Diff line change
`@@ -133,11 +133,12 @@ def initialize(document)`
`133`	`133`	`#`
`134`	`134`	`# @param [ BSON::ByteBuffer ] buffer The encoded BSON buffer to append to.`
`135`	`135`	`# @param [ true, false ] validating_keys Whether keys should be validated when serializing.`
	`136`	`+ # This option is deprecated and will not be used. It will removed in version 3.0.`
`136`	`137`	`#`
`137`	`138`	`# @return [ String ] The raw BSON data.`
`138`	`139`	`#`
`139`	`140`	`# @since 2.0.0`
`140`		`- def to_bson(buffer = BSON::ByteBuffer.new, validating_keys = BSON::Config.validating_keys?)`
	`141`	`+ def to_bson(buffer = BSON::ByteBuffer.new, validating_keys = nil)`
`141`	`142`	`document.to_bson(buffer)`
`142`	`143`	`end`
`143`	`144`
Original file line number	Diff line number	Diff line change
`@@ -228,11 +228,12 @@ def update_md5(bytes)`
`228`	`228`	`#`
`229`	`229`	`# @param [ BSON::ByteBuffer ] buffer The encoded BSON buffer to append to.`
`230`	`230`	`# @param [ true, false ] validating_keys Whether keys should be validated when serializing.`
	`231`	`+ # This option is deprecated and will not be used. It will removed in version 3.0.`
`231`	`232`	`#`
`232`	`233`	`# @return [ String ] The raw BSON data.`
`233`	`234`	`#`
`234`	`235`	`# @since 2.0.0`
`235`		`- def to_bson(buffer = BSON::ByteBuffer.new, validating_keys = BSON::Config.validating_keys?)`
	`236`	`+ def to_bson(buffer = BSON::ByteBuffer.new, validating_keys = nil)`
`236`	`237`	`if @client_md5 && !document[:md5]`
`237`	`238`	`document[:md5] = @client_md5.hexdigest`
`238`	`239`	`end`
Original file line number	Diff line number	Diff line change
`@@ -39,9 +39,11 @@ def initialize(layout)`
`39`	`39`	`#`
`40`	`40`	`# @param buffer [ String ] Buffer to receive the serialized vector`
`41`	`41`	`# @param value [ Array<Symbol> ] Array of flags to encode`
	`42`	`+ # @param [ true, false ] validating_keys Whether keys should be validated when serializing.`
	`43`	`+ # This option is deprecated and will not be used. It will removed in version 3.0.`
`42`	`44`	`#`
`43`	`45`	`# @return [ String ] Buffer that received the serialized vector`
`44`		`- def serialize(buffer, value, validating_keys = BSON::Config.validating_keys?)`
	`46`	`+ def serialize(buffer, value, validating_keys = nil)`
`45`	`47`	`bits = 0`
`46`	`48`	`value.each { \|flag\| bits \|= (@masks[flag] \|\| 0) }`
`47`	`49`	`buffer.put_int32(bits)`
Original file line number	Diff line number	Diff line change
`@@ -58,6 +58,7 @@ class Msg < Message`
`58`	`58`	`# @option options [ true, false ] validating_keys Whether keys should be`
`59`	`59`	`# validated for being valid document keys (i.e. not begin with $ and`
`60`	`60`	`# not contain dots).`
	`61`	`+ # This option is deprecated and will not be used. It will removed in version 3.0.`
`61`	`62`	`#`
`62`	`63`	`# @api private`
`63`	`64`	`#`