avromatic 2.2.6 → 3.0.2

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,6 +80,8 @@ module Avromatic
       included do
         class_attribute :attribute_definitions, instance_writer: false
         self.attribute_definitions = {}
+
+        delegate :recursively_immutable?, to: :class
       end
 
       def initialize(data = {})
@@ -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

@@ -19,9 +19,12 @@ module Avromatic
         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
@@ -67,6 +70,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,
+               :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/nested_models.rb

@@ -14,12 +14,14 @@ module Avromatic
         def register!
           return unless key_avro_schema.nil? && value_avro_schema.type_sym == :record
 
+          processed = Set.new
           roots = [self]
           until roots.empty?
             model = roots.shift
-            next if nested_models.registered?(model)
+            # Avoid any nested model dependency cycles by ignoring already processed models
+            next unless processed.add?(model)
 
-            nested_models.register(model)
+            nested_models.ensure_registered_model(model)
             roots.concat(model.referenced_model_classes)
           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,55 +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_references, 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_references, validate: validate)
+            avro_hash(value_avro_field_references)
           end
         end
 
-        def key_attributes_for_avro(validate: true)
-          avro_hash(key_avro_field_references, 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_references, 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_references, 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_references, 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(field_references, strict: false, validate:)
-          avro_validate! if validate
+        def avro_hash(field_references, strict: false)
           field_references.each_with_object(Hash.new) do |field_reference, result|
-            next unless _attributes.include?(field_reference.name_sym)
-
+            attribute_definition = self.class.attribute_definitions[field_reference.name_sym]
             value = _attributes[field_reference.name_sym]
-            result[field_reference.name] = attribute_definitions[field_reference.name_sym].serialize(value, strict)
+
+            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
 
@@ -81,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/record_type.rb

@@ -42,13 +42,10 @@ module Avromatic
         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 }
+          elsif strict
+            value.avro_value_datum
           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)
+            value.value_attributes_for_avro
           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,15 +23,15 @@ 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)
             end
           end
 
-          unless result
+          if result.nil?
             raise ArgumentError.new("Could not coerce '#{input.inspect}' to #{name}")
           end
 
@@ -40,12 +39,16 @@ 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
@@ -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)
-          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