protobuf-cucumber 3.10.4

data/lib/protobuf/field/base_field.rb

@@ -0,0 +1,380 @@
+require 'active_support/core_ext/hash/slice'
+require 'protobuf/field/field_array'
+require 'protobuf/field/field_hash'
+require 'protobuf/field/base_field_object_definitions'
+
+module Protobuf
+  module Field
+    class BaseField
+      include ::Protobuf::Logging
+      ::Protobuf::Optionable.inject(self, false) { ::Google::Protobuf::FieldOptions }
+
+      ##
+      # Constants
+      #
+      OBJECT_MODULE = ::Protobuf::Field::BaseFieldObjectDefinitions
+      PACKED_TYPES = [
+        ::Protobuf::WireType::VARINT,
+        ::Protobuf::WireType::FIXED32,
+        ::Protobuf::WireType::FIXED64,
+      ].freeze
+
+      ##
+      # Attributes
+      #
+      attr_reader :default_value, :message_class, :name, :fully_qualified_name, :options, :rule, :tag, :type_class
+
+      ##
+      # Class Methods
+      #
+
+      def self.default
+        nil
+      end
+
+      ##
+      # Constructor
+      #
+
+      def initialize(message_class, rule, type_class, fully_qualified_name, tag, simple_name, options)
+        @message_class = message_class
+        @name = simple_name || fully_qualified_name
+        @fully_qualified_name = fully_qualified_name
+        @rule          = rule
+        @tag           = tag
+        @type_class    = type_class
+        # Populate the option hash with all the original default field options, for backwards compatibility.
+        # However, both default and custom options should ideally be accessed through the Optionable .{get,get!}_option functions.
+        @options = options.slice(:ctype, :packed, :deprecated, :lazy, :jstype, :weak, :uninterpreted_option, :default, :extension)
+        options.each do |option_name, value|
+          set_option(option_name, value)
+        end
+
+        @extension = options.key?(:extension)
+        @deprecated = options.key?(:deprecated)
+        @required = rule == :required
+        @repeated = rule == :repeated
+        @optional = rule == :optional
+        @packed = @repeated && options.key?(:packed)
+
+        validate_packed_field if packed?
+        define_accessor(simple_name, fully_qualified_name) if simple_name
+        set_repeated_message!
+        set_map!
+        @value_from_values = nil
+        @value_from_values_for_serialization = nil
+        @field_predicate = nil
+        @field_and_present_predicate = nil
+        @set_field = nil
+        @set_method = nil
+        @to_message_hash = nil
+        @to_message_hash_string_keys = nil
+        @encode_to_stream = nil
+
+        define_value_from_values!
+        define_value_from_values_for_serialization!
+        define_field_predicate!
+        define_field_and_present_predicate!
+        define_set_field!
+        define_set_method!
+        define_to_message_hash!
+        define_encode_to_stream!
+        set_default_value!
+      end
+
+      ##
+      # Public Instance Methods
+      #
+
+      def acceptable?(_value)
+        true
+      end
+
+      def coerce!(value)
+        value
+      end
+
+      def decode(_bytes)
+        fail NotImplementedError, "#{self.class.name}##{__method__}"
+      end
+
+      def default
+        options[:default]
+      end
+
+      def set_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
+                             fail "Unknown field label -- something went very wrong"
+                           end
+      end
+
+      def define_encode_to_stream!
+        @encode_to_stream = if repeated? && packed?
+                              OBJECT_MODULE::RepeatedPackedEncodeToStream.new(self)
+                            elsif repeated?
+                              OBJECT_MODULE::RepeatedNotPackedEncodeToStream.new(self)
+                            elsif message? || type_class == ::Protobuf::Field::BytesField
+                              OBJECT_MODULE::BytesEncodeToStream.new(self)
+                            elsif type_class == ::Protobuf::Field::StringField
+                              OBJECT_MODULE::StringEncodeToStream.new(self)
+                            else
+                              OBJECT_MODULE::BaseEncodeToStream.new(self)
+                            end
+      end
+
+      def encode_to_stream(value, stream)
+        @encode_to_stream.call(value, stream)
+      end
+
+      def define_field_predicate!
+        @field_predicate = if repeated?
+                             OBJECT_MODULE::RepeatedFieldPredicate.new(self)
+                           else
+                             OBJECT_MODULE::BaseFieldPredicate.new(self)
+                           end
+      end
+
+      def field?(values)
+        @field_predicate.call(values)
+      end
+
+      def define_field_and_present_predicate!
+        @field_and_present_predicate = if !repeated? && type_class == ::Protobuf::Field::BoolField # boolean present check
+                                         OBJECT_MODULE::BoolFieldAndPresentPredicate.new(self)
+                                       else
+                                         OBJECT_MODULE::BaseFieldAndPresentPredicate.new(self)
+                                       end
+      end
+
+      def field_and_present?(values)
+        @field_and_present_predicate.call(values)
+      end
+
+      def define_value_from_values!
+        @value_from_values = if map?
+                               OBJECT_MODULE::MapValueFromValues.new(self)
+                             elsif repeated?
+                               OBJECT_MODULE::RepeatedFieldValueFromValues.new(self)
+                             elsif type_class == ::Protobuf::Field::BoolField # boolean present check
+                               OBJECT_MODULE::BoolFieldValueFromValues.new(self)
+                             else
+                               OBJECT_MODULE::BaseFieldValueFromValues.new(self)
+                             end
+      end
+
+      def value_from_values(values)
+        @value_from_values.call(values)
+      end
+
+      def define_value_from_values_for_serialization!
+        @value_from_values_for_serialization = if map?
+                                                 OBJECT_MODULE::MapValueFromValuesForSerialization.new(self)
+                                               elsif repeated?
+                                                 OBJECT_MODULE::RepeatedFieldValueFromValuesForSerialization.new(self)
+                                               elsif type_class == ::Protobuf::Field::BoolField # boolean present check
+                                                 OBJECT_MODULE::BoolFieldValueFromValuesForSerialization.new(self)
+                                               else
+                                                 OBJECT_MODULE::BaseFieldValueFromValuesForSerialization.new(self)
+                                               end
+      end
+
+      def value_from_values_for_serialization(values)
+        @value_from_values_for_serialization.call(values)
+      end
+
+      def define_set_field!
+        @set_field = if map? && required?
+                       OBJECT_MODULE::RequiredMapSetField.new(self)
+                     elsif repeated? && required?
+                       OBJECT_MODULE::RequiredRepeatedSetField.new(self)
+                     elsif type_class == ::Protobuf::Field::StringField && required?
+                       OBJECT_MODULE::RequiredStringSetField.new(self)
+                     elsif required?
+                       OBJECT_MODULE::RequiredBaseSetField.new(self)
+                     elsif map?
+                       OBJECT_MODULE::MapSetField.new(self)
+                     elsif repeated?
+                       OBJECT_MODULE::RepeatedSetField.new(self)
+                     elsif type_class == ::Protobuf::Field::StringField
+                       OBJECT_MODULE::StringSetField.new(self)
+                     else
+                       OBJECT_MODULE::BaseSetField.new(self)
+                     end
+      end
+
+      def set_field(values, value, ignore_nil_for_repeated, message_instance)
+        @set_field.call(values, value, ignore_nil_for_repeated, message_instance)
+      end
+
+      def define_to_message_hash!
+        if message? || enum? || repeated? || map?
+          @to_message_hash = OBJECT_MODULE::ToHashValueToMessageHash.new(self)
+          @to_message_hash_string_keys = OBJECT_MODULE::ToHashValueToMessageHashWithStringKey.new(self)
+        else
+          @to_message_hash = OBJECT_MODULE::BaseToMessageHash.new(self)
+          @to_message_hash_string_keys = OBJECT_MODULE::BaseToMessageHashWithStringKey.new(self)
+        end
+      end
+
+      def to_message_hash(values, result)
+        @to_message_hash.call(values, result)
+      end
+
+      def to_message_hash_with_string_key(values, result)
+        @to_message_hash_string_keys.call(values, result)
+      end
+
+      def deprecated?
+        @deprecated
+      end
+
+      def encode(_value)
+        fail NotImplementedError, "#{self.class.name}##{__method__}"
+      end
+
+      def extension?
+        @extension
+      end
+
+      def enum?
+        false
+      end
+
+      def message?
+        false
+      end
+
+      def set_map!
+        set_repeated_message!
+        @is_map = repeated_message? && type_class.get_option!(:map_entry)
+      end
+
+      def map?
+        @is_map
+      end
+
+      def optional?
+        @optional
+      end
+
+      def packed?
+        @packed
+      end
+
+      def repeated?
+        @repeated
+      end
+
+      def set_repeated_message!
+        @repeated_message = repeated? && message?
+      end
+
+      def repeated_message?
+        @repeated_message
+      end
+
+      def required?
+        @required
+      end
+
+      def define_set_method!
+        @set_method = if map?
+                        OBJECT_MODULE::MapSetMethod.new(self)
+                      elsif repeated? && packed?
+                        OBJECT_MODULE::RepeatedPackedSetMethod.new(self)
+                      elsif repeated?
+                        OBJECT_MODULE::RepeatedNotPackedSetMethod.new(self)
+                      else
+                        OBJECT_MODULE::BaseSetMethod.new(self)
+                      end
+      end
+
+      def set(message_instance, bytes)
+        @set_method.call(message_instance, bytes)
+      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}]" : ''}"
+      end
+
+      ::Protobuf.deprecator.define_deprecated_methods(self, :type => :type_class)
+
+      def wire_type
+        ::Protobuf::WireType::VARINT
+      end
+
+      def fully_qualified_name_only!
+        @name = @fully_qualified_name
+
+        ##
+        # Recreate all of the meta methods as they may have used the original `name` value
+        #
+        define_value_from_values!
+        define_value_from_values_for_serialization!
+        define_field_predicate!
+        define_field_and_present_predicate!
+        define_set_field!
+        define_set_method!
+        define_to_message_hash!
+        define_encode_to_stream!
+      end
+
+      private
+
+      ##
+      # Private Instance Methods
+      #
+
+      def define_accessor(simple_field_name, fully_qualified_field_name)
+        message_class.class_eval do
+          define_method("#{simple_field_name}!") do
+            @values[fully_qualified_field_name] if field?(fully_qualified_field_name)
+          end
+        end
+
+        message_class.class_eval do
+          define_method(simple_field_name) { self[fully_qualified_field_name] }
+          define_method("#{simple_field_name}=") { |v| set_field(fully_qualified_field_name, v, false) }
+        end
+
+        return unless deprecated?
+
+        ::Protobuf.field_deprecator.deprecate_method(message_class, simple_field_name)
+        ::Protobuf.field_deprecator.deprecate_method(message_class, "#{simple_field_name}!")
+        ::Protobuf.field_deprecator.deprecate_method(message_class, "#{simple_field_name}=")
+      end
+
+      def typed_default_value
+        if default.nil?
+          self.class.default
+        else
+          default
+        end
+      end
+
+      def validate_packed_field
+        if packed? && ! ::Protobuf::Field::BaseField::PACKED_TYPES.include?(wire_type)
+          fail "Can't use packed encoding for '#{type_class}' type"
+        end
+      end
+    end
+  end
+end

