avromatic 2.2.2 → 2.3.0

data/lib/avromatic/io/datum_writer.rb

@@ -7,10 +7,11 @@ module Avromatic
     class DatumWriter < Avro::IO::DatumWriter
       def write_union(writers_schema, datum, encoder)
         optional = writers_schema.schemas.first.type_sym == :null
-        if datum.is_a?(Hash) && datum.key?(Avromatic::IO::UNION_MEMBER_INDEX)
-          index_of_schema = datum[Avromatic::IO::UNION_MEMBER_INDEX]
+        if datum.is_a?(Avromatic::IO::UnionDatum)
+          index_of_schema = datum.member_index
           # Avromatic does not treat the null of an optional field as part of the union
           index_of_schema += 1 if optional
+          datum = datum.datum
         elsif optional && writers_schema.schemas.size == 2
           # Optimize for the common case of a union that's just an optional field
           index_of_schema = datum.nil? ? 0 : 1
@@ -19,21 +20,14 @@ module Avromatic
             Avro::Schema.validate(schema, datum)
           end
         end
+
         unless index_of_schema
           raise Avro::IO::AvroTypeError.new(writers_schema, datum)
         end
+
         encoder.write_long(index_of_schema)
         write_data(writers_schema.schemas[index_of_schema], datum, encoder)
       end
-
-      def write_record(writers_schema, datum, encoder)
-        if datum.is_a?(Hash) && datum.key?(Avromatic::IO::ENCODING_PROVIDER)
-          # This is only used for recursive serialization so validation has already been done
-          encoder.write(datum[Avromatic::IO::ENCODING_PROVIDER].avro_raw_value(validate: false))
-        else
-          super
-        end
-      end
     end
   end
 end

data/lib/avromatic/io/union_datum.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Avromatic
+  module IO
+    class UnionDatum
+      attr_reader :member_index, :datum
+
+      def initialize(member_index, datum)
+        @member_index = member_index
+        @datum = datum
+      end
+
+      def ==(other)
+        other.is_a?(Avromatic::IO::UnionDatum) &&
+          member_index == other.member_index &&
+          datum == other.datum
+      end
+      alias_method :eql?, :==
+
+      def hash
+        31 * datum.hash + member_index
+      end
+    end
+  end
+end

data/lib/avromatic/messaging.rb

@@ -29,7 +29,8 @@ module Avromatic
       end
 
       # The following line differs from the parent class to use a custom DatumReader
-      reader = Avromatic::IO::DatumReader.new(writers_schema, readers_schema)
+      reader_class = Avromatic.use_custom_datum_reader ? Avromatic::IO::DatumReader : Avro::IO::DatumReader
+      reader = reader_class.new(writers_schema, readers_schema)
       reader.read(decoder)
     end
 
@@ -50,7 +51,8 @@ module Avromatic
       encoder.write([schema_id].pack('N'))
 
       # The following line differs from the parent class to use a custom DatumWriter
-      writer = Avromatic::IO::DatumWriter.new(schema)
+      writer_class = Avromatic.use_custom_datum_writer ? Avromatic::IO::DatumWriter : Avro::IO::DatumWriter
+      writer = writer_class.new(schema)
 
       # The actual message comes last.
       writer.write(message, encoder)

data/lib/avromatic/model/attributes.rb

@@ -74,23 +74,23 @@ module Avromatic
       def initialize(data = {})
         super()
 
-        valid_keys = []
+        num_valid_keys = 0
         attribute_definitions.each do |attribute_name, attribute_definition|
           if data.include?(attribute_name)
-            valid_keys << attribute_name
+            num_valid_keys += 1
             value = data.fetch(attribute_name)
             send(attribute_definition.setter_name, value)
           elsif data.include?(attribute_definition.name_string)
-            valid_keys << attribute_name
+            num_valid_keys += 1
             value = data[attribute_definition.name_string]
             send(attribute_definition.setter_name, value)
-          elsif !attributes.include?(attribute_name)
+          elsif !_attributes.include?(attribute_name)
             send(attribute_definition.setter_name, attribute_definition.default)
           end
         end
 
