emery 0.0.2 → 0.0.3

data/lib/emery/type.rb

@@ -1,187 +1,185 @@
-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
+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
+  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
+  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)
-        type = types.find {|t| T.instance_of?(t, value) }
-        if type == nil
-          raise TypeError.new("Value '#{value.inspect.to_s}' type is #{value.class} - any of #{@types.map { |t| t.to_s}.join(', ')} required")
-        end
-      end
-      def ==(other)
-        T.instance_of?(AnyType, other) and (self.types - other.types).empty?
+  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)
+      type = types.find {|t| T.instance_of?(t, value) }
+      if type == nil
+        raise TypeError.new("Value '#{value.inspect.to_s}' type is #{value.class} - any of #{@types.map { |t| t.to_s}.join(', ')} required")
       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(', ')}]"
-      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(', ')}]"
+    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
+  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
+  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
-      def ==(other)
-        T.instance_of?(HashType, other) and self.key_type == other.key_type and self.value_type == other.value_type
+      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>"
+  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
-      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
+      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
+  def T.check(type, value)
+    if type.methods.include? :check
+      type.check(value)
+    else
+      if type != NilClass
+        T.check_not_nil(type, value)
       end
-      return value
-    end
-
-    def T.instance_of?(type, value)
-      begin
-        T.check(type, value)
-        true
-      rescue TypeError
-        false
+      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.nilable(value_type)
-      Nilable.new(value_type)
+  def T.instance_of?(type, value)
+    begin
+      T.check(type, value)
+      true
+    rescue TypeError
+      false
     end
+  end
 
-    def T.array(item_type)
-      ArrayType.new(item_type)
-    end
+  def T.nilable(value_type)
+    Nilable.new(value_type)
+  end
 
-    def T.hash(key_type, value_type)
-      HashType.new(key_type, value_type)
-    end
+  def T.array(item_type)
+    ArrayType.new(item_type)
+  end
 
-    def T.any(*typdefs)
-      AnyType.new(*typdefs)
-    end
+  def T.hash(key_type, value_type)
+    HashType.new(key_type, value_type)
+  end
 
-    def T.union(*cases)
-      UnionType.new(*cases)
-    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
+  def T.union(*cases)
+    UnionType.new(*cases)
+  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
+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}$/)

data/lib/emery.rb

@@ -2,5 +2,4 @@ require 'emery/tod'
 require 'emery/type'
 require 'emery/jsoner'
 require 'emery/enum'
-require 'emery/dataclass'
-require 'emery/client'
+require 'emery/dataclass'

data/test/dataclass_test.rb

@@ -1,115 +1,112 @@
 require "test/unit/runner/junitxml"
 
-require 'emery/dataclass'
-require 'emery/jsoner'
+require 'emery'
 
-module Emery
-  class DataClassTypeEquality < Test::Unit::TestCase
-    def test_equals
-      assert_true TheClass == TheClass
-    end
+class DataClassTypeEquality < Test::Unit::TestCase
+  def test_equals
+    assert_true TheClass == TheClass
+  end
 
-    def test_not_equals
-      assert_false TheClass == TheClassWithNested
-    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
+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_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_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
+  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
+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_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
+  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
+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_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
+  def test_deserialize_object_fail
+    assert_raise JsonerError do
+      Jsoner.from_json(TheClass, '"string"')
     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
+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
+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
 
-  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_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
+  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
+class TheClass
+  include DataClass
 
-    val :string, String
-    var :int, Integer
-  end
+  val :string, String
+  var :int, Integer
+end
 
-  class TheClassWithNested
-    include DataClass
+class TheClassWithNested
+  include DataClass
 
-    val :nested, TheClass
-  end
+  val :nested, TheClass
 end

data/test/enum_test.rb

@@ -1,47 +1,43 @@
 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
+require 'emery'
 
-    def test_fail
-      assert_raise TypeError do
-        T.check(SomeEnum, "non existing")
-      end
-    end
+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
 
-  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"
+  def test_fail
+    assert_raise TypeError do
+      T.check(SomeEnum, "non existing")
     end
+  end
+end
 
-    def test_deserialize_enum_non_existing_item
-      assert_raise JsonerError do
-        Jsoner.from_json(SomeEnum, '"non_existing"')
-      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
 
-  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"
+  def test_deserialize_enum_non_existing_item
+    assert_raise JsonerError do
+      Jsoner.from_json(SomeEnum, '"non_existing"')
     end
   end
+end
 
-  class SomeEnum
-    include Enum
-
-    define :one, 'one'
-    define :two, 'two'
+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