avromatic 1.0.0 → 2.0.0

data/lib/avromatic/model/{type_registry.rb → custom_type_registry.rb}

@@ -1,8 +1,10 @@
-require 'avromatic/model/custom_type'
+# frozen_string_literal: true
+
+require 'avromatic/model/custom_type_configuration'
 
 module Avromatic
   module Model
-    class TypeRegistry
+    class CustomTypeRegistry
 
       delegate :clear, to: :custom_types
 
@@ -16,35 +18,30 @@ module Avromatic
       # @block If a block is specified then the CustomType is yielded for
       #   additional configuration.
       def register_type(fullname, value_class = nil)
-        custom_types[fullname.to_s] = Avromatic::Model::CustomType.new(value_class).tap do |type|
+        custom_types[fullname.to_s] = Avromatic::Model::CustomTypeConfiguration.new(value_class).tap do |type|
           yield(type) if block_given?
         end
       end
 
       # @object [Avro::Schema] Custom type may be fetched based on a Avro field
-      #   or schema. If there is no custom type, then NullCustomType is returned.
-      # @field_class [Object] Value class that has been determined for a field.
-      def fetch(object, field_class = nil)
+      #   or schema.
+      def registered?(object)
         field_type = object.is_a?(Avro::Schema::Field) ? object.type : object
+        custom_types.include?(field_type.fullname) if field_type.is_a?(Avro::Schema::NamedSchema)
+      end
 
-        if field_class && field_type.type_sym == :union && !union_attribute?(field_class)
-          field_type = Avromatic::Model::Attributes.first_union_schema(field_type)
-        end
-
+      # @object [Avro::Schema] Custom type may be fetched based on a Avro field
+      #   or schema. If there is no custom type, then an exception will be thrown.
+      # @field_class [Object] Value class that has been determined for a field.
+      def fetch(object)
+        field_type = object.is_a?(Avro::Schema::Field) ? object.type : object
         fullname = field_type.fullname if field_type.is_a?(Avro::Schema::NamedSchema)
-        custom_types.fetch(fullname, NullCustomType)
+        custom_types.fetch(fullname)
       end
 
       private
 
       attr_reader :custom_types
-
-      # The type that is used to define a Virtus attribute may be a Class or
-      # for an array or map field it may be an instance of an Array or Hash.
-      # This method safely checks if a Union class has been selected.
-      def union_attribute?(attribute_type)
-        attribute_type.is_a?(Class) && attribute_type < Avromatic::Model::AttributeType::Union
-      end
     end
   end
 end

data/lib/avromatic/model/field_helper.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Avromatic
+  module Model
+    module FieldHelper
+      extend self
+
+      # An optional field is represented as a union where the first member
+      # is null.
+      def optional?(field)
+        field.type.type_sym == :union &&
+          field.type.schemas.first.type_sym == :null
+      end
+
+      def required?(field)
+        !optional?(field)
+      end
+    end
+  end
+end

data/lib/avromatic/model/message_decoder.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Avromatic
   module Model
 

data/lib/avromatic/model/messaging_serialization.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Avromatic
   module Model
 

data/lib/avromatic/model/nested_models.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'active_support/inflector/methods'
 
 module Avromatic
@@ -8,26 +10,9 @@ module Avromatic
       extend ActiveSupport::Concern
 
       module ClassMethods
-        def build_nested_model(schema)
-          fullname = nested_models.remove_prefix(schema.fullname)
-
-          if nested_models.registered?(fullname)
-            nested_models[fullname]
-          else
-            Avromatic::Model.model(schema: schema,
-                                   nested_models: nested_models)
-          end
-        end
-
         # Register this model if it can be used as a nested model.
         def register!
           if key_avro_schema.nil? && value_avro_schema.type_sym == :record
-            # Register the generated model with Axiom to prevent it being
-            # treated as a BasicObject.
-            # See https://github.com/solnic/virtus/issues/284#issuecomment-56405137
-            nested_model = self
-            Axiom::Types::Object.new { primitive(nested_model) }
-
             nested_models.register(self)
           end
         end

data/lib/avromatic/model/raw_serialization.rb

@@ -1,4 +1,4 @@
-require 'avromatic/model/passthrough_serializer'
+# frozen_string_literal: true
 
 module Avromatic
   module Model
@@ -11,108 +11,52 @@ module Avromatic
       module Encode
         extend ActiveSupport::Concern
 
-        delegate :avro_serializer, :datum_writer, :datum_reader, :attribute_set,
-                 to: :class
-        private :avro_serializer, :datum_writer, :datum_reader
+        delegate :datum_writer, :datum_reader, to: :class
+        private :datum_writer, :datum_reader
 
-        EMPTY_ARRAY = [].freeze
-
-        included do
-          @attribute_member_types = {}
-        end
-
-        module ClassMethods
-          def recursive_serialize(value, name: nil, member_types: nil, strict: false) # rubocop:disable Lint/ShadowedArgument
-            member_types = attribute_member_types(name) if name
-            member_types ||= EMPTY_ARRAY
-
-            if value.is_a?(Avromatic::Model::Attributes)
-              hash = strict ? value.avro_value_datum : value.value_attributes_for_avro
-              if !strict && Avromatic.use_custom_datum_writer
-                if Avromatic.use_encoding_providers? && !value.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...
-                  hash = { Avromatic::IO::ENCODING_PROVIDER => value }
-                end
-                member_index = member_types.index(value.class) if member_types.any?
-                hash[Avromatic::IO::UNION_MEMBER_INDEX] = member_index if member_index
-              end
-              hash
-            elsif value.is_a?(Array)
-              value.map { |v| recursive_serialize(v, member_types: member_types, strict: strict) }
-            elsif value.is_a?(Hash)
-              value.each_with_object({}) do |(k, v), map|
-                map[k] = recursive_serialize(v, member_types: member_types, strict: strict)
-              end
-            else
-              avro_serializer[name].call(value)
-            end
-          end
-
-          private
-
-          def attribute_member_types(name)
-            @attribute_member_types.fetch(name) do
-              member_types = nil
-              attribute = attribute_set[name] if name
-              if attribute
-                if attribute.primitive == Array &&
-                  attribute.member_type.is_a?(Avromatic::Model::Attribute::Union)
-                  member_types = attribute.member_type.primitive.types
-                elsif attribute.primitive == Hash &&
-                  attribute.value_type.is_a?(Avromatic::Model::Attribute::Union)
-                  member_types = attribute.value_type.primitive.types
-                elsif attribute.options[:primitive] == Avromatic::Model::AttributeType::Union
-                  member_types = attribute.primitive.types
-                end
-              end
-              @attribute_member_types[name] = member_types
-            end
-          end
-        end
-
-        def avro_raw_value
+        def avro_raw_value(validate: true)
           if self.class.config.mutable
-            avro_raw_encode(value_attributes_for_avro, :value)
+            avro_raw_encode(value_attributes_for_avro(validate: validate), :value)
           else
-            @avro_raw_value ||= avro_raw_encode(value_attributes_for_avro, :value)
+            @avro_raw_value ||= avro_raw_encode(value_attributes_for_avro(validate: validate), :value)
           end
         end
 
-        def avro_raw_key
+        def avro_raw_key(validate: true)
           raise 'Model has no key schema' unless key_avro_schema
-          avro_raw_encode(key_attributes_for_avro, :key)
+          avro_raw_encode(key_attributes_for_avro(validate: validate), :key)
         end
 
-        def value_attributes_for_avro
+        def value_attributes_for_avro(validate: true)
           if self.class.config.mutable
-            avro_hash(value_avro_field_names)
+            avro_hash(value_avro_field_names, validate: validate)
           else
-            @value_attributes_for_avro ||= avro_hash(value_avro_field_names)
+            @value_attributes_for_avro ||= avro_hash(value_avro_field_names, validate: validate)
           end
         end
 
-        def key_attributes_for_avro
-          avro_hash(key_avro_field_names)
+        def key_attributes_for_avro(validate: true)
+          avro_hash(key_avro_field_names, validate: validate)
         end
 
-        def avro_value_datum
+        def avro_value_datum(validate: true)
           if self.class.config.mutable
-            avro_hash(value_avro_field_names, strict: true)
+            avro_hash(value_avro_field_names, strict: true, validate: validate)
           else
-            @avro_datum ||= avro_hash(value_avro_field_names, strict: true)
+            @avro_datum ||= avro_hash(value_avro_field_names, strict: true, validate: validate)
           end
         end
 
-        def avro_key_datum
-          avro_hash(key_avro_field_names, strict: true)
+        def avro_key_datum(validate: true)
+          avro_hash(key_avro_field_names, strict: true, validate: validate)
         end
 
         private
 
-        def avro_hash(fields, strict: false)
+        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] = self.class.recursive_serialize(value, name: key, strict: strict)
+            result[key.to_s] = attribute_definitions[key].serialize(value, strict: strict)
           end
         end
 
@@ -161,13 +105,6 @@ module Avromatic
           Avromatic.use_custom_datum_writer ? Avromatic::IO::DatumWriter : Avro::IO::DatumWriter
         end
 
