emery 0.0.19 → 0.1.27

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5f535777bdcdeeb081d54dfa26b70b4c7d1b723f736dcf30cdea65773d046524
-  data.tar.gz: 2147536d60c93be8a684f8057d56bf0f4da6e7f35c81b6ada80ffbcb69ca6a7e
+  metadata.gz: ed5b5ad376a8f3ffef14484fd9f299e0461bdb0b567e76b5e8e6fb913c6dcc71
+  data.tar.gz: '09ed0d4e68b06d7353852ce79b7d7fa93de1ea97cdf38f32bf9c8edc08e77fd6'
 SHA512:
-  metadata.gz: 1883cb44758c3e2b2490a8eefded6a6c806ab25fd34045d058130cbd186304808168f67e509ed1fc05a5463e395df680f1b70dd2cd94a2363b905a344187716d
-  data.tar.gz: d1c401503e30f85992058692441d5cdf4e59cb5d3c151380cf326b28d5cc88e18eb04bef8a84a429982dcc535994afbd7160a760784993db76e24eeed1cf9e80
+  metadata.gz: e1a8443886e984bf7fe51196f7df9b7d7b5a57378d23b699f9adfa14ce691b35e41b71d027526f5fccbc49b54a602f168d19b6e4e4dc37060e985873379ee267
+  data.tar.gz: '0282d146e1a49b4ad3608e0378d8688373e55b6e20c48442f7d783afa75a6747619fdc2a87f27cd7309a47ad60a50b3c15366eb6e98a13f076d13b9f44bcd082'

data/lib/emery/codecs.rb

@@ -0,0 +1,255 @@
+require "date"
+
+module Codecs
+  module BuiltinTypeCodec
+    def self.applicable?(type)
+      [String, Float, Integer, TrueClass, FalseClass, NilClass].include? type
+    end
+    def self.deserialize(type, json_value)
+      T.check(type, json_value)
+    end
+    def self.serialize(type, value)
+      T.check(type, value)
+    end
+  end
+
+  module UnknownCodec
+    def self.applicable?(type)
+      type.instance_of? T::UnknownType
+    end
+    def self.deserialize(type, json_value)
+      json_value
+    end
+    def self.serialize(type, value)
+      value
+    end
+  end
+
+  module ArrayCodec
+    def self.applicable?(type)
+      type.instance_of? T::ArrayType
+    end
+    def self.deserialize(type, json_value)
+      T.check_not_nil(type, json_value)
+      if !json_value.is_a?(Array)
+        raise JsonerError.new("JSON value type #{json_value.class} is not Array")
+      end
+      json_value.map { |item_json_value| Jsoner.deserialize(type.item_type, item_json_value) }
+    end
+    def self.serialize(type, value)
+      if !value.is_a?(Array)
+        raise JsonerError.new("Value type #{json_value.class} is not Array")
+      end
+      value.map { |item| Jsoner.serialize(type.item_type, item) }
+    end
+  end
+
+  module HashCodec
+    def self.applicable?(type)
+      type.instance_of? T::HashType
+    end
+    def self.deserialize(type, json_value)
+      T.check_not_nil(type, json_value)
+      if type.key_type != String
+        raise JsonerError.new("Hash key type #{type.key_type} is not supported for JSON (de)serialization - key should be String")
+      end
+      if !json_value.is_a?(Hash)
+        raise JsonerError.new("JSON value type #{json_value.class} is not Hash")
+      end
+      json_value.map do |key, value|
+        [T.check(type.key_type, key), Jsoner.deserialize(type.value_type, value)]
+      end.to_h
+    end
+    def self.serialize(type, value)
+      if type.key_type != String
+        raise JsonerError.new("Hash key type #{type.key_type} is not supported for JSON (de)serialization - key should be String")
+      end
+      if !value.is_a?(Hash)
+        raise JsonerError.new("Value type #{value.class} is not Hash")
+      end
+      value.map do |key, value|
+        [T.check(type.key_type, key), Jsoner.serialize(type.value_type, value)]
+      end.to_h
+    end
+  end
+
+  module UnionCodec
+    def self.applicable?(type)
+      type.instance_of? T::UnionType
+    end
+    def self.deserialize(type, json_value)
+      type.types.each do |t|
+        begin
+          return Jsoner.deserialize(t, json_value)
+        rescue JsonerError
+        end
+      end
+      raise JsonerError.new("Value '#{json_value.inspect.to_s}' can not be deserialized as any of #{type.types.map { |t| t.to_s}.join(', ')}")
+    end
+    def self.serialize(type, value)
+      T.check(type, value)
+      t = type.types.find {|t| T.instance_of?(t, value) }
+      Jsoner.serialize(t, value)
+    end
+  end
+
+  module NilableCodec
+    def self.applicable?(type)
+      type.instance_of? T::NilableType
+    end
+    def self.deserialize(type, json_value)
+      if json_value != nil
+        Jsoner.deserialize(type.inner_type, json_value)
+      else
+        nil
+      end
+    end
+    def self.serialize(type, value)
+      if value != nil
+        Jsoner.serialize(type.inner_type, value)
+      else
+        nil
+      end
+    end
+  end
+
+  module StringFormattedCodec
+    def self.applicable?(type)
+      type.instance_of? T::StringFormattedType
+    end
+    def self.deserialize(type, json_value)
+      T.check(type, json_value)
+    end
+    def self.serialize(type, value)
+      T.check(type, value)
+    end
+  end
+
+  module FloatCodec
+    def self.applicable?(type)
+      type == Float
+    end
+    def self.deserialize(type, json_value)
+      T.check(T.union(Float, Integer), json_value)
+      json_value.to_f
+    end
+    def self.serialize(type, value)
+      T.check(Float, value)
+    end
+  end
+
+  module DateTimeCodec
+    def self.applicable?(type)
+      type == DateTime
+    end
+    def self.deserialize(type, json_value)
+      T.check(String, json_value)
+      begin
+        DateTime.strptime(json_value, '%Y-%m-%dT%H:%M:%S')
+      rescue
+        raise JsonerError.new("Failed to parse DateTime from '#{json_value.inspect.to_s}' format %Y-%m-%dT%H:%M:%S is required")
+      end
+    end
+    def self.serialize(type, value)
+      T.check(DateTime, value)
+      value.strftime('%Y-%m-%dT%H:%M:%S')
+    end
+  end
+
+  module DateCodec
+    def self.applicable?(type)
+      type == Date
+    end
+    def self.deserialize(type, json_value)
+      T.check(String, json_value)
+      begin
+        Date.strptime(json_value, '%Y-%m-%d')
+      rescue
+        raise JsonerError.new("Failed to parse Date from '#{json_value.inspect.to_s}' format %Y-%m-%d is required")
+      end
+    end
+    def self.serialize(type, value)
+      T.check(Date, value)
+      value.strftime('%Y-%m-%d')
+    end
+  end
+
+  module EnumCodec
+    def self.applicable?(type)
+      type.respond_to? :ancestors and type.ancestors.include? Enum
+    end
+    def self.deserialize(type, json_value)
+      T.check(type, json_value)
+    end
+
+    def self.serialize(type, value)
+      T.check(type, value)
+    end
+  end
+
+  module DataClassCodec
+    def self.applicable?(type)
+      type.respond_to? :ancestors and type.ancestors.include? DataClass
+    end
+    def self.deserialize(type, json_value)
+      T.check(T.hash(String, NilableUnknown), json_value)
+      parameters = type.typed_attributes.map do |attr, attr_type|
+        attr_value = json_value[attr.to_s]
+        [attr, Jsoner.deserialize(attr_type, attr_value)]
+      end
+      return type.new(parameters.to_h)
+    end
+
+    def self.serialize(type, value)
+      T.check(type, value)
+      attrs = type.typed_attributes.map do |attr, attr_type|
+        [attr, Jsoner.serialize(attr_type, value.send(attr))]
+      end
+      return attrs.to_h
+    end
+  end
+
+  module TaggedUnionCodec
+    def self.applicable?(type)
+      type.respond_to? :ancestors and type.ancestors.include? TaggedUnion
+    end
+    def self.deserialize(type, json_value)
+      if !json_value.is_a?(Hash)
+        raise JsonerError.new("JSON value type #{json_value.class} is not Hash but it has to be Hash to represent a union")
+      end
+      if type.discriminator == nil
+        if json_value.keys.length != 1
+          raise JsonerError.new("JSON value #{json_value} should have only one key to represent union type wrapper object, found #{json_value.keys.length}")
+        end
+        tag_key = json_value.keys[0]
+        if not type.typed_tags.key? tag_key.to_sym
+          raise JsonerError.new("JSON key '#{tag_key}' does not match any tag in union type #{self}")
+        end
+        tag_type = type.typed_tags[tag_key.to_sym]
+        tag_json_value = json_value[tag_key]
+        tag_value = Jsoner.deserialize(tag_type, tag_json_value)
+        return type.new({tag_key.to_sym => tag_value})
+      else
+        if not json_value.key? type.discriminator
+          raise JsonerError.new("JSON value #{json_value} does not have discriminator field #{type.discriminator}")
+        end
+        tag_key = json_value[type.discriminator]
+        tag_type = type.typed_tags[tag_key.to_sym]
+        tag_value = Jsoner.deserialize(tag_type, json_value)
+        return type.new({tag_key.to_sym => tag_value})
+      end
+    end
+    def self.serialize(type, value)
+      T.check(type, value)
+      tag_key = value.current_tag
+      tag_type = type.typed_tags[tag_key]
+      tag_json_value = Jsoner.serialize(tag_type, value.send(tag_key))
+      if type.discriminator == nil
+        return { tag_key => tag_json_value }
+      else
+        tag_json_value[type.discriminator] = tag_key
+        return tag_json_value
+      end
+    end
+  end
+end

data/lib/emery/dataclass.rb

@@ -1,6 +1,6 @@
 module DataClass
   def initialize(params)
-    self.class.json_attributes.each do |attr, attr_type|
+    self.class.typed_attributes.each do |attr, attr_type|
       attr_value = params[attr]
       self.instance_variable_set("@#{attr}", T.check_var(attr, attr_type, attr_value))
     end
@@ -9,7 +9,7 @@ module DataClass
   def ==(other)
     begin
       T.check(self.class, other)
-      self.class.json_attributes.keys.each do |attr|
+      self.class.typed_attributes.keys.each do |attr|
         if self.instance_variable_get("@#{attr}") != other.instance_variable_get("@#{attr}")
           return false
         end
@@ -21,13 +21,13 @@ module DataClass
   end
 
   def copy(params)
-    params.each do |attr, attr_value|
-      if !self.class.json_attributes.key?(attr)
+    params.keys.each do |attr|
+      if !self.class.typed_attributes.key?(attr)
         raise TypeError.new("Non existing attribute #{attr}")
       end
     end
     new_params =
-      self.class.json_attributes.map do |attr, attr_type|
+      self.class.typed_attributes.keys.map do |attr|
         attr_value =
           if params.key?(attr)
             params[attr]
@@ -48,41 +48,24 @@ module DataClass
   end
 
   module ClassMethods
-    def json_attributes
-      @json_attributes
+    def typed_attributes
+      @typed_attributes
     end
 
     def val(name, type)
-      if @json_attributes == nil
-        @json_attributes = {}
+      if @typed_attributes == nil
+        @typed_attributes = {}
       end
-      @json_attributes[name] = type
+      @typed_attributes[name] = type
       attr_reader name
     end
 
     def var(name, type)
-      if @json_attributes == nil
-        @json_attributes = {}
+      if @typed_attributes == nil
+        @typed_attributes = {}
       end
-      @json_attributes[name] = type
+      @typed_attributes[name] = type
       attr_accessor name
     end
-
-    def jsoner_deserialize(json_value)
-      T.check(T.hash(String, NilableUntyped), json_value)
-      parameters = @json_attributes.map do |attr, attr_type|
-        attr_value = json_value[attr.to_s]
-        [attr, Jsoner.deserialize(attr_type, attr_value)]
-      end
-      return self.new parameters.to_h
-    end
-
-    def jsoner_serialize(value)
-      T.check(self, value)
-      attrs = @json_attributes.map do |attr, attr_type|
-        [attr, Jsoner.serialize(attr_type, value.send(attr))]
-      end
-      return attrs.to_h
-    end
   end
 end

data/lib/emery/enum.rb

@@ -21,14 +21,6 @@ module Enum
       end
     end
 
-    def jsoner_deserialize(json_value)
-      T.check(self, json_value)
-    end
-
-    def jsoner_serialize(value)
-      T.check(self, value)
-    end
-
     def define(key, value)
       @_enum_hash ||= {}
       @_enums_by_value ||= {}

data/lib/emery/jsoner.rb

@@ -1,176 +1,36 @@
 require "json"
-require "date"
 
 class JsonerError < StandardError
 end
 
 module Jsoner
-  T::StringFormatted.class_eval do
-    def jsoner_deserialize(json_value)
-      T.check(self, json_value)
-    end
-    def jsoner_serialize(value)
-      T.check(self, value)
-    end
-  end
-
-  T::UntypedType.class_eval do
-    def jsoner_deserialize(json_value)
-      json_value
-    end
-    def jsoner_serialize(value)
-      value
-    end
-  end
-
-  T::ArrayType.class_eval do
-    def jsoner_deserialize(json_value)
-      T.check_not_nil(self, json_value)
-      if !json_value.is_a?(Array)
-        raise JsonerError.new("JSON value type #{json_value.class} is not Array")
-      end
-      json_value.map { |item_json_value| Jsoner.deserialize(self.item_type, item_json_value) }
-    end
-    def jsoner_serialize(value)
-      if !value.is_a?(Array)
-        raise JsonerError.new("Value type #{json_value.class} is not Array")
-      end
-      value.map { |item| Jsoner.serialize(self.item_type, item) }
-    end
-  end
-
-  T::HashType.class_eval do
-    def jsoner_deserialize(json_value)
-      T.check_not_nil(self, json_value)
-      if self.key_type != String
-        raise JsonerError.new("Hash key type #{self.key_type} is not supported for JSON (de)serialization - key should be String")
-      end
-      if !json_value.is_a?(Hash)
-        raise JsonerError.new("JSON value type #{json_value.class} is not Hash")
-      end
-      json_value.map do |key, value|
-        [T.check(self.key_type, key), Jsoner.deserialize(self.value_type, value)]
-      end.to_h
-    end
-    def jsoner_serialize(value)
-      if self.key_type != String
-        raise JsonerError.new("Hash key type #{self.key_type} is not supported for JSON (de)serialization - key should be String")
-      end
-      if !value.is_a?(Hash)
-        raise JsonerError.new("Value type #{value.class} is not Hash")
-      end
-      value.map do |key, value|
-        [T.check(self.key_type, key), Jsoner.serialize(self.value_type, value)]
-      end.to_h
-    end
-  end
-
-  T::AnyType.class_eval do
-    def jsoner_deserialize(json_value)
-      types.each do |type|
-        begin
-          return Jsoner.deserialize(type, json_value)
-        rescue JsonerError
-        end
-      end
-      raise JsonerError.new("Value '#{json_value.inspect.to_s}' can not be deserialized as any of #{@types.map { |t| t.to_s}.join(', ')}")
-    end
-    def jsoner_serialize(value)
-      T.check(self, value)
-      type = types.find {|t| T.instance_of?(t, value) }
-      Jsoner.serialize(type, value)
-    end
+  @@codecs = [
+    Codecs::FloatCodec,
+    Codecs::DateCodec,
+    Codecs::DateTimeCodec,
+    Codecs::StringFormattedCodec,
+    Codecs::UnionCodec,
+    Codecs::NilableCodec,
+    Codecs::ArrayCodec,
+    Codecs::HashCodec,
+    Codecs::UnknownCodec,
+    Codecs::EnumCodec,
+    Codecs::DataClassCodec,
+    Codecs::TaggedUnionCodec,
+    Codecs::BuiltinTypeCodec,
+  ]
+
+  def self.insert_codec(codec)
+    @@codecs.insert(0, codec)
   end
 
-  T::UnionType.class_eval do
-    def jsoner_deserialize(json_value)
-      if !json_value.is_a?(Hash)
-        raise JsonerError.new("JSON value type #{json_value.class} is not Hash")
+  def Jsoner.find_codec(type)
+    @@codecs.each do |serializer|
+      if serializer.applicable?(type)
+        return serializer
       end
-      if json_value.keys.length != 1
-        raise JsonerError.new("JSON value #{json_value} should have only one key to represent union type, found #{json_value.keys.length}")
-      end
-      case_key = json_value.keys[0]
-      if not cases.key? case_key.to_sym
-        raise JsonerError.new("JSON key '#{case_key}' does not match any case in union type #{self}")
-      end
-      type = cases[case_key.to_sym]
-      case_json_value = json_value[case_key]
-      return Jsoner.deserialize(type, case_json_value)
-    end
-    def jsoner_serialize(value)
-      T.check(self, value)
-      type = types.find {|t| T.instance_of?(t, value) }
-      case_key = cases.key(type)
-      result = { case_key => Jsoner.serialize(type, value) }
-      result
-    end
-  end
-
-  T::Nilable.class_eval do
-    def jsoner_deserialize(json_value)
-      if json_value != nil
-        Jsoner.deserialize(self.type, json_value)
-      else
-        nil
-      end
-    end
-    def jsoner_serialize(value)
-      if value != nil
-        Jsoner.serialize(self.type, value)
-      else
-        nil
-      end
-    end
-  end
-
-  module FloatSerializer
-    def self.jsoner_deserialize(json_value)
-      T.check(T.any(Float, Integer), json_value)
-      json_value.to_f
-    end
-    def self.jsoner_serialize(value)
-      T.check(Float, value)
     end
-  end
-
-  module DateTimeSerializer
-    def self.jsoner_deserialize(json_value)
-      T.check(String, json_value)
-      begin
-        DateTime.strptime(json_value, '%Y-%m-%dT%H:%M:%S')
-      rescue
-        raise JsonerError.new("Failed to parse DateTime from '#{json_value.inspect.to_s}' format %Y-%m-%dT%H:%M:%S is required")
-      end
-    end
-    def self.jsoner_serialize(value)
-      T.check(DateTime, value)
-      value.strftime('%Y-%m-%dT%H:%M:%S')
-    end
-  end
-
-  module DateSerializer
-    def self.jsoner_deserialize(json_value)
-      T.check(String, json_value)
-      begin
-        Date.strptime(json_value, '%Y-%m-%d')
-      rescue
-        raise JsonerError.new("Failed to parse Date from '#{json_value.inspect.to_s}' format %Y-%m-%d is required")
-      end
-    end
-    def self.jsoner_serialize(value)
-      T.check(Date, value)
-      value.strftime('%Y-%m-%d')
-    end
-  end
-
-  @@serializers = {
-      Float => FloatSerializer,
-      Date => DateSerializer,
-      DateTime => DateTimeSerializer
-  }
-  def self.add_serializer(type, serializer)
-    @@serializers[type] = serializer
+    return nil
   end
 
   def Jsoner.from_json(type, json)
@@ -180,16 +40,11 @@ module Jsoner
 
   def Jsoner.deserialize(type, json_value)
     begin
-      if type.methods.include? :jsoner_deserialize
-        return type.jsoner_deserialize(json_value)
-      elsif @@serializers.include? type
-        return @@serializers[type].jsoner_deserialize(json_value)
-      else
-        if ![String, Float, Integer, TrueClass, FalseClass, NilClass].include? type
-          raise JsonerError.new("Type #{type} is not supported in Jsoner deserialization")
-        end
-        return T.check(type, json_value)
+      codec = Jsoner.find_codec(type)
+      if codec == nil
+        raise JsonerError.new("Type #{type} is not supported in Jsoner deserialization")
       end
+      return codec.deserialize(type, json_value)
     rescue StandardError => error
       raise JsonerError.new(error.message)
     end
@@ -201,16 +56,11 @@ module Jsoner
 
   def Jsoner.serialize(type, value)
     begin
-      if type.methods.include? :jsoner_serialize
-        return type.jsoner_serialize(value)
-      elsif @@serializers.include? type
-        return @@serializers[type].jsoner_serialize(value)
-      else
-        if ![String, Float, Integer, TrueClass, FalseClass, NilClass].include? type
-          raise JsonerError.new("Type #{type} is not supported in Jsoner serialization")
-        end
-        return T.check(type, value)
+      codec = Jsoner.find_codec(type)
+      if codec == nil
+        raise JsonerError.new("Type #{type} is not supported in Jsoner serialization")
       end
+      return codec.serialize(type, value)
     rescue StandardError => error
       raise JsonerError.new(error.message)
     end

data/lib/emery/taggedunion.rb

