protobuf 3.8.5 → 3.9.0.pre

data/lib/protobuf/field/bool_field.rb

@@ -3,10 +3,14 @@ require 'protobuf/field/varint_field'
 module Protobuf
   module Field
     class BoolField < VarintField
+      ONE = 1
       FALSE_ENCODE = [0].pack('C')
       FALSE_STRING = "false".freeze
+      FALSE_VALUES = [false, FALSE_STRING].freeze
       TRUE_ENCODE = [1].pack('C')
       TRUE_STRING = "true".freeze
+      TRUE_VALUES = [true, TRUE_STRING].freeze
+      ACCEPTABLES = [true, false, TRUE_STRING, FALSE_STRING].freeze
 
       ##
       # Class Methods
@@ -21,20 +25,21 @@ module Protobuf
       # #
 
       def acceptable?(val)
-        val == true || val == false || val == TRUE_STRING || val == FALSE_STRING
+        ACCEPTABLES.include?(val)
       end
 
       def coerce!(val)
-        return true if val == true
-        return false if val == false
-        return true if val == TRUE_STRING
-        return false if val == FALSE_STRING
-
-        fail TypeError, "Expected value of type '#{type_class}' for field #{name}, but got '#{val.class}'"
+        if TRUE_VALUES.include?(val)
+          true
+        elsif FALSE_VALUES.include?(val)
+          false
+        else
+          fail TypeError, "Expected value of type '#{type_class}' for field #{name}, but got '#{val.class}'"
+        end
       end
 
       def decode(value)
-        value == 1
+        value == ONE
       end
 
       def encode(value)

data/lib/protobuf/field/bytes_field.rb

@@ -27,30 +27,19 @@ module Protobuf
       end
 
       def decode(bytes)
-        bytes_to_decode = bytes.dup
-        bytes_to_decode.force_encoding(::Protobuf::Field::BytesField::BYTES_ENCODING)
-        bytes_to_decode
+        bytes.force_encoding(::Protobuf::Field::BytesField::BYTES_ENCODING)
+        bytes
       end
 
       def encode(value)
-        value_to_encode =
-          if value.is_a?(::Protobuf::Message)
-            value.encode
-          else
-            value.dup
-          end
+        value_to_encode = if value.is_a?(::Protobuf::Message)
+                            value.encode
+                          else
+                            "" + value
+                          end
 
         value_to_encode.force_encoding(::Protobuf::Field::BytesField::BYTES_ENCODING)
-        string_size = ::Protobuf::Field::VarintField.encode(value_to_encode.size)
-
-        "#{string_size}#{value_to_encode}"
-      end
-
-      def encode_to_stream(value, stream)
-        value = value.encode if value.is_a?(::Protobuf::Message)
-        byte_size = ::Protobuf::Field::VarintField.encode(value.bytesize)
-
-        stream << tag_encoded << byte_size << value
+        "#{::Protobuf::Field::VarintField.encode(value_to_encode.bytesize)}#{value_to_encode}"
       end
 
       def wire_type

data/lib/protobuf/field/enum_field.rb

@@ -15,18 +15,18 @@ module Protobuf
       ##
       # Public Instance Methods
       #
-
-      def acceptable?(val)
-        !type_class.fetch(val).nil?
-      end
-
       def encode(value)
-        super(value.to_i)
+        # original Google's library uses 64bits integer for negative value
+        ::Protobuf::Field::VarintField.encode(value.to_i & 0xffff_ffff_ffff_ffff)
       end
 
       def decode(value)
-        decoded = super(value)
-        decoded if acceptable?(decoded)
+        value -= 0x1_0000_0000_0000_0000 if (value & 0x8000_0000_0000_0000).nonzero?
+        value if acceptable?(value)
+      end
+
+      def acceptable?(val)
+        !type_class.fetch(val).nil?
       end
 
       def enum?
@@ -34,9 +34,7 @@ module Protobuf
       end
 
       def coerce!(value)
