avromatic 1.0.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8ef79f75351178c3006ab6c03ed41b05340be9f81acc032d43c977c1d428182b
-  data.tar.gz: 94df5ca22cbf1689f47547347663a6a23e75adc2b3a02b010580267af5319f2a
+  metadata.gz: 25174d8c67bde4e8a9d7a53dc357ed72db2e1faa08bbf8945d1f93dd69c46942
+  data.tar.gz: b0b2fce3ddb92a463fade05c2cb29cdadd60037357432c99ece5f892d3b54f45
 SHA512:
-  metadata.gz: f837a8b95d1328788bbff5b55bd2ef2c19f9ad66416855e0767b196d79cea7b08461049d64dcd8cb93e61418aadf5c248662e54ed4e588d00122ede2157057ab
-  data.tar.gz: 5917d121753d94057e7fb7c9d658f9a59e00d58fb058644762a0a3c8a711049de41e605a969f5d410cc48af58418c7b50f20b39014393b4d10f29ac62fa788b8
+  metadata.gz: 6566f793b850761a3d7dc2fa88b403c20ab8402e57d062322843038b473c7daf98b5e2484107063dbc2e9014919fabe1b5ac2e140c8e78f81a552356cbf8c5a2
+  data.tar.gz: 25071f9751683a41bb23fc7932e8570b663c87e903a4ad5d953da863e92c47f0e464355278ec712af41490b7abdc6ac6f11f004472ef3b802e274c8ddf83f503

data/.rubocop.yml

@@ -2,10 +2,13 @@ inherit_gem:
   salsify_rubocop: conf/rubocop.yml
 
 AllCops:
-  TargetRubyVersion: 2.2
+  TargetRubyVersion: 2.3
 
 Style/MultilineBlockChain:
   Enabled: false
 
 Style/NumericPredicate:
   Enabled: false
+
+Style/FrozenStringLiteralComment:
+  Enabled: true

data/Appraisals

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 appraise 'rails5_0' do
   gem 'avro', '1.8.2'
   gem 'activesupport', '~> 5.0.6'

data/CHANGELOG.md

@@ -1,5 +1,20 @@
 # avromatic changelog
 