@@ -0,0 +1,79 @@
+module TaggedUnion
+  def initialize(params)
+    if params.length != 1
+      raise ArgumentError.new("Tagged union #{self.class} should have one only one tag set, found #{params.length}" )
+    end
+
+    tag = params.keys[0]
+    tag_type = self.class.typed_tags[tag]
+    tag_value = T.check_var(tag, tag_type, params[tag])
+    self.instance_variable_set("@#{tag}", tag_value)
+    self.current_tag = tag
+    self.current_value = tag_value
+  end
+
+  def ==(other)
+    begin
+      T.check(self.class, other)
+      self.class.typed_tags.keys.each do |attr|
+        if self.instance_variable_get("@#{attr}") != other.instance_variable_get("@#{attr}")
+          return false
+        end
+      end
+      return true
+    rescue
+      return false
+    end
+  end
+
+  def copy(params)
+    params.keys.each do |attr|
+      if !self.class.typed_tags.key?(attr)
+        raise TypeError.new("Non existing attribute #{attr}")
+      end
+    end
+    new_params =
+      self.class.typed_tags.keys.map do |attr|
+        attr_value =
+          if params.key?(attr)
+            params[attr]
+          else
+            self.instance_variable_get("@#{attr}")
+          end
+        [attr, attr_value]
+      end.to_h
+    return self.class.new(new_params)
+  end
+
+  def to_json
+    return Jsoner.serialize(self.class, self)
+  end
+
+  def self.included(base)
+    base.extend ClassMethods
+    attr_accessor :current_tag
+    attr_accessor :current_value
+  end
+
+  module ClassMethods
+    def typed_tags
+      @typed_tags
+    end
+
+    def tag(name, type)
+      if @typed_tags == nil
+        @typed_tags = {}
+      end
+      @typed_tags[name] = type
+      attr_accessor name
+    end
+
+    def discriminator
+      @discriminator
+    end
+
+    def with_discriminator(value)
+      @discriminator = value
+    end
+  end
+end

data/lib/emery/type.rb

@@ -1,3 +1,5 @@
+require 'emery/enum'
+
 module T
   def T.check_not_nil(type, value)
     if value == nil
@@ -5,40 +7,40 @@ module T
     end
   end
 
-  class UntypedType
+  class UnknownType
     def to_s
-      "Untyped"
+      "Unknown"
     end
     def check(value)
       T.check_not_nil(self, value)
     end
   end
 
-  class Nilable
-    attr_reader :type
-    def initialize(type)
-      @type = type
+  class NilableType
+    attr_reader :inner_type
+    def initialize(inner_type)
+      @inner_type = inner_type
     end
     def to_s
-      "Nilable[#{type.to_s}]"
+      "Nilable[#{inner_type.to_s}]"
     end
     def check(value)
       if value != nil
-        T.check(type, value)
+        T.check(inner_type, value)
       end
     end
     def ==(other)
-      T.instance_of?(Nilable, other) and self.type == other.type
+      T.instance_of?(NilableType, other) and self.inner_type == other.inner_type
     end
   end
 
-  class AnyType
+  class UnionType
     attr_reader :types
     def initialize(*types)
       @types = types
     end
     def to_s
-      "Any[#{types.map { |t| t.to_s}.join(', ')}]"
+      "Union[#{types.map { |t| t.to_s}.join(', ')}]"
     end
     def check(value)
       type = types.find {|t| T.instance_of?(t, value) }
@@ -47,18 +49,7 @@ module T
       end
     end
     def ==(other)
-      T.instance_of?(AnyType, other) and (self.types - other.types).empty?
-    end
-  end
-
-  class UnionType < AnyType
-    attr_reader :cases
-    def initialize(cases)
-      @cases = cases
-      super(*cases.values)
-    end
-    def to_s
-      "Union[#{cases.map { |k, t| "#{k}: #{t}"}.join(', ')}]"
+      T.instance_of?(UnionType, other) and (self.types - other.types).empty?
     end
   end
 
@@ -107,13 +98,13 @@ module T
     end
   end
 
-  class StringFormatted
+  class StringFormattedType
     attr_reader :regex
     def initialize(regex)
       @regex = regex
     end
     def to_s
-      "String<#@regex>"
+      "StringFormatted<#@regex>"
     end
     def check(value)
       T.check_not_nil(self, value)
@@ -150,7 +141,7 @@ module T
   end
 
   def T.nilable(value_type)
-    Nilable.new(value_type)
+    NilableType.new(value_type)
   end
 
   def T.array(item_type)
@@ -161,12 +152,8 @@ module T
     HashType.new(key_type, value_type)
   end
 
-  def T.any(*typdefs)
-    AnyType.new(*typdefs)
-  end
-
-  def T.union(*cases)
-    UnionType.new(*cases)
+  def T.union(*typdefs)
+    UnionType.new(*typdefs)
   end
 
   def T.check_var(var_name, type, value)
@@ -179,7 +166,7 @@ module T
   end
 end
 
-Boolean = T.any(TrueClass, FalseClass)
-Untyped = T::UntypedType.new
-NilableUntyped = T.nilable(Untyped)
-UUID = T::StringFormatted.new(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/)
+Boolean = T.union(TrueClass, FalseClass)
+Unknown = T::UnknownType.new
+NilableUnknown = T.nilable(Unknown)
+UUID = T::StringFormattedType.new(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/)

data/lib/emery.rb

@@ -1,4 +1,6 @@
 require 'emery/type'
-require 'emery/jsoner'
 require 'emery/enum'
