protobuf 3.6.2 → 3.6.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1ade84f515216bc1d573cf3bf09ddab628bcd315
-  data.tar.gz: 57c0b9827e458ed1bfd2ea3d792201bc56e1b7ab
+  metadata.gz: 5d7a39cf0258c19f6f58ef3742803720e48db604
+  data.tar.gz: 3f51a132c2a97163934f7ab91b0ac42db9f62d18
 SHA512:
-  metadata.gz: 3caab35f4594aa538e48fc41af7a802e3b99d1c0797d82f2b1a4c0cc5e4256b4bbeea819e36274594009a0ebf21fa5d70d4915ef8cf8d5f9523677d29477bf29
-  data.tar.gz: b6da3a96f2d8a4492a981098e964af5c597c439caa5f99316df79a994390c13945a1e297a85bdefb70097ec46e4c9b33eeb94b8298fb1ceaeed8a1415c6ab2bd
+  metadata.gz: a4fa8f4ab802085285b5456cdac743e89891cbe0cb0586bcc174ff4cc8f1b6e7eb0297c1b25aa2fc37416b9f9807aa7beca029830582a3ef33fc110e97e3cc6a
+  data.tar.gz: 844d39f70bd8a9cfe47a8051db363a705776f2cd143d5cc437013c1a3d8e5d0be51ca530ccfc311e7ed7b31af76530b4956dde65d563bcbed90adfd9b997ad06

data/lib/protobuf/decoder.rb

@@ -5,62 +5,27 @@ module Protobuf
   class Decoder
 
     # Read bytes from +stream+ and pass to +message+ object.
-    def self.decode_each_field(stream, &block)
+    def self.decode_each_field(stream)
       until stream.eof?
-        tag, bytes = read_field(stream)
-        block.call(tag, bytes)
+        bits = Varint.decode(stream)
+        wire_type = bits & 0x07
+        tag = bits >> 3
+
+        bytes = if wire_type == ::Protobuf::WireType::VARINT
+                  Varint.decode(stream)
+                elsif wire_type == ::Protobuf::WireType::LENGTH_DELIMITED
+                  value_length = Varint.decode(stream)
+                  stream.read(value_length)
+                elsif wire_type == ::Protobuf::WireType::FIXED64
+                  stream.read(8)
+                elsif wire_type == ::Protobuf::WireType::FIXED32
+                  stream.read(4)
+                else
+                  fail InvalidWireType, wire_type
+                end
+
+        yield(tag, bytes)
       end
     end
-
-    def self.read_field(stream)
-      tag, wire_type = read_key(stream)
-      bytes = case wire_type
-              when ::Protobuf::WireType::VARINT then
-                Varint.decode(stream)
-              when ::Protobuf::WireType::FIXED64 then
-                read_fixed64(stream)
-              when ::Protobuf::WireType::LENGTH_DELIMITED then
-                read_length_delimited(stream)
-              when ::Protobuf::WireType::FIXED32 then
-                read_fixed32(stream)
-              when ::Protobuf::WireType::START_GROUP then
-                fail NotImplementedError, 'Group is deprecated.'
-              when ::Protobuf::WireType::END_GROUP then
-                fail NotImplementedError, 'Group is deprecated.'
-              else
-                fail InvalidWireType, wire_type
-              end
-
-      [tag, bytes]
-    end
-
-    # Read 32-bit string value from +stream+.
-    def self.read_fixed32(stream)
-      stream.read(4)
-    end
-
-    # Read 64-bit string value from +stream+.
-    def self.read_fixed64(stream)
-      stream.read(8)
-    end
-
-    # Read key pair (tag and wire-type) from +stream+.
-    def self.read_key(stream)
-      bits = read_varint(stream)
-      wire_type = bits & 0x07
-      tag = bits >> 3
-      [tag, wire_type]
-    end
-
-    # Read length-delimited string value from +stream+.
-    def self.read_length_delimited(stream)
-      value_length = read_varint(stream)
-      stream.read(value_length)
-    end
-
-    # Read varint integer value from +stream+.
-    def self.read_varint(stream)
-      Varint.decode(stream)
-    end
   end
 end

