avromatic 1.0.0 → 2.0.0

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'avromatic/model/types/abstract_type'
+
+module Avromatic
+  module Model
+    module Types
+      class FloatType < AbstractType
+        VALUE_CLASSES = [::Float].freeze
+        INPUT_CLASSES = [::Float, ::Integer].freeze
+
+        def value_classes
+          VALUE_CLASSES
+        end
+
+        def input_classes
+          INPUT_CLASSES
+        end
+
+        def name
+          'float'
+        end
+
+        def coerce(input)
+          if input.nil? || input.is_a?(::Float)
+            input
+          elsif input.is_a?(::Integer)
+            input.to_f
+          else
+            raise ArgumentError.new("Could not coerce '#{input.inspect}' to #{name}")
+          end
+        end
+
+        def coercible?(input)
+          input.nil? || input.is_a?(::Float) || input.is_a?(::Integer)
+        end
+
+        def coerced?(input)
+          input.nil? || input.is_a?(::Float)
+        end
+
+        def serialize(value, **)
+          value
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require 'avromatic/model/types/abstract_type'
+
+module Avromatic
+  module Model
+    module Types
+      class MapType < AbstractType
+        VALUE_CLASSES = [::Hash].freeze
+
+        attr_reader :value_type, :key_type
+
+        def initialize(key_type:, value_type:)
+          @key_type = key_type
+          @value_type = value_type
+        end
+
+        def name
+          "map[#{key_type.name} => #{value_type.name}]"
+        end
+
+        def value_classes
+          VALUE_CLASSES
+        end
+
+        def coerce(input)
+          if input.nil?
+            input
+          elsif input.is_a?(::Hash)
+            input.each_with_object({}) do |(key_input, value_input), result|
+              result[key_type.coerce(key_input)] = value_type.coerce(value_input)
+            end
+          else
+            raise ArgumentError.new("Could not coerce '#{input.inspect}' to #{name}")
+          end
+        end
+
+        def coercible?(input)
+          if input.nil?
+            true
+          elsif input.is_a?(Hash)
+            input.all? do |key_input, value_input|
+              key_type.coercible?(key_input) && value_type.coercible?(value_input)
+            end
+          else
+            false
+          end
+        end
+
+        def coerced?(value)
+          if value.nil?
+            true
+          elsif value.is_a?(Hash)
+            value.all? do |element_key, element_value|
+              key_type.coerced?(element_key) && value_type.coerced?(element_value)
+            end
+          else
+            false
+          end
+        end
+
+        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)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'avromatic/model/types/abstract_type'
+
+module Avromatic
+  module Model
+    module Types
+      class RecordType < AbstractType
+        attr_reader :record_class, :value_classes, :input_classes
+
+        def initialize(record_class:)
+          @record_class = record_class
+          @value_classes = [record_class].freeze
+          @input_classes = [record_class, Hash].freeze
+        end
+
+        def name
+          record_class.name.to_s.freeze
+        end
+
+        def coerce(input)
+          if input.nil? || input.is_a?(record_class)
+            input
+          elsif input.is_a?(Hash)
+            record_class.new(input)
+          else
+            raise ArgumentError.new("Could not coerce '#{input.inspect}' to #{name}")
+          end
+        end
+
+        def coercible?(input)
+          # TODO: Is there a better way to figure this out?
+          input.nil? || input.is_a?(record_class) || coerce(input).valid?
+        rescue StandardError
+          false
+        end
+
+        def coerced?(value)
+          value.nil? || value.is_a?(record_class)
+        end
+
+        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)
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'avromatic/model/types/abstract_timestamp_type'
+
+module Avromatic
+  module Model
+    module Types
+
+      # This subclass is used to truncate timestamp values to microseconds.
+      class TimestampMicrosType < Avromatic::Model::Types::AbstractTimestampType
+
+        def name
+          'timestamp-micros'
+        end
+
+        private
+
+        def truncated?(value)
+          value.nsec % 1000 == 0
+        end
+
+        def coerce_time(input)
+          # value is coerced to a local Time
+          # The Avro representation of a timestamp is Epoch seconds, independent
+          # of time zone.
+          ::Time.at(input.to_i, input.usec)
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'avromatic/model/types/abstract_timestamp_type'
+
+module Avromatic
+  module Model
+    module Types
+
+      # This subclass is used to truncate timestamp values to milliseconds.
+      class TimestampMillisType < Avromatic::Model::Types::AbstractTimestampType
+
+        def name
+          'timestamp-millis'
+        end
+
+        private
+
+        def truncated?(value)
+          value.usec % 1000 == 0
+        end
+
+        def coerce_time(input)
+          # value is coerced to a local Time
+          # The Avro representation of a timestamp is Epoch seconds, independent
+          # of time zone.
+          ::Time.at(input.to_i, input.usec / 1000 * 1000)
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require 'avromatic/model/types/array_type'
+require 'avromatic/model/types/boolean_type'
+require 'avromatic/model/types/custom_type'
+require 'avromatic/model/types/date_type'
+require 'avromatic/model/types/enum_type'
+require 'avromatic/model/types/fixed_type'
+require 'avromatic/model/types/float_type'
+require 'avromatic/model/types/integer_type'
+require 'avromatic/model/types/map_type'
+require 'avromatic/model/types/null_type'
+require 'avromatic/model/types/record_type'
+require 'avromatic/model/types/string_type'
+require 'avromatic/model/types/timestamp_micros_type'
+require 'avromatic/model/types/timestamp_millis_type'
+require 'avromatic/model/types/union_type'
+
+module Avromatic
+  module Model
+    module Types
+      module TypeFactory
+        extend self
+
+        SINGLETON_TYPES = {
+          'date' => Avromatic::Model::Types::DateType.new,
+          'timestamp-micros' => Avromatic::Model::Types::TimestampMicrosType.new,
+          'timestamp-millis' => Avromatic::Model::Types::TimestampMillisType.new,
+          'string' => Avromatic::Model::Types::StringType.new,
+          'bytes' => Avromatic::Model::Types::StringType.new,
+          'boolean' => Avromatic::Model::Types::BooleanType.new,
+          'int' => Avromatic::Model::Types::IntegerType.new,
+          'long' => Avromatic::Model::Types::IntegerType.new,
+          'float' => Avromatic::Model::Types::FloatType.new,
+          'double' => Avromatic::Model::Types::FloatType.new,
+          'null' => Avromatic::Model::Types::NullType.new
+        }.deep_freeze
+
+        def create(schema:, nested_models:, use_custom_types: true)
+          if use_custom_types && Avromatic.custom_type_registry.registered?(schema)
+            custom_type_configuration = Avromatic.custom_type_registry.fetch(schema)
+            default_type = create(
+              schema: schema,
+              nested_models: nested_models,
+              use_custom_types: false
+            )
+            Avromatic::Model::Types::CustomType.new(
+              custom_type_configuration: custom_type_configuration,
+              default_type: default_type
+            )
+          elsif schema.respond_to?(:logical_type) && SINGLETON_TYPES.include?(schema.logical_type)
+            SINGLETON_TYPES.fetch(schema.logical_type)
+          elsif SINGLETON_TYPES.include?(schema.type)
+            SINGLETON_TYPES.fetch(schema.type)
+          else
+            case schema.type_sym
+            when :fixed
+              Avromatic::Model::Types::FixedType.new(schema.size)
+            when :enum
+              Avromatic::Model::Types::EnumType.new(schema.symbols)
+            when :array
+              value_type = create(schema: schema.items, nested_models: nested_models, use_custom_types: use_custom_types)
+              Avromatic::Model::Types::ArrayType.new(value_type: value_type)
+            when :map
+              value_type = create(schema: schema.values, nested_models: nested_models, use_custom_types: use_custom_types)
+              Avromatic::Model::Types::MapType.new(
+                key_type: Avromatic::Model::Types::StringType.new,
+                value_type: value_type
+              )
+            when :union
+              null_index = schema.schemas.index { |member_schema| member_schema.type_sym == :null }
+              raise 'a null type in a union must be the first member' if null_index && null_index > 0
+
+              member_schemas = schema.schemas.reject { |member_schema| member_schema.type_sym == :null }
+              if member_schemas.size == 1
+                create(schema: member_schemas.first, nested_models: nested_models)
+              else
+                member_types = member_schemas.map do |member_schema|
+                  create(schema: member_schema, nested_models: nested_models, use_custom_types: use_custom_types)
+                end
+                Avromatic::Model::Types::UnionType.new(member_types: member_types)
+              end
+            when :record
+              record_class = build_nested_model(schema: schema, nested_models: nested_models)
+              Avromatic::Model::Types::RecordType.new(record_class: record_class)
+            else
+              raise ArgumentError.new("Unsupported type #{schema.type_sym}")
+            end
+          end
+        end
+
+        private
+
+        def build_nested_model(schema:, nested_models:)
+          fullname = nested_models.remove_prefix(schema.fullname)
+
+          if nested_models.registered?(fullname)
+            nested_model = nested_models[fullname]
+            unless schema_fingerprint(schema) == schema_fingerprint(nested_model.avro_schema)
+              raise "The #{nested_model.name} model is already registered with an incompatible version of the #{schema.fullname} schema"
+            end
+            nested_model
+          else
+            Avromatic::Model.model(schema: schema, nested_models: nested_models)
+          end
+        end
+
+        def schema_fingerprint(schema)
+          if schema.respond_to?(:sha256_resolution_fingerprint)
+            schema.sha256_resolution_fingerprint
+          else
+            schema.sha256_fingerprint
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require 'avromatic/io'
+require 'avromatic/model/types/abstract_type'
+
+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:)
+          @member_types = member_types
+          @value_classes = member_types.flat_map(&:value_classes)
+          @input_classes = member_types.flat_map(&:input_classes).uniq
+        end
+
+        def name
+          "union[#{member_types.map(&:name).join(', ')}]"
+        end
+
+        def coerce(input)
+          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)
+          else
+            member_types.find do |member_type|
+              result = safe_coerce(member_type, input)
+            end
+          end
+
+          unless result
+            raise ArgumentError.new("Could not coerce '#{input.inspect}' to #{name}")
+          end
+
+          result
+        end
+
+        def coerced?(value)
+          value.nil? || member_types.any? do |member_type|
+            member_type.coerced?(value)
+          end
+        end
+
+        def coercible?(input)
+          coerced?(input) || member_types.any? do |member_type|
+            member_type.coercible?(input)
+          end
+        end
+
+        def serialize(value, strict:)
+          # Avromatic does not treat the null of an optional field as part of the union
+          return nil if value.nil?
+
+          member_index = find_index(value)
+          if member_index.nil?
+            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
+          end
+          hash
+        end
+
+        private
+
+        def find_index(value)
+          # TODO: Cache this?
+          member_types.find_index do |member_type|
+            member_type.value_classes.any? { |value_class| value.is_a?(value_class) }
+          end
+        end
+
+        def safe_coerce(member_type, input)
+          member_type.coerce(input) if member_type.coercible?(input)
+        rescue StandardError
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/avromatic/model/unknown_attribute_error.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Avromatic
+  module Model
+    class UnknownAttributeError < StandardError
+      attr_reader :unknown_attributes, :allowed_attributes
+
+      def initialize(message, unknown_attributes:, allowed_attributes:)
+        super(message)
+        @unknown_attributes = unknown_attributes
+        @allowed_attributes = allowed_attributes
+      end
+    end
+  end
+end