avromatic 2.3.0 → 2.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e695eda252fc8374491c000581104f96383a397a118097e9b9c87b256823b267
-  data.tar.gz: 792f85d1fde7b223491265ff9a82024373063aeb942daa8818510e4fdbfb4d65
+  metadata.gz: a7401c0e72992925f02234f5d3d2ab8e762a36bc62aa25c631569d6f4d9918d2
+  data.tar.gz: f2121b2a62bf60893ea0eb143ed83a142ea069d07839fb8121d0618483b469d5
 SHA512:
-  metadata.gz: e0fbee30489961e56e3ce6a7026beb7e687a38de373c72fd0cc6c39a0afa02ef1618f2c730e4647a3339059591ad2252744a0f1a760a1f5282dafeb0cfd93ff8
-  data.tar.gz: ef315a61ba34cefec8508a20d64eb6eb4fe530837c9ade67ac8a6075e146c3516a9dbc0a9cfc34ec71265b333865f93a4d36c588d9c9703f80b5a455e1bad408
+  metadata.gz: 42be85747686fca4ec66d6e178f7e5aab6d9e9ab88cd4d107ed1c5de8a83017f083a510889ced33a2eb284f45865b3c32b3a9edad200011aed5b17c284f3a593
+  data.tar.gz: be13122bca8693d33e20d1317ae5cd88d8c1c975c08d94ed522d0330d70f202bc43d79d7f2941032bc7540ad83b2d647d3c7d29bb5b72c03a560dfedb85e62f7

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 # avromatic changelog
 
+## v2.4.0
+- Ignore the `validate` argument and always validate during serialization. This
+  argument will be removed in Avromatic 3.0.
+- Optimize model validation during serialization.
+- Don't cache immutable model validation results or serialized Avro attributes if a model has mutable children.
+
 ## v2.3.0
 - Add support for Rails 6.1.
 - Optimize nested model serialization.

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/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
 

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

@@ -42,9 +42,10 @@ module Avromatic
         def serialize(value, strict)
           if value.nil?
             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/validation.rb

@@ -64,8 +64,8 @@ module Avromatic
           end
         end
 
-        unless self.class.config.mutable
-          @missing_attributes = missing_attributes.deep_freeze
+        if recursively_immutable?
+          @missing_attributes = missing_attributes.freeze
         end
 
         missing_attributes

data/lib/avromatic/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Avromatic
-  VERSION = '2.3.0'
+  VERSION = '2.4.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: avromatic
 version: !ruby/object:Gem::Version
-  version: 2.3.0
+  version: 2.4.0
 platform: ruby
 authors:
 - Salsify Engineering
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-12-11 00:00:00.000000000 Z
+date: 2021-01-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel