protobuf 3.7.5 → 3.8.0.pre1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9c47dbd9243cb8e69f27b6331483bad1f6eb65f2
-  data.tar.gz: 15ef0eeeb8e59e0fdb5f72f8a3e5d1d3d279f334
+  metadata.gz: 36998518e999db66696a856ca6489d2e7b4063a6
+  data.tar.gz: 9b342418d7b1bf86249fcb2ed4924b9c2cfc28a3
 SHA512:
-  metadata.gz: 60930731ad74a300c1ee588165ba17279286f512c6eb944a0b2c8ab4f9103c564866cd8eb2a76e25e66f0504d7fa9f5eccad8ea9a75c8816354ce90e1920c531
-  data.tar.gz: b18f39b0728038ec14b85c256f7d9b2a07bab07eedfdadfcc622b8bb4a68d0ff88f347a5e132947815ec7fafe3b302a764c18633b0f7b4092cbb80c3d6aa422b
+  metadata.gz: 481bb0ddef459a46e0f34feab99b584dfdc21503e9198fd3df15bafe59d40b8d1115ef3c796bf531f67dfa60dfa112142affa4ab75c2553a4096abaa99683da4
+  data.tar.gz: 9db74e2292597dd416c9c69f299282dc3a7e928a4ff2c5da686a1ca2d8931b8ad5831a904dfec338c602fbd28fa3c833599e19083a3988c00f1827ed002d0422

data/lib/protobuf/field/base_field.rb

@@ -1,5 +1,7 @@
 require 'active_support/core_ext/hash/slice'
 require 'protobuf/field/field_array'
+require 'protobuf/field/field_hash'
+
 module Protobuf
   module Field
     class BaseField
@@ -82,6 +84,8 @@ module Protobuf
       def default_value
         @default_value ||= if optional? || required?
                              typed_default_value
+                           elsif map?
+                             ::Protobuf::Field::FieldHash.new(self).freeze
                            elsif repeated?
                              ::Protobuf::Field::FieldArray.new(self).freeze
                            else
@@ -113,6 +117,10 @@ module Protobuf
         false
       end
 
+      def map?
+        @is_map ||= repeated_message? && type_class.get_option(:map_entry)
+      end
+
       def optional?
         @optional
       end
@@ -136,6 +144,16 @@ module Protobuf
       # FIXME: need to cleanup (rename) this warthog of a method.
       def set(message_instance, bytes)
         return message_instance[name] = decode(bytes) unless repeated?
+
+        if map?
+          hash = message_instance[name]
+          entry = decode(bytes)
+          # decoded value could be nil for an
+          # enum value that is not recognized
+          hash[entry.key] = entry.value unless entry.value.nil?
+          return hash[entry.key]
+        end
+
         return message_instance[name] << decode(bytes) unless packed?
 
         array = message_instance[name]

data/lib/protobuf/field/field_hash.rb

@@ -0,0 +1,104 @@
+module Protobuf
+  module Field
+    class FieldHash < Hash
+
+      ##
+      # Attributes
+      #
+
+      attr_reader :field, :key_field, :value_field
+
+      ##
+      # Constructor
+      #
+
+      def initialize(field)
+        @field = field
+        @key_field = field.type_class.get_field(:key)
+        @value_field = field.type_class.get_field(:value)
+      end
+
+      ##
+      # Public Instance Methods
+      #
+
+      def []=(key, val)
+        super(normalize_key(key), normalize_val(val))
+      end
+
+      alias store []=
+
+      def replace(val)
+        raise_type_error(val) unless val.is_a?(Hash)
+        clear
+        update(val)
+      end
+
+      def merge!(other)
+        raise_type_error(other) unless other.is_a?(Hash)
+        # keys and values will be normalized by []= above
+        other.each { |k, v| self[k] = v }
+      end
+
+      alias update merge!
+
+      # Return a hash-representation of the given values for this field type.
+      # The value in this case would be the hash itself, right? Unfortunately
+      # not because the values of the map could be messages themselves that we
+      # need to transform.
+      def to_hash_value
+        each_with_object({}) do |(key, value), hash|
+          hash[key] = value.respond_to?(:to_hash_value) ? value.to_hash_value : value
+        end
+      end
+
+      def to_s
+        "{#{field.name}}"
+      end
+
+      private
+
+      ##
+      # Private Instance Methods
+      #
+
+      def normalize_key(key)
+        normalize(:key, key, key_field)
+      end
+
+      def normalize_val(value)
+        normalize(:value, value, value_field)
+      end
+
+      def normalize(what, value, normalize_field)
+        raise_type_error(value) if value.nil?
+        value = value.to_proto if value.respond_to?(:to_proto)
+        fail TypeError, "Unacceptable #{what} #{value} for field #{field.name} of type #{normalize_field.type_class}" unless normalize_field.acceptable?(value)
+
+        if normalize_field.is_a?(::Protobuf::Field::EnumField)
+          fetch_enum(normalize_field.type_class, value)
+        elsif normalize_field.is_a?(::Protobuf::Field::MessageField) && value.is_a?(normalize_field.type_class)
+          value
+        elsif normalize_field.is_a?(::Protobuf::Field::MessageField) && value.respond_to?(:to_hash)
+          normalize_field.type_class.new(value.to_hash)
+        else
+          value
+        end
+      end
+
+      def fetch_enum(type, val)
+        en = type.fetch(val)
+        raise_type_error(val) if en.nil?
+        en
+      end
+
+      def raise_type_error(val)
+        fail TypeError, <<-TYPE_ERROR
+          Expected map value of type '#{key_field.type_class} -> #{value_field.type_class}'
+          Got '#{val.class}' for map protobuf field #{field.name}
+        TYPE_ERROR
+      end
+
+    end
+  end
+end

