emery 0.0.1

data/lib/emery/type.rb

@@ -0,0 +1,176 @@
+module Emery
+  module T
+    def T.check_not_nil(type, value)
+      if value == nil
+        raise TypeError.new("Type #{type.to_s} does not allow nil value")
+      end
+    end
+
+    class UntypedType
+      def to_s
+        "Untyped"
+      end
+      def check(value)
+        T.check_not_nil(self, value)
+      end
+    end
+
+    class Nilable
+      attr_reader :type
+      def initialize(type)
+        @type = type
+      end
+      def to_s
+        "Nilable[#{type.to_s}]"
+      end
+      def check(value)
+        if value != nil
+          T.check(type, value)
+        end
+      end
+      def ==(other)
+        T.instance_of?(Nilable, other) and self.type == other.type
+      end
+    end
+
+    class AnyType
+      attr_reader :types
+      def initialize(*types)
+        @types = types
+      end
+      def to_s
+        "Any[#{types.map { |t| t.to_s}.join(', ')}]"
+      end
+      def check(value)
+        types.each do |type|
+          begin
+            T.check(type, value)
+            return
+          rescue TypeError
+          end
+        end
+        raise TypeError.new("Value '#{value.inspect.to_s}' type is #{value.class} - any of #{@types.map { |t| t.to_s}.join(', ')} required")
+      end
+      def ==(other)
+        T.instance_of?(AnyType, other) and (self.types - other.types).empty?
+      end
+    end
+
+    class ArrayType
+      attr_reader :item_type
+      def initialize(item_type)
+        @item_type = item_type
+      end
+      def to_s
+        "Array[#{item_type.to_s}]"
+      end
+      def check(value)
+        T.check_not_nil(self, value)
+        if !value.is_a? Array
+          raise TypeError.new("Value '#{value.inspect.to_s}' type is #{value.class} - Array is required")
+        end
+        value.each { |item_value| T.check(item_type, item_value) }
+      end
+      def ==(other)
+        T.instance_of?(ArrayType, other) and self.item_type == other.item_type
+      end
+    end
+
+    class HashType
+      attr_reader :key_type
+      attr_reader :value_type
+      def initialize(key_type, value_type)
+        @key_type = key_type
+        @value_type = value_type
+      end
+      def to_s
+        "Hash[#{@key_type.to_s}, #{@value_type.to_s}]"
+      end
+      def check(value)
+        T.check_not_nil(self, value)
+        if !value.is_a? Hash
+          raise TypeError.new("Value '#{value.inspect.to_s}' type is #{value.class} - Hash is required")
+        end
+        value.each do |item_key, item_value|
+          T.check(@key_type, item_key)
+          T.check(@value_type, item_value)
+        end
+      end
+      def ==(other)
+        T.instance_of?(HashType, other) and self.key_type == other.key_type and self.value_type == other.value_type
+      end
+    end
+
+    class StringFormatted
+      attr_reader :regex
+      def initialize(regex)
+        @regex = regex
+      end
+      def to_s
+        "String<#@regex>"
+      end
+      def check(value)
+        T.check_not_nil(self, value)
+        if !value.is_a? String
+          raise TypeError.new("Value '#{value.inspect.to_s}' type is #{value.class} - String is required for StringFormatted")
+        end
+        if !@regex.match?(value)
+          raise TypeError.new("Value '#{value.inspect.to_s}' is not in required format '#{@regex}'")
+        end
+      end
+    end
+
+    def T.check(type, value)
+      if type.methods.include? :check
+        type.check(value)
+      else
+        if type != NilClass
+          T.check_not_nil(type, value)
+        end
+        if !value.is_a? type
+          raise TypeError.new("Value '#{value.inspect.to_s}' type is #{value.class} - #{type} is required")
+        end
+      end
+      return value
+    end
+
+    def T.instance_of?(type, value)
+      begin
+        T.check(type, value)
+        true
+      rescue TypeError
+        false
+      end
+    end
+
+    def T.nilable(value_type)
+      Nilable.new(value_type)
+    end
+
+    def T.array(item_type)
+      ArrayType.new(item_type)
+    end
+
+    def T.hash(key_type, value_type)
+      HashType.new(key_type, value_type)
+    end
+
+    def T.any(*typdefs)
+      AnyType.new(*typdefs)
+    end
+
+    def T.check_var(var_name, type, value)
+      begin
+        check(type, value)
+        return value
+      rescue TypeError => e
+        raise TypeError.new("Variable #{var_name} type check failed, expected type: #{type.to_s}, value: #{value}")
+      end
+    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}$/)
+end

