Add serialization.

Author: treeform

README.md

@@ -1,16 +1,42 @@
-# JSONy - A loose, direct to object json parser with hooks.
+# JSONy - A loose, direct to object json parser and serializer with hooks.
 
 `nimble install jsony`
 
+```nim
+@[1, 2, 3].toJson() -> "[1,2,3]"
+"[1, 2, 3]".fromJson(seq[int]) -> @[1, 2, 3]
+```
+
 Real world json is *never what you want*. It might have extra fields that you don't care about. It might have missing fields requiring default values. It might change or grow new fields at any moment. Json might use `camelCase` or `snake_case`. It might use inconsistent naming.
 
-With this library you can parse json your way, from the mess you get to the objects you want.
+With this library you can use json your way, from the mess you get to the objects you want.
+
+## Fast.
+
+Currently the Nim standard module first parses or serializes json into JsonNodes and then turns the JsonNodes into your objects with the `to()` macro. This is slower and creates unnecessary work for the garbage collector. This library skips the JsonNodes and creates the objects you want directly.
 
-## Fast/No garbage.
+Another speed up comes from not using `StringStream`. `Stream` has a function dispatch overhead because it has not know if you are using it as a `StringStream` or `FileStream`. Jsony skips the overhead and just directly writes to memory buffers.
+
+### Parse speed.
+```
+name ............................... min time      avg time    std dv  times
+treeform/jsony .................... 10.121 ms     10.809 ms    ±1.208   x100
+planetis-m/eminim ................. 12.006 ms     12.574 ms    ±1.156   x100
+nim std/json ...................... 23.282 ms     34.679 ms    ±7.512   x100
+```
+
+### Serialize speed.
+```
+name ............................... min time      avg time    std dv  times
+treeform/jsony ..................... 4.047 ms      4.172 ms    ±0.225   x100
+planetis-m/eminim .................. 7.173 ms      7.324 ms    ±0.253   x100
+disruptek/jason ................... 10.220 ms     11.155 ms    ±0.689   x100
+nim std/json ...................... 11.526 ms     15.181 ms    ±0.857   x100
+```
 
-Currently the Nim standard module first parses json into JsonNodes and then turns the JsonNodes into your objects with the `to()` macro. This is slower and creates unnecessary work for the garbage collector. This library skips the JsonNodes and creates the objects you want directly.
+Note: If you find a faster nim json parser or serializer let me know!
 
-## Can parse most object types:
+## Can parse or serializer most types:
 
 * numbers and strings
 * objects and ref objects
@@ -169,3 +195,25 @@ Gives us:
   (id: "3", count: 99, filled: 99)
 ]"""
 ```
+
+### `proc dumpHook()` Can be used to serializer into custom representation.
+
+Just like reading custom data types you can also write faster data types with `dumpHook`. Using `Fraction` from the above example:
+
+```nim
+proc dumpHook(s: var string, v: Fraction) =
+  ## Output fraction type as a string "x/y".
+  s.add '"'
+  s.add $v.numerator
+  s.add '/'
+  s.add $v.denominator
+  s.add '"'
+
+var f = Fraction(numerator: 10, denominator: 13)
+let s = f.toJson()
+```
+
+Gives us:
+```
+"10/13"
+```

src/jsony.nim

@@ -302,3 +302,81 @@ proc fromJson*[T](s: string): T =
 
   var i = 0
   parseHook(s, i, result)
+
+proc dumpHook*(s: var string, v: bool) =
+  if v:
+    s.add "true"
+  else:
+    s.add "false"
+
+proc dumpHook*(s: var string, v: SomeNumber) =
+  s.add $v
+
+proc dumpHook*(s: var string, v: string) =
+  s.add '"'
+  for c in v:
+    case c:
+    of '\\': s.add r"\\"
+    of '\b': s.add r"\b"
+    of '\f': s.add r"\f"
+    of '\n': s.add r"\n"
+    of '\r': s.add r"\r"
+    of '\t': s.add r"\t"
+    else:
+      s.add c
+  s.add '"'
+
+proc dumpHook*(s: var string, v: char) =
+  s.add '"'
+  s.add v
+  s.add '"'
+
+proc dumpHook*(s: var string, v: object) =
+  s.add '{'
+  var i = 0
+  when compiles(for k, e in v.pairs: discard):
+    # Tables and table like objects.
+    for k, e in v.pairs:
+      if i > 0:
+        s.add ','
+      s.dumpHook(k)
+      s.add ':'
+      s.dumpHook(e)
+      inc i
+  else:
+    # Normal objects.
+    for k, e in v.fieldPairs:
+      if i > 0:
+        s.add ','
+      s.dumpHook(k)
+      s.add ':'
+      s.dumpHook(e)
+      inc i
+  s.add '}'
+
+proc dumpHook*(s: var string, v: ref object) =
+  if v == nil:
+    s.add "null"
+  else:
+    s.dumpHook(v[])
+
+proc dumpHook*(s: var string, v: tuple) =
+  s.add '['
+  var i = 0
+  for _, e in v.fieldPairs:
+    if i > 0:
+      s.add ','
+    s.dumpHook(e)
+    inc i
+  s.add ']'
+
+proc dumpHook*[T](s: var string, v: openarray[T]) =
+  s.add '['
+  for i, e in v:
+    if i != 0:
+      s.add ','
+    s.dumpHook(e)
+  s.add ']'
+
+proc toJson*[T](v: T): string =
+  dumpHook(result, v)

tests/bench.nim

@@ -1,8 +1,11 @@
-import benchy, random, json, jsony, eminim, streams, jsutils/jsons
-from packedjson import parseJson, toJsonNode
-from packedjson/deserialiser import to
+import benchy, random, streams
+import jsony, jason
+import eminim
+#import packedjson, packedjson/deserialiser
+import json
 
 type Node = ref object
+  active: bool
   kind: string
   name: string
   id: int
@@ -13,30 +16,54 @@ var genId: int
 proc genTree(depth: int): Node =
   result = Node()
   result.id = genId
+  if r.rand(0 .. 1) == 0:
+    result.active = true
   inc genId
   result.name = "node" & $result.id
   result.kind = "NODE"
   if depth > 0:
     for i in 0 .. r.rand(0..3):
       result.kids.add genTree(depth - 1)
+    for i in 0 .. r.rand(0..3):
+      result.kids.add nil
 
 var tree = genTree(10)
 
-var treeStr = pretty(%tree)
+var treeStr = tree.toJson()
 
 echo genId, " node tree:"
 
-timeIt "treeform/jsony":
+timeIt "treeform/jsony", 100:
   keep jsony.fromJson[Node](treeStr)
 
-timeIt "nim std/json":
-  keep json.parseJson(treeStr).to(Node)
-
-timeIt "araq/packedjson":
-  keep deserialiser.to(packedjson.parseJson(treeStr).toJsonNode(), Node)
+timeIt "nim std/json", 100:
+  keep json.to(json.parseJson(treeStr), Node)
 
-timeIt "treeform/jsutils/jsons":
-  keep jsons.fromJson(json.parseJson(treeStr), Node)
+# timeIt "araq/packedjson", 100:
+#   keep deserialiser.to(packedjson.parseJson(treeStr), Node)
 
-timeIt "planetis-m/eminim":
+timeIt "planetis-m/eminim", 100:
   keep newStringStream(treeStr).jsonTo(Node)
+
+# timeIt "disruptek/jason", 100:
+#   discard
+
+echo "serialize:"
+
+timeIt "treeform/jsony", 100:
+  keep tree.toJson()
+
+timeIt "nim std/json", 100:
+  keep json.`$`(json.`%`(tree))
+
+# timeIt "araq/packedjson", 100:
+#   keep packedjson.`$`(packedjson.`%`(tree))
+
+timeIt "planetis-m/eminim", 100:
+  var s = newStringStream()
+  s.storeJson(tree)
+  s.setPosition(0)
+  keep s.data
+
+timeIt "disruptek/jason", 100:
+  keep tree.jason

tests/test_tojson.nim

@@ -0,0 +1,80 @@
+import jsony, strutils, json, tables
+
+proc match[T](what: T) =
+  doAssert what.toJson() == $(%what)
+
+doAssert 1.uint8.toJson() == "1"
+doAssert 1.uint16.toJson() == "1"
+doAssert 1.uint32.toJson() == "1"
+doAssert 1.uint64.toJson() == "1"
+doAssert 1.int8.toJson() == "1"
+doAssert 1.int16.toJson() == "1"
+doAssert 1.int32.toJson() == "1"
+doAssert 1.int64.toJson() == "1"
+doAssert 3.14.float32.toJson() == "3.140000104904175"
+doAssert 3.14.float64.toJson() == "3.14"
+
+match 1
+match 3.14.float32
+match 3.14.float64
+
+doAssert [1, 2, 3].toJson() == "[1,2,3]"
+doAssert @[1, 2, 3].toJson() == "[1,2,3]"
+
+match [1, 2, 3]
+match @[1, 2, 3]
+
+doAssert true.toJson == "true"
+doAssert false.toJson == "false"
+
+doAssert 'a'.toJson == "\"a\""
+match "hi there"
+match "hi\nthere\b\f\n\r\t"
+match "как дела"
+
+block:
+  type
+    Obj = object
+      a: int
+      b: float
+      c: string
+  var obj = Obj()
+  doAssert obj.toJson() == """{"a":0,"b":0.0,"c":""}"""
+  match obj
+
+block:
+  type
+    Obj = ref object
+      a: int
+      b: float
+      c: string
+  var obj = Obj()
+  doAssert obj.toJson() == """{"a":0,"b":0.0,"c":""}"""
+  match obj
+
+  var obj2: Obj
+  doAssert obj2.toJson() == "null"
+  match obj
+
+var t = (1, 2.2, "hi")
+doAssert t.toJson() == """[1,2.2,"hi"]"""
+
+var tb: Table[string, int]
+tb["hi"] = 1
+tb["bye"] = 2
+doAssert tb.toJson() == """{"hi":1,"bye":2}"""
+
+type Fraction = object
+  numerator: int
+  denominator: int
+
+proc dumpHook(s: var string, v: Fraction) =
+  ## Output fraction type as a string "x/y".
+  s.add '"'
+  s.add $v.numerator
+  s.add '/'
+  s.add $v.denominator
+  s.add '"'
+
+var f = Fraction(numerator: 10, denominator: 13)
+doAssert f.toJson() == "\"10/13\""