avromatic 0.8.0 → 0.9.0.rc0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c5cf8d1ba64c3de84625325553fbeeff017e3ac7
-  data.tar.gz: f536b77ce377759a8f70f7ba3d9d0ea4cb796815
+  metadata.gz: 1a36670183dc6e3348395dcc336222da9ac1bd00
+  data.tar.gz: b37d41366b6737fb4aa7d4793128c13d90860920
 SHA512:
-  metadata.gz: 9241a4262287eda4cadfb2f636b3ee74c655863ccab6b779c0a6c28f12c7cce84cc3fcddc6bbdf7b8f3ce817b96c9cabd95f34afa8a0099c2fcb9daf7518ea40
-  data.tar.gz: 389244130b9ac99560219d2019222c5f7576f3b5df1b4795926569f0d6e158b4db1378ec33e9c8b0459836cf4d490dec58d26adae51f0c4131f498435a0889bf
+  metadata.gz: d316d600c9e38743538abc7b1a598cb13cfa102c6181476ed7e2684ccf63000a6856998ebc9ad065bfb71c98a54adab72a8675aa06f67622f5d2eb415acfea73
+  data.tar.gz: 86ac869dd270188af7f24f22ce1259ed2cf0b109e09d23ff3da9af4288deb191ab1fc7a05f4c2d81159335216b07e3e63e8618c86d3e0c4b09055246881b830f

data/CHANGELOG.md

@@ -1,5 +1,8 @@
 # avromatic changelog
 
+## v0.9.0 (unreleased)
+- Add support for more than one non-null type in a union.
+
 ## v0.8.0
 - Add support for logical types. Currently this requires using the
   `avro-salsify-fork` gem for logical types support with Ruby.

data/README.md

@@ -116,6 +116,9 @@ 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)
@@ -248,8 +251,7 @@ The following validations are supported:
 
 The following types/features are not supported for generated models:
 
-- Generic union fields: The special case of an optional field, the union of `:null` and
-  another type, is supported.
+- Custom types for members within a union.
 - Reused models for nested records: Currently an anonymous model class is
   generated for each subrecord.
 

data/lib/avromatic/model/attribute/union.rb

@@ -0,0 +1,52 @@
+require 'avromatic/model/attribute_type/union'
+
+module Avromatic
+  module Model
+    module Attribute
+
+      # This subclass of Virtus::Attribute is used for any unions that are
+      # defined as subclasses of the primitive Avromatic::Model::AttributeType::Union.
+      # Values are coerced by first checking if they already match one of the
+      # member types, and then by attempting to coerce to each member type in
+      # order.
+      class Union < Virtus::Attribute
+        primitive Avromatic::Model::AttributeType::Union
+
+        def initialize(*)
+          super
+
+          primitive.types.each do |type|
+            member_attributes << Virtus::Attribute.build(type)
+          end
+        end
+
+        def coerce(input)
+          return input if value_coerced?(input)
+
+          result = nil
+          member_attributes.find do |union_attribute|
+            begin
+              coerced = union_attribute.coerce(input)
+              result = coerced unless coerced.is_a?(Avromatic::Model::Attributes) && coerced.invalid?
+            rescue
+              nil
+            end
+          end
+          result
+        end
+
+        def value_coerced?(value)
+          member_attributes.any? do |union_attribute|
+            union_attribute.value_coerced?(value)
+          end
+        end
+
+        private
+
+        def member_attributes
+          @member_attributes ||= Array.new
+        end
+      end
+    end
+  end
+end

data/lib/avromatic/model/attribute_type/union.rb