data/test/dataclass_test.rb

@@ -0,0 +1,115 @@
+require "test/unit/runner/junitxml"
+
+require 'emery/dataclass'
+require 'emery/jsoner'
+
+module Emery
+  class DataClassTypeEquality < Test::Unit::TestCase
+    def test_equals
+      assert_true TheClass == TheClass
+    end
+
+    def test_not_equals
+      assert_false TheClass == TheClassWithNested
+    end
+  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"
+    end
+
+    def test_read
+      obj = TheClass.new(string: "the string", int: 123)
+      assert_equal "the string", obj.string, "Immutable field should be readable"
+      assert_equal 123, obj.int, "Mutable field should be readable"
+    end
+
+    def test_write_mutable
+      obj = TheClass.new(string: "the string", int: 123)
+      obj.int = 124
+      assert_equal 124, obj.int, "Mutable field should be writable"
+    end
+
+    def test_write_immutable
+      obj = TheClass.new(string: "the string", int: 123)
+      assert_raise NoMethodError do
+        obj.string = "the other string"
+      end
+    end
+  end
+
+  class DataClassEquality < Test::Unit::TestCase
+    def test_nil
+      assert_not_equal nil, TheClass.new(string: "the string", int: 123), "Object should not be equal to nil"
+    end
+
+    def test_same_fields_values
+      assert_equal TheClass.new(string: "the string", int: 123), TheClass.new(string: "the string", int: 123), "Objects with same fields should be equal"
+    end
+
+    def test_different_fields_values
+      assert_not_equal TheClass.new(string: "the string 2", int: 123), TheClass.new(string: "the string", int: 123), "Objects with different fields should not be equal"
+    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"
+    end
+
+    def test_deserialize_object_fail
+      assert_raise JsonerError do
+        Jsoner.from_json(TheClass, '"string"')
+      end
+    end
+
+  end
+
+  class DataClassSerialization < 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_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
+    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")
+      end
+    end
+  end
+
+  class TheClass
+    include DataClass
+
+    val :string, String
+    var :int, Integer
+  end
+
+  class TheClassWithNested
+    include DataClass
+
+    val :nested, TheClass
+  end
+end

data/test/enum_test.rb

@@ -0,0 +1,47 @@
+require "test/unit/runner/junitxml"
+
+require 'emery/type'
+require 'emery/enum'
+require 'emery/jsoner'
+
+module Emery
+  class TypeCheckEnum < Test::Unit::TestCase
+    def test_success
+      assert_equal SomeEnum::one, T.check(SomeEnum, SomeEnum::one), "Plain enum type should pass type check"
+    end
+
+    def test_fail
+      assert_raise TypeError do
+        T.check(SomeEnum, "non existing")
+      end
+    end
+  end
+
+  class EnumDeserialization < Test::Unit::TestCase
+    def test_deserialize_enum
+      data = Jsoner.from_json(SomeEnum, '"two"')
+      T.check(SomeEnum, data)
+      assert_equal SomeEnum::two, data, "Enum should be parsable from JSON"
+    end
+
+    def test_deserialize_enum_non_existing_item
+      assert_raise JsonerError do
+        Jsoner.from_json(SomeEnum, '"non_existing"')
+      end
+    end
+  end
+
+  class EnumSerialization < Test::Unit::TestCase
+    def test_serialize_enum
+      json_str = Jsoner.to_json(SomeEnum, SomeEnum::two)
+      assert_equal '"two"', json_str, "Enum should be serializable to JSON"
+    end
+  end
+
+  class SomeEnum
+    include Enum
+
+    define :one, 'one'
+    define :two, 'two'
+  end
+end

data/test/jsoner_test.rb

