avromatic 2.2.4 → 3.0.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

@@ -27,7 +27,10 @@ module Avromatic
         def initialize(owner:, field:, type:)
           @owner = owner
           @field = field
+          @required = FieldHelper.required?(field)
+          @nullable = FieldHelper.nullable?(field)
           @type = type
+          @values_immutable = type.referenced_model_classes.all?(&:recursively_immutable?)
           @name = field.name.to_sym
           @name_string = field.name.to_s.dup.freeze
           @setter_name = "#{field.name}=".to_sym
@@ -40,8 +43,16 @@ module Avromatic
                      end
         end
 
+        def nullable?
+          @nullable
+        end
+
         def required?
-          FieldHelper.required?(field)
+          @required
+        end
+
+        def values_immutable?
+          @values_immutable
         end
 
         def coerce(input)
@@ -69,28 +80,30 @@ module Avromatic
       included do
         class_attribute :attribute_definitions, instance_writer: false
         self.attribute_definitions = {}
+
+        delegate :recursively_immutable?, to: :class
       end
 
       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}"
@@ -130,6 +143,12 @@ module Avromatic
           define_avro_attributes(avro_schema, generated_methods_module)
         end
 
+        def recursively_immutable?
+          return @recursively_immutable if defined?(@recursively_immutable)
+
+          @recursively_immutable = immutable? && attribute_definitions.each_value.all?(&:values_immutable?)
+        end
+
         private
 
         def check_for_field_conflicts!
@@ -174,10 +193,10 @@ module Avromatic
             generated_methods_module.send(:define_method, "#{field.name}?") { !!_attributes[symbolized_field_name] } if FieldHelper.boolean?(field)
 
             generated_methods_module.send(:define_method, "#{field.name}=") do |value|
-              _attributes[symbolized_field_name] = attribute_definitions[symbolized_field_name].coerce(value)
+              _attributes[symbolized_field_name] = attribute_definition.coerce(value)
             end
 
-            unless config.mutable # rubocop:disable Style/Next
+            unless mutable? # rubocop:disable Style/Next
               generated_methods_module.send(:private, "#{field.name}=")
               generated_methods_module.send(:define_method, :clone) { self }
               generated_methods_module.send(:define_method, :dup) { self }

data/lib/avromatic/model/configurable.rb

@@ -8,9 +8,23 @@ 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
+
+      included do
+        class_attribute :config, instance_accessor: false, instance_predicate: false
+      end
+
       module ClassMethods
-        attr_accessor :config
-        delegate :avro_schema, :value_avro_schema, :key_avro_schema, to: :config
+        delegate :avro_schema, :value_avro_schema, :key_avro_schema, :mutable?, :immutable?, to: :config
 
         def value_avro_field_names
           @value_avro_field_names ||= value_avro_schema.fields.map(&:name).map(&:to_sym).freeze
@@ -20,6 +34,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 +69,8 @@ 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,
+               :mutable?, :immutable?,
                to: :class
     end
   end

data/lib/avromatic/model/configuration.rb

@@ -8,6 +8,7 @@ module Avromatic
 
       attr_reader :avro_schema, :key_avro_schema, :nested_models, :mutable,
                   :allow_optional_key_fields
+      alias_method :mutable?, :mutable
       delegate :schema_store, to: Avromatic
 
       # Either schema(_name) or value_schema(_name), but not both, must be
@@ -34,6 +35,10 @@ module Avromatic
 
       alias_method :value_avro_schema, :avro_schema
 
+      def immutable?
+        !mutable?
+      end
+
       private
 
       def find_avro_schema(**options)

data/lib/avromatic/model/field_helper.rb

@@ -16,9 +16,13 @@ module Avromatic
         !optional?(field)
       end
 
+      def nullable?(field)
+        optional?(field) || field.type.type_sym == :null
+      end
+
       def boolean?(field)
         field.type.type_sym == :boolean ||
-          (FieldHelper.optional?(field) && field.type.schemas.last.type_sym == :boolean)
+          (optional?(field) && field.type.schemas.last.type_sym == :boolean)
       end
     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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'active_support/deprecation'
+
 module Avromatic
   module Model
 
@@ -11,52 +13,93 @@ module Avromatic
       module Encode
         extend ActiveSupport::Concern
 