data/lib/protobuf/generators/field_generator.rb

@@ -19,6 +19,11 @@ module Protobuf
       #
       attr_reader :field_options
 
+      def initialize(field_descriptor, enclosing_msg_descriptor, indent_level)
+        super(field_descriptor, indent_level)
+        @enclosing_msg_descriptor = enclosing_msg_descriptor
+      end
+
       def applicable_options
         # Note on the strange use of `#inspect`:
         #   :boom.inspect #=> ":boom"
@@ -60,7 +65,11 @@ module Protobuf
 
       def compile
         run_once(:compile) do
-          field_definition = ["#{label} #{type_name}", name, number, applicable_options]
+          field_definition = if map?
+                               ["map #{map_key_type_name}", map_value_type_name, name, number, applicable_options]
+                             else
+                               ["#{label} #{type_name}", name, number, applicable_options]
+                             end
           puts field_definition.flatten.compact.join(', ')
         end
       end
@@ -101,15 +110,28 @@ module Protobuf
 
       # Determine the field type
       def type_name
-        @type_name ||= begin
-                         case descriptor.type.name
-                         when :TYPE_MESSAGE, :TYPE_ENUM, :TYPE_GROUP then
-                           modulize(descriptor.type_name)
-                         else
-                           type_name = descriptor.type.name.to_s.downcase.sub(/type_/, '')
-                           ":#{type_name}"
-                         end
-                       end
+        @type_name ||= determine_type_name(descriptor)
+      end
+
+      # If this field is a map field, this returns a message descriptor that
+      # represents the entries in the map. Returns nil if this field is not
+      # a map field.
+      def map_entry
+        @map_entry ||= determine_map_entry
+      end
+
+      def map?
+        !map_entry.nil?
+      end
+
+      def map_key_type_name
+        return nil if map_entry.nil?
+        determine_type_name(map_entry.field.find { |v| v.name == 'key' && v.number == 1 })
+      end
+
+      def map_value_type_name
+        return nil if map_entry.nil?
+        determine_type_name(map_entry.field.find { |v| v.name == 'value' && v.number == 2 })
       end
 
       private
@@ -145,6 +167,27 @@ module Protobuf
         descriptor.default_value
       end
 
+      def determine_type_name(descriptor)
+        case descriptor.type.name
+        when :TYPE_MESSAGE, :TYPE_ENUM, :TYPE_GROUP then
+          modulize(descriptor.type_name)
+        else
+          type_name = descriptor.type.name.to_s.downcase.sub(/^type_/, '')
+          ":#{type_name}"
+        end
+      end
+
+      def determine_map_entry
+        return nil if @enclosing_msg_descriptor.nil?
+        return nil unless descriptor.label.name == :LABEL_REPEATED && descriptor.type.name == :TYPE_MESSAGE
+        # find nested message type
+        name_parts = descriptor.type_name.split(".")
+        return nil if name_parts.size < 2 || name_parts[-2] != @enclosing_msg_descriptor.name
+        nested = @enclosing_msg_descriptor.nested_type.find { |e| e.name == name_parts[-1] }
+        return nested if !nested.nil? && nested.options.try(:map_entry?)
+        nil
+      end
+
     end
   end
 end

data/lib/protobuf/generators/group_generator.rb