-        unless Avromatic.allow_unknown_attributes || valid_keys.size == data.size
-          unknown_attributes = (data.keys.map(&:to_s) - valid_keys.map(&:to_s)).sort
+        unless Avromatic.allow_unknown_attributes || num_valid_keys == data.size
+          unknown_attributes = (data.keys.map(&:to_s) - _attributes.keys.map(&:to_s)).sort
           allowed_attributes = attribute_definitions.keys.map(&:to_s).sort
           message = "Unexpected arguments for #{self.class.name}#initialize: #{unknown_attributes.join(', ')}. " \
             "Only the following arguments are allowed: #{allowed_attributes.join(', ')}. Provided arguments: #{data.inspect}"

data/lib/avromatic/model/configurable.rb

@@ -8,6 +8,17 @@ module Avromatic
     module Configurable
       extend ActiveSupport::Concern
 
+      # Wraps a reference to a field so we can access both the string and symbolized versions of the name
+      # without repeated memory allocations.
+      class FieldReference
+        attr_reader :name, :name_sym
+
+        def initialize(name)
+          @name = -name
+          @name_sym = name.to_sym
+        end
+      end
+
       module ClassMethods
         attr_accessor :config
         delegate :avro_schema, :value_avro_schema, :key_avro_schema, to: :config
@@ -20,6 +31,18 @@ module Avromatic
           @key_avro_field_names ||= key_avro_schema.fields.map(&:name).map(&:to_sym).freeze
         end
 
+        def value_avro_field_references
+          @value_avro_field_references ||= value_avro_schema.fields.map do |field|
+            Avromatic::Model::Configurable::FieldReference.new(field.name)
+          end.freeze
+        end
+
+        def key_avro_field_references
+          @key_avro_field_references ||= key_avro_schema.fields.map do |field|
+            Avromatic::Model::Configurable::FieldReference.new(field.name)
+          end.freeze
+        end
+
         def value_avro_fields_by_name
           @value_avro_fields_by_name ||= mapped_by_name(value_avro_schema)
         end
@@ -43,6 +66,7 @@ module Avromatic
 
       delegate :avro_schema, :value_avro_schema, :key_avro_schema,
                :value_avro_field_names, :key_avro_field_names,
+               :value_avro_field_references, :key_avro_field_references,
                to: :class
     end
   end

data/lib/avromatic/model/messaging_serialization.rb

@@ -48,7 +48,8 @@ module Avromatic
           value_attributes = avro_messaging
             .decode(message_value, schema_name: avro_schema.fullname)
 
-          value_attributes.merge!(key_attributes || {})
+          value_attributes.merge!(key_attributes) if key_attributes
+          value_attributes
         end
       end
 

data/lib/avromatic/model/raw_serialization.rb

@@ -29,34 +29,37 @@ module Avromatic
 
         def value_attributes_for_avro(validate: true)
           if self.class.config.mutable
-            avro_hash(value_avro_field_names, validate: validate)
+            avro_hash(value_avro_field_references, validate: validate)
           else
-            @value_attributes_for_avro ||= avro_hash(value_avro_field_names, validate: validate)
+            @value_attributes_for_avro ||= avro_hash(value_avro_field_references, validate: validate)
           end
         end
 
         def key_attributes_for_avro(validate: true)
-          avro_hash(key_avro_field_names, validate: validate)
+          avro_hash(key_avro_field_references, validate: validate)
         end
 
         def avro_value_datum(validate: true)
           if self.class.config.mutable
-            avro_hash(value_avro_field_names, strict: true, validate: validate)
+            avro_hash(value_avro_field_references, strict: true, validate: validate)
           else
-            @avro_datum ||= avro_hash(value_avro_field_names, strict: true, validate: validate)
+            @avro_datum ||= avro_hash(value_avro_field_references, strict: true, validate: validate)
           end
         end
 
         def avro_key_datum(validate: true)
-          avro_hash(key_avro_field_names, strict: true, validate: validate)
+          avro_hash(key_avro_field_references, strict: true, validate: validate)
         end
 
         private
 
-        def avro_hash(fields, strict: false, validate:)
+        def avro_hash(field_references, strict: false, validate:)
           avro_validate! if validate
-          attributes.slice(*fields).each_with_object(Hash.new) do |(key, value), result|
-            result[key.to_s] = attribute_definitions[key].serialize(value, strict: strict)
+          field_references.each_with_object(Hash.new) do |field_reference, result|
+            next unless _attributes.include?(field_reference.name_sym)
+
+            value = _attributes[field_reference.name_sym]
+            result[field_reference.name] = attribute_definitions[field_reference.name_sym].serialize(value, strict)
           end
         end
 
