support dynamic token values

Author: rjrodger

.gitignore

@@ -26,3 +26,4 @@ test/coverage.html
 coverage
 
 package-lock.json
+yarn.lock

grammar.js

@@ -108,15 +108,16 @@ function grammar(jsonic: Jsonic) {
         { b: 1, g: 'val,json,more' },
       ])
 
-      .bc((rule: Rule) => {
+      .bc((rule: Rule, ctx: Context) => {
         // console.log('VAL BC A', rule.node, rule.o0.val, rule.os, rule.child.node)
 
         // NOTE: val can be undefined when there is no value at all
         // (eg. empty string, thus no matched opening token)
         rule.node =
           undefined === rule.node ?
             undefined === rule.child.node ?
-              (0 === rule.os ? undefined : rule.o0.val) :
+              // (0 === rule.os ? undefined : rule.o0.val) :
+              (0 === rule.os ? undefined : rule.o0.resolveVal(rule, ctx)) :
               rule.child.node :
             rule.node
 

grammar.js.map

@@ -26,6 +26,7 @@ declare class TokenImpl implements Token {
     err?: string;
     why?: string;
     constructor(name: string, tin: Tin, val: any, src: string, pnt: Point, use?: any, why?: string);
+    resolveVal(rule: Rule, ctx: Context): any;
     bad(err: string, details?: any): Token;
     toString(): string;
     [INSPECT](): string;

grammar.ts

@@ -114,6 +114,15 @@ class TokenImpl implements Token {
     this.len = null == src ? 0 : src.length
   }
 
+
+  resolveVal(rule: Rule, ctx: Context): any {
+    let out = 'function' === typeof this.val ?
+      (this.val as any)(rule, ctx) :
+      this.val
+    return out
+  }
+
+
   bad(err: string, details?: any): Token {
     this.err = err
     if (null != details) {

lexer.d.ts

@@ -302,18 +302,53 @@ describe('custom', function () {
 
 
   it('parser-value', () => {
-    let b = ''
+    function Car() {this.m = true}
+    let c0 = new Car()
+    expect(c0 instanceof Car).toEqual(true)
+    
+    let o0 = {x:1}
+    let f1 = ()=>'F1'
+    
     let j = Jsonic.make({
       value: {
         map: {
           foo: {val:'FOO'},
           bar: {val:'BAR'},
+          zed: {val:123},
+          qaz: {val:false},
+          obj: {val:o0},
+
+          // This won't work - cloning removes constructor
+          car: {val:c0},
+
+          // Functions build values dynamically, or prevent cloning
+          fun: {val:()=>'f0'},
+          high: {val:()=>f1},
+          ferry: {val:()=>new Car()},
         }
       }
     })
 
     expect(j('foo')).toEqual('FOO')
     expect(j('bar')).toEqual('BAR')
+    expect(j('zed')).toEqual(123)
+    expect(j('qaz')).toEqual(false)
+
+    // Options get copied, so `obj` should remain {x:1}
+    o0.x = 2
+    expect(j('obj')).toEqual({x:1})
+
+    // Instance properties are copied, but not constructor
+    expect(j('car')).toEqual({m:true})
+    expect(j('car') instanceof Car ).toEqual(false)
+    
+    expect(j('fun')).toEqual('f0')
+    expect(j('high')).toEqual(f1)
+
+    // constructor is protected
+    expect(j('ferry')).toEqual({m:true})
+    expect(j('ferry') instanceof Car).toEqual(true)
+
   })
 
 

lexer.js

@@ -340,6 +340,7 @@ export interface Token {
     err?: string;
     why?: string;
     bad(err: string, details?: any): Token;
+    resolveVal(rule: Rule, ctx: Context): any;
 }
 export interface AltSpec {
     s?: (Tin | Tin[] | null | undefined)[] | null;

lexer.js.map

@@ -227,14 +227,12 @@ export interface Rule {
   parent: Rule       // The parent rule, that pushed this rule onto the stack.
   prev: Rule         // The previous sibling rule, that issued an `r` command.
 
-  // open: Token[]      // The tokens than matched in the open state.
-  // close: Token[]     // The tokens than matched in the close state.
-  os: number
-  o0: Token
-  o1: Token
-  cs: number
-  c0: Token
-  c1: Token
+  os: number         // Number of open state tokens (# 'opens').
+  o0: Token          // First open state token.
+  o1: Token          // Second open state token.
+  cs: number         // Number of close state tokens (# 'closes').
+  c0: Token          // First close state token.  
+  c1: Token          // Second close state token. 
 
   n: Counters        // Named counter values.
   d: number          // The current stack depth.   
@@ -457,6 +455,8 @@ export interface Token {
 
   // Convert into an error Token.
   bad(err: string, details?: any): Token
+
+  resolveVal(rule: Rule, ctx: Context): any
 }