Implement stringify

Author: gilbert

index.ts

@@ -1,5 +1,6 @@
 import {Pos, ZamlError, Schema} from './src/util'
 import {parseSchema} from './src/schema'
+import {stringify as str, StringifyOptions} from './src/stringify'
 import {lex, parseZaml, ParseOptions} from './src/parser'
 
 export {parseSchema} from './src/schema'
@@ -25,3 +26,7 @@ export function parse (source: string, schema: string | Schema.Block, options: P
     throw e
   }
 }
+
+export function stringify (value: any, schema: string | Schema.Block, options: StringifyOptions={}) {
+  return str(value, typeof schema === 'string' ? parseSchema(schema) : schema, options) + '\n'
+}

src/parser.ts

@@ -389,7 +389,9 @@ function parseArgs (
       }
       continue
     }
-    throw new ZamlError('syntax-error', pos, unexp(c2, ' (did you forget a comma?)'))
+    if (pos.i < source.length) {
+      throw new ZamlError('syntax-error', pos, unexp(c2, ' (did you forget a comma?)'))
+    }
   }
 
   return args

src/stringify.ts

@@ -0,0 +1,107 @@
+import { Schema } from './util'
+
+export type StringifyOptions = {
+  indentDepth?: number
+}
+
+
+export function stringify (data: any, blockSchema: Schema.Block, opts: StringifyOptions): string {
+  const parts: string[] = []
+
+  const depth = opts.indentDepth || 0
+  const i_1 = indentation(depth)
+
+  const dataItems = blockSchema.type === 'hash'
+    ? Object.keys(blockSchema.schema).map(configKey => [configKey, data[configKey]])
+    : data
+
+  for (let [key, _value] of dataItems) {
+    console.log("Serialize", key, _value)
+
+    if ( _value === undefined ) continue;
+
+    let t = blockSchema.schema[key]
+    let [value, block] = ('block' in t && t.type !== 'list')
+      ? _value
+      : [_value, null]
+
+    if (
+      t.type === 'num' ||
+      t.type === 'str' ||
+      t.type === 'bool' ||
+      t.type === 'enum'
+    ) {
+      parts.push(i_1 + `${key} ${value}`)
+    }
+    else if (t.type === 'list') {
+      let i_2 = indentation(depth + 1)
+
+      parts.push(i_1 + `${key} {`)
+
+      if (Array.isArray(value)) {
+        for (let item of value) {
+
+          if (t.block) {
+            let [itemValue, itemBlock] = item
+            parts.push(i_2 + itemValue)
+            if (itemBlock) {
+              addBlockBracket(parts)
+              parts.push(stringify(itemBlock, t.block, indent(depth+1, opts)))
+              parts.push(i_2 + '}')
+            }
+          }
+          else {
+            parts.push(i_2 + item)
+          }
+        }
+      }
+      parts.push(i_1 + '}')
+    }
+    else if (t.type === 'kv') {
+      let i_2 = indentation(depth + 1)
+      parts.push(i_1 + `${key} {`)
+
+      for (let key in value) {
+        parts.push(i_2 + `${key} ${value[key]}`)
+      }
+
+      parts.push(i_1 + '}')
+    }
+    else if (t.type === 'tuple') {
+      parts.push(i_1 + `${key} ${value.join(', ')}`)
+    }
+    else if (t.type === 'hash' || t.type === 'array') {
+      parts.push(i_1 + `${key} {`)
+
+      parts.push(stringify(value, t, indent(depth, opts)))
+
+      parts.push(i_1 + '}')
+    }
+
+    if ('block' in t && t.block && block) {
+      addBlockBracket(parts)
+
+      parts.push(stringify(block, t.block, indent(depth, opts)))
+
+      parts.push(i_1 + '}')
+    }
+  }
+
+  return parts.join('\n')
+}
+
+function indentation (n: number) {
+  let result = ''
+  for (let i=0; i < n; i++) {
+    result += '  '
+  }
+  return result
+}
+
+function indent (depth: number, opts: StringifyOptions) {
+  return { ...opts, indentDepth: depth+1 }
+}
+
+function addBlockBracket (parts: string[]) {
+  parts[parts.length-1] = parts[parts.length-1] + ' {'
+}

tests/regression-tests.js

@@ -23,4 +23,9 @@ o.spec("Regression tests", function () {
       }
     })
   })
+
+  o("list eof", function () {
+    var result = parse('nums 10, 20', '{nums:list}')
+    o(result).deepEquals({ nums: ['10','20'] })
+  })
 })

tests/stringify-test.js

@@ -0,0 +1,136 @@
+var o = require("ospec")
+var {stringify} = require('../dist/index.js')
+
+o.spec("Stringify", function () {
+
+  o("basic", function () {
+    var result = stringify({
+      a: 10,
+      b: true,
+      c: 'cool',
+      d: 'x',
+      e: 'ignored'
+    }, '{a:num,b:bool,c,d:enum(x,y)}')
+
+    o(result).deepEquals(
+`a 10
+b true
+c cool
+d x
+`
+    )
+  })
+
+  o("list", function () {
+    var result = stringify({
+      a: 'A',
+      b: [10,20,30],
+      c: 'C'
+    }, '{a,b:list,c}')
+
+    o(result).deepEquals(
+`a A
+b {
+  10
+  20
+  30
+}
+c C
+`
+    )
+  })
+
+  o("kv", function () {
+    var result = stringify({
+      k: { a: 10, b: 20 }
+    }, '{k:kv}')
+
+    o(result).deepEquals(
+`k {
+  a 10
+  b 20
+}
+`
+    )
+  })
+
+  o("tuple", function () {
+    var result = stringify({
+      t: [10, 20]
+    }, '{t:(num,str)}')
+
+    o(result).deepEquals(`t 10, 20\n`)
+  })
+
+  o("hash", function () {
+    var result = stringify({
+      top: {
+        title: 'Nice'
+      }
+    }, '{top:{title}}')
+
+    o(result).deepEquals(
+`top {
+  title Nice
+}
+`
+    )
+  })
+
+  o("array", function () {
+    var result = stringify({
+      top: [
+        ['title', 'Nice'],
+        ['stuff', [10,20]],
+      ]
+    }, '{top:[title, stuff:list]}')
+
+    o(result).deepEquals(
+`top {
+  title Nice
+  stuff {
+    10
+    20
+  }
+}
+`
+    )
+  })
+
+  o("value with block", function () {
+    var result = stringify({
+      user: ['alice', {
+        admin: true
+      }]
+    }, '{user:str{admin:bool}}')
+
+    o(result).deepEquals(
+`user alice {
+  admin true
+}
+`
+    )
+  })
+
+  o("list with block", function () {
+    var result = stringify({
+      letters: [
+        ['x'],
+        ['y', { special: true }],
+        ['z'],
+      ]
+    }, '{letters:list{special:bool}}')
+
+    o(result).deepEquals(
+`letters {
+  x
+  y {
+    special true
+  }
+  z
+}
+`
+    )
+  })
+
+})