@@ -78,8 +81,8 @@ module Avromatic
         def avro_raw_decode(key: nil, value:, key_schema: nil, value_schema: nil)
           key_attributes = key && decode_avro_datum(key, key_schema, :key)
           value_attributes = decode_avro_datum(value, value_schema, :value)
-
-          new(value_attributes.merge!(key_attributes || {}))
+          value_attributes.merge!(key_attributes) if key_attributes
+          new(value_attributes)
         end
 
         private

data/lib/avromatic/model/types/abstract_timestamp_type.rb

@@ -38,7 +38,7 @@ module Avromatic
           value.is_a?(::Time) && value.class != ActiveSupport::TimeWithZone && truncated?(value)
         end
 
-        def serialize(value, **)
+        def serialize(value, _strict)
           value
         end
 

data/lib/avromatic/model/types/abstract_type.rb

@@ -31,7 +31,9 @@ module Avromatic
           raise "#{__method__} must be overridden by #{self.class.name}"
         end
 
-        def serialize(_value, **)
+        # Note we use positional args rather than keyword args to reduce
+        # memory allocations
+        def serialize(_value, _strict)
           raise "#{__method__} must be overridden by #{self.class.name}"
         end
 

data/lib/avromatic/model/types/array_type.rb

@@ -40,11 +40,11 @@ module Avromatic
           value.nil? || (value.is_a?(::Array) && value.all? { |element| value_type.coerced?(element) })
         end
 
-        def serialize(value, strict:)
+        def serialize(value, strict)
           if value.nil?
             value
           else
-            value.map { |element| value_type.serialize(element, strict: strict) }
+            value.map { |element| value_type.serialize(element, strict) }
           end
         end
 

data/lib/avromatic/model/types/boolean_type.rb

@@ -30,7 +30,7 @@ module Avromatic
 
         alias_method :coerced?, :coercible?
 
-        def serialize(value, **)
+        def serialize(value, _strict)
           value
         end
 

data/lib/avromatic/model/types/custom_type.rb

@@ -55,7 +55,7 @@ module Avromatic
           false
         end
 
-        def serialize(value, **)
+        def serialize(value, _strict)
           @serializer.call(value)
         end
 

data/lib/avromatic/model/types/date_type.rb

@@ -32,7 +32,7 @@ module Avromatic
 
         alias_method :coerced?, :coercible?
 
-        def serialize(value, **)
+        def serialize(value, _strict)
           value
         end
 

data/lib/avromatic/model/types/enum_type.rb

@@ -47,7 +47,7 @@ module Avromatic
             (input.is_a?(::Symbol) && allowed_values.include?(input.to_s))
         end
 
-        def serialize(value, **)
+        def serialize(value, _strict)
           value
         end
 

data/lib/avromatic/model/types/fixed_type.rb

@@ -36,7 +36,7 @@ module Avromatic
 
         alias_method :coerced?, :coercible?
 
-        def serialize(value, **)
+        def serialize(value, _strict)
           value
         end
 

data/lib/avromatic/model/types/float_type.rb

@@ -39,7 +39,7 @@ module Avromatic
           input.nil? || input.is_a?(::Float)
         end
 
-        def serialize(value, **)
+        def serialize(value, _strict)
           value
         end
 

data/lib/avromatic/model/types/integer_type.rb

@@ -30,7 +30,7 @@ module Avromatic
 
         alias_method :coerced?, :coercible?
 
-        def serialize(value, **)
+        def serialize(value, _strict)
           value
         end
 

data/lib/avromatic/model/types/map_type.rb

@@ -59,12 +59,12 @@ module Avromatic
           end
         end
 
-        def serialize(value, strict:)
+        def serialize(value, strict)
           if value.nil?
             value
           else
             value.each_with_object({}) do |(element_key, element_value), result|
-              result[key_type.serialize(element_key, strict: strict)] = value_type.serialize(element_value, strict: strict)
+              result[key_type.serialize(element_key, strict)] = value_type.serialize(element_value, strict)
             end
           end
         end

data/lib/avromatic/model/types/null_type.rb

@@ -30,7 +30,7 @@ module Avromatic
 
         alias_method :coerced?, :coercible?
 
-        def serialize(_value, **)
+        def serialize(_value, _strict)
           nil
         end
 