-require 'emery/dataclass'
+require 'emery/dataclass'
+require 'emery/taggedunion'
+require 'emery/codecs'
+require 'emery/jsoner'

data/test/dataclass_test.rb

@@ -1,6 +1,6 @@
 require "test/unit/runner/junitxml"
 
-require 'emery'
+require "emery"
 
 class DataClassTypeEquality < Test::Unit::TestCase
   def test_equals
@@ -14,7 +14,7 @@ end
 
 class DataClassFields < Test::Unit::TestCase
   def test_fields_meta
-    assert_equal ({:string => String, :int => Integer}), TheClass.json_attributes, "Attributes with types should be available on data class"
+    assert_equal ({:string => String, :int => Integer}), TheClass.typed_attributes, "Attributes with types should be available on data class"
   end
 
   def test_read
@@ -51,49 +51,46 @@ class DataClassEquality < Test::Unit::TestCase
   end
 end
 
-class DataClassDeserialization < Test::Unit::TestCase
-  def test_deserialize_object
-    data = Jsoner.from_json(TheClass, '{"string": "the string", "int": 123}')
-    T.check(TheClass, data)
-    assert_equal TheClass.new(string: "the string", int: 123), data, "Should parse data class object"
-  end
-
-  def test_deserialize_nested_object
-    data = Jsoner.from_json(TheClassWithNested, '{"nested": {"string": "the string", "int": 123}}')
-    T.check(TheClassWithNested, data)
-    assert_equal TheClassWithNested.new(nested: TheClass.new(string: "the string", int: 123)), data, "Should parse nested data class object"
+class DataClassCopy < Test::Unit::TestCase
+  def test_copy
+    a = TheClass.new(string: "the string", int: 123)
+    b = a.copy(string: "the other string")
+    assert_equal "the string", a.string
+    assert_equal "the other string", b.string
   end
 
-  def test_deserialize_object_fail
-    assert_raise JsonerError do
-      Jsoner.from_json(TheClass, '"string"')
+  def test_copy_non_existing_field
+    assert_raise TypeError do
+      a = TheClass.new(string: "the string", int: 123)
+      a.copy(non_existing: "the other string")
     end
   end
-
 end
 
-class DataClassSerialization < Test::Unit::TestCase
+class DataClassJson < Test::Unit::TestCase
   def test_serialize_object
     assert_equal '{"string":"the string","int":123}', Jsoner.to_json(TheClass, TheClass.new(string: "the string", int: 123)), "nil should be serializable to JSON"
   end
 
+  def test_deserialize_object
+    data = Jsoner.from_json(TheClass, '{"string": "the string", "int": 123}')
+    T.check(TheClass, data)
+    assert_equal TheClass.new(string: "the string", int: 123), data, "Should parse data class object"
+  end
+
   def test_serialize_array_of_objects
     assert_equal '[{"string":"the string","int":123},{"string":"the string 2","int":456}]', Jsoner.to_json(T.array(TheClass), [TheClass.new(string: "the string", int: 123), TheClass.new(string: "the string 2", int: 456)]), "Array of objects should be serializable to JSON"
   end
-end
 
-class DataClassCopy < Test::Unit::TestCase
-  def test_copy
-    a = TheClass.new(string: "the string", int: 123)
-    b = a.copy(string: "the other string")
-    assert_equal "the string", a.string
-    assert_equal "the other string", b.string
+  def test_deserialize_nested_object
+    data = Jsoner.from_json(TheClassWithNested, '{"nested": {"string": "the string", "int": 123}}')
+    T.check(TheClassWithNested, data)
+    assert_equal TheClassWithNested.new(nested: TheClass.new(string: "the string", int: 123)), data, "Should parse nested data class object"
   end
 
-  def test_copy_non_existing_field
-    assert_raise TypeError do
-      a = TheClass.new(string: "the string", int: 123)
-      a.copy(non_existing: "the other string")
+  def test_deserialize_object_fail
+    assert_raise JsonerError do
+      Jsoner.from_json(TheClass, '"string"')
     end
   end
 end

data/test/enum_test.rb

@@ -1,6 +1,6 @@
 require "test/unit/runner/junitxml"
 
-require 'emery'
+require "emery"
 
 class TypeCheckEnum < Test::Unit::TestCase
   def test_success

data/test/jsoner_test.rb

@@ -1,6 +1,6 @@
 require "test/unit/runner/junitxml"
 
-require 'emery'
+require "emery"
 
 class PlainTypesDeserialization < Test::Unit::TestCase
   def test_deserialize_integer
@@ -162,7 +162,7 @@ class PlainTypesSerialization < Test::Unit::TestCase
   end
 
   def test_serialize_nil
-    json_str = Jsoner.to_json(T.nilable(Untyped), nil)
+    json_str = Jsoner.to_json(T.nilable(Unknown), nil)
     assert_equal "null", json_str, "nil should be serializable to JSON"
   end
 
@@ -219,67 +219,46 @@ class HashSerialization < Test::Unit::TestCase
   end
 end
 
-class UntypedDeserialization < Test::Unit::TestCase
+class UnknownDeserialization < Test::Unit::TestCase
   def test_deserialize_hash
-    data = Jsoner.from_json(Untyped, '{"one":123,"two":"some string"}')
+    data = Jsoner.from_json(Unknown, '{"one":123,"two":"some string"}')
     assert_equal ({"one" => 123, "two" => "some string"}), data
   end
 
   def test_deserialize_array