@@ -46,7 +46,7 @@ module Protobuf
 
       def add_extension_fields(field_descriptors)
         field_descriptors.each do |field_descriptor|
-          @groups[:extension_field] << FieldGenerator.new(field_descriptor, indent_level)
+          @groups[:extension_field] << FieldGenerator.new(field_descriptor, nil, indent_level)
         end
       end
 
@@ -61,18 +61,22 @@ module Protobuf
 
       def add_message_declarations(descriptors)
         descriptors.each do |descriptor|
+          # elide synthetic map entry messages (we handle map fields differently)
+          next if descriptor.options.try(:map_entry?) { false }
           @groups[:message_declaration] << MessageGenerator.new(descriptor, indent_level, :declaration => true)
         end
       end
 
-      def add_message_fields(field_descriptors)
+      def add_message_fields(field_descriptors, msg_descriptor)
         field_descriptors.each do |field_descriptor|
-          @groups[:field] << FieldGenerator.new(field_descriptor, indent_level)
+          @groups[:field] << FieldGenerator.new(field_descriptor, msg_descriptor, indent_level)
         end
       end
 
       def add_messages(descriptors, options = {})
         descriptors.each do |descriptor|
+          # elide synthetic map entry message (we handle map fields differently)
+          next if descriptor.options.try(:map_entry?) { false }
           @groups[:message] << MessageGenerator.new(descriptor, indent_level, options)
         end
       end

data/lib/protobuf/generators/message_generator.rb

@@ -44,7 +44,7 @@ module Protobuf
               group.add_messages(descriptor.nested_type, :extension_fields => @extension_fields, :namespace => type_namespace)
               group.add_comment(:options, 'Message Options')
               group.add_options(descriptor.options) if options?
-              group.add_message_fields(descriptor.field)
+              group.add_message_fields(descriptor.field, descriptor)
               self.class.validate_tags(fully_qualified_type_namespace, descriptor.field.map(&:number))
 
               group.add_comment(:extension_range, 'Extension Fields')

data/lib/protobuf/message.rb

@@ -50,7 +50,7 @@ module Protobuf
 
     def clear!
       @values.delete_if do |_, value|
-        if value.is_a?(::Protobuf::Field::FieldArray)
+        if value.is_a?(::Protobuf::Field::FieldArray) || value.is_a?(::Protobuf::Field::FieldHash)
           value.clear
           false
         else
@@ -86,6 +86,17 @@ module Protobuf
           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
 
         yield(field, value)
       end
@@ -151,8 +162,9 @@ module Protobuf
 
     def [](name)
       field = self.class.get_field(name, true)
-      return @values[field.fully_qualified_name] ||= ::Protobuf::Field::FieldArray.new(field) if field.repeated?
 
+      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)
     rescue # not having a field should be the exceptional state
       raise if field
@@ -184,9 +196,24 @@ 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.repeated?
+        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

data/lib/protobuf/message/fields.rb

@@ -44,6 +44,19 @@ module Protobuf
           define_field(:required, type_class, name, tag, options)
         end
 
+        # Define a map field.
+        #
+        def map(key_type_class, value_type_class, name, tag, options = {})
+          # manufacture a message that represents the map entry, used for
+          # serialization and deserialization
+          entry_type = Class.new(::Protobuf::Message) do
+            set_option :map_entry, true
+            optional key_type_class, :key, 1
+            optional value_type_class, :value, 2
+          end
+          define_field(:repeated, entry_type, name, tag, options)
+        end
+
         # Define an extension range.
         #
         def extensions(range)

data/lib/protobuf/version.rb

@@ -1,3 +1,3 @@
 module Protobuf
-  VERSION = '3.7.5' # rubocop:disable Style/MutableConstant
+  VERSION = '3.8.0.pre1' # rubocop:disable Style/MutableConstant
 end

data/spec/functional/code_generator_spec.rb

@@ -24,6 +24,26 @@ RSpec.describe 'code generation' do
     expect(code_generator.response_bytes).to eq(expected_output)
   end
 