data/lib/avromatic/model/types/record_type.rb

@@ -39,13 +39,9 @@ module Avromatic
           value.nil? || value.is_a?(record_class)
         end
 
-        def serialize(value, strict:)
+        def serialize(value, strict)
           if value.nil?
             value
-          elsif !strict && Avromatic.use_custom_datum_writer && Avromatic.use_encoding_providers? && !record_class.config.mutable
-            # n.b. Ideally we'd just return value here instead of wrapping it in a
-            # hash but then we'd have no place to stash the union member index...
-            { Avromatic::IO::ENCODING_PROVIDER => value }
           else
             # This is only used for recursive serialization so validation has already been done
             strict ? value.avro_value_datum(validate: false) : value.value_attributes_for_avro(validate: false)

data/lib/avromatic/model/types/string_type.rb

@@ -39,7 +39,7 @@ module Avromatic
           value.nil? || value.is_a?(::String)
         end
 
-        def serialize(value, **)
+        def serialize(value, _strict)
           value
         end
 

data/lib/avromatic/model/types/timestamp_micros_type.rb

@@ -13,6 +13,10 @@ module Avromatic
           'timestamp-micros'
         end
 
+        def referenced_model_classes
+          EMPTY_ARRAY
+        end
+
         private
 
         def truncated?(value)
@@ -25,10 +29,6 @@ module Avromatic
           # of time zone.
           ::Time.at(input.to_i, input.usec)
         end
-
-        def referenced_model_classes
-          EMPTY_ARRAY
-        end
       end
     end
   end

data/lib/avromatic/model/types/timestamp_millis_type.rb

@@ -13,6 +13,10 @@ module Avromatic
           'timestamp-millis'
         end
 
+        def referenced_model_classes
+          EMPTY_ARRAY
+        end
+
         private
 
         def truncated?(value)
@@ -25,10 +29,6 @@ module Avromatic
           # of time zone.
           ::Time.at(input.to_i, input.usec / 1000 * 1000)
         end
-
-        def referenced_model_classes
-          EMPTY_ARRAY
-        end
       end
     end
   end

data/lib/avromatic/model/types/union_type.rb

@@ -7,7 +7,6 @@ module Avromatic
   module Model
     module Types
       class UnionType < AbstractType
-        MEMBER_INDEX = ::Avromatic::IO::DatumReader::UNION_MEMBER_INDEX
         attr_reader :member_types, :value_classes, :input_classes
 
         def initialize(member_types:)
@@ -24,8 +23,8 @@ module Avromatic
           return input if coerced?(input)
 
           result = nil
-          if input.is_a?(Hash) && input.key?(MEMBER_INDEX)
-            result = member_types[input.delete(MEMBER_INDEX)].coerce(input)
+          if input.is_a?(Avromatic::IO::UnionDatum)
+            result = member_types[input.member_index].coerce(input.datum)
           else
             member_types.find do |member_type|
               result = safe_coerce(member_type, input)
@@ -40,18 +39,22 @@ module Avromatic
         end
 
         def coerced?(value)
+          return false if value.is_a?(Avromatic::IO::UnionDatum)
+
           value.nil? || member_types.any? do |member_type|
             member_type.coerced?(value)
           end
         end
 
         def coercible?(input)
+          return true if value.is_a?(Avromatic::IO::UnionDatum)
+
           coerced?(input) || member_types.any? do |member_type|
             member_type.coercible?(input)
           end
         end
 
-        def serialize(value, strict:)
+        def serialize(value, strict)
           # Avromatic does not treat the null of an optional field as part of the union
           return nil if value.nil?
 
@@ -60,11 +63,11 @@ module Avromatic
             raise ArgumentError.new("Expected #{value.inspect} to be one of #{value_classes.map(&:name)}")
           end
 
-          hash = member_types[member_index].serialize(value, strict: strict)
-          if !strict && Avromatic.use_custom_datum_writer && value.is_a?(Avromatic::Model::Attributes)
-            hash[Avromatic::IO::UNION_MEMBER_INDEX] = member_index
+          serialized_value = member_types[member_index].serialize(value, strict)
+          if !strict && Avromatic.use_custom_datum_writer
+            serialized_value = Avromatic::IO::UnionDatum.new(member_index, serialized_value)
           end
-          hash
+          serialized_value
         end
 
         def referenced_model_classes