Full support for case variant objects.

Author: treeform

README.md

@@ -231,3 +231,18 @@ thing.toStaticJson()
 ```
 
 Make sure `thing` is a `static` or a `const` value and you will get a compile time string with your JSON.
+
+### Full support for case variant objects.
+
+Case variant objects like this are fully supported:
+
+```nim
+t=oe RefNode = ref object
+  case kind: NodeNumKind  # The ``kind`` field is the discriminator.
+  of nkInt: intVal: int
+  of nkFloat: floatVal: float
+```
+
+The discriminator do no have to come first, if they do come in the middle this
+library will scan the object, find the discriminator field, then rewind and
+parse the object normally.

src/jsony.nim

@@ -1,4 +1,4 @@
-import macros, strutils, tables, unicode
+import jsony/objvar, strutils, tables, unicode
 
 type JsonError* = object of ValueError
 
@@ -220,10 +220,7 @@ proc skipValue(s: string, i: var int) =
   else:
     discard parseSymbol(s, i)
 
-proc camelCase(s: string): string =
-  return s
-
-proc snakeCase(s: string): string =
+proc snakeCaseDynamic(s: string): string =
   if s.len == 0:
     return
   var prevCap = false
@@ -237,39 +234,9 @@ proc snakeCase(s: string): string =
       prevCap = false
       result.add c
 
-macro fieldsMacro(v: typed, key: string) =
-  ## Crates a parser for object fields.
-  result = nnkCaseStmt.newTree(ident"key")
-  # Get implementation of v's type.
-  var impl = getTypeImpl(v)
-  # Walk refs and pointers to the real type.
-  while impl.kind in {nnkRefTy, nnkPtrTy}:
-    impl = getTypeImpl(impl[0])
-  # For each field in the type:
-  var used: seq[string]
-  for f in impl[2]:
-    # Get fields name and type information.
-    let fieldName = f[0]
-    let filedNameStr = fieldName.strVal()
-    let filedType = f[1]
-    # Output a name/type checker for it:
-    for fn in [camelCase, snakeCase]:
-      let caseName = fn(filedNameStr)
-      if caseName in used:
-        continue
-      used.add(caseName)
-      let ofClause = nnkOfBranch.newTree(newLit(caseName))
-      let body = quote:
-        var value: `filedType`
-        parseHook(s, i, value)
-        v.`fieldName` = value
-      ofClause.add(body)
-      result.add(ofClause)
-  let ofElseClause = nnkElse.newTree()
-  let body = quote:
-    skipValue(s, i)
-  ofElseClause.add(body)
-  result.add(ofElseClause)
+template snakeCase(s: string): string =
+  const k = snakeCaseDynamic(s)
+  k
 
 proc parseHook*[T: enum](s: string, i: var int, v: var T) =
   eatSpace(s, i)
@@ -291,16 +258,37 @@ proc parseHook*[T: enum](s: string, i: var int, v: var T) =
       error("Can't parse enum.", i)
 
 proc parseHook*[T: object|ref object](s: string, i: var int, v: var T) =
-  ## Parse an object.
+  ## Parse an object or ref object.
   eatSpace(s, i)
   if i + 3 < s.len and s[i+0] == 'n' and s[i+1] == 'u' and s[i+2] == 'l' and s[i+3] == 'l':
     i += 4
     return
   eatChar(s, i, '{')
-  when compiles(newHook(v)):
-    newHook(v)
-  elif compiles(new(v)):
-    new(v)
+  when not v.isObjectVariant:
+    when compiles(newHook(v)):
+      newHook(v)
+    elif compiles(new(v)):
+      new(v)
+  else:
+    # Look for the discriminatorFieldName
+    eatSpace(s, i)
+    var saveI = i
+    while i < s.len:
+      var key: string
+      parseHook(s, i, key)
+      eatChar(s, i, ':')
+      if key == v.discriminatorFieldName:
+        var discriminator: type(v.discriminatorField)
+        parseHook(s, i, discriminator)
+        new(v, discriminator)
+        when compiles(newHook(v)):
+          newHook(v)
+        break
+      skipValue(s, i)
+      if i < s.len and s[i] == '}':
+        error("No discriminator field.", i)
+      eatChar(s, i, ',')
+    i = saveI
   while i < s.len:
     eatSpace(s, i)
     if i < s.len and s[i] == '}':
@@ -310,7 +298,14 @@ proc parseHook*[T: object|ref object](s: string, i: var int, v: var T) =
     eatChar(s, i, ':')
     when compiles(renameHook(v, key)):
       renameHook(v, key)
-    fieldsMacro(v, key)
+    block all:
+      for k, v in v.fieldPairs:
+        if k == key or snakeCase(k) == key:
+          var v2: type(v)
+          parseHook(s, i, v2)
+          v = v2
+          break all
+      skipValue(s, i)
     eatSpace(s, i)
     if i < s.len and s[i] == ',':
       inc i
@@ -339,15 +334,6 @@ proc parseHook*[T](s: string, i: var int, v: var Table[string, T]) =
       break
   eatChar(s, i, '}')
 
-# proc fromJson*[T](s: string): T =
-#   ## Takes json and outputs the object it represents.
-#   ## * Extra json fields are ignored.
-#   ## * Missing json fields keep their default values.
-#   ## * `proc newHook(foo: var ...)` Can be used to populate default values.
-
-#   var i = 0
-#   parseHook(s, i, result)
-
 proc fromJson*[T](s: string, x: typedesc[T]): T =
   ## Takes json and outputs the object it represents.
   ## * Extra json fields are ignored.

src/jsony/objvar.nim

@@ -0,0 +1,53 @@
+import macros
+
+proc hasKind(node: NimNode, kind: NimNodeKind): bool =
+  for c in node.children:
+    if c.kind == kind:
+      return true
+  return false
+
+proc `[]`(node: NimNode, kind: NimNodeKind): NimNode =
+  for c in node.children:
+    if c.kind == kind:
+      return c
+  return nil
+
+template fieldPairs*[T: ref object](x: T): untyped =
+  x[].fieldPairs
+
+macro isObjectVariant*(v: typed): bool =
+  ## Is this an object variant?
+  var typ = v.getTypeImpl()
+  if typ.kind == nnkSym:
+    return ident("false")
+  while typ.kind != nnkObjectTy:
+    typ = typ[0].getTypeImpl()
+  if typ[2].hasKind(nnkRecCase):
+    ident("true")
+  else:
+    ident("false")
+
+proc discriminator*(v: NimNode): NimNode =
+  var typ = v.getTypeImpl()
+  while typ.kind != nnkObjectTy:
+    typ = typ[0].getTypeImpl()
+  return typ[nnkRecList][nnkRecCase][nnkIdentDefs][nnkSym]
+
+macro discriminatorFieldName*(v: typed): untyped =
+  ## Turns into the discriminator field.
+  return newLit($discriminator(v))
+
+macro discriminatorField*(v: typed): untyped =
+  ## Turns into the discriminator field.
+  let
+    fieldName = discriminator(v)
+  return quote do:
+    `v`.`fieldName`
+
+macro new*(v: typed, d: typed): untyped =
+  ## Creates a new object variant with the discriminator field.
+  let
+    typ = v.getTypeInst()
+    fieldName = discriminator(v)
+  return quote do:
+    `v` = `typ`(`fieldName`: `d`)

tests/test_objects.nim

@@ -164,37 +164,67 @@ var sizer = """{"size":10}""".fromJson(Sizer)
 doAssert sizer.size == 10
 doAssert sizer.originalSize == 10
 
-# block:
-
-#   type
-#     NodeNumKind = enum  # the different node types
-#       nkInt,          # a leaf with an integer value
-#       nkFloat,        # a leaf with a float value
-#     RefNode = ref object
-#       active: bool
-#       case kind: NodeNumKind  # the ``kind`` field is the discriminator
-#       of nkInt: intVal: int
-#       of nkFloat: floatVal: float
-#     ValueNode = object
-#       active: bool
-#       case kind: NodeNumKind  # the ``kind`` field is the discriminator
-#       of nkInt: intVal: int
-#       of nkFloat: floatVal: float
-
-#   block:
-#     var nodeNum = RefNode(kind: nkFloat, active: true, floatVal: 3.14)
-#     var nodeNum2 = RefNode(kind: nkInt, active: false, intVal: 42)
-
-#     doAssert nodeNum.toJson.fromJson(type(nodeNum)).floatVal == nodeNum.floatVal
-#     doAssert nodeNum2.toJson.fromJson(type(nodeNum2)).intVal == nodeNum2.intVal
-#     doAssert nodeNum.toJson.fromJson(type(nodeNum)).active == nodeNum.active
-#     doAssert nodeNum2.toJson.fromJson(type(nodeNum2)).active == nodeNum2.active
-
-#   block:
-#     var nodeNum = ValueNode(kind: nkFloat, active: true, floatVal: 3.14)
-#     var nodeNum2 = ValueNode(kind: nkInt, active: false, intVal: 42)
-
-#     doAssert nodeNum.toJson.fromJson(type(nodeNum)).floatVal == nodeNum.floatVal
-#     doAssert nodeNum2.toJson.fromJson(type(nodeNum2)).intVal == nodeNum2.intVal
-#     doAssert nodeNum.toJson.fromJson(type(nodeNum)).active == nodeNum.active
-#     doAssert nodeNum2.toJson.fromJson(type(nodeNum2)).active == nodeNum2.active
+block:
+
+  type
+    NodeNumKind = enum  # the different node types
+      nkInt,          # a leaf with an integer value
+      nkFloat,        # a leaf with a float value
+    RefNode = ref object
+      active: bool
+      case kind: NodeNumKind  # the ``kind`` field is the discriminator
+      of nkInt: intVal: int
+      of nkFloat: floatVal: float
+    ValueNode = object
+      active: bool
+      case kind: NodeNumKind  # the ``kind`` field is the discriminator
+      of nkInt: intVal: int
+      of nkFloat: floatVal: float
+
+  block:
+    var nodeNum = RefNode(kind: nkFloat, active: true, floatVal: 3.14)
+    var nodeNum2 = RefNode(kind: nkInt, active: false, intVal: 42)
+    doAssert nodeNum.toJson.fromJson(type(nodeNum)).floatVal == nodeNum.floatVal
+    doAssert nodeNum2.toJson.fromJson(type(nodeNum2)).intVal == nodeNum2.intVal
+    doAssert nodeNum.toJson.fromJson(type(nodeNum)).active == nodeNum.active
+    doAssert nodeNum2.toJson.fromJson(type(nodeNum2)).active == nodeNum2.active
+
+  block:
+    # Test discriminator Field Name not being first.
+    let
+      a = """{"active":true,"kind":"nkFloat","floatVal":3.14}""".fromJson(RefNode)
+      b = """{"floatVal":3.14,"active":true,"kind":"nkFloat"}""".fromJson(RefNode)
+      c = """{"kind":"nkFloat","floatVal":3.14,"active":true}""".fromJson(RefNode)
+    doAssert a.kind == nkFloat
+    doAssert b.kind == nkFloat
+    doAssert c.kind == nkFloat
+
+  block:
+    # Test discriminator field name not being there.
+    doAssertRaises JsonError:
+      let
+        a = """{"active":true,"floatVal":3.14}""".fromJson(RefNode)
+
+  block:
+    var nodeNum = ValueNode(kind: nkFloat, active: true, floatVal: 3.14)
+    var nodeNum2 = ValueNode(kind: nkInt, active: false, intVal: 42)
+    doAssert nodeNum.toJson.fromJson(type(nodeNum)).floatVal == nodeNum.floatVal
+    doAssert nodeNum2.toJson.fromJson(type(nodeNum2)).intVal == nodeNum2.intVal
+    doAssert nodeNum.toJson.fromJson(type(nodeNum)).active == nodeNum.active
+    doAssert nodeNum2.toJson.fromJson(type(nodeNum2)).active == nodeNum2.active
+
+  block:
+    # Test discriminator Field Name not being first.
+    let
+      a = """{"active":true,"kind":"nkFloat","floatVal":3.14}""".fromJson(ValueNode)
+      b = """{"floatVal":3.14,"active":true,"kind":"nkFloat"}""".fromJson(ValueNode)
+      c = """{"kind":"nkFloat","floatVal":3.14,"active":true}""".fromJson(ValueNode)
+    doAssert a.kind == nkFloat
+    doAssert b.kind == nkFloat
+    doAssert c.kind == nkFloat
+
+  block:
+    # Test discriminator field name not being there.
+    doAssertRaises JsonError:
+      let
+        a = """{"active":true,"floatVal":3.14}""".fromJson(ValueNode)

tests/test_tojson.nim

@@ -39,7 +39,6 @@ block:
       b: float
       c: string
   var obj = Obj()
-  echo obj.toJson()
   doAssert obj.toJson() == """{"a":0,"b":0.0,"c":""}"""
   match obj
 
@@ -79,3 +78,31 @@ proc dumpHook(s: var string, v: Fraction) =
 
 var f = Fraction(numerator: 10, denominator: 13)
 doAssert f.toJson() == "\"10/13\""
+
+block:
+  type
+    NodeNumKind = enum  # the different node types
+      nkInt,          # a leaf with an integer value
+      nkFloat,        # a leaf with a float value
+    RefNode = ref object
+      active: bool
+      case kind: NodeNumKind  # the ``kind`` field is the discriminator
+      of nkInt: intVal: int
+      of nkFloat: floatVal: float
+    ValueNode = object
+      active: bool
+      case kind: NodeNumKind  # the ``kind`` field is the discriminator
+      of nkInt: intVal: int
+      of nkFloat: floatVal: float
+
+  var
+    refNode1 = RefNode(kind: nkFloat, active: true, floatVal: 3.14)
+    refNode2 = RefNode(kind: nkInt, active: false, intVal: 42)
+
+    valueNode1 = ValueNode(kind: nkFloat, active: true, floatVal: 3.14)
+    valueNode2 = ValueNode(kind: nkInt, active: false, intVal: 42)
+
+  doAssert refNode1.toJson() == """{"active":true,"kind":"nkFloat","floatVal":3.14}"""
+  doAssert refNode2.toJson() == """{"active":false,"kind":"nkInt","intVal":42}"""
+  doAssert valueNode1.toJson() == """{"active":true,"kind":"nkFloat","floatVal":3.14}"""
+  doAssert valueNode2.toJson() == """{"active":false,"kind":"nkInt","intVal":42}"""