+  it "generates code for map types" do
+    input_descriptor = ::Google::Protobuf::FileDescriptorSet.decode(
+      IO.read(PROTOS_PATH.join('map-test.bin'), :mode => 'rb'))
+    request = ::Google::Protobuf::Compiler::CodeGeneratorRequest.new(:file_to_generate => ['map-test.proto'],
+                                                                     :proto_file => input_descriptor.file)
+
+    file_name = "map-test.pb.rb"
+    file_content = File.open(PROTOS_PATH.join(file_name), "r:UTF-8", &:read)
+    expected_file_output =
+      ::Google::Protobuf::Compiler::CodeGeneratorResponse::File.new(
+        :name => file_name, :content => file_content)
+
+    expected_response =
+      ::Google::Protobuf::Compiler::CodeGeneratorResponse.encode(:file => [expected_file_output])
+
+    code_generator = ::Protobuf::CodeGenerator.new(request.encode)
+    code_generator.eval_unknown_extensions!
+    expect(code_generator.response_bytes).to eq(expected_response)
+  end
+
   it "generates code (including service stubs) with custom field and method options" do
     expected_unittest_custom_options =
       File.open(PROTOS_PATH.join('google_unittest_custom_options.pb.rb'), "r:UTF-8", &:read)

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

@@ -2,21 +2,39 @@ require 'spec_helper'
 
 RSpec.describe Protobuf::Field::FieldArray do
 
-  class SomeBasicMessage < ::Protobuf::Message
-    optional :string, :field, 1
+  let(:basic_message) do
+    Class.new(::Protobuf::Message) do
+      optional :string, :field, 1
+    end
   end
 
-  class MoreComplexMessage < SomeBasicMessage
+  let(:more_complex_message) do
+    Class.new(BasicMessage) do
+    end
   end
 
-  class OtherBasicMessage < ::Protobuf::Message
-    optional :string, :other_field, 1
+  let(:some_enum) do
+    Class.new(::Protobuf::Enum) do
+      define :FOO, 1
+      define :BAR, 2
+      define :BAZ, 3
+    end
   end
 
-  class SomeRepeatMessage < ::Protobuf::Message
-    optional :string, :some_string, 1
-    repeated :string, :multiple_strings, 2
-    repeated SomeBasicMessage, :multiple_basic_msgs, 3
+  let(:repeat_message) do
+    Class.new(::Protobuf::Message) do
+      optional :string, :some_string, 1
+      repeated :string, :multiple_strings, 2
+      repeated BasicMessage, :multiple_basic_msgs, 3
+      repeated SomeEnum, :multiple_enums, 4
+    end
+  end
+
+  before do
+    stub_const('BasicMessage', basic_message)
+    stub_const('MoreComplexMessage', more_complex_message)
+    stub_const('SomeEnum', some_enum)
+    stub_const('SomeRepeatMessage', repeat_message)
   end
 
   let(:instance) { SomeRepeatMessage.new }
@@ -40,17 +58,21 @@ RSpec.describe Protobuf::Field::FieldArray do
       context 'when applied to a MessageField field array' do
         it 'adds a MessageField object' do
           expect(instance.multiple_basic_msgs).to be_empty
-          basic_msg1 = SomeBasicMessage.new
+          basic_msg1 = BasicMessage.new
           instance.multiple_basic_msgs.send(method, basic_msg1)
           expect(instance.multiple_basic_msgs).to eq([basic_msg1])
-          basic_msg2 = SomeBasicMessage.new
+          basic_msg2 = BasicMessage.new
           instance.multiple_basic_msgs.send(method, basic_msg2)
           expect(instance.multiple_basic_msgs).to eq([basic_msg1, basic_msg2])
         end
 
+        it 'fails if not adding a MessageField' do
+          expect { instance.multiple_basic_msgs.send(method, 100.0) }.to raise_error(TypeError)
+        end
+
         it 'adds a Hash from a MessageField object' do
           expect(instance.multiple_basic_msgs).to be_empty
-          basic_msg1 = SomeBasicMessage.new
+          basic_msg1 = BasicMessage.new
           basic_msg1.field = 'my value'
           instance.multiple_basic_msgs.send(method, basic_msg1.to_hash)
           expect(instance.multiple_basic_msgs).to eq([basic_msg1])
@@ -64,6 +86,20 @@ RSpec.describe Protobuf::Field::FieldArray do
           expect(instance.multiple_basic_msgs.first).to be_a(MoreComplexMessage)
         end
       end
+
+      context 'when applied to an EnumField field array' do
+        it 'adds an EnumField object' do
+          expect(instance.multiple_enums).to be_empty
+          instance.multiple_enums.send(method, SomeEnum::FOO)
+          expect(instance.multiple_enums).to eq([SomeEnum::FOO])
+          instance.multiple_enums.send(method, SomeEnum::BAR)
+          expect(instance.multiple_enums).to eq([SomeEnum::FOO, SomeEnum::BAR])
+        end
+
+        it 'fails if not adding an EnumField' do
+          expect { instance.multiple_basic_msgs.send(method, 100.0) }.to raise_error(TypeError)
+        end
+      end
     end
   end
 end