emery 0.0.1 → 0.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8dc449ad3ba135140479a6711b016e63bfc30f9fd6dcf6dba8ff78ee71208a6a
-  data.tar.gz: 9c2f86bde90521cfa5adb78eda8ceef5504c2fbcf44de558cf2450c550cea96e
+  metadata.gz: 924ace300767e7dd836ccdc9084bd9752d5e068b39889452b8a1d1d2e8dfccfc
+  data.tar.gz: e979657cad032c4d3025269a43614cea3400eb2f2505d429922c362a9a014221
 SHA512:
-  metadata.gz: e9695fe9eeed44ad9d3bc33e1dc92ae4de5a31e024c7fa9ba1fa34dbd3df554cf5cd73e9634dbaec1246ca80b8ac536fd1020b129ef26d9973512c34ca77b920
-  data.tar.gz: 8f7b8961c1c39cf2a354163725bd1fc761e620627ebbb73cb1dd91c7d5746bdc6fd937ccc17fa2bf70ef7af826dd0eb60f09102a4b27ab7f6cf1343633686ecf
+  metadata.gz: 6b1833b10580a5c01ea37bba0ba6072fb76151f02fa12b69c235b181313ada403de9b4e32b8813b87bcf1bee0d4f08c32f8e0830e73ee1a3679712250521c8ea
+  data.tar.gz: '06908264f18d6c01636280541627217126df75a9a1aeb64840eca4a000a73beb2d9809690e749e907455b5fc6473f0aee9ed0c845c4e4f81d795415af0be8b32'

data/lib/emery.rb

@@ -1,6 +1,4 @@
-require 'emery/tod'
 require 'emery/type'
 require 'emery/jsoner'
 require 'emery/enum'
-require 'emery/dataclass'
-require 'emery/client'
+require 'emery/dataclass'

data/lib/emery/dataclass.rb

@@ -1,86 +1,88 @@
-module Emery
-  module DataClass
-    def initialize(params)
-      self.class.json_attributes.each do |attr, attr_type|
-        attr_value = params[attr]
-        self.instance_variable_set("@#{attr}", T.check_var(attr, attr_type, attr_value))
-      end
+module DataClass
+  def initialize(params)
+    self.class.json_attributes.each do |attr, attr_type|
+      attr_value = params[attr]
+      self.instance_variable_set("@#{attr}", T.check_var(attr, attr_type, attr_value))
     end
+  end
 
-    def ==(other)
-      begin
-        T.check(self.class, other)
-        self.class.json_attributes.keys.each do |attr|
-          if self.instance_variable_get("@#{attr}") != other.instance_variable_get("@#{attr}")
-            return false
-          end
+  def ==(other)
+    begin
+      T.check(self.class, other)
+      self.class.json_attributes.keys.each do |attr|
+        if self.instance_variable_get("@#{attr}") != other.instance_variable_get("@#{attr}")
+          return false
         end
-        return true
-      rescue
-        return false
       end
+      return true
+    rescue
+      return false
     end
+  end
 
-    def copy(params)
-      params.each do |attr, attr_value|
-        if !self.class.json_attributes.key?(attr)
-          raise TypeError.new("Non existing attribute #{attr}")
-        end
+  def copy(params)
+    params.each do |attr, attr_value|
+      if !self.class.json_attributes.key?(attr)
+        raise TypeError.new("Non existing attribute #{attr}")
       end
-      new_params =
-        self.class.json_attributes.map do |attr, attr_type|
-          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
+    new_params =
+      self.class.json_attributes.map do |attr, attr_type|
+        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 self.included(base)
-      base.extend ClassMethods
-    end
+  def to_json
+    return Jsoner.serialize(self.class, self)
+  end
 
-    module ClassMethods
-      def json_attributes
-        @json_attributes
-      end
+  def self.included(base)
+    base.extend ClassMethods
+  end
 
