Flavor automatic serialization (#122)

* Flavor automatic serialization

* Range is a typeclass

* Add range typeclass

* Add distinct typeclass

* cleanup

* Fix import

* Does not works with nim 1.6

* fix

Author: jangko

json_serialization/format.nim

@@ -8,9 +8,48 @@
 # those terms.
 
 import
-  serialization/[formats, object_serialization]
+  serialization/[formats, object_serialization],
+  ./types
+
+from std/json import JsonNode
+
+export formats, JsonNode
+
+template generateJsonAutoSerializationAddon*(FLAVOR: typed) {.dirty.} =
+  generateAutoSerializationAddon(FLAVOR)
+
+  template automaticPrimitivesSerialization*(F: type FLAVOR, enable: static[bool]) =
+    ## Set all supported primitives automatic serialization flag.
+    static:
+      F.setAutoSerialize(string, enable)
+      F.setAutoSerialize(seq[char], enable)
+      F.setAutoSerialize(bool, enable)
+      F.setAutoSerialize(ref, enable)
+      F.setAutoSerialize(ptr, enable)
+      F.setAutoSerialize(enum, enable)
+      F.setAutoSerialize(SomeInteger, enable)
+      F.setAutoSerialize(SomeFloat, enable)
+      F.setAutoSerialize(seq, enable)
+      F.setAutoSerialize(array, enable)
+      F.setAutoSerialize(cstring, enable)
+      F.setAutoSerialize(openArray[char], enable)
+      F.setAutoSerialize(openArray, enable)
+      F.setAutoSerialize(range, enable)
+      F.setAutoSerialize(distinct, enable)
+
+  template automaticBuiltinSerialization*(F: type FLAVOR, enable: static[bool]) =
+    ## Enable or disable all builtin serialization.
+    automaticPrimitivesSerialization(F, enable)
+    static:
+      F.setAutoSerialize(JsonString, enable)
+      F.setAutoSerialize(JsonNode, enable)
+      F.setAutoSerialize(JsonNumber, enable)
+      F.setAutoSerialize(JsonVoid, enable)
+      F.setAutoSerialize(JsonValueRef, enable)
+      F.setAutoSerialize(object, enable)
+      F.setAutoSerialize(tuple, enable)
+
 
-export formats
 
 serializationFormat Json,
                     mimeType = "application/json"
@@ -44,6 +83,11 @@ template flavorEnumRep*(T: type Json, rep: static[EnumRepresentation]) =
   static:
     DefaultFlavorEnumRep = rep
 
+when declared(macrocache.hasKey): # Nim 1.6 have no macrocache.hasKey
+  # Keep backward compatibility behavior, DefaultFlavor always enable all built in serialization.
+  generateJsonAutoSerializationAddon(DefaultFlavor)
+  DefaultFlavor.automaticBuiltinSerialization(true)
+
 # We create overloads of these traits to force the mixin treatment of the symbols
 type DummyFlavor* = object
 template flavorUsesAutomaticObjectSerialization*(T: type DummyFlavor): bool = true
@@ -52,6 +96,10 @@ template flavorRequiresAllFields*(T: type DummyFlavor): bool = false
 template flavorAllowsUnknownFields*(T: type DummyFlavor): bool = false
 template flavorSkipNullFields*(T: type DummyFlavor): bool = false
 
+when declared(macrocache.hasKey): # Nim 1.6 have no macrocache.hasKey
+  generateJsonAutoSerializationAddon(DummyFlavor)
+  DummyFlavor.automaticBuiltinSerialization(false)
+
 template createJsonFlavor*(FlavorName: untyped,
                            mimeTypeValue = "application/json",
                            automaticObjectSerialization = false,
@@ -82,3 +130,12 @@ template createJsonFlavor*(FlavorName: untyped,
   template flavorEnumRep*(T: type FlavorName, rep: static[EnumRepresentation]) =
     static:
       `FlavorName EnumRep` = rep
+
+  when declared(macrocache.hasKey): # Nim 1.6 have no macrocache.hasKey
+    generateJsonAutoSerializationAddon(FlavorName)
+
+    # Set default to true for backward compatibility
+    # but user can call it again later with different value.
+    # Or fine tuning use `Flavor.automaticSerialization(type, true/false)`
+    FlavorName.automaticBuiltinSerialization(true)
+

json_serialization/reader_desc.nim

@@ -24,7 +24,7 @@ type
   JsonReader*[Flavor = DefaultFlavor] = object
     lex*: JsonLexer
 
-  JsonReaderError* = object of JsonError
+  JsonReaderError* = object of types.JsonError
     line*, col*: int
 
   UnexpectedField* = object of JsonReaderError

json_serialization/reader_impl.nim

@@ -225,6 +225,23 @@ proc readRecordValue*[T](r: var JsonReader, value: var T)
       else:
         r.raiseUnexpectedField(key, cstring typeName)
 
+template autoSerializeCheck(F: distinct type, T: distinct type) =
+  when declared(macrocache.hasKey): # Nim 1.6 have no macrocache.hasKey
+    mixin typeAutoSerialize
+    when not F.typeAutoSerialize(T):
+      const typeName = typetraits.name(T)
+      {.error: "automatic serialization is not enabled or readValue not implemented for `" &
+        typeName & "`".}
+
+template autoSerializeCheck(F: distinct type, TC: distinct type, M: distinct type) =
+  when declared(macrocache.hasKey): # Nim 1.6 have no macrocache.hasKey
+    mixin typeClassOrMemberAutoSerialize
+    when not F.typeClassOrMemberAutoSerialize(TC, M):
+      const typeName = typetraits.name(M)
+      const typeClassName = typetraits.name(TC)
+      {.error: "automatic serialization is not enabled or readValue not implemented for `" &
+        typeName & "` of typeclass `" & typeClassName & "`".}
+
 proc readValue*[T](r: var JsonReader, value: var T)
                   {.raises: [SerializationError, IOError].} =
   ## Master field/object parser. This function relies on
@@ -241,31 +258,41 @@ proc readValue*[T](r: var JsonReader, value: var T)
   ##       value = reader.readValue(int).FancyInt
   mixin readValue
 
+  type Flavor = JsonReader.Flavor
+
   when value is JsonString:
+    autoSerializeCheck(Flavor, JsonString)
     value = r.parseAsString()
 
   elif value is JsonNode:
+    autoSerializeCheck(Flavor, JsonNode)
     value = r.parseJsonNode()
 
   elif value is JsonNumber:
+    autoSerializeCheck(Flavor, JsonNumber)
     r.parseNumber(value)
 
   elif value is JsonVoid:
+    autoSerializeCheck(Flavor, JsonVoid)
     r.skipSingleJsValue()
 
   elif value is JsonValueRef:
+    autoSerializeCheck(Flavor, JsonValueRef)
     r.parseValue(value)
 
   elif value is string:
+    autoSerializeCheck(Flavor, string)
     value = r.parseString()
 
   elif value is seq[char]:
+    autoSerializeCheck(Flavor, seq[char])
     let val = r.parseString()
     value.setLen(val.len)
     for i in 0..<val.len:
       value[i] = val[i]
 
   elif isCharArray(value):
+    autoSerializeCheck(Flavor, array, typeof(value))
     let val = r.parseString()
     if val.len != value.len:
       # Raise tkString because we expected a `"` earlier
@@ -274,9 +301,16 @@ proc readValue*[T](r: var JsonReader, value: var T)
       value[i] = val[i]
 
   elif value is bool:
+    autoSerializeCheck(Flavor, bool)
     value = r.parseBool()
 
   elif value is ref|ptr:
+    when value is ref:
+      autoSerializeCheck(Flavor, ref, typeof(value))
+
+    when value is ptr:
+      autoSerializeCheck(Flavor, ptr, typeof(value))
+
     when compiles(isNotNilCheck(value)):
       allocPtr value
       value[] = readValue(r, type(value[]))
@@ -289,26 +323,31 @@ proc readValue*[T](r: var JsonReader, value: var T)
         value[] = readValue(r, type(value[]))
 
   elif value is enum:
+    autoSerializeCheck(Flavor, enum, typeof(value))
     r.parseEnum(value)
 
   elif value is SomeInteger:
+    autoSerializeCheck(Flavor, SomeInteger, typeof(value))
     value = r.parseInt(typeof value,
       JsonReaderFlag.portableInt in r.lex.flags)
 
   elif value is SomeFloat:
+    autoSerializeCheck(Flavor, SomeFloat, typeof(value))
     let val = r.parseNumber(uint64)
     if val.isFloat:
       value = r.toFloat(val, typeof value)
     else:
       value = T(val.integer)
 
   elif value is seq:
+    autoSerializeCheck(Flavor, seq, typeof(value))
     r.parseArray:
       let lastPos = value.len
       value.setLen(lastPos + 1)
       readValue(r, value[lastPos])
 
   elif value is array:
+    autoSerializeCheck(Flavor, array, typeof(value))
     type IDX = typeof low(value)
     r.parseArray(idx):
       if idx < value.len:
@@ -318,9 +357,17 @@ proc readValue*[T](r: var JsonReader, value: var T)
         r.raiseUnexpectedValue("Too many items for " & $(typeof(value)))
 
   elif value is (object or tuple):
+    when declared(macrocache.hasKey): # Nim 1.6 have no macrocache.hasKey
+      when value is object:
+        autoSerializeCheck(Flavor, object, typeof(value))
+
+      when value is tuple:
+        autoSerializeCheck(Flavor, tuple, typeof(value))
+
+    # Keep existing object/tuple auto serialization
+    # But make it deprecated.
     mixin flavorUsesAutomaticObjectSerialization
 
-    type Flavor = JsonReader.Flavor
     const isAutomatic =
       flavorUsesAutomaticObjectSerialization(Flavor)
 

json_serialization/writer.nim

@@ -380,35 +380,65 @@ template writeValue*(w: var JsonWriter, value: enum) =
   type Flavor = type(w).Flavor
   writeEnumImpl(w, value, Flavor.flavorEnumRep())
 
-template isStringLike(v: string|cstring|openArray[char]|seq[char]): bool = true
+type
+  StringLikeTypes = string|cstring|openArray[char]|seq[char]
+
+template isStringLike(v: StringLikeTypes): bool = true
 template isStringLike[N](v: array[N, char]): bool = true
 template isStringLike(v: auto): bool = false
 
+template autoSerializeCheck(F: distinct type, T: distinct type) =
+  when declared(macrocache.hasKey): # Nim 1.6 have no macrocache.hasKey
+    mixin typeAutoSerialize
+    when not F.typeAutoSerialize(T):
+      const typeName = typetraits.name(T)
+      {.error: "automatic serialization is not enabled or writeValue not implemented for `" &
+        typeName & "`".}
+
+template autoSerializeCheck(F: distinct type, TC: distinct type, M: distinct type) =
+  when declared(macrocache.hasKey): # Nim 1.6 have no macrocache.hasKey
+    mixin typeClassOrMemberAutoSerialize
+    when not F.typeClassOrMemberAutoSerialize(TC, M):
+      const typeName = typetraits.name(M)
+      const typeClassName = typetraits.name(TC)
+      {.error: "automatic serialization is not enabled or writeValue not implemented for `" &
+        typeName & "` of typeclass `" & typeClassName & "`".}
+
 proc writeValue*[V: not void](w: var JsonWriter, value: V) {.raises: [IOError].} =
   ## Write a generic value as JSON, using type-based dispatch. Overload this
   ## function to provide custom conversions of your own types.
   mixin writeValue
 
+  type Flavor = JsonWriter.Flavor
+
   when value is JsonNode:
+    autoSerializeCheck(Flavor, JsonNode)
     w.streamElement(s):
       s.write if w.hasPrettyOutput: value.pretty
               else: $value
 
   elif value is JsonString:
+    autoSerializeCheck(Flavor, JsonString)
     w.streamElement(s):
       s.write $value
 
   elif value is JsonVoid:
+    autoSerializeCheck(Flavor, JsonVoid)
     discard
 
   elif value is ref:
+    autoSerializeCheck(Flavor, ref, typeof(value))
     if value.isNil:
       w.streamElement(s):
         s.write "null"
     else:
       writeValue(w, value[])
 
   elif isStringLike(value):
+    when value isnot array:
+      autoSerializeCheck(Flavor, StringLikeTypes, typeof(value))
+    when value is array:
+      autoSerializeCheck(Flavor, array, typeof(value))
     w.streamElement(s):
       when value is cstring:
         if value == nil:
@@ -439,36 +469,54 @@ proc writeValue*[V: not void](w: var JsonWriter, value: V) {.raises: [IOError].}
       s.write '"'
 
   elif value is bool:
+    autoSerializeCheck(Flavor, bool)
     w.streamElement(s):
       s.write if value: "true" else: "false"
 
   elif value is range:
+    autoSerializeCheck(Flavor, range, typeof(value))
     when low(typeof(value)) < 0:
       w.writeValue int64(value)
     else:
       w.writeValue uint64(value)
 
   elif value is SomeInteger:
+    autoSerializeCheck(Flavor, SomeInteger, typeof(value))
     w.streamElement(s):
       s.writeText value
 
   elif value is SomeFloat:
+    autoSerializeCheck(Flavor, SomeFloat, typeof(value))
     w.streamElement(s):
       # TODO Implement writeText for floats
       #      to avoid the allocation here:
       s.write $value
 
   elif value is (seq or array or openArray) or
       (value is distinct and distinctBase(value) is (seq or array or openArray)):
+
+    when value is seq or(value is distinct and distinctBase(value) is seq):
+      autoSerializeCheck(Flavor, seq, typeof(value))
+    when value is array or(value is distinct and distinctBase(value) is array):
+      autoSerializeCheck(Flavor, array, typeof(value))
+    when value is openArray or(value is distinct and distinctBase(value) is openArray):
+      autoSerializeCheck(Flavor, openArray, typeof(value))
     when value is distinct:
       w.writeArray(distinctBase value)
     else:
       w.writeArray(value)
 
   elif value is (distinct or object or tuple):
+    when declared(macrocache.hasKey):# Nim 1.6 have no macrocache.hasKey
+      when value is object:
+        autoSerializeCheck(Flavor, object, typeof(value))
+      when value is tuple:
+        autoSerializeCheck(Flavor, tuple, typeof(value))
+      when value is distinct:
+        autoSerializeCheck(Flavor, distinct, typeof(value))
+
     mixin flavorUsesAutomaticObjectSerialization
 
-    type Flavor = JsonWriter.Flavor
     const isAutomatic =
       flavorUsesAutomaticObjectSerialization(Flavor)