@@ -0,0 +1,29 @@
+module Avromatic
+  module Model
+    module AttributeType
+
+      # This class is used as the base class for Virtus attributes that
+      # represent unions. A subclass is generated using Union[*types]. This
+      # subclass is specified when defining a Virtus attribute.
+      class Union
+        class << self
+          attr_reader :types
+
+          protected
+
+          attr_writer :types
+        end
+
+        # Factory method to define Union types with the specified list of
+        # types (classes).
+        def self.[](*types)
+          Class.new(self).tap do |klass|
+            klass.types = types
+            # See https://github.com/solnic/virtus/issues/284#issuecomment-56405137
+            Axiom::Types::Object.new { primitive(klass) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/avromatic/model/attributes.rb

@@ -13,9 +13,10 @@ module Avromatic
         # 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.
-        schemas = field_type.schemas.reject { |schema| schema.type_sym == :null }
-        raise "Only the union of null with one other type is supported #{field_type}" if schemas.size > 1
-        schemas.first
+        # 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
       end
 
       module ClassMethods
@@ -60,10 +61,10 @@ module Avromatic
 
             attribute(field.name,
                       field_class,
-                      avro_field_options(field))
+                      avro_field_options(field, field_class))
 
             add_validation(field)
-            add_serializer(field)
+            add_serializer(field, field_class)
           end
         end
 
@@ -127,22 +128,29 @@ module Avromatic
           when :record
             # TODO: This should add the generated model to a module.
             # A hash of generated models should be kept by name for reuse.
-            Class.new do
-              include Avromatic::Model.build(schema: field_type)
-            end
+            Avromatic::Model.model(schema: field_type)
           else
             raise "Unsupported type #{field_type}"
           end
         end
 
         def union_field_class(field_type)
-          avro_field_class(Avromatic::Model::Attributes.first_union_schema(field_type))
+          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)
+        def avro_field_options(field, field_class)
           options = {}
 
-          custom_type = Avromatic.type_registry.fetch(field)
+          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
 
@@ -154,8 +162,10 @@ module Avromatic
           options
         end
 
-        def add_serializer(field)
-          custom_type = Avromatic.type_registry.fetch(field)
+        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
@@ -164,6 +174,24 @@ module Avromatic
         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
+        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
+        end
+
       end
 
     end

data/lib/avromatic/model/builder.rb

@@ -4,6 +4,7 @@ require 'active_model'
 require 'avromatic/model/configuration'
 require 'avromatic/model/value_object'
 require 'avromatic/model/configurable'
+require 'avromatic/model/attribute/union'
 require 'avromatic/model/attributes'
 require 'avromatic/model/raw_serialization'
 require 'avromatic/model/messaging_serialization'

data/lib/avromatic/model/type_registry.rb

@@ -23,10 +23,11 @@ module Avromatic
 
       # @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.
-      def fetch(object)
+      # @field_class [Object] Value class that has been determined for a field.
+      def fetch(object, field_class = nil)
         field_type = object.is_a?(Avro::Schema::Field) ? object.type : object
 
-        if field_type.type_sym == :union
+        if field_class && field_type.type_sym == :union && !(field_class < Avromatic::Model::AttributeType::Union)
           field_type = Avromatic::Model::Attributes.first_union_schema(field_type)
         end
 

data/lib/avromatic/version.rb

@@ -1,3 +1,3 @@
 module Avromatic
-  VERSION = '0.8.0'.freeze
+  VERSION = '0.9.0.rc0'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: avromatic
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.9.0.rc0
 platform: ruby
 authors:
 - Salsify Engineering
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-08-29 00:00:00.000000000 Z
+date: 2016-09-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: avro
@@ -246,6 +246,8 @@ files:
 - gemfiles/rails4_2.gemfile
 - lib/avromatic.rb
 - lib/avromatic/model.rb
+- lib/avromatic/model/attribute/union.rb
+- lib/avromatic/model/attribute_type/union.rb
 - lib/avromatic/model/attributes.rb
 - lib/avromatic/model/builder.rb
 - lib/avromatic/model/configurable.rb
@@ -278,12 +280,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.6
+rubygems_version: 2.4.8
 signing_key: 
 specification_version: 4
 summary: Generate Ruby models from Avro schemas