-        # Store a hash of Procs by field name (as a symbol) to convert
-        # the value before Avro serialization.
-        # Returns the default PassthroughSerializer if a key is not present.
-        def avro_serializer
-          @avro_serializer ||= Hash.new(PassthroughSerializer)
-        end
-
         def datum_writer
           @datum_writer ||= begin
                               hash = { value: datum_writer_class.new(value_avro_schema) }

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'active_support/time_with_zone'
+
+module Avromatic
+  module Model
+    module Types
+      class AbstractTimestampType < AbstractType
+        VALUE_CLASSES = [::Time].freeze
+        INPUT_CLASSES = [::Time, ::DateTime, ::ActiveSupport::TimeWithZone].freeze
+
+        def value_classes
+          VALUE_CLASSES
+        end
+
+        def input_classes
+          INPUT_CLASSES
+        end
+
+        def coerce(input)
+          if input.nil? || coerced?(input)
+            input
+          elsif input.is_a?(::Time) || input.is_a?(::DateTime)
+            coerce_time(input)
+          else
+            raise ArgumentError.new("Could not coerce '#{input.inspect}' to #{name}")
+          end
+        end
+
+        def coercible?(input)
+          input.nil? || input.is_a?(::Time) || input.is_a?(::DateTime)
+        end
+
+        def coerced?(value)
+          # ActiveSupport::TimeWithZone overrides is_a? is to make it look like a Time
+          # even though it's not which can lead to unexpected behavior if we don't force
+          # a coercion
+          value.is_a?(::Time) && value.class != ActiveSupport::TimeWithZone && truncated?(value)
+        end
+
+        def serialize(value, **)
+          value
+        end
+
+        private
+
+        def truncated?(_value)
+          raise "#{__method__} must be overridden by #{self.class.name}"
+        end
+
+        def coerce_time(_input)
+          raise "#{__method__} must be overridden by #{self.class.name}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Avromatic
+  module Model
+    module Types
+      class AbstractType
+        def value_classes
+          raise "#{__method__} must be overridden by #{self.class.name}"
+        end
+
+        def input_classes
+          value_classes
+        end
+
+        def name
+          raise "#{__method__} must be overridden by #{self.class.name}"
+        end
+
+        def coerce(_input)
+          raise "#{__method__} must be overridden by #{self.class.name}"
+        end
+
+        def coercible?(_input)
+          raise "#{__method__} must be overridden by #{self.class.name}"
+        end
+
+        def coerced?(_value)
+          raise "#{__method__} must be overridden by #{self.class.name}"
+        end
+
+        def serialize(_value, **)
+          raise "#{__method__} must be overridden by #{self.class.name}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'avromatic/model/types/abstract_type'
+
+module Avromatic
+  module Model
+    module Types
+      class ArrayType < AbstractType
+        VALUE_CLASSES = [::Array].freeze
+
+        attr_reader :value_type
+
+        def initialize(value_type:)
+          @value_type = value_type
+        end
+
+        def value_classes
+          VALUE_CLASSES
+        end
+
+        def name
+          "array[#{value_type.name}]"
+        end
+
+        def coerce(input)
+          if input.nil?
+            input
+          elsif input.is_a?(::Array)
+            input.map { |element_input| value_type.coerce(element_input) }
+          else
+            raise ArgumentError.new("Could not coerce '#{input.inspect}' to #{name}")
+          end
+        end
+
+        def coercible?(input)
+          input.nil? || (input.is_a?(::Array) && input.all? { |element_input| value_type.coercible?(element_input) })
+        end
+
+        def coerced?(value)
+          value.nil? || (value.is_a?(::Array) && value.all? { |element| value_type.coerced?(element) })
+        end
+
+        def serialize(value, strict:)
+          if value.nil?
+            value
+          else
+            value.map { |element| value_type.serialize(element, strict: strict) }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'avromatic/model/types/abstract_type'
+
+module Avromatic
+  module Model
+    module Types
+      class BooleanType < AbstractType
+        VALUE_CLASSES = [::TrueClass, ::FalseClass].freeze
+
+        def value_classes
+          VALUE_CLASSES
+        end
+
+        def name
+          'boolean'
+        end
+
+        def coerce(input)
+          if coercible?(input)
+            input
+          else
+            raise ArgumentError.new("Could not coerce '#{input.inspect}' to #{name}")
+          end
+        end
+
+        def coercible?(input)
+          input.nil? || input.is_a?(::TrueClass) || input.is_a?(::FalseClass)
+        end
+
+        alias_method :coerced?, :coercible?
+
+        def serialize(value, **)
+          value
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'avromatic/model/types/abstract_type'
+
+module Avromatic
+  module Model
+    module Types
+      class CustomType < AbstractType
+        IDENTITY_PROC = Proc.new { |value| value }
+
+        attr_reader :custom_type_configuration, :value_classes, :default_type
+
+        def initialize(custom_type_configuration:, default_type:)
+          @custom_type_configuration = custom_type_configuration
+          @default_type = default_type
+          @deserializer = custom_type_configuration.deserializer || IDENTITY_PROC
+          @serializer = custom_type_configuration.serializer || IDENTITY_PROC
+          @value_classes = if custom_type_configuration.value_class
+                             [custom_type_configuration.value_class].freeze
+                           else
+                             default_type.value_classes
+                           end
+        end
+
+        def input_classes
+          # We don't know the valid input classes for a custom type
+        end
+
+        def name
+          custom_type_configuration.value_class ? custom_type_configuration.value_class.name.to_s.freeze : default_type.name
+        end
+
+        def coerce(input)
+          if input.nil?
+            input
+          else
+            @deserializer.call(input)
+          end
+        rescue StandardError => e
+          # TODO: Don't swallow this
+          raise ArgumentError.new("Could not coerce '#{input.inspect}' to #{name}: #{e.message}")
+        end
+
+        def coercible?(input)
+          # TODO: Delegate this to optional configuration
+          input.nil? || !coerce(input).nil?
+        rescue ArgumentError
+          false
+        end
+
+        def coerced?(value)
+          # TODO: Delegate this to optional configuration
+          coerce(value) == value
+        rescue ArgumentError
+          false
+        end
+
+        def serialize(value, **)
+          @serializer.call(value)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'avromatic/model/types/abstract_type'
+
+module Avromatic
+  module Model
+    module Types
+      class DateType < AbstractType
+        VALUE_CLASSES = [::Date].freeze
+
+        def value_classes
+          VALUE_CLASSES
+        end
+
+        def name
+          'date'
+        end
+
+        def coerce(input)
+          if input.is_a?(::Time) || input.is_a?(::DateTime)
+            ::Date.new(input.year, input.month, input.day)
+          elsif input.nil? || input.is_a?(::Date)
+            input
+          else
+            raise ArgumentError.new("Could not coerce '#{input.inspect}' to #{name}")
+          end
+        end
+
+        def coercible?(input)
+          input.nil? || input.is_a?(::Date) || input.is_a?(::Time)
+        end
+
+        alias_method :coerced?, :coercible?
+
+        def serialize(value, **)
+          value
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'avromatic/model/types/abstract_type'
+
+module Avromatic
+  module Model
+    module Types
+      class EnumType < AbstractType
+        VALUE_CLASSES = [::String].freeze
+        INPUT_CLASSES = [::String, ::Symbol].freeze
+
+        attr_reader :allowed_values
+
+        def initialize(allowed_values)
+          @allowed_values = allowed_values.to_set
+        end
+
+        def name
+          "enum#{allowed_values.to_a}"
+        end
+
+        def value_classes
+          VALUE_CLASSES
+        end
+
+        def input_classes
+          INPUT_CLASSES
+        end
+
+        def coerce(input)
+          if input.nil?
+            input
+          elsif coercible?(input)
+            input.to_s
+          else
+            raise ArgumentError.new("Could not coerce '#{input.inspect}' to #{name}")
+          end
+        end
+
+        def coerced?(input)
+          input.nil? || (input.is_a?(::String) && allowed_values.include?(input))
+        end
+
+        def coercible?(input)
+          input.nil? ||
+            (input.is_a?(::String) && allowed_values.include?(input)) ||
+            (input.is_a?(::Symbol) && allowed_values.include?(input.to_s))
+        end
+
+        def serialize(value, **)
+          value
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'avromatic/model/types/abstract_type'
+
+module Avromatic
+  module Model
+    module Types
+      class FixedType < AbstractType
+        VALUE_CLASSES = [::String].freeze
+
+        attr_reader :size
+
+        def initialize(size)
+          @size = size
+        end
+
+        def name
+          "fixed(#{size})"
+        end
+
+        def value_classes
+          VALUE_CLASSES
+        end
+
+        def coerce(input)
+          if coercible?(input)
+            input
+          else
+            raise ArgumentError.new("Could not coerce '#{input.inspect}' to #{name}")
+          end
+        end
+
+        def coercible?(input)
+          input.nil? || (input.is_a?(::String) && input.length == size)
+        end
+
+        alias_method :coerced?, :coercible?
+
+        def serialize(value, **)
+          value
+        end
+      end
+    end
+  end
+end