data/lib/protobuf/field/base_field_object_definitions.rb

@@ -0,0 +1,504 @@
+module Protobuf
+  module Field
+    module BaseFieldObjectDefinitions
+
+      class ToHashValueToMessageHashWithStringKey
+        def initialize(selph)
+          @selph = selph
+          @name = selph.name.to_s
+        end
+
+        def call(values, result)
+          result[@name] = @selph.value_from_values(values).to_hash_value
+        end
+      end
+
+      class BaseToMessageHashWithStringKey
+        def initialize(selph)
+          @selph = selph
+          @name = selph.name.to_s
+        end
+
+        def call(values, result)
+          result[@name] = @selph.value_from_values(values)
+        end
+      end
+
+      class ToHashValueToMessageHash
+        def initialize(selph)
+          @selph = selph
+          @name = selph.name.to_sym
+        end
+
+        def call(values, result)
+          result[@name] = @selph.value_from_values(values).to_hash_value
+        end
+      end
+
+      class BaseToMessageHash
+        def initialize(selph)
+          @selph = selph
+          @name = selph.name.to_sym
+        end
+
+        def call(values, result)
+          result[@name] = @selph.value_from_values(values)
+        end
+      end
+
+      class RepeatedPackedEncodeToStream
+        def initialize(selph)
+          @selph = selph
+          @tag_encoded = selph.tag_encoded
+        end
+
+        def call(value, stream)
+          packed_value = value.map { |val| @selph.encode(val) }.join
+          stream << @tag_encoded << "#{::Protobuf::Field::VarintField.encode(packed_value.size)}#{packed_value}"
+        end
+      end
+
+      class BytesEncodeToStream
+        def initialize(selph)
+          @selph = selph
+          @tag_encoded = selph.tag_encoded
+        end
+
+        def call(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
+        end
+      end
+
+      class StringEncodeToStream
+        def initialize(selph)
+          @selph = selph
+          @tag_encoded = selph.tag_encoded
+        end
+
+        def call(value, stream)
+          new_value = "" + value
+          if new_value.encoding != ::Protobuf::Field::StringField::ENCODING
+            new_value.encode!(::Protobuf::Field::StringField::ENCODING, :invalid => :replace, :undef => :replace, :replace => "")
+          end
+
+          stream << @tag_encoded << ::Protobuf::Field::VarintField.encode(new_value.bytesize) << new_value
+        end
+      end
+
+      class BaseEncodeToStream
+        def initialize(selph)
+          @selph = selph
+          @tag_encoded = selph.tag_encoded
+        end
+
+        def call(value, stream)
+          stream << @tag_encoded << @selph.encode(value)
+        end
+      end
+
+      class RepeatedNotPackedEncodeToStream
+        def initialize(selph)
+          @selph = selph
+          @tag_encoded = selph.tag_encoded
+        end
+
+        def call(value, stream)
+          value.each do |val|
+            stream << @tag_encoded << @selph.encode(val)
+          end
+        end
+      end
+
+      class BaseSetMethod
+        def initialize(selph)
+          @selph = selph
+          @name = selph.name
+        end
+
+        def call(message_instance, bytes)
+          message_instance.set_field(@name, @selph.decode(bytes), true, @selph)
+        end
+      end
+
+      class MapSetMethod
+        def initialize(selph)
+          @selph = selph
+          @name = selph.name
+        end
+
+        def call(message_instance, bytes)
+          hash = message_instance[@name]
+          entry = @selph.decode(bytes)
+          # decoded value could be nil for an
+          # enum value that is not recognized
+          hash[entry.key] = entry.value unless entry.value.nil?
+          hash[entry.key]
+        end
+      end
+
+      class RepeatedNotPackedSetMethod
+        def initialize(selph)
+          @selph = selph
+          @name = selph.name
+        end
+
+        def call(message_instance, bytes)
+          message_instance[@name] << @selph.decode(bytes)
+        end
+      end
+
+      class RepeatedPackedSetMethod
+        def initialize(selph)
+          @selph = selph
+          @name = selph.name
+          @wire_type = selph.wire_type
+        end
+
+        def call(message_instance, bytes)
+          array = message_instance[@name]
+          stream = ::StringIO.new(bytes)
+
+          if @wire_type == ::Protobuf::WireType::VARINT
+            array << @selph.decode(Varint.decode(stream)) until stream.eof?
+          elsif @wire_type == ::Protobuf::WireType::FIXED64
+            array << @selph.decode(stream.read(8)) until stream.eof?
+          elsif @wire_type == ::Protobuf::WireType::FIXED32
+            array << @selph.decode(stream.read(4)) until stream.eof?
+          end
+        end
+      end
+
+      class RequiredMapSetField
+        def initialize(selph)
+          @selph = selph
+          @tag = selph.tag
+          @fully_qualified_name = selph.fully_qualified_name
+        end
+
+        def call(values, value, _ignore_nil_for_repeated, message_instance)
+          unless value.is_a?(Hash)
+            fail TypeError, <<-TYPE_ERROR
+                    Expected map value
+                    Got '#{value.class}' for map protobuf field #{@selph.name}
+            TYPE_ERROR
+          end
+
+          if value.empty?
+            values.delete(@fully_qualified_name)
+            message_instance._protobuf_message_unset_required_field_tags << @tag
+          else
+            message_instance._protobuf_message_unset_required_field_tags.delete(@tag)
+            values[@fully_qualified_name] ||= ::Protobuf::Field::FieldHash.new(@selph)
+            values[@fully_qualified_name].replace(value)
+          end
+        end
+      end
+
+      class MapSetField
+        def initialize(selph)
+          @selph = selph
+          @tag = selph.tag
+          @fully_qualified_name = selph.fully_qualified_name
+        end
+
+        def call(values, value, _ignore_nil_for_repeated, _message_instance)
+          unless value.is_a?(Hash)
+            fail TypeError, <<-TYPE_ERROR
+                    Expected map value
+                    Got '#{value.class}' for map protobuf field #{@selph.name}
+            TYPE_ERROR
+          end
+
+          if value.empty?
+            values.delete(@fully_qualified_name)
+          else
+            values[@fully_qualified_name] ||= ::Protobuf::Field::FieldHash.new(@selph)
+            values[@fully_qualified_name].replace(value)
+          end
+        end
+      end
+
+      class RequiredRepeatedSetField
+        def initialize(selph)
+          @selph = selph
+          @tag = selph.tag
+          @fully_qualified_name = selph.fully_qualified_name
+        end
+
+        def call(values, value, ignore_nil_for_repeated, message_instance)
+          if value.nil? && ignore_nil_for_repeated
+            ::Protobuf.deprecator.deprecation_warning("['#{@fully_qualified_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 '#{@selph.type_class}'
+                  Got '#{value.class}' for repeated protobuf field #{@selph.name}
+            TYPE_ERROR
+          end
+
+          value = value.compact
+
+          if value.empty?
+            values.delete(@fully_qualified_name)
+            message_instance._protobuf_message_unset_required_field_tags << @tag
+          else
+            message_instance._protobuf_message_unset_required_field_tags.delete(@tag)
+            values[@fully_qualified_name] ||= ::Protobuf::Field::FieldArray.new(@selph)
+            values[@fully_qualified_name].replace(value)
+          end
+        end
+      end
+
+      class RepeatedSetField
+        def initialize(selph)
+          @selph = selph
+          @tag = selph.tag
+          @fully_qualified_name = selph.fully_qualified_name
+        end
+
+        def call(values, value, ignore_nil_for_repeated, _message_instance)
+          if value.nil? && ignore_nil_for_repeated
+            ::Protobuf.deprecator.deprecation_warning("['#{@fully_qualified_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 '#{@selph.type_class}'
+                  Got '#{value.class}' for repeated protobuf field #{@selph.name}
+            TYPE_ERROR
+          end
+
+          value = value.compact
+
+          if value.empty?
+            values.delete(@fully_qualified_name)
+          else
+            values[@fully_qualified_name] ||= ::Protobuf::Field::FieldArray.new(@selph)
+            values[@fully_qualified_name].replace(value)
+          end
+        end
+      end
+
+      class RequiredStringSetField
+        def initialize(selph)
+          @selph = selph
+          @tag = selph.tag
+          @fully_qualified_name = selph.fully_qualified_name
+        end
+
+        def call(values, value, _ignore_nil_for_repeated, message_instance)
+          if value
+            message_instance._protobuf_message_unset_required_field_tags.delete(@tag)
+            values[@fully_qualified_name] = if value.is_a?(String)
+                                              value
+                                            else
+                                              @selph.coerce!(value)
+                                            end
+          else
+            values.delete(@fully_qualified_name)
+            message_instance._protobuf_message_unset_required_field_tags << @tag
+          end
+        end
+      end
+
+      class StringSetField
+        def initialize(selph)
+          @selph = selph
+          @tag = selph.tag
+          @fully_qualified_name = selph.fully_qualified_name
+        end
+
+        def call(values, value, _ignore_nil_for_repeated, _message_instance)
+          if value
+            values[@fully_qualified_name] = if value.is_a?(String)
+                                              value
+                                            else
+                                              @selph.coerce!(value)
+                                            end
+          else
+            values.delete(@fully_qualified_name)
+          end
+        end
+      end
+
+      class RequiredBaseSetField
+        def initialize(selph)
+          @selph = selph
+          @tag = selph.tag
+          @fully_qualified_name = selph.fully_qualified_name
+        end
+
+        def call(values, value, _ignore_nil_for_repeated, message_instance)
+          if value.nil?
+            values.delete(@fully_qualified_name)
+            message_instance._protobuf_message_unset_required_field_tags << @tag
+          else
+            message_instance._protobuf_message_unset_required_field_tags.delete(@tag)
+            values[@fully_qualified_name] = @selph.coerce!(value)
+          end
+        end
+      end
+
+      class BaseSetField
+        def initialize(selph)
+          @selph = selph
+          @tag = selph.tag
+          @fully_qualified_name = selph.fully_qualified_name
+        end
+
+        def call(values, value, _ignore_nil_for_repeated, _message_instance)
+          if value.nil?
+            values.delete(@fully_qualified_name)
+          else
+            values[@fully_qualified_name] = @selph.coerce!(value)
+          end
+        end
+      end
+
+      class BaseFieldAndPresentPredicate
+        def initialize(selph)
+          @fully_qualified_name = selph.fully_qualified_name
+        end
+
+        def call(values)
+          values[@fully_qualified_name].present?
+        end
+      end
+
+      class BoolFieldAndPresentPredicate
+        BOOL_VALUES = [true, false].freeze
+
+        def initialize(selph)
+          @fully_qualified_name = selph.fully_qualified_name
+        end
+
+        def call(values)
+          BOOL_VALUES.include?(values[@fully_qualified_name])
+        end
+      end
+
+      class BaseFieldPredicate
+        def initialize(selph)
+          @fully_qualified_name = selph.fully_qualified_name
+        end
+
+        def call(values)
+          values.key?(@fully_qualified_name)
+        end
+      end
+
+      class RepeatedFieldPredicate
+        def initialize(selph)
+          @fully_qualified_name = selph.fully_qualified_name
+        end
+
+        def call(values)
+          values.key?(@fully_qualified_name) &&
+            values[@fully_qualified_name].present?
+        end
+      end
+
+      class BoolFieldValueFromValues
+        def initialize(selph)
+          @selph = selph
+          @fully_qualified_name = selph.fully_qualified_name
+        end
+
+        def call(values)
+          values.fetch(@fully_qualified_name) { @selph.default_value }
+        end
+      end
+
+      class BoolFieldValueFromValuesForSerialization
+        def initialize(selph)
+          @selph = selph
+          @fully_qualified_name = selph.fully_qualified_name
+        end
+
+        def call(values)
+          values.fetch(@fully_qualified_name) { @selph.default_value }
+        end
+      end
+
+      class BaseFieldValueFromValues
+        def initialize(selph)
+          @selph = selph
+          @fully_qualified_name = selph.fully_qualified_name
+        end
+
+        def call(values)
+          values[@fully_qualified_name] || @selph.default_value
+        end
+      end
+
+      class BaseFieldValueFromValuesForSerialization
+        def initialize(selph)
+          @selph = selph
+          @fully_qualified_name = selph.fully_qualified_name
+        end
+
+        def call(values)
+          values[@fully_qualified_name] || @selph.default_value
+        end
+      end
+
+      class MapValueFromValues
+        def initialize(selph)
+          @selph = selph
+          @fully_qualified_name = selph.fully_qualified_name
+        end
+
+        def call(values)
+          values[@fully_qualified_name] ||= ::Protobuf::Field::FieldHash.new(@selph)
+        end
+      end
+
+      class MapValueFromValuesForSerialization
+        def initialize(selph)
+          @selph = selph
+          @fully_qualified_name = selph.fully_qualified_name
+          @type_class = selph.type_class
+        end
+
+        def call(values)
+          value = values[@fully_qualified_name] ||= ::Protobuf::Field::FieldHash.new(@selph)
+
+          array = []
+          value.each do |k, v|
+            array << @type_class.new(:key => k, :value => v)
+          end
+
+          array
+        end
+      end
+
+      class RepeatedFieldValueFromValues
+        def initialize(selph)
+          @selph = selph
+          @fully_qualified_name = selph.fully_qualified_name
+        end
+
+        def call(values)
+          values[@fully_qualified_name] ||= ::Protobuf::Field::FieldArray.new(@selph)
+        end
+      end
+
+      class RepeatedFieldValueFromValuesForSerialization
+        def initialize(selph)
+          @selph = selph
+          @fully_qualified_name = selph.fully_qualified_name
+        end
+
+        def call(values)
+          values[@fully_qualified_name] ||= ::Protobuf::Field::FieldArray.new(@selph)
+        end
+      end
+    end
+  end
+end