-    data = Jsoner.from_json(Untyped, '[123,"some string"]')
+    data = Jsoner.from_json(Unknown, '[123,"some string"]')
     assert_equal [123, "some string"], data
   end
 end
 
-class UntypedSerialization < Test::Unit::TestCase
+class UnknownSerialization < Test::Unit::TestCase
   def test_serialize_hash
-    assert_equal '{"one":123,"two":"some string"}', Jsoner.to_json(Untyped, {"one" => 123, "two" => "some string"})
+    assert_equal '{"one":123,"two":"some string"}', Jsoner.to_json(Unknown, { "one" => 123, "two" => "some string"})
   end
 
   def test_serialize_array
-    assert_equal '[123,"some string"]', Jsoner.to_json(Untyped, [123, "some string"])
+    assert_equal '[123,"some string"]', Jsoner.to_json(Unknown, [123, "some string"])
   end
 end
 
-class AnyDeserialization < Test::Unit::TestCase
+class UnionDeserialization < Test::Unit::TestCase
   def test_deserialize
-    data = Jsoner.from_json(T.any(String, Integer), '"the string"')
-    T.check(T.any(String, Integer), data)
+    data = Jsoner.from_json(T.union(String, Integer), '"the string"')
+    T.check(T.union(String, Integer), data)
     assert_equal "the string", data, "Should parse any type"
   end
 
   def test_deserialize_fail
     assert_raise JsonerError do
-      Jsoner.from_json(T.any(Integer, Float), '"the string"')
-    end
-  end
-end
-
-class AnySerialization < Test::Unit::TestCase
-  def test_serialize
-    data = Jsoner.to_json(T.any(String, Integer), "the string")
-    T.check(T.any(String, Integer), data)
-    assert_equal '"the string"', data, "Should serialize any type"
-  end
-end
-
-class UnionDeserialization < Test::Unit::TestCase
-  def test_deserialize
-    data = Jsoner.from_json(T.union(str: String, int: Integer), '{"str":"the string"}')
-    T.check(T.union(str: String, int: Integer), data)
-    assert_equal "the string", data, "Should parse union type"
-  end
-
-  def test_deserialize_any_fail
-    assert_raise JsonerError do
-      Jsoner.from_json(T.union(str: String, int: Integer), '{"bool":true}')
+      Jsoner.from_json(T.union(Integer, Float), '"the string"')
     end
   end
 end
 
 class UnionSerialization < Test::Unit::TestCase
   def test_serialize
-    data = Jsoner.to_json(T.union(str: String, int: Integer), "the string")
-    assert_equal '{"str":"the string"}', data, "Should serialize union type with wrapping object"
+    data = Jsoner.to_json(T.union(String, Integer), "the string")
+    T.check(T.union(String, Integer), data)
+    assert_equal '"the string"', data, "Should serialize any type"
   end
 end

data/test/taggedunion_test.rb

@@ -0,0 +1,104 @@
+require "test/unit/runner/junitxml"
+
+require "emery"
+
+class TaggedUnionTypeEquality < Test::Unit::TestCase
+  def test_equals
+    assert_true Shape == Shape
+  end
+
+  def test_not_equals
+    assert_false Shape == SmoothShape
+  end
+end
+
+class TaggedUnionTags < Test::Unit::TestCase
+  def test_tags_meta
+    assert_equal ({:circle => Circle, :square => Square}), Shape.typed_tags, "Tags with types should be available on tagged union"
+  end
+
+  def test_read_tag
+    u = Shape.new(circle: Circle.new(radius: 123))
+    assert_equal :circle, u.current_tag, "Current tag should be readable"
+    assert_equal Circle.new(radius: 123), u.current_value, "Current value should be readable"
+    assert_equal Circle.new(radius: 123), u.circle, "Current union tag should allow to read it's data"
+    assert_equal nil, u.square, "Non current tag should be nil"
+  end
+
+  def test_set_more_then_one_tag
+    assert_raise ArgumentError do
+      Shape.new(circle: Circle.new(radius: 123), square: Square.new(side: 123))
+    end
+  end
+end
+
+class TypeCheckTaggedUnion < Test::Unit::TestCase
+  def test_success
+    assert_equal(Shape.new(circle: Circle.new(radius: 123)), T.check(Shape, Shape.new(circle: Circle.new(radius: 123))))
+  end
+
+  def test_fail
+    assert_raise TypeError do
+      T.check(Shape, 123)
+    end
+  end
+end
+
+class TaggedUnionJson < Test::Unit::TestCase
+  def test_serialize_wrapper
+    data = Jsoner.to_json(Shape, Shape.new(circle: Circle.new(radius: 123)))
+    assert_equal '{"circle":{"radius":123}}', data, "Should serialize tagged union type to wrapper object"
+  end
+
+  def test_deserialize_wrapper
+    data = Jsoner.from_json(Shape, '{"circle":{"radius":123}}')
+    T.check(Shape, data)
+    assert_equal Shape.new(circle: Circle.new(radius: 123)), data, "Should deserialize tagged union type from wrapper object"
+  end
+
+  def test_deserialize_wrapper_fail
+    assert_raise JsonerError do
+      Jsoner.from_json(Shape, '{"non_exisiting":{"radius":123}}')
+    end
+  end
+
+  def test_serialize_discriminator
+    data = Jsoner.to_json(SmoothShape, SmoothShape.new(circle: Circle.new(radius: 123)))
+    assert_equal '{"radius":123,"_type":"circle"}', data, "Should serialize tagged union to object with discriminator"
+  end
+
+  def test_deserialize_discriminator
+    data = Jsoner.from_json(SmoothShape, '{"_type":"circle","radius":123}')
+    T.check(SmoothShape, data)
+    assert_equal SmoothShape.new(circle: Circle.new(radius: 123)), data, "Should deserialize tagged union type from object with discriminator"
+  end
+end
+
+class Circle
+  include DataClass
+  val :radius, Integer
+end
+
+class Square
+  include DataClass
+  val :side, Integer
+end
+
+class Shape
+  include TaggedUnion
+  tag :circle, Circle
+  tag :square, Square
+end
+
+class Oval
+  include DataClass
+  val :height, Integer
+  val :width, Integer
+end
+
+class SmoothShape
+  include TaggedUnion
+  with_discriminator "_type"
+  tag :circle, Circle
+  tag :oval, Oval
+end