+        UNSPECIFIED = Object.new
+
         delegate :datum_writer, :datum_reader, to: :class
         private :datum_writer, :datum_reader
 
-        def avro_raw_value(validate: true)
-          if self.class.config.mutable
-            avro_raw_encode(value_attributes_for_avro(validate: validate), :value)
+        def avro_raw_value(validate: UNSPECIFIED)
+          unless validate == UNSPECIFIED
+            ActiveSupport::Deprecation.warn("The 'validate' argument to #{__method__} is deprecated.")
+          end
+
+          if self.class.recursively_immutable?
+            @avro_raw_value ||= avro_raw_encode(value_attributes_for_avro, :value)
           else
-            @avro_raw_value ||= avro_raw_encode(value_attributes_for_avro(validate: validate), :value)
+            avro_raw_encode(value_attributes_for_avro, :value)
           end
         end
 
-        def avro_raw_key(validate: true)
+        def avro_raw_key(validate: UNSPECIFIED)
+          unless validate == UNSPECIFIED
+            ActiveSupport::Deprecation.warn("The 'validate' argument to #{__method__} is deprecated.")
+          end
+
           raise 'Model has no key schema' unless key_avro_schema
-          avro_raw_encode(key_attributes_for_avro(validate: validate), :key)
+          avro_raw_encode(key_attributes_for_avro, :key)
         end
 
-        def value_attributes_for_avro(validate: true)
-          if self.class.config.mutable
-            avro_hash(value_avro_field_names, validate: validate)
+        def value_attributes_for_avro(validate: UNSPECIFIED)
+          unless validate == UNSPECIFIED
+            ActiveSupport::Deprecation.warn("The 'validate' argument to #{__method__} is deprecated.")
+          end
+
+          if self.class.recursively_immutable?
+            @value_attributes_for_avro ||= avro_hash(value_avro_field_references)
           else
-            @value_attributes_for_avro ||= avro_hash(value_avro_field_names, validate: validate)
+            avro_hash(value_avro_field_references)
           end
         end
 
-        def key_attributes_for_avro(validate: true)
-          avro_hash(key_avro_field_names, validate: validate)
+        def key_attributes_for_avro(validate: UNSPECIFIED)
+          unless validate == UNSPECIFIED
+            ActiveSupport::Deprecation.warn("The 'validate' argument to #{__method__} is deprecated.")
+          end
+
+          avro_hash(key_avro_field_references)
         end
 
-        def avro_value_datum(validate: true)
-          if self.class.config.mutable
-            avro_hash(value_avro_field_names, strict: true, validate: validate)
+        def avro_value_datum(validate: UNSPECIFIED)
+          unless validate == UNSPECIFIED
+            ActiveSupport::Deprecation.warn("The 'validate' argument to #{__method__} is deprecated.")
+          end
+
+          if self.class.recursively_immutable?
+            @avro_value_datum ||= avro_hash(value_avro_field_references, strict: true)
           else
-            @avro_datum ||= avro_hash(value_avro_field_names, strict: true, validate: validate)
+            avro_hash(value_avro_field_references, strict: true)
           end
         end
 
-        def avro_key_datum(validate: true)
-          avro_hash(key_avro_field_names, strict: true, validate: validate)
+        def avro_key_datum(validate: UNSPECIFIED)
+          unless validate == UNSPECIFIED
+            ActiveSupport::Deprecation.warn("The 'validate' argument to #{__method__} is deprecated.")
+          end
+
+          avro_hash(key_avro_field_references, strict: true)
         end
 
         private
 
-        def avro_hash(fields, 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)
+        def avro_hash(field_references, strict: false)
+          field_references.each_with_object(Hash.new) do |field_reference, result|
+            attribute_definition = self.class.attribute_definitions[field_reference.name_sym]
+            value = _attributes[field_reference.name_sym]
+
+            if value.nil? && !attribute_definition.nullable?
+              # We're missing a required attribute so perform an explicit validation to generate
+              # a more complete error message
+              avro_validate!
+            elsif _attributes.include?(field_reference.name_sym)
+              begin
+                result[field_reference.name] = attribute_definition.serialize(value, strict)
+              rescue Avromatic::Model::ValidationError
+                # Perform an explicit validation to generate a more complete error message
+                avro_validate!
+                # We should never get here but just in case...
+                raise
+              end
+            end
           end
         end
 
@@ -78,8 +121,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