@@ -0,0 +1,239 @@
+require "test/unit/runner/junitxml"
+
+require 'emery/type'
+require 'emery/jsoner'
+
+module Emery
+  class PlainTypesDeserialization < Test::Unit::TestCase
+    def test_deserialize_integer
+      data = Jsoner.from_json(Integer, '123')
+      T.check(Integer, data)
+      assert_equal 123, data, "Integer should be parsable from JSON"
+    end
+
+    def test_deserialize_integer_fail
+      assert_raise JsonerError do
+        Jsoner.from_json(Integer, '"abc"')
+      end
+    end
+
+    def test_deserialize_float
+      data = Jsoner.from_json(Float, '1.23')
+      T.check(Float, data)
+      assert_equal 1.23, data, "Float should be parsable from JSON"
+    end
+
+    def test_deserialize_float_from_integer
+      data = Jsoner.from_json(Float, '123')
+      T.check(Float, data)
+      assert_equal 123.0, data, "Float should be parsable from JSON"
+    end
+
+    def test_deserialize_float_fail
+      assert_raise JsonerError do
+        Jsoner.from_json(Float, '"abc"')
+      end
+    end
+
+    def test_deserialize_boolean
+      data = Jsoner.from_json(Boolean, 'true')
+      T.check(Boolean, data)
+      assert_equal true, data, "Boolean should be parsable from JSON"
+    end
+
+    def test_deserialize_boolean_fail
+      assert_raise JsonerError do
+        Jsoner.from_json(Boolean, '1')
+      end
+    end
+
+    def test_deserialize_string
+      data = Jsoner.from_json(String, '"the string"')
+      T.check(String, data)
+      assert_equal "the string", data, "String should be parsable from JSON"
+    end
+
+    def test_deserialize_string_fail
+      assert_raise JsonerError do
+        Jsoner.from_json(String, '123')
+      end
+    end
+
+    def test_deserialize_uuid
+      data = Jsoner.from_json(UUID, '"58d5e212-165b-4ca0-909b-c86b9cee0111"')
+      T.check(UUID, data)
+      assert_equal "58d5e212-165b-4ca0-909b-c86b9cee0111", data, "String should be parsable from JSON"
+    end
+
+    def test_deserialize_uuid_fail
+      assert_raise JsonerError do
+        Jsoner.from_json(UUID, '"abc"')
+      end
+    end
+
+    def test_deserialize_date
+      data = Jsoner.from_json(Date, '"2019-11-30"')
+      T.check(Date, data)
+      assert_equal Date.new(2019, 11, 30), data, "Date should be parsable from JSON"
+    end
+
+    def test_deserialize_date_wrong_format
+      assert_raise JsonerError do
+        Jsoner.from_json(Date, '"11/30/2019"')
+      end
+    end
+
+    def test_deserialize_datetime
+      data = Jsoner.from_json(DateTime, '"2019-11-30T17:45:55+00:00"')
+      T.check(DateTime, data)
+      assert_equal DateTime.new(2019, 11, 30, 17, 45, 55), data, "DateTime should be parsable from JSON"
+    end
+
+    def test_deserialize_datetime_wrong_format
+      assert_raise JsonerError do
+        Jsoner.from_json(DateTime, '"2019-11-30 17:45:55"')
+      end
+    end
+
+    def test_deserialize_nilable_nil
+      data = Jsoner.from_json(T.nilable(String), 'null')
+      T.check(T.nilable(String), data)
+      assert_equal nil, data, "Nilable null value should be parsable from JSON"
+    end
+
+    def test_deserialize_nilable_string
+      data = Jsoner.from_json(T.nilable(String), '"some string"')
+      T.check(T.nilable(String), data)
+      assert_equal "some string", data, "Nilable non-null value should be parsable from JSON"
+    end
+
+    def test_deserialize_non_nilable
+      assert_raise JsonerError do
+        Jsoner.from_json(String, 'null')
+      end
+    end
+  end
+
+  class PlainTypesSerialization < Test::Unit::TestCase
+    def test_serialize_integer
+      assert_equal "123", Jsoner.to_json(Integer,123), "Integer should be serializable to JSON"
+    end
+
+    def test_serialize_integer_fail
+      assert_raise JsonerError do
+        Jsoner.to_json(Integer,123.4)
+      end
+    end
+
+    def test_serialize_float
+      assert_equal "12.3", Jsoner.to_json(Float,12.3), "Float should be serializable to JSON"
+    end
+
+    def test_serialize_float_fail
+      assert_raise JsonerError do
+        Jsoner.to_json(Float,123)
+      end
+    end
+
+    def test_serialize_boolean
+      assert_equal "true", Jsoner.to_json(Boolean, true), "Boolean should be serializable to JSON"
+    end
+
+    def test_serialize_string
+      assert_equal '"the string"', Jsoner.to_json(String,"the string"), "String should be serializable to JSON"
+    end
+
+    def test_serialize_date
+      assert_equal '"2019-11-30"', Jsoner.to_json(Date, Date.new(2019, 11, 30)), "Date should be serializable to JSON"
+    end
+
+    def test_serialize_date_fail
+      assert_raise JsonerError do
+        Jsoner.to_json(Date, 123)
+      end
+    end
+
+    def test_serialize_datetime
+      assert_equal '"2019-11-30T17:45:55"', Jsoner.to_json(DateTime, DateTime.new(2019, 11, 30, 17, 45, 55)), "DateTime should be serializable to JSON"
+    end
+
+    def test_serialize_nil
+      json_str = Jsoner.to_json(T.nilable(Untyped), nil)
+      assert_equal "null", json_str, "nil should be serializable to JSON"
+    end
+
+    def test_serialize_uuid
+      assert_equal '"58d5e212-165b-4ca0-909b-c86b9cee0111"', Jsoner.to_json(UUID, "58d5e212-165b-4ca0-909b-c86b9cee0111"), "UUID should be serializable to JSON"
+    end
+  end
+
+  class ArrayDeserialization < Test::Unit::TestCase
+    def test_deserialize_array
+      data = Jsoner.from_json(T.array(String), '["the string", "the other string"]')
+      T.check(T.array(String), data)
+      assert_equal ["the string", "the other string"], data, "Should parse array of strings"
+    end
+
+    def test_deserialize_array_of_datetime
+      data = Jsoner.from_json(T.array(DateTime), '["2019-11-30T17:45:55+00:00"]')
+      T.check(T.array(DateTime), data)
+      assert_equal [DateTime.new(2019, 11, 30, 17, 45, 55)], data, "Should parse array of DateTime"
+    end
+  end
+
+  class ArraySerialization < Test::Unit::TestCase
+    def test_serialize_array
+      assert_equal '["the string","the other string"]', Jsoner.to_json(T.array(String), ["the string", "the other string"]), "Array should be serializable to JSON"
+    end
+
+    def test_serialize_array_of_datetime
+      assert_equal '["2019-11-30T17:45:55"]', Jsoner.to_json(T.array(DateTime), [DateTime.new(2019, 11, 30, 17, 45, 55)]), "Array should be serializable to JSON"
+    end
+  end
+
+  class HashDeserialization < Test::Unit::TestCase
+    def test_deserialize_hash
+      data = Jsoner.from_json(T.hash(String, Integer), '{"one": 123, "two": 456}')
+      T.check(T.hash(String, Integer), data)
+      assert_equal ({"one" => 123, "two" => 456}), data, "Should parse hash"
+    end
+
+    def test_deserialize_hash_string_to_datetime
+      data = Jsoner.from_json(T.hash(String, DateTime), '{"one": "2019-11-30T17:45:55+00:00"}')
+      T.check(T.hash(String, DateTime), data)
+      assert_equal ({"one" => DateTime.new(2019, 11, 30, 17, 45, 55)}), data, "Should parse hash"
+    end
+  end
+
+  class HashSerialization < Test::Unit::TestCase
+    def test_serialize_hash
+      assert_equal '{"one":123,"two":456}', Jsoner.to_json(T.hash(String, Integer), {"one" => 123, "two" => 456}), "Hash should be serializable to JSON"
+    end
+
+    def test_serialize_hash_string_to_datetime
+      assert_equal '{"one":"2019-11-30T17:45:55"}', Jsoner.to_json(T.hash(String, DateTime), {"one" => DateTime.new(2019, 11, 30, 17, 45, 55)}), "Hash should be serializable to JSON"
+    end
+  end
+
+  class AnyDeserialization < Test::Unit::TestCase
+    def test_deserialize_any
+      data = Jsoner.from_json(T.any(String, Integer), '"the string"')
+      T.check(T.any(String, Integer), data)
+      assert_equal "the string", data, "Should parse any type"
+    end
+
+    def test_deserialize_any_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_any
+      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
+end