-        enum_value = type_class.fetch(value)
-        fail TypeError, "Invalid Enum value: #{value.inspect} for #{name}" unless enum_value
-        enum_value
+        type_class.fetch(value) || fail(TypeError, "Invalid Enum value: #{value.inspect} for #{name}")
       end
 
       private

data/lib/protobuf/field/int64_field.rb

@@ -16,6 +16,19 @@ module Protobuf
         INT64_MIN
       end
 
+      ##
+      # Instance Methods
+      #
+      def acceptable?(val)
+        if val.is_a?(Integer) || val.is_a?(Numeric)
+          val >= INT64_MIN && val <= INT64_MAX
+        else
+          Integer(val, 10) >= INT64_MIN && Integer(val, 10) <= INT64_MAX
+        end
+      rescue
+        return false
+      end
+
     end
   end
 end

data/lib/protobuf/field/message_field.rb

@@ -18,7 +18,7 @@ module Protobuf
 
       def encode(value)
         bytes = value.encode
-        result = ::Protobuf::Field::VarintField.encode(bytes.size)
+        result = ::Protobuf::Field::VarintField.encode(bytes.bytesize)
         result << bytes
       end
 

data/lib/protobuf/field/string_field.rb

@@ -14,28 +14,33 @@ module Protobuf
       # Public Instance Methods
       #
 
-      def decode(bytes)
-        bytes_to_decode = bytes.dup
-        bytes_to_decode.force_encoding(::Protobuf::Field::StringField::ENCODING)
-        bytes_to_decode
+      def acceptable?(val)
+        val.is_a?(String) || val.nil? || val.is_a?(Symbol)
       end
 
-      def encode(value)
-        value_to_encode = value.dup
-        value_to_encode.encode!(::Protobuf::Field::StringField::ENCODING, :invalid => :replace, :undef => :replace, :replace => "")
-        value_to_encode.force_encoding(::Protobuf::Field::BytesField::BYTES_ENCODING)
+      def coerce!(value)
+        if value.nil?
+          nil
+        elsif acceptable?(value)
+          value.to_s
+        else
+          fail TypeError, "Unacceptable value #{value} for field #{name} of type #{type_class}"
+        end
+      end
 
-        "#{::Protobuf::Field::VarintField.encode(value_to_encode.size)}#{value_to_encode}"
+      def decode(bytes)
+        bytes.force_encoding(::Protobuf::Field::StringField::ENCODING)
+        bytes
       end
 
-      def encode_to_stream(value, stream)
-        if value.encoding != ::Protobuf::Field::StringField::ENCODING
-          value = value.dup
-          value.encode!(::Protobuf::Field::StringField::ENCODING, :invalid => :replace, :undef => :replace, :replace => "")
+      def encode(value)
+        value_to_encode = "" + value # dup is slower
+        unless value_to_encode.encoding == ENCODING
+          value_to_encode.encode!(::Protobuf::Field::StringField::ENCODING, :invalid => :replace, :undef => :replace, :replace => "")
         end
+        value_to_encode.force_encoding(::Protobuf::Field::BytesField::BYTES_ENCODING)
 
-        byte_size = ::Protobuf::Field::VarintField.encode(value.bytesize)
-        stream << tag_encoded << byte_size << value
+        "#{::Protobuf::Field::VarintField.encode(value_to_encode.bytesize)}#{value_to_encode}"
       end
 
       def json_encode(value)

data/lib/protobuf/field/varint_field.rb

@@ -7,8 +7,6 @@ module Protobuf
       ##
       # Constants
       #
-
-      CACHE_LIMIT = 2048
       INT32_MAX  =  2**31 - 1
       INT32_MIN  = -2**31
       INT64_MAX  =  2**63 - 1
@@ -24,27 +22,8 @@ module Protobuf
         0
       end
 