-      def val(name, type)
-        if @json_attributes == nil
-          @json_attributes = {}
-        end
-        @json_attributes[name] = type
-        attr_reader name
+  module ClassMethods
+    def json_attributes
+      @json_attributes
+    end
+
+    def val(name, type)
+      if @json_attributes == nil
+        @json_attributes = {}
       end
+      @json_attributes[name] = type
+      attr_reader name
+    end
 
-      def var(name, type)
-        if @json_attributes == nil
-          @json_attributes = {}
-        end
-        @json_attributes[name] = type
-        attr_accessor name
+    def var(name, type)
+      if @json_attributes == nil
+        @json_attributes = {}
       end
+      @json_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
+    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
+    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

@@ -1,101 +1,99 @@
-module Emery
-  module Enum
-    attr_reader :key, :value
+module Enum
+  attr_reader :key, :value
 
-    def initialize(key, value)
-      @key = key
-      @value = value
-    end
+  def initialize(key, value)
+    @key = key
+    @value = value
+  end
 
-    def self.included(base)
-      base.extend Enumerable
-      base.extend ClassMethods
+  def self.included(base)
+    base.extend Enumerable
+    base.extend ClassMethods
 
-      base.private_class_method(:new)
-    end
+    base.private_class_method(:new)
+  end
 
-    module ClassMethods
-      def check(value)
-        T.check_not_nil(self, value)
-        if !value?(value)
-          raise TypeError.new("Value '#{value.inspect.to_s}' is not a member of enum #{self}")
-        end
+  module ClassMethods
+    def check(value)
+      T.check_not_nil(self, value)
+      if !value?(value)
+        raise TypeError.new("Value '#{value.inspect.to_s}' is not a member of enum #{self}")
       end
+    end
 
-      def jsoner_deserialize(json_value)
-        T.check(self, json_value)
-      end
+    def jsoner_deserialize(json_value)
+      T.check(self, json_value)
+    end
 
-      def jsoner_serialize(value)
-        T.check(self, value)
-      end
+    def jsoner_serialize(value)
+      T.check(self, value)
+    end
 
-      def define(key, value)
-        @_enum_hash ||= {}
-        @_enums_by_value ||= {}
+    def define(key, value)
+      @_enum_hash ||= {}
+      @_enums_by_value ||= {}
 
-        if @_enum_hash.key?(key) then
-          raise TypeError.new("Duplicate key: #{key}")
-        end
+      if @_enum_hash.key?(key) then
+        raise TypeError.new("Duplicate key: #{key}")
+      end
 
-        if @_enums_by_value.key?(value) then
-          raise TypeError.new("Duplicate value: #{value}")
-        end
+      if @_enums_by_value.key?(value) then
+        raise TypeError.new("Duplicate value: #{value}")
+      end
 
-        new_instance = new(key, value)
-        @_enum_hash[key] = new_instance
-        @_enums_by_value[value] = new_instance
+      new_instance = new(key, value)
+      @_enum_hash[key] = new_instance
+      @_enums_by_value[value] = new_instance
 
-        if key.to_s == key.to_s.upcase
-          const_set key, value
-        else
-          define_singleton_method(key) { value }
-        end
+      if key.to_s == key.to_s.upcase
+        const_set key, value
+      else
+        define_singleton_method(key) { value }
       end
+    end
 
-      def each(&block)
-        @_enum_hash.each(&block)
-      end
+    def each(&block)
+      @_enum_hash.each(&block)
+    end
 
-      def parse(k)
-        k = k.to_s.upcase
-        each do |key, enum|
-          return enum.value if key.to_s.upcase == k
-        end
-        nil
+    def parse(k)
+      k = k.to_s.upcase
+      each do |key, enum|
+        return enum.value if key.to_s.upcase == k
       end
+      nil
+    end
 
-      def key?(k)
-        @_enum_hash.key?(k)
-      end
+    def key?(k)
+      @_enum_hash.key?(k)
+    end
 
-      def value(k)
-        enum = @_enum_hash[k]
-        enum.value if enum
-      end
+    def value(k)
+      enum = @_enum_hash[k]
+      enum.value if enum
+    end
 
-      def value?(v)
-        @_enums_by_value.key?(v)
-      end
+    def value?(v)
+      @_enums_by_value.key?(v)
+    end
 
-      def key(v)
-        enum = @_enums_by_value[v]
-        enum.key if enum
-      end
+    def key(v)
+      enum = @_enums_by_value[v]
+      enum.key if enum
+    end
 
-      def keys
-        @_enum_hash.values.map(&:key)
-      end
+    def keys
+      @_enum_hash.values.map(&:key)
+    end
 
-      def values
-        @_enum_hash.values.map(&:value)
-      end
+    def values
+      @_enum_hash.values.map(&:value)
+    end
 
-      def to_h
-        Hash[@_enum_hash.map do |key, enum|
-          [key, enum.value]
-        end]
-      end
+    def to_h
+      Hash[@_enum_hash.map do |key, enum|
+        [key, enum.value]
+      end]
     end
   end
 end

data/lib/emery/jsoner.rb

@@ -1,188 +1,218 @@
 require "json"
 require "date"
 
-require "emery/type"
+class JsonerError < StandardError
+end
 
-module Emery
-  class JsonerError < StandardError
+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
 
-  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
+  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) }
+  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
-      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) }
+      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
+  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
-      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
+      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 TypeError
-          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
-        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
+      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
+  end
 
-    T::Nilable.class_eval do
-      def jsoner_deserialize(json_value)
-        if json_value != nil
-          Jsoner.deserialize(self.type, json_value)
-        else
-          nil
-        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")
       end
-      def jsoner_serialize(value)
-        if value != nil
-          Jsoner.serialize(self.type, value)
-        else
-          nil
-        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
 
-    module FloatSerializer
-      def self.jsoner_deserialize(json_value)
-        T.check(T.any(Float, Integer), json_value)
-        json_value.to_f
+  T::Nilable.class_eval do
+    def jsoner_deserialize(json_value)
+      if json_value != nil
+        Jsoner.deserialize(self.type, json_value)
+      else
+        nil
       end
-      def self.jsoner_serialize(value)
-        T.check(Float, value)
+    end
+    def jsoner_serialize(value)
+      if value != nil
+        Jsoner.serialize(self.type, value)
+      else
+        nil
       end
     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
+  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 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')
+  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
-
-    @@serializers = {
-        Float => FloatSerializer,
-        Date => DateSerializer,
-        DateTime => DateTimeSerializer
-    }
-    def self.add_serializer(type, serializer)
-      @@serializers[type] = serializer
+    def self.jsoner_serialize(value)
+      T.check(DateTime, value)
+      value.strftime('%Y-%m-%dT%H:%M:%S')
     end
+  end
 
-    def Jsoner.from_json(type, json)
-      data = JSON.parse(json)
-      return deserialize(type, data)
+  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
 
-    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)
+  @@serializers = {
+      Float => FloatSerializer,
+      Date => DateSerializer,
+      DateTime => DateTimeSerializer
+  }
+  def self.add_serializer(type, serializer)
+    @@serializers[type] = serializer
+  end
+
+  def Jsoner.from_json(type, json)
+    data = JSON.parse(json)
+    return deserialize(type, data)
+  end
+
+  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
-      rescue StandardError => error
-        raise JsonerError.new(error.message)
+        return T.check(type, json_value)
       end
+    rescue StandardError => error
+      raise JsonerError.new(error.message)
     end
+  end
 
-    def Jsoner.to_json(type, value)
-      JSON.dump(serialize(type, value))
-    end
+  def Jsoner.to_json(type, value)
+    JSON.dump(serialize(type, value))
+  end
 
-    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)
+  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
-      rescue StandardError => error
-        raise JsonerError.new(error.message)
+        return T.check(type, value)
       end
+    rescue StandardError => error
+      raise JsonerError.new(error.message)
     end
   end
 end