+## v2.0.0 (unreleased)
+- Remove [virtus](https://github.com/solnic/virtus) dependency resulting in a 3x performance improvement in model instantation and 1.4x - 2.0x performance improvement in Avro serialization and Avromatic code simplification.
+- Raise `Avromatic::Model::CoercionError` when attribute values can't be coerced to the target type in model constructors and attribute setters. Previously coercion errors weren't detected until Avro serialization or an explicit call to `valid?`.
+- Prevent model instances from being constructed with unknown attributes. Previously unknown attributes were ignored. 
+  This can be disabled by setting `Avromatic.allow_unknown_attributes` to `true`.
+  WARNING: Setting `Avromatic.allow_unknown_attributes` to `true` will result in incorrect union member coercions 
+  if an earlier union member is satisfied by a subset of the latter union member's attributes.
+- Validate required attributes are present when serializing to Avro for better error messages. Explicit 
+  validation can still be done by calling the `valid?` or `invalid?` methods from the 
+  [ActiveModel::Validations](https://edgeapi.rubyonrails.org/classes/ActiveModel/Validations.html) interface
+  but errors will now appear under the `:base` key. Previously these errors were detected late in the Avro serialization process resulting in hard to understand error messages. 
+- Support for custom types in unions with more than one non-null type.
+- Drop support for Ruby < 2.3 and Rails < 5.0.
+- Call `super()` in model constructor making it easier to define class/module hierarchies for models.
+
 ## v1.0.0
 - No changes.
 

data/Gemfile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 source 'https://rubygems.org'
 
 # Specify your gem's dependencies in avromatic.gemspec

data/README.md

@@ -8,6 +8,9 @@
 `Avromatic` generates Ruby models from [Avro](http://avro.apache.org/) schemas
 and provides utilities to encode and decode them.
 
+**This README reflects unreleased changes in Avromatic 2.0. Please see the 
+[1-0-stable](https://github.com/salsify/avromatic/blob/1-0-stable/README.md) branch for the latest stable release.**
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -49,6 +52,10 @@ Avromatic with unreleased Avro features.
   `Avromatic.configure` and during code reloading in Rails applications. This
   option is useful for defining models that will be extended when the load order
   is important.
+* **allow_unknown_attributes**: Optionally allow model constructors to silently
+  ignore unknown attributes. Defaults to `false`. WARNING: Setting this to `true` 
+  will result in incorrect union member coercions if an earlier union member is 
+  satisfied by a subset of the latter union member's attributes.
 
 #### Custom Types
 
@@ -116,6 +123,26 @@ The Avro schema can be specified by name and loaded using the schema store:
 class MyModel
   include Avromatic::Model.build(schema_name :my_model)
 end
+
+# Construct instances by passing in a hash of attributes
+instance = MyModel.new(id: 123, name: 'Tesla Model 3', enabled: true)
+
+# Access attribute values with readers
+instance.name # => "Tesla Model 3"
+
+# Models are immutable by default
+instance.name = 'Tesla Model X' # => NoMethodError (private method `name=' called for #<MyModel:0x00007ff711e64e60>) 
+
+# Booleans can also be accessed by '?' readers that coerce nil to false
+instance.enabled? # => true
+
+# Models implement ===, eql? and hash
+instance == MyModel.new(id: 123, name: 'Tesla Model 3', enabled: true) # => true
+instance.eql?(MyModel.new(id: 123, name: 'Tesla Model 3', enabled: true)) # => true
+instance.hash # => -1279155042741869898
+
+# Retrieve a hash of the model's attributes via to_h, to_hash or attributes
+instance .to_h # => {:id=>123, :name=>"Tesla Model 3", :enabled=>true}
 ```
 
 Or an `Avro::Schema` object can be specified directly:
@@ -126,7 +153,7 @@ class MyModel
 end
 ```
 
-Models are generated as [Virtus](https://github.com/solnic/virtus) value
+Models are generated as immutable value
 objects by default, but can optionally be defined as mutable:
 
 ```ruby
@@ -135,9 +162,8 @@ class MyModel
 end
 ```
 
-`Virtus` attributes are added for each field in the Avro schema
-including any default values defined in the schema. `ActiveModel` validations
-are used to define validations on certain types of fields ([see below](#validations)).
+Generated models include attributes for each field in the Avro schema
+including any default values defined in the schema.
 
 A model may be defined with both a key and a value schema:
 
@@ -176,7 +202,7 @@ MyModel = Avromatic::Model.model(schema_name :my_model)
 #### Experimental: Union Support
 
 Avromatic contains experimental support for unions containing more than one
-non-null member type. This feature is experimental because Virtus attributes
+non-null member type. This feature is experimental because Avromatic
 may attempt to coerce between types too aggressively.
 
 For now, if a union contains [nested models](#nested-models) then it is
@@ -186,7 +212,7 @@ Some combination of the ordering of member types in the union and relying on
 model validation may be required so that the correct member is selected,
 especially when deserializing from Avro.
 
-In the future, the type coercion used in the gem will be replaced to better
+In the future, the type coercion used in the gem will be enhanced to better
 support the union use case.
 
 #### Nested Models
@@ -251,9 +277,6 @@ These customizations are registered on the `Avromatic` module. Once a custom typ
 is registered, it is used for all models with a schema that references that type.
 It is recommended to register types within a block passed to `Avromatic.configure`:
 
-Note: custom types are not currently supported on members of unions with more
-than one non-null type.
-
 ```ruby
 Avromatic.configure do |config|
   config.register_type('com.example.my_string', MyString)
@@ -381,16 +404,31 @@ decoder.decode(model2_message_value)
 # => instance of MyModel2
 ```
 
-### Validations
-
-The following validations are supported:
-
-- The size of the value for a fixed type field.
-- The value for an enum type field is in the declared set of values.
-- Presence of a value for required fields. Empty arrays and maps are considered
-  valid for required fields.
-- Validity of nested records, including records embedded in array, maps, and
-  unions.
+### Validations and Coercions
+
+An exception will be thrown if an attribute value cannot be coerced to the corresponding Avro schema field's type.
+The following coercions are supported:
+
+| Ruby Type | Avro Type |
+| --------- | --------- |
+| String, Symbol | string |
+| Array | array |
+| Hash | map |
+| Integer, Float | int |
+| Integer | long |
+| Float | float |
+| Float | double |
+| String | bytes |
+| Date, Time, DateTime | date |
+| Time, DateTime | timestamp-millis |
+| Time, DateTime | timestamp-micros |
+| TrueClass, FalseClass | boolean |
+| NilClass | null |
+| Hash | record |
+
+Validation of required fields is done automatically when serializing a model to Avro. It can also be done
+explicitly by calling the `valid?` or `invalid?` methods from the 
+[ActiveModel::Validations](https://edgeapi.rubyonrails.org/classes/ActiveModel/Validations.html) interface.
 
 ### Logical Types
 
@@ -418,12 +456,6 @@ Requiring this file configures a RSpec before hook that directs any schema
 registry requests to a fake, in-memory schema registry and rebuilds the
 `Avromatic::Messaging` object for each example.
 
-### Unsupported/Future
-
-The following types/features are not supported for generated models:
-
-- Custom types for members within a union.
-
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/Rakefile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'bundler/gem_tasks'
 require 'rspec/core/rake_task'
 require 'appraisal/task'

data/avromatic.gemspec

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'avromatic/version'
@@ -18,12 +20,14 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
 
-  spec.add_runtime_dependency 'activemodel', '>= 4.1', '< 5.3'
-  spec.add_runtime_dependency 'activesupport', '>= 4.1', '< 5.3'
+  spec.required_ruby_version = '>= 2.3'
+
+  spec.add_runtime_dependency 'activemodel', '>= 5.0', '< 5.3'
+  spec.add_runtime_dependency 'activesupport', '>= 5.0', '< 5.3'
   spec.add_runtime_dependency 'avro', '>= 1.7.7'
   spec.add_runtime_dependency 'avro_schema_registry-client', '>= 0.3.0'
   spec.add_runtime_dependency 'avro_turf'
-  spec.add_runtime_dependency 'virtus'
+  spec.add_runtime_dependency 'ice_nine'
 
   spec.add_development_dependency 'avro-builder', '>= 0.12.0'
   spec.add_development_dependency 'bundler', '~> 1.11'

data/lib/avromatic/io/datum_reader.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # rubocop:disable Style/WhenThen
 module Avromatic
   module IO

data/lib/avromatic/io/datum_writer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Avromatic
   module IO
     # Subclass DatumWriter to use additional information about union member
@@ -9,6 +11,9 @@ module Avromatic
           index_of_schema = datum[Avromatic::IO::UNION_MEMBER_INDEX]
           # Avromatic does not treat the null of an optional field as part of the union
           index_of_schema += 1 if optional
+        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
         else
           index_of_schema = writers_schema.schemas.find_index do |schema|
             Avro::Schema.validate(schema, datum)
@@ -23,7 +28,8 @@ module Avromatic
 
       def write_record(writers_schema, datum, encoder)
         if datum.is_a?(Hash) && datum.key?(Avromatic::IO::ENCODING_PROVIDER)
-          encoder.write(datum[Avromatic::IO::ENCODING_PROVIDER].avro_raw_value)
+          # 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

data/lib/avromatic/io.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 module Avromatic
   module IO
-    UNION_MEMBER_INDEX = '__avromatic_member_index'.freeze
-    ENCODING_PROVIDER = '__avromatic_encoding_provider'.freeze
+    UNION_MEMBER_INDEX = '__avromatic_member_index'
+    ENCODING_PROVIDER = '__avromatic_encoding_provider'
   end
 end
 

data/lib/avromatic/messaging.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'avro_turf/messaging'
 require 'avromatic/io'
 

data/lib/avromatic/model/attributes.rb

@@ -1,7 +1,7 @@
+# frozen_string_literal: true
+
 require 'active_support/core_ext/object/duplicable'
 require 'active_support/time'
-require 'ice_nine/core_ext/object'
-require 'avromatic/model/allowed_type_validator'
 
 module Avromatic
   module Model
@@ -20,14 +20,94 @@ module Avromatic
         end
       end
 
-      def self.first_union_schema(field_type)
-        # TODO: This is a hack until I find a better solution for unions with
-        # Virtus. This only handles a union for an optional field with :null
-        # and one other type.
-        # This hack lives on for now because custom type coercion is not pushed
-        # down into unions. This means that custom types can only be optional
-        # fields, not members of real unions.
-        field_type.schemas.reject { |schema| schema.type_sym == :null }.first
+      class AttributeDefinition
+        attr_reader :name, :type, :field, :default, :owner
+        delegate :serialize, to: :type
+
+        def initialize(owner:, field:, type:)
+          @owner = owner
+          @field = field
+          @type = type
+          @name = field.name.to_sym
+          @default = if field.default == :no_default
+                       nil
+                     elsif field.default.duplicable?
+                       field.default.dup.deep_freeze
+                     else
+                       field.default
+                     end
+        end
+
+        def required?
+          FieldHelper.required?(field)
+        end
+
+        def coerce(input)
+          type.coerce(input)
+        rescue Avromatic::Model::UnknownAttributeError => e
+          raise Avromatic::Model::CoercionError.new("Value for #{owner.name}##{name} could not be coerced to a #{type.name} " \
+            "because the following unexpected attributes were provided: #{e.unknown_attributes.join(', ')}. " \
+            "Only the following attributes are allowed: #{e.allowed_attributes.join(', ')}. " \
+            "Provided argument: #{input.inspect}")
+        rescue StandardError
+          if type.input_classes && type.input_classes.none? { |input_class| input.is_a?(input_class) }
+            raise Avromatic::Model::CoercionError.new("Value for #{owner.name}##{name} could not be coerced to a #{type.name} " \
+              "because a #{input.class.name} was provided but expected a #{type.input_classes.map(&:name).to_sentence(two_words_connector: ' or ', last_word_connector: ', or ')}. " \
+              "Provided argument: #{input.inspect}")
+          elsif input.is_a?(Hash) && type.is_a?(Avromatic::Model::Types::UnionType)
+            raise Avromatic::Model::CoercionError.new("Value for #{owner.name}##{name} could not be coerced to a #{type.name} " \
+              "because no union member type matches the provided attributes: #{input.inspect}")
+          else
+            raise Avromatic::Model::CoercionError.new("Value for #{owner.name}##{name} could not be coerced to a #{type.name}. " \
+              "Provided argument: #{input.inspect}")
+          end
+        end
+      end
+
+      included do
+        class_attribute :attribute_definitions, instance_writer: false
+        self.attribute_definitions = {}
+      end
+
+      def initialize(data = {})
+        super()
+
+        valid_keys = []
+        attribute_definitions.each do |attribute_name, attribute_definition|
+          if data.include?(attribute_name)
+            valid_keys << attribute_name
+            value = data.fetch(attribute_name)
+            _attributes[attribute_name] = attribute_definition.coerce(value)
+          elsif data.include?(attribute_name.to_s)
+            valid_keys << attribute_name
+            value = data[attribute_name.to_s]
+            _attributes[attribute_name] = attribute_definition.coerce(value)
+          elsif !attributes.include?(attribute_name)
+            _attributes[attribute_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
+          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}"
+          raise Avromatic::Model::UnknownAttributeError.new(message, unknown_attributes: unknown_attributes,
+                                                            allowed_attributes: allowed_attributes)
+        end
+      end
+
+      def to_h
+        _attributes.dup
+      end
+
+      alias_method :to_hash, :to_h
+      alias_method :attributes, :to_h
+
+      private
+
+      def _attributes
+        @attributes ||= {}
       end
 
       module ClassMethods
@@ -77,165 +157,39 @@ module Avromatic
           end
 
           schema.fields.each do |field|
-            raise OptionalFieldError.new(field) if !allow_optional && optional?(field)
-
-            field_class = avro_field_class(field.type)
-
-            attribute(field.name,
-                      field_class,
-                      avro_field_options(field, field_class))
-
-            add_validation(field, field_class)
-            add_serializer(field, field_class)
-          end
-        end
+            raise OptionalFieldError.new(field) if !allow_optional && FieldHelper.optional?(field)
 
-        def add_validation(field, field_class)
-          case field.type.type_sym
-          when :enum
-            validates(field.name,
-                      inclusion: { in: Set.new(field.type.symbols.map(&:freeze)).freeze })
-          when :fixed
-            validates(field.name, length: { is: field.type.size })
-          when :record, :array, :map, :union
-            validate_complex(field.name)
-          else
-            add_type_validation(field.name, field_class)
-          end
-
-          add_required_validation(field)
-        end
+            symbolized_field_name = field.name.to_sym
+            attribute_definition = AttributeDefinition.new(
+              owner: self,
+              field: field,
+              type: create_type(field)
+            )
+            attribute_definitions[symbolized_field_name] = attribute_definition
 
-        def add_type_validation(name, field_class)
-          allowed_types = if field_class == Axiom::Types::Boolean
-                            [TrueClass, FalseClass]
-                          elsif field_class < Avromatic::Model::Attribute::AbstractTimestamp
-                            [Time]
-                          else
-                            [field_class]
-                          end
+            define_method(field.name) { _attributes[symbolized_field_name] }
+            define_method("#{field.name}?") { !!_attributes[symbolized_field_name] } if boolean?(field)
 
-          validates(name, allowed_type: allowed_types, allow_blank: true)
-        end
-
-        def add_required_validation(field)
-          if required?(field) && field.default == :no_default
-            case field.type.type_sym
-            when :array, :map, :boolean
-              validates(field.name, exclusion: { in: [nil], message: "can't be nil" })
-            else
-              validates(field.name, presence: true)
+            define_method("#{field.name}=") do |value|
+              _attributes[symbolized_field_name] = attribute_definitions[symbolized_field_name].coerce(value)
             end
-          end
-        end
 
-        # 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
-
-        def avro_field_class(field_type)
-          custom_type = Avromatic.type_registry.fetch(field_type)
-          return custom_type.value_class if custom_type.value_class
-
-          if field_type.respond_to?(:logical_type)
-            value_class = Avromatic::Model::LogicalTypes.value_class(field_type.logical_type)
-            return value_class if value_class
-          end
-
-          case field_type.type_sym
-          when :string, :bytes, :fixed
-            String
-          when :boolean
-            Axiom::Types::Boolean
-          when :int, :long
-            Integer
-          when :float, :double
-            Float
-          when :enum
-            String
-          when :null
-            NilClass
-          when :array
-            Array[avro_field_class(field_type.items)]
-          when :map
-            Hash[String => avro_field_class(field_type.values)]
-          when :union
-            union_field_class(field_type)
-          when :record
-            build_nested_model(field_type)
-          else
-            raise "Unsupported type #{field_type}"
-          end
-        end
-
-        def union_field_class(field_type)
-          null_index = field_type.schemas.index { |schema| schema.type_sym == :null }
-          raise 'a null type in a union must be the first member' if null_index && null_index > 0
-
-          field_classes = field_type.schemas.reject { |schema| schema.type_sym == :null }
-                            .map { |schema| avro_field_class(schema) }
-
-          if field_classes.size == 1
-            field_classes.first
-          else
-            Avromatic::Model::AttributeType::Union[*field_classes]
-          end
-        end
-
-        def avro_field_options(field, field_class)
-          options = {}
-
-          prevent_union_including_custom_type!(field, field_class)
-
-          custom_type = Avromatic.type_registry.fetch(field, field_class)
-          coercer = custom_type.deserializer
-          options[:coercer] = coercer if coercer
-
-          # See: https://github.com/dasch/avro_turf/pull/36
-          if field.default != :no_default
-            options.merge!(default: default_for(field.default), lazy: true)
+            unless config.mutable # rubocop:disable Style/Next
+              private("#{field.name}=")
+              define_method(:clone) { self }
+              define_method(:dup) { self }
+            end
           end
-
-          options
-        end
-
-        def add_serializer(field, field_class)
-          prevent_union_including_custom_type!(field, field_class)
-
-          custom_type = Avromatic.type_registry.fetch(field, field_class)
-          serializer = custom_type.serializer
-
-          avro_serializer[field.name.to_sym] = serializer if serializer
-        end
-
-        def default_for(value)
-          value.duplicable? ? value.dup.deep_freeze : value
         end
 
-        # TODO: the methods below are temporary until support for custom types
-        # as union members are supported.
-        def member_uses_custom_type?(field)
-          field.type.schemas.any? do |klass|
-            Avromatic.type_registry.fetch(klass) != NullCustomType
-          end
+        def boolean?(field)
+          field.type.type_sym == :boolean ||
+            (FieldHelper.optional?(field) && field.type.schemas.last.type_sym == :boolean)
         end
 
-        def prevent_union_including_custom_type!(field, field_class)
-          if field_class.is_a?(Class) &&
-            field_class < Avromatic::Model::AttributeType::Union &&
-            member_uses_custom_type?(field)
-
-            raise 'custom types within unions are currently unsupported'
-          end
+        def create_type(field)
+          Avromatic::Model::Types::TypeFactory.create(schema: field.type, nested_models: nested_models)
         end
-
       end
 
     end

data/lib/avromatic/model/builder.rb

@@ -1,15 +1,15 @@
-require 'virtus'
+# frozen_string_literal: true
+
 require 'active_support/concern'
 require 'active_model'
-require 'avromatic/model/allowed_writer_methods_memoization'
 require 'avromatic/model/configuration'
 require 'avromatic/model/value_object'
 require 'avromatic/model/configurable'
+require 'avromatic/model/field_helper'
 require 'avromatic/model/nested_models'
 require 'avromatic/model/validation'
-require 'avromatic/model/attribute/union'
+require 'avromatic/model/types/type_factory'
 require 'avromatic/model/attributes'
-require 'avromatic/model/attribute/record'
 require 'avromatic/model/raw_serialization'
 require 'avromatic/model/messaging_serialization'
 
@@ -42,9 +42,6 @@ module Avromatic
 
       def inclusions
         [
-          ActiveModel::Validations,
-          config.mutable ? Virtus.model : Virtus.value_object,
-          Avromatic::Model::AllowedWriterMethodsMemoization,
           Avromatic::Model::Configurable,
           Avromatic::Model::NestedModels,
           Avromatic::Model::Validation,

data/lib/avromatic/model/coercion_error.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Avromatic
+  module Model
+    class CoercionError < StandardError
+    end
+  end
+end

data/lib/avromatic/model/configurable.rb

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

data/lib/avromatic/model/configuration.rb

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

data/lib/avromatic/model/{custom_type.rb → custom_type_configuration.rb}

@@ -1,11 +1,11 @@
-require 'avromatic/model/null_custom_type'
+# frozen_string_literal: true
 
 module Avromatic
   module Model
 
     # Instances of this class contains the configuration for custom handling of
     # a named type (record, enum, fixed).
-    class CustomType
+    class CustomTypeConfiguration
 
       attr_accessor :to_avro, :from_avro, :value_class