data/lib/protobuf/encoder.rb

@@ -1,67 +1,22 @@
 module Protobuf
   class Encoder
-
-    def self.encode(stream, message)
-      new(stream, message).encode
-    end
-
-    private
-
-    attr_writer :message, :stream
-
-    public
-
-    attr_reader :message, :stream
-
-    def initialize(message, stream)
-      unless message.respond_to?(:each_field_for_serialization)
-        fail ArgumentError, "Message instance must respond to :each_field_for_serialization"
-      end
-
-      self.message = message
-      self.stream = stream
-    end
-
-    def encode
+    def self.encode(message, stream)
       message.each_field_for_serialization do |field, value|
-        encode_field(field, value)
+        if field.repeated?
+          if field.packed?
+            packed_value = value.map { |val| field.encode(val) }.join
+            stream << "#{field.tag_encoded}#{::Protobuf::Field::VarintField.encode(packed_value.size)}#{packed_value}"
+          else
+            value.each do |val|
+              stream << "#{field.tag_encoded}#{field.encode(val)}"
+            end
+          end
+        else
+          stream << "#{field.tag_encoded}#{field.encode(value)}"
+        end
       end
 
       stream
     end
-
-    private
-
-    def encode_field(field, value)
-      if field.repeated?
-        encode_repeated_field(field, value)
-      else
-        write_pair(field, value)
-      end
-    end
-
-    def encode_packed_field(field, value)
-      key = (field.tag << 3) | ::Protobuf::WireType::LENGTH_DELIMITED
-      packed_value = value.map { |val| field.encode(val) }.join
-      stream << ::Protobuf::Field::VarintField.encode(key)
-      stream << ::Protobuf::Field::VarintField.encode(packed_value.size)
-      stream << packed_value
-    end
-
-    def encode_repeated_field(field, value)
-      if field.packed?
-        encode_packed_field(field, value)
-      else
-        value.each { |val| write_pair(field, val) }
-      end
-    end
-
-    # Encode key and value, and write to +stream+.
-    def write_pair(field, value)
-      key = (field.tag << 3) | field.wire_type
-      stream << ::Protobuf::Field::VarintField.encode(key)
-      stream << field.encode(value)
-    end
-
   end
 end

data/lib/protobuf/enum.rb

@@ -131,8 +131,7 @@ module Protobuf
     #   Enums, the first enum defined will be returned.
     #
     def self.enum_for_tag(tag)
-      value = mapped_enums[tag.to_i]
-      value ? value.first : nil
+      (mapped_enums[tag.to_i] || []).first
     end
 
     # Public: Get an Enum by a variety of type-checking mechanisms.
@@ -156,12 +155,14 @@ module Protobuf
     # Returns an Enum object or nil.
     #
     def self.fetch(candidate)
+      return enum_for_tag(candidate) if candidate.is_a?(::Integer)
+
       case candidate
-      when self then
+      when self
         candidate
-      when ::Numeric then
+      when ::Numeric
         enum_for_tag(candidate.to_i)
-      when ::String, ::Symbol then
+      when ::String, ::Symbol
         enum_for_name(candidate)
       else
         nil
@@ -280,9 +281,9 @@ module Protobuf
 
     def to_s(format = :tag)
       case format
-      when :tag then
+      when :tag
         to_i.to_s
-      when :name then
+      when :name
         name.to_s
       else
         to_i.to_s

data/lib/protobuf/field/base_field.rb

@@ -21,7 +21,6 @@ module Protobuf
       ##
       # Attributes
       #
-
       attr_reader :message_class, :name, :options, :rule, :tag, :type_class
 
       ##
@@ -46,6 +45,7 @@ module Protobuf
 
         validate_packed_field if packed?
         define_accessor
+        tag_encoded
       end
 
       ##