data/test/type_test.rb

@@ -1,7 +1,7 @@
 require "test/unit/runner/junitxml"
 require "date"
 
-require 'emery'
+require "emery"
 
 class TypeEquality < Test::Unit::TestCase
   def test_plain_equals
@@ -21,7 +21,7 @@ class TypeEquality < Test::Unit::TestCase
   end
 
   def test_untyped_equals
-    assert_true Untyped == Untyped
+    assert_true Unknown == Unknown
   end
 
   def test_nilable_equals
@@ -56,16 +56,16 @@ class TypeEquality < Test::Unit::TestCase
     assert_false T.hash(String, Integer) == T.hash(String, String)
   end
 
-  def test_any_equals
-    assert_true T.any(String, Integer) == T.any(String, Integer)
+  def test_union_equals
+    assert_true T.union(String, Integer) == T.union(String, Integer)
   end
 
-  def test_any_equals_other_order
-    assert_true T.any(String, Integer) == T.any(Integer, String)
+  def test_union_equals_other_order
+    assert_true T.union(String, Integer) == T.union(Integer, String)
   end
 
-  def test_any_of_other_type
-    assert_false T.any(String, Integer) == T.any(Integer, Float)
+  def test_union_of_other_type
+    assert_false T.union(String, Integer) == T.union(Integer, Float)
   end
 end
 
@@ -82,12 +82,8 @@ class TypeToString < Test::Unit::TestCase
     assert_equal "Hash[String, Integer]", T.hash(String, Integer).to_s
   end
 
-  def test_any
-    assert_equal "Any[String, Integer]", T.any(String, Integer).to_s
-  end
-
   def test_union
-    assert_equal "Union[str: String, int: Integer]", T.union(str: String, int: Integer).to_s
+    assert_equal "Union[String, Integer]", T.union(String, Integer).to_s
   end
 end
 
@@ -146,12 +142,12 @@ class TypeCheck < Test::Unit::TestCase
   end
 
   def test_untyped_success
-    assert_equal "bla", T.check(Untyped, "bla"), "Untyped should accept strings"
+    assert_equal "bla", T.check(Unknown, "bla"), "Untyped should accept strings"
   end
 
   def test_untyped_nil
     assert_raise TypeError do
-      T.check(Untyped, nil)
+      T.check(Unknown, nil)
     end
   end
 
@@ -189,30 +185,18 @@ class TypeCheckHash < Test::Unit::TestCase
   end
 
   def test_hash_string_to_untyped
-    assert_equal({"key" => "the value"}, T.check(T.hash(String, Untyped), {"key" => "the value"}), "Hash of String -> Untyped should allow String -> String value")
-  end
-end
-
-class TypeCheckAny < Test::Unit::TestCase
-  def test_success
-    assert_equal(123, T.check(T.any(String, Integer), 123), "Any of String, Integer should allow Integer value")
-  end
-
-  def test_fail
-    assert_raise TypeError do
-      T.check(T.any(String, Integer), true)
-    end
+    assert_equal({"key" => "the value"}, T.check(T.hash(String, Unknown), { "key" => "the value"}), "Hash of String -> Untyped should allow String -> String value")
   end
 end
 
 class TypeCheckUnion < Test::Unit::TestCase
   def test_success
-    assert_equal(123, T.check(T.union(str: String, int: Integer), 123))
+    assert_equal(123, T.check(T.union(String, Integer), 123), "Any of String, Integer should allow Integer value")
   end
 
   def test_fail
     assert_raise TypeError do
-      T.check(T.union(str: String, int: Integer), true)
+      T.check(T.union(String, Integer), true)
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: emery
 version: !ruby/object:Gem::Version
-  version: 0.0.19
+  version: 0.1.27
 platform: ruby
 authors:
 - Vladimir Sapronov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-06-09 00:00:00.000000000 Z
+date: 2021-09-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -31,13 +31,16 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/emery.rb
+- lib/emery/codecs.rb
 - lib/emery/dataclass.rb
 - lib/emery/enum.rb
 - lib/emery/jsoner.rb
+- lib/emery/taggedunion.rb
 - lib/emery/type.rb
 - test/dataclass_test.rb
 - test/enum_test.rb
 - test/jsoner_test.rb
+- test/taggedunion_test.rb
 - test/type_test.rb
 homepage: https://github.com/vsapronov/emery
 licenses: