adds fromNif procs to nifply and supports enum and object types (#1217)

Author: demotomohiro

lib/std/nifply.nim

@@ -1,6 +1,7 @@
-import ../../src/lib/nifbuilder
+import std/assertions
+import ../../src/lib/[nifbuilder, nifreader]
 
-export open, close, extract
+export close, extract
 
 proc internalTypeName*[T](x: typedesc[T]): string {.magic: "InternalTypeName", noSideEffect.}
 
@@ -10,6 +11,12 @@ iterator internalFieldPairs*[T: tuple|object](x: T): tuple[key: string, val: unt
 type
   NifBuilder* = Builder
 
+proc nifBuilderOpen*(filename: string; compact = false): Builder =
+  nifbuilder.open(filename, compact)
+
+proc nifBuilderOpen*(sizeHint: int; compact = false): Builder =
+  nifbuilder.open(sizeHint, compact)
+
 proc toNif*(b: var NifBuilder; x: string) =
   b.addStrLit x
 
@@ -24,4 +31,85 @@ proc toNif*(b: var NifBuilder; x: float) =
 
 proc toNif*(b: var NifBuilder; x: bool) =
   b.addKeyw($x)
-  discard
+
+proc toNif*[E: enum](b: var NifBuilder; x: E) =
+  b.withTree "conv":
+    b.addSymbol internalTypeName(E)
+    b.addUIntLit uint(x)
+
+proc toNif*[O: object](b: var NifBuilder; x: O) =
+  b.withTree "oconstr":
+    b.addSymbol internalTypeName(O)
+    for name, f in internalFieldPairs(x):
+      b.withTree "kv":
+        b.addSymbol name
+        toNif b, f
+
+type
+  NifReader* = Reader
+
+proc nifReaderOpen*(filename: string): Reader =
+  nifreader.open(filename)
+
+proc nifReaderOpenFromBuffer*(buf: sink string): Reader =
+  nifreader.openFromBuffer(buf)
+
+template expectTree(r: var NifReader; tag: string; body: untyped) =
+  let t = r.next
+  assert t.tk == ParLe
+  assert t.s == tag
+  body
+  let t2 = r.next
+  assert t2.tk == ParRi
+
+proc expectSymbol(r: var NifReader; sym: string) =
+  let t = r.next
+  assert t.tk == Symbol
+  assert t.s == sym
+
+proc fromNif*[T: not typedesc](r: var NifReader; x: var T) {.untyped, inline.} =
+  x = r.fromNif T
+
+proc fromNif*(r: var NifReader; t: typedesc[string]): string =
+  let t = r.next
+  assert t.tk == StringLit
+  result = $t.s
+
+proc fromNif*(r: var NifReader; t: typedesc[int]): int =
+  let t = r.next
+  result = decodeInt t
+
+proc fromNif*(r: var NifReader; t: typedesc[uint]): uint =
+  let t = r.next
+  result = decodeUInt t
+
+proc fromNif*(r: var NifReader; t: typedesc[float]): float =
+  let t = r.next
+  result = decodeFloat t
+
+proc fromNif*(r: var NifReader; t: typedesc[bool]): bool =
+  let t = r.next
+
+  if t.s == "true":
+    result = true
+  elif t.s == "false":
+    result = false
+  else:
+    assert false, "got unexpected token: " & $t.s
+
+  let t2 = r.next
+  assert t2.tk == ParRi
+
+proc fromNif*[E: enum](r: var NifReader; t: typedesc[E]): E =
+  r.expectTree "conv":
+    r.expectSymbol internalTypeName E
+    let val = r.next
+    result = E decodeUInt val
+
+proc fromNif*[O: object](r: var NifReader; t: typedesc[O]): O =
+  r.expectTree "oconstr":
+    r.expectSymbol internalTypeName O
+    for name, f in internalFieldPairs(result):
+      r.expectTree "kv":
+        r.expectSymbol name
+        r.fromNif f

tests/nimony/stdlib/tnifply.nim

@@ -1,4 +1,4 @@
-import std/[nifply, syncio]
+import std/[assertions, nifply, syncio]
 
 type
   Foo = object
@@ -8,6 +8,16 @@ type
     barFieldX: string
     barFieldY: float
 
+  TestEnum = enum
+    teX
+    teY
+    teZ
+
+  FooBar = object
+    foo: Foo
+    bar: Bar
+    en: TestEnum
+
 echo internalTypeName(Foo)
 echo internalTypeName(Bar)
 
@@ -34,31 +44,87 @@ testInternalFieldPairs(y)
 
 const DefaultBufSize = 8
 block:
-  var b = open(DefaultBufSize)
+  var b = nifBuilderOpen(DefaultBufSize)
   b.toNif "hello"
   echo b.extract
 
 block:
-  var b = open(DefaultBufSize)
+  var b = nifBuilderOpen(DefaultBufSize)
   b.toNif 123
   echo b.extract
 
 block:
-  var b = open(DefaultBufSize)
+  var b = nifBuilderOpen(DefaultBufSize)
   b.toNif 123'u
   echo b.extract
 
 block:
-  var b = open(DefaultBufSize)
+  var b = nifBuilderOpen(DefaultBufSize)
   b.toNif 123.456
   echo b.extract
 
 block:
-  var b = open(DefaultBufSize)
+  var b = nifBuilderOpen(DefaultBufSize)
   b.toNif true
   echo b.extract
 
 block:
-  var b = open(DefaultBufSize)
+  var b = nifBuilderOpen(DefaultBufSize)
   b.toNif false
   echo b.extract
+
+block:
+  var b = nifBuilderOpen(DefaultBufSize)
+  b.toNif teX
+  echo b.extract
+
+block:
+  var b = nifBuilderOpen(DefaultBufSize)
+  b.toNif Foo(fooFieldX: 123)
+  b.toNif Bar(barFieldX: "bar field X", barFieldY: 321)
+  b.toNif FooBar(foo: Foo(fooFieldX: 321), bar: Bar(barFieldX: "bar", barFieldY: 567.5), en: teY)
+  echo b.extract
+
+block:
+  var b = nifBuilderOpen(DefaultBufSize)
+  const TestString = "test string"
+  b.toNif TestString
+  const TestInt = 1234567
+  b.toNif TestInt
+  const TestUint = 1234567'u
+  b.toNif TestUint
+  const TestFloat = 0.125
+  b.toNif TestFloat
+  b.toNif false
+  b.toNif true
+  b.toNif teX
+  b.toNif teY
+  b.toNif teZ
+  let testFoo = Foo(fooFieldX: 987)
+  b.toNif testFoo
+  let testBar = Bar(barFieldX: "bar field", barFieldY: 1.75)
+  b.toNif testBar
+  let testFooBar = FooBar(foo: Foo(fooFieldX: 4567), bar: Bar(barFieldX: "foobar", barFieldY: 2.625), en: teZ)
+  b.toNif testFooBar
+
+  var r = nifReaderOpenFromBuffer(b.extract)
+  assert r.fromNif(string) == TestString
+  assert r.fromNif(int) == TestInt
+  assert r.fromNif(uint) == TestUint
+  assert r.fromNif(float) == TestFloat
+  assert not r.fromNif(bool)
+  assert r.fromNif(bool)
+  assert r.fromNif(TestEnum) == teX
+  assert r.fromNif(TestEnum) == teY
+  assert r.fromNif(TestEnum) == teZ
+  let readFoo = r.fromNif(Foo)
+  assert readFoo.fooFieldX == testFoo.fooFieldX
+  let readBar = r.fromNif(Bar)
+  assert readBar.barFieldX == testBar.barFieldX
+  assert readBar.barFieldY == testBar.barFieldY
+  var readFooBar = default FooBar
+  r.fromNif readFooBar
+  assert readFooBar.foo.fooFieldX == testFooBar.foo.fooFieldX
+  assert readFooBar.bar.barFieldX == testFooBar.bar.barFieldX
+  assert readFooBar.bar.barFieldY == testFooBar.bar.barFieldY
+  assert readFooBar.en == testFooBar.en

tests/nimony/stdlib/tnifply.output

@@ -14,3 +14,17 @@ barFieldY.0.tni7snh9s = 456
 +123.456
 (true)
 (false)
+(conv TestEnum.0.tni7snh9s +0u)
+(oconstr Foo.0.tni7snh9s
+ (kv fooFieldX.0.tni7snh9s +123))(oconstr Bar.0.tni7snh9s
+ (kv barFieldX.0.tni7snh9s "bar field X")
+ (kv barFieldY.0.tni7snh9s +321))(oconstr FooBar.0.tni7snh9s
+ (kv foo.0.tni7snh9s
+  (oconstr Foo.0.tni7snh9s
+   (kv fooFieldX.0.tni7snh9s +321)))
+ (kv bar.0.tni7snh9s
+  (oconstr Bar.0.tni7snh9s
+   (kv barFieldX.0.tni7snh9s "bar")
+   (kv barFieldY.0.tni7snh9s +567.5)))
+ (kv en.0.tni7snh9s
+  (conv TestEnum.0.tni7snh9s +1u)))