@@ -70,9 +70,9 @@ module Protobuf
 
       def default_value
         @default_value ||= case
+                           when optional? then typed_default_value
                            when repeated? then ::Protobuf::Field::FieldArray.new(self).freeze
                            when required? then nil
-                           when optional? then typed_default_value
                            end
       end
 
@@ -122,26 +122,18 @@ module Protobuf
 
       # FIXME: need to cleanup (rename) this warthog of a method.
       def set(message_instance, bytes)
-        if packed?
-          array = message_instance.__send__(getter)
-          method = \
-            case wire_type
-            when ::Protobuf::WireType::FIXED32 then :read_fixed32
-            when ::Protobuf::WireType::FIXED64 then :read_fixed64
-            when ::Protobuf::WireType::VARINT  then :read_varint
-            end
-          stream = StringIO.new(bytes)
-
-          until stream.eof?
-            array << decode(::Protobuf::Decoder.__send__(method, stream))
-          end
-        else
-          value = decode(bytes)
-          if repeated?
-            message_instance.__send__(getter) << value
-          else
-            message_instance.__send__(setter, value)
-          end
+        return message_instance.__send__(setter, decode(bytes)) unless repeated?
+        return message_instance.__send__(getter) << decode(bytes) unless packed?
+
+        array = message_instance.__send__(getter)
+        stream = StringIO.new(bytes)
+
+        if wire_type == ::Protobuf::WireType::VARINT
+          array << Varint.decode(stream) until stream.eof?
+        elsif wire_type == ::Protobuf::WireType::FIXED64
+          array << stream.read(8) until stream.eof?
+        elsif wire_type == ::Protobuf::WireType::FIXED32
+          array << stream.read(4) until stream.eof?
         end
       end
 
@@ -149,6 +141,17 @@ module Protobuf
         @setter ||= "#{name}="
       end
 