-      # Because all tags and enums are calculated as VarInt it is "most common" to have
-      # values < CACHE_LIMIT (low numbers) which is defaulting to 1024
-      def self.cached_varint(value)
-        @_varint_cache ||= {}
-        (@_varint_cache[value] ||= encode(value, false)).dup
-      end
-
-      def self.encode(value, use_cache = true)
-        return cached_varint(value) if use_cache && value >= 0 && value <= CACHE_LIMIT
-
-        bytes = []
-        until value < 128
-          bytes << (0x80 | (value & 0x7f))
-          value >>= 7
-        end
-        (bytes << value).pack('C*')
-      end
-
-      # Load the cache of VarInts on load of file
-      (0..CACHE_LIMIT).each do |cached_value|
-        cached_varint(cached_value)
+      def self.encode(value)
+        ::Protobuf::Varint.encode(value)
       end
 
       ##
@@ -66,9 +45,17 @@ module Protobuf
       end
 
       def coerce!(val)
-        fail TypeError, "Expected value of type '#{type_class}' for field #{name}, but got '#{val.class}'" unless acceptable?(val)
-        return val.to_i if val.is_a?(Numeric)
-        Integer(val, 10)
+        if val.is_a?(Integer) && val >= 0 && val <= INT32_MAX
+          val
+        else
+          fail TypeError, "Expected value of type '#{type_class}' for field #{name}, but got '#{val.class}'" unless acceptable?(val)
+
+          if val.is_a?(Integer) || val.is_a?(Numeric)
+            val.to_i
+          else
+            Integer(val, 10)
+          end
+        end
       rescue ArgumentError
         fail TypeError, "Expected value of type '#{type_class}' for field #{name}, but got '#{val.class}'"
       end

data/lib/protobuf/message.rb

@@ -1,15 +1,5 @@
 require 'protobuf/message/fields'
 require 'protobuf/message/serialization'
-
-# Under MRI, this optimizes proto decoding by around 15% in tests.
-# When unavailable, we fall to pure Ruby.
-# rubocop:disable Lint/HandleExceptions
-begin
-  require 'varint/varint'
-rescue LoadError
-end
-# rubocop:enable Lint/HandleExceptions
-
 require 'protobuf/varint'
 
 module Protobuf
@@ -80,37 +70,26 @@ module Protobuf
     end
 
     def each_field_for_serialization
-      self.class.all_fields.each do |field|
-        value = @values[field.fully_qualified_name]
-        if value.nil?
-          fail ::Protobuf::SerializationError, "Required field #{self.class.name}##{field.name} does not have a value." if field.required?
-          next
-        end
-        if field.map?
-          # on-the-wire, maps are represented like an array of entries where
-          # each entry is a message of two fields, key and value.
-          array = Array.new(value.size)
-          i = 0
-          value.each do |k, v|
-            array[i] = field.type_class.new(:key => k, :value => v)
-            i += 1
-          end
-          value = array
-        end
+      _protobuf_message_unset_required_field_tags.each do |tag|
+        fail ::Protobuf::SerializationError, "Required field #{self.class.name}##{_protobuf_message_field[tag].name} does not have a value."
+      end
 
-        yield(field, value)
+      @values.each_key do |fully_qualified_name|
+        field = _protobuf_message_field[fully_qualified_name]
+        yield(field, field.value_from_values_for_serialization(@values))
       end
     end
 
     def field?(name)
-      field = self.class.get_field(name, true)
-      return false if field.nil?
-      if field.repeated?
-        @values.key?(field.fully_qualified_name) && @values[field.fully_qualified_name].present?
+      field = _protobuf_message_field[name]
+
+      if field
+        field.field?(@values)
       else
-        @values.key?(field.fully_qualified_name)
+        false
       end
     end
+    alias :respond_to_has? field?
     ::Protobuf.deprecator.define_deprecated_methods(self, :has_field? => :field?)
 
     def inspect
@@ -121,13 +100,14 @@ module Protobuf
       "#<#{self.class} #{attrs}>"
     end
 
-    def respond_to_has?(key)
-      respond_to?(key) && field?(key)
-    end
-
     def respond_to_has_and_present?(key)
-      respond_to_has?(key) &&
-        (self[key].present? || [true, false].include?(self[key]))
+      field = _protobuf_message_field[key]
+
+      if field
+        field.field_and_present?(@values)
+      else
+        false
+      end
     end
 
     # Return a hash-representation of the given fields for this message type.
@@ -135,10 +115,19 @@ module Protobuf
       result = {}
 
       @values.each_key do |field_name|
-        value = self[field_name]
-        field = self.class.get_field(field_name, true)
-        hashed_value = value.respond_to?(:to_hash_value) ? value.to_hash_value : value
-        result[field.name] = hashed_value
+        field = _protobuf_message_field[field_name]
+        field.to_message_hash(@values, result)
+      end
+
+      result
+    end
+
+    def to_hash_with_string_keys
+      result = {}
+
+      @values.each_key do |field_name|
+        field = _protobuf_message_field[field_name]
+        field.to_message_hash_with_string_key(@values, result)
       end
 
       result
@@ -186,11 +175,8 @@ module Protobuf
     end
 
     def [](name)
-      field = self.class.get_field(name, true)
-
-      return @values[field.fully_qualified_name] ||= ::Protobuf::Field::FieldHash.new(field) if field.map?
-      return @values[field.fully_qualified_name] ||= ::Protobuf::Field::FieldArray.new(field) if field.repeated?
-      @values.fetch(field.fully_qualified_name, field.default_value)
+      field = _protobuf_message_field[name]
+      field.value_from_values(@values)
     rescue # not having a field should be the exceptional state
       raise if field
       fail ArgumentError, "invalid field name=#{name.inspect}"
@@ -200,6 +186,16 @@ module Protobuf
       set_field(name, value, true)
     end
 
+    def set_field(name, value, ignore_nil_for_repeated, field = nil)
+      field ||= _protobuf_message_field[name]
+
+      if field
+        field.set_field(@values, value, ignore_nil_for_repeated, self)
+      else
+        fail(::Protobuf::FieldNotDefinedError, name) unless ::Protobuf.ignore_unknown_fields?
+      end
+    end
+
     ##
     # Instance Aliases
     #
@@ -222,57 +218,6 @@ module Protobuf
 
     private
 
-    # rubocop:disable Metrics/MethodLength
-    def set_field(name, value, ignore_nil_for_repeated)
-      if (field = self.class.get_field(name, true))
-        if field.map?
-          unless value.is_a?(Hash)
-            fail TypeError, <<-TYPE_ERROR
-                Expected map value
-                Got '#{value.class}' for map protobuf field #{field.name}
-            TYPE_ERROR
-          end
-
-          if value.empty?
-            @values.delete(field.fully_qualified_name)
-          else
-            @values[field.fully_qualified_name] ||= ::Protobuf::Field::FieldHash.new(field)
-            @values[field.fully_qualified_name].replace(value)
-          end
-        elsif field.repeated?
-          if value.nil? && ignore_nil_for_repeated
-            ::Protobuf.deprecator.deprecation_warning("#{self.class}#[#{name}]=nil", "use an empty array instead of nil")
-            return
-          end
-          unless value.is_a?(Array)
-            fail TypeError, <<-TYPE_ERROR
-                Expected repeated value of type '#{field.type_class}'
-                Got '#{value.class}' for repeated protobuf field #{field.name}
-            TYPE_ERROR
-          end
-
-          value = value.compact
-
-          if value.empty?
-            @values.delete(field.fully_qualified_name)
-          else
-            @values[field.fully_qualified_name] ||= ::Protobuf::Field::FieldArray.new(field)
-            @values[field.fully_qualified_name].replace(value)
-          end
-        else
-          if value.nil? # rubocop:disable Style/IfInsideElse
-            @values.delete(field.fully_qualified_name)
-          else
-            @values[field.fully_qualified_name] = field.coerce!(value)
-          end
-        end
-      else
-        unless ::Protobuf.ignore_unknown_fields?
-          fail ::Protobuf::FieldNotDefinedError, name
-        end
-      end
-    end
-
     def copy_to(object, method)
       duplicate = proc do |obj|
         case obj