+      def tag_encoded
+        @tag_encoded ||= begin
+                           case
+                           when repeated? && packed?
+                             ::Protobuf::Field::VarintField.encode((tag << 3) | ::Protobuf::WireType::LENGTH_DELIMITED)
+                           else
+                             ::Protobuf::Field::VarintField.encode((tag << 3) | wire_type)
+                           end
+                         end
+      end
+
       # FIXME: add packed, deprecated, extension options to to_s output
       def to_s
         "#{rule} #{type_class} #{name} = #{tag} #{default ? "[default=#{default.inspect}]" : ''}"
@@ -195,6 +198,7 @@ module Protobuf
 
         message_class.class_eval do
           define_method(method_name) do |val|
+            @encode = nil
             if val.is_a?(Array)
               val = val.dup
               val.compact!
@@ -223,7 +227,7 @@ module Protobuf
 
         message_class.class_eval do
           define_method(method_name) do
-            @values.fetch(field.name, field.default_value)
+            @values[field.name] || field.default_value
           end
         end
 
@@ -236,6 +240,7 @@ module Protobuf
 
         message_class.class_eval do
           define_method(method_name) do |val|
+            @encode = nil
             if val.nil? || (val.respond_to?(:empty?) && val.empty?)
               @values.delete(field.name)
             elsif field.acceptable?(val)

data/lib/protobuf/field/bool_field.rb

@@ -3,6 +3,8 @@ require 'protobuf/field/varint_field'
 module Protobuf
   module Field
     class BoolField < VarintField
+      FALSE_STRING = "false".freeze
+      TRUE_STRING = "true".freeze
 
       ##
       # Class Methods
@@ -21,10 +23,9 @@ module Protobuf
       end
 
       def coerce!(val)
-        if val == 'true'
-          true
-        elsif val == 'false'
-          false
+        case val
+        when String
+          val == TRUE_STRING
         else
           val
         end
@@ -45,13 +46,20 @@ module Protobuf
       #
 
       def define_getter
-        super
-
         field = self
+        method_name = field.getter
 
         message_class.class_eval do
-          alias_method "#{field.getter}?", field.getter
+          define_method(method_name) do
+            @values.fetch(field.name, field.default_value)
+          end
         end
+
+        message_class.class_eval do
+          alias_method "#{method_name}?", method_name
+        end
+
+        ::Protobuf.field_deprecator.deprecate_method(message_class, method_name) if field.deprecated?
       end
 
     end

data/lib/protobuf/field/bytes_field.rb

@@ -23,7 +23,7 @@ module Protobuf
       #
 
       def acceptable?(val)
-        val.nil? || val.is_a?(String) || val.is_a?(Symbol) || val.is_a?(::Protobuf::Message)
+        val.is_a?(String) || val.nil? || val.is_a?(Symbol) || val.is_a?(::Protobuf::Message)
       end
 
       def decode(bytes)
@@ -33,12 +33,17 @@ module Protobuf
       end
 
       def encode(value)
-        value_to_encode = value.dup
-        value_to_encode = value.encode if value.is_a?(::Protobuf::Message)
-        value_to_encode.force_encoding(::Protobuf::Field::BytesField::BYTES_ENCODING)
+        value_to_encode = ""
+        if value.is_a?(::Protobuf::Message)
+          value_to_encode = value.encode
+        else
+          value_to_encode = value.dup
+        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
+
+        "#{string_size}#{value_to_encode}"
       end
 
       def wire_type
@@ -57,20 +62,16 @@ module Protobuf
 
         message_class.class_eval do
           define_method(method_name) do |val|
-            begin
-              val = "#{val}" if val.is_a?(Symbol)
-
-              if val.nil?
-                @values.delete(field.name)
-              elsif field.acceptable?(val)
-                @values[field.name] = val.dup
-              else
-                fail TypeError, "Unacceptable value #{val} for field #{field.name} of type #{field.type_class}"
-              end
-            rescue NoMethodError => ex
-              logger.error { ex.message }
-              logger.error { ex.backtrace.join("\n") }
-              raise TypeError, "Got NoMethodError attempting to set #{val} for field #{field.name} of type #{field.type_class}: #{ex.message}"
+            @encode = nil
+            case val
+            when String, Symbol
+              @values[field.name] = "#{val}"
+            when NilClass
+              @values.delete(field.name)
+            when ::Protobuf::Message
+              @values[field.name] = val.dup
+            else
+              fail TypeError, "Unacceptable value #{val} for field #{field.name} of type #{field.type_class}"
             end
           end
         end

data/lib/protobuf/field/enum_field.rb

@@ -42,6 +42,7 @@ module Protobuf
         field = self
         message_class.class_eval do
           define_method("#{field.name}=") do |value|
+            @encode = nil
             orig_value = value
             if value.nil?
               @values.delete(field.name)

data/lib/protobuf/field/message_field.rb

@@ -9,11 +9,7 @@ module Protobuf
       #
 
       def acceptable?(val)
-        unless val.is_a?(type_class) || val.respond_to?(:to_hash)
-          fail TypeError, "Expected value of type '#{type_class}' for field #{name}, but got '#{val.class}'"
-        end
-
-        true
+        val.is_a?(type_class) || val.respond_to?(:to_hash)
       end
 
       def decode(bytes)
@@ -44,14 +40,15 @@ module Protobuf
         field = self
         message_class.class_eval do
           define_method("#{field.name}=") do |val|
+            @encode = nil
             case
-            when val.nil? then
+            when val.nil?
               @values.delete(field.name)
-            when val.is_a?(field.type_class) then
+            when val.is_a?(field.type_class)
               @values[field.name] = val
-            when val.respond_to?(:to_proto) then
+            when val.respond_to?(:to_proto)
               @values[field.name] = val.to_proto
-            when val.respond_to?(:to_hash) then
+            when val.respond_to?(:to_hash)
               @values[field.name] = field.type_class.new(val.to_hash)
             else
               fail TypeError, "Expected value of type '#{field.type_class}' for field #{field.name}, but got '#{val.class}'"

data/lib/protobuf/field/string_field.rb

@@ -25,8 +25,7 @@ module Protobuf
         value_to_encode.encode!(::Protobuf::Field::StringField::ENCODING, :invalid => :replace, :undef => :replace, :replace => "")
         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
+        "#{::Protobuf::Field::VarintField.encode(value_to_encode.size)}#{value_to_encode}"
       end
 
     end

data/lib/protobuf/field/varint_field.rb

@@ -8,7 +8,7 @@ module Protobuf
       # Constants
       #
 
-      CACHE_LIMIT = 1024
+      CACHE_LIMIT = 2048
       INT32_MAX  =  2**31 - 1
       INT32_MIN  = -2**31
       INT64_MAX  =  2**63 - 1
@@ -43,7 +43,7 @@ module Protobuf
       end
 
       # Load the cache of VarInts on load of file
-      (0..CACHE_LIMIT).to_a.each do |cached_value|
+      (0..CACHE_LIMIT).each do |cached_value|
         cached_varint(cached_value)
       end
 
@@ -68,15 +68,7 @@ module Protobuf
       end
 
       def encode(value)
-        return [value].pack('C') if value < 128
-
-        bytes = []
-        until value == 0
-          bytes << (0x80 | (value & 0x7f))
-          value >>= 7
-        end
-        bytes[-1] &= 0x7f
-        bytes.pack('C*')
+        ::Protobuf::Field::VarintField.encode(value)
       end
 
       def wire_type

data/lib/protobuf/generators/field_generator.rb

@@ -27,11 +27,11 @@ module Protobuf
         @default_value ||= begin
                              if defaulted?
                                case descriptor.type.name
-                               when :TYPE_ENUM then
+                               when :TYPE_ENUM
                                  enum_default_value
-                               when :TYPE_STRING, :TYPE_BYTES then
+                               when :TYPE_STRING, :TYPE_BYTES
                                  string_default_value
-                               when :TYPE_FLOAT, :TYPE_DOUBLE then
+                               when :TYPE_FLOAT, :TYPE_DOUBLE
                                  float_double_default_value
                                else
                                  verbatim_default_value

data/lib/protobuf/lifecycle.rb

@@ -1,12 +1,12 @@
 module Protobuf
   class Lifecycle
     class << self
-      def register(event_name, &blk)
+      def register(event_name)
         fail "Lifecycle register must have a block" unless block_given?
         event_name = normalized_event_name(event_name)
 
         ::ActiveSupport::Notifications.subscribe(event_name) do |_name, _start, _finish, _id, args|
-          blk.call(*args)
+          yield(*args)
         end
       end
       alias_method :on, :register

data/lib/protobuf/message.rb

@@ -40,7 +40,7 @@ module Protobuf
 
     def initialize(fields = {})
       @values = {}
-      fields.to_hash.each_pair do |name, value|
+      fields.to_hash.each do |name, value|
         self[name] = value
       end
 
@@ -85,8 +85,10 @@ module Protobuf
     def each_field_for_serialization
       self.class.all_fields.each do |field|
         value = @values[field.getter]
-        fail ::Protobuf::SerializationError, "Required field #{self.class.name}##{field.name} does not have a value." if value.nil? && field.required?
-        next if value.nil?
+        if value.nil?
+          fail ::Protobuf::SerializationError, "Required field #{self.class.name}##{field.name} does not have a value." if field.required?
+          next
+        end
 
         yield(field, value)
       end
@@ -118,10 +120,10 @@ module Protobuf
     def to_hash
       result = {}
 
-      @values.keys.each do |field_name|
+      @values.each_key do |field_name|
         value = __send__(field_name)
         hashed_value = value.respond_to?(:to_hash_value) ? value.to_hash_value : value
-        result.merge!(field_name => hashed_value)
+        result[field_name] = hashed_value
       end
 
       result

data/lib/protobuf/message/fields.rb

@@ -78,12 +78,12 @@ module Protobuf
         end
 
         def get_extension_field(name_or_tag)
-          field = field_store[name_or_tag] || str_field_store[name_or_tag]
+          field = field_store[name_or_tag]
           field if field.try(:extension?) { false }
         end
 
         def get_field(name_or_tag, allow_extension = false)
-          field = field_store[name_or_tag] || str_field_store[name_or_tag]
+          field = field_store[name_or_tag]
 
           if field && (allow_extension || !field.extension?)
             field
@@ -97,14 +97,13 @@ module Protobuf
           raise_if_name_collision(field_name)
 
           field = ::Protobuf::Field.build(self, rule, type_class, field_name, tag, options)
-          field_store[field_name] = field
           field_store[tag] = field
+          field_store[field_name] = field
+          field_store[field_name.to_s] = field
           # defining a new field for the message will cause cached @all_fields, @extension_fields,
           # and @fields to be incorrect; reset them
           @all_fields = @extension_fields = @fields = nil
 
-          str_field_store[field_name.to_s] = field
-
           define_method("#{field_name}!") do
             @values[field_name]
           end
@@ -129,10 +128,6 @@ module Protobuf
         end
         private :inherit_fields!
 
-        def str_field_store
-          @str_field_store ||= {}
-        end
-        private :str_field_store
       end
     end
   end

data/lib/protobuf/message/serialization.rb

@@ -48,10 +48,12 @@ module Protobuf
       # Encode this message
       #
       def encode
-        stream = ::StringIO.new
-        stream.set_encoding(::Protobuf::Field::BytesField::BYTES_ENCODING)
-        encode_to(stream)
-        stream.string
+        @encode ||= begin
+          stream = ::StringIO.new
+          stream.set_encoding(::Protobuf::Field::BytesField::BYTES_ENCODING)
+          encode_to(stream)
+          stream.string
+        end
       end
 
       # Encode this message to the given stream.

data/lib/protobuf/rpc/service_filters.rb

@@ -122,7 +122,7 @@ module Protobuf
         def invoke_via_if?(_rpc_method, filter)
           if_check = filter.fetch(:if) { ->(_service) { return true } }
           do_invoke = case
-                      when if_check.nil? then
+                      when if_check.nil?
                         true
                       else
                         call_or_send(if_check)
@@ -152,7 +152,7 @@ module Protobuf
         def invoke_via_unless?(_rpc_method, filter)
           unless_check = filter.fetch(:unless) { ->(_service) { return false } }
           skip_invoke = case
-                        when unless_check.nil? then
+                        when unless_check.nil?
                           false
                         else
                           call_or_send(unless_check)
@@ -254,9 +254,9 @@ module Protobuf
         #
         def call_or_send(callable, *args, &block)
           return_value = case
-                         when callable.respond_to?(:call) then
+                         when callable.respond_to?(:call)
                            callable.call(self, *args, &block)
-                         when respond_to?(callable, true) then
+                         when respond_to?(callable, true)
                            __send__(callable, *args, &block)
                          else
                            fail "Object #{callable} is not callable"

data/lib/protobuf/version.rb

@@ -1,3 +1,3 @@
 module Protobuf
-  VERSION = '3.6.2'
+  VERSION = '3.6.6'
 end

data/spec/benchmark/tasks.rb

@@ -97,7 +97,7 @@ namespace :benchmark do
     args.with_defaults(:number => 1000, :profile_output => "/tmp/profiler_new_#{Time.now.to_i}")
     create_params = { :name => "The name that we set", :date_created => Time.now.to_i, :status => 2 }
     profile_code(args[:profile_output]) do
-      Integer(args[:number]).times { Test::Resource.new(create_params).serialize }
+      Integer(args[:number]).times { Test::Resource.decode(Test::Resource.new(create_params).serialize) }
     end
 
     puts args[:profile_output]
@@ -107,7 +107,9 @@ namespace :benchmark do
     case RUBY_ENGINE.to_sym
     when :ruby
       profile_data = RubyProf.profile(&block)
-      RubyProf::FlatPrinter.new(profile_data).print(:path => output)
+      ::File.open(output, "w") do |output_file|
+        RubyProf::FlatPrinter.new(profile_data).print(output_file)
+      end
     when :rbx
       profiler = Rubinius::Profiler::Instrumenter.new
       profiler.profile(false, &block)

data/spec/lib/protobuf/field/bool_field_spec.rb

@@ -4,6 +4,7 @@ RSpec.describe Protobuf::Field::Int32Field do
 
   class SomeBoolMessage < ::Protobuf::Message
     optional :bool, :some_bool, 1
+    required :bool, :required_bool, 2
   end
 
   let(:instance) { SomeBoolMessage.new }
@@ -48,4 +49,13 @@ RSpec.describe Protobuf::Field::Int32Field do
     end
   end
 
+  describe '#define_getter' do
+    context 'when required bool field is set to false' do
+      subject { instance.required_bool = false; instance.required_bool }
+
+      it 'returns false' do
+        expect(subject).to eq(false)
+      end
+    end
+  end
 end

data/spec/lib/protobuf/message_spec.rb

@@ -268,6 +268,64 @@ RSpec.describe Protobuf::Message do
       end
     end
 
+    describe 'memoization' do
+      it "should memoize enum message" do
+        test_enum = Test::EnumTestMessage.new
+        test_enum.encode
+        expect(test_enum.instance_variable_get(:@encode)).to eq("")
+        test_enum.non_default_enum = 2
+        expect(test_enum.instance_variable_get(:@encode)).to be_nil
+      end
+
+      context "boolean fields" do
+        let(:values) { { :ext_is_searchable => true, :name => "STEPH CURRY" } }
+        let(:test_resource) { ::Test::Resource.new(values) }
+
+        it "should memoize after bool values change " do
+          test_resource.encode
+          expect(test_resource.instance_variable_get(:@encode)).to eq(test_resource.encode)
+          test_resource.ext_is_searchable = false
+          expect(test_resource.instance_variable_get(:@encode)).to be_nil
+        end
+      end
+
+      context "string" do
+        let(:values) { { :ext_is_searchable => true, :name => "STEPH CURRY" } }
+        let(:test_resource) { ::Test::Resource.new(values) }
+
+        it "should memoize after bool values change " do
+          test_resource.encode
+          expect(test_resource.instance_variable_get(:@encode)).to eq(test_resource.encode)
+          test_resource.name = "MVP"
+          expect(test_resource.instance_variable_get(:@encode)).to be_nil
+        end
+      end
+
+      context "string" do
+        let(:values) { { :ext_is_searchable => true, :name => "STEPH CURRY" } }
+        let(:test_resource) { ::Test::Resource.new(values) }
+
+        it "should memoize after string values change " do
+          test_resource.encode
+          expect(test_resource.instance_variable_get(:@encode)).to eq(test_resource.encode)
+          test_resource.name = "MVP"
+          expect(test_resource.instance_variable_get(:@encode)).to be_nil
+        end
+      end
+
+      context "Int64" do
+        let(:values) { { :name => "STEPH CURRY", :date_created => 1454712125 } }
+        let(:test_resource) { ::Test::Resource.new(values) }
+
+        it "should memoize after Int64 values change " do
+          test_resource.encode
+          expect(test_resource.instance_variable_get(:@encode)).to eq(test_resource.encode)
+          test_resource.date_created = 5554712127
+          expect(test_resource.instance_variable_get(:@encode)).to be_nil
+        end
+      end
+    end
+
     context "when there's no value for a required field" do
       let(:message) { ::Test::ResourceWithRequiredField.new }
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: protobuf
 version: !ruby/object:Gem::Version
-  version: 3.6.2
+  version: 3.6.6
 platform: ruby
 authors:
 - BJ Neilsen
@@ -11,7 +11,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2016-02-02 00:00:00.000000000 Z
+date: 2016-02-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement