aontu 0.1.1 → 0.3.0

package/lib/lang.ts

@@ -6,7 +6,7 @@ import {
   Rule,
   RuleSpec,
   Context,
-} from 'jsonic'
+} from '@jsonic/jsonic-next'
 
 import {
   MultiSource
@@ -21,6 +21,10 @@ import {
   Op,
 } from '@jsonic/expr'
 
+import {
+  Path
+} from '@jsonic/path'
+
 
 
 import {
@@ -32,6 +36,7 @@ import {
   Nil,
   TOP,
   MapVal,
+  ListVal,
   ScalarTypeVal,
   Integer,
   StringVal,
@@ -45,7 +50,6 @@ import {
 } from './val'
 
 
-
 class Site {
   row: number = -1
   col: number = -1
@@ -67,64 +71,81 @@ class Site {
 
 let AontuJsonic: Plugin = function aontu(jsonic: Jsonic) {
 
+  jsonic.use(Path)
+
+  // TODO: refactor Val constructor
+  let addpath = (v: Val, p: string[]) => (v.path = [...(p || [])], v)
+
+
   jsonic.options({
     value: {
-      // JSONIC-UPDATE: map: { val: ... }
       map: {
         // NOTE: specify with functions as jsonic/deep will
         // remove class prototype as options are assumed plain
         // (except for functions).
         // TODO: jsonic should be able to pass context into these
-        'string': { val: () => new ScalarTypeVal(String) },
-        'number': { val: () => new ScalarTypeVal(Number) },
-        'integer': { val: () => new ScalarTypeVal(Integer) },
-        'boolean': { val: () => new ScalarTypeVal(Boolean) },
-        'nil': { val: () => new Nil('literal') },
+        'string': {
+          val: (r: Rule) =>
+            addpath(new ScalarTypeVal(String), r.keep.path)
+        },
+        'number': {
+          val: (r: Rule) =>
+            addpath(new ScalarTypeVal(Number), r.keep.path)
+        },
+        'integer': {
+          val: (r: Rule) =>
+            addpath(new ScalarTypeVal(Integer), r.keep.path)
+        },
+        'boolean': {
+          val: (r: Rule) =>
+            addpath(new ScalarTypeVal(Boolean), r.keep.path)
+        },
+        'nil': {
+          val: (r: Rule) =>
+            addpath(new Nil('literal'), r.keep.path)
+        },
+
+        // TODO: FIX: need a TOP instance to hold path
         'top': { val: () => TOP },
       }
     },
 
-    // // JSONIC-UPDATE: fixed: { token }
-    // fixed: {
-    //   token: {
-    //     '#A&': '&',
-    //     '#A|': '|',
-    //     '#A/': '/',
-    //     '#A*': '*', // TODO: REVIEW char as * is a bit overloaded
-    //     '#A=': '=',
-    //   }
-    // },
-
-    // JSONIC-UPDATE: check impl
     map: {
       merge: (prev: any, curr: any) => {
         let pval = (prev as Val)
         let cval = (curr as Val)
-        return new ConjunctVal([pval, cval])
+        return addpath(new ConjunctVal([pval, cval]), prev.path)
       }
     }
   })
 
 
   let opmap: any = {
-    'conjunct-infix': (_op: Op, terms: any) => new ConjunctVal(terms),
-    'disjunct-infix': (_op: Op, terms: any) => new DisjunctVal(terms),
-
-    'dot-prefix': (_op: Op, terms: any) => new RefVal(terms, true),
-    'dot-infix': (_op: Op, terms: any) => new RefVal(terms),
-
-    'star-prefix': (_op: Op, terms: any) => new PrefVal(terms[0]),
+    'conjunct-infix': (r: Rule, _op: Op, terms: any) =>
+      addpath(new ConjunctVal(terms), r.keep.path),
+    'disjunct-infix': (r: Rule, _op: Op, terms: any) =>
+      addpath(new DisjunctVal(terms), r.keep.path),
+
+    'dot-prefix': (r: Rule, _op: Op, terms: any) =>
+      addpath(new RefVal(terms, true), r.keep.path),
+    'dot-infix': (r: Rule, _op: Op, terms: any) =>
+      addpath(new RefVal(terms), r.keep.path),
+
+    'star-prefix': (r: Rule, _op: Op, terms: any) =>
+      addpath(new PrefVal(terms[0]), r.keep.path),
   }
 
 
   jsonic
     .use(Expr, {
       op: {
+        // disjunct > conjunct: c & b|a -> c & (b|a)
         'conjunct': {
           infix: true, src: '&', left: 14000, right: 15000
         },
         'disjunct': {
-          infix: true, src: '|', left: 14000, right: 15000
+          // infix: true, src: '|', left: 14000, right: 15000
+          infix: true, src: '|', left: 16000, right: 17000
         },
 
         'dot-infix': {
@@ -145,307 +166,127 @@ let AontuJsonic: Plugin = function aontu(jsonic: Jsonic) {
           right: 14_000_000,
         },
       },
-      evaluate: (op: Op, terms: any) => {
-        // console.log('LANG EVAL', op, terms)
-        return opmap[op.name](op, terms)
+      evaluate: (r: Rule, op: Op, terms: any) => {
+        // console.log('LANG EVAL', r.keep, op, terms)
+        let val: Val = opmap[op.name](r, op, terms)
+        // console.dir(val, { depth: null })
+
+        return val
       }
     })
 
-  // console.log(jsonic.token)
+
   let CJ = jsonic.token['#E&']
   let CL = jsonic.token.CL
 
-  // let NR = jsonic.token.NR
-  // let TX = jsonic.token.TX
-  // let ST = jsonic.token.ST
-  // let VL = jsonic.token.VL
-  // let OB = jsonic.token.OB
-  // let OS = jsonic.token.OS
-
-
-  // let DJ = jsonic.token['#A|']
-  // let FS = jsonic.token['#A/']
-  // let AK = jsonic.token['#A*']
-  // let EQ = jsonic.token['#A=']
-
-
-  // JSONIC-UPDATE: rule.open[], rule.close[] - replace with rule.oN|cN
-
-  // jsonic.rule('expr', (rs: RuleSpec) => {
-  //   rs
-  //     .open([
-  //       { s: [[CJ, DJ, AK]], p: 'disjunct', b: 1, n: { expr: 1 } },
-  //     ])
-
-  //     .close([
-  //       { s: [] }
-  //     ])
-
-  //     // NOTE: expr node are meta structures, not Vals
-  //     // t=most recent term on the left, o=Val
-  //     .bo((r: Rule) => r.node = { t: r.node })
-
-  //     .ac((r: Rule) => {
-  //       let cn = r.child.node.o
-
-  //       if (cn instanceof PrefVal) {
-  //         return r.o0.bad('single-pref')
-  //       }
-
-  //       // replace first val with expr val
-  //       r.node = cn
-
-  //       if ('val' === r.parent?.name) {
-  //         r.parent.node = r.node
-  //       }
-  //     })
-
-  // })
-
-
-  // jsonic.rule('disjunct', (rs: RuleSpec) => {
-  //   rs
-  //     .open([
-  //       {
-  //         s: [CJ], p: 'conjunct', b: 1
-  //       },
-  //       {
-  //         s: [AK], p: 'pref', b: 1
-  //       },
-  //       {
-  //         s: [DJ, AK], p: 'pref', b: 1,
-  //         a: (r: Rule) => {
-  //           // Append to existing or start new
-  //           r.node.o = r.node.o instanceof DisjunctVal ?
-  //             r.node.o : new DisjunctVal([r.node.t])
-  //         }
-  //       },
-  //       {
-  //         s: [DJ, [NR, TX, ST, VL, OB, OS]], b: 1,
-  //         p: 'val',
-  //         a: (r: Rule) => {
-  //           // Append to existing or start new
-  //           r.node.o = r.node.o instanceof DisjunctVal ?
-  //             r.node.o : new DisjunctVal([r.node.t])
-  //         }
-  //       },
-  //     ])
-
-  //     .close([
-  //       {
-  //         s: [DJ], r: 'disjunct', b: 1, a: (r: Rule) => {
-  //           // higher precedence term (e.g &) was on the left
-  //           let cn = r.child.node?.o || r.child.node
-  //           r.node.t = cn
-  //         }
-  //       },
-  //       {
-  //         s: [CJ], r: 'disjunct', b: 1, a: (r: Rule) => {
-  //           // & with higher precedence to the right
-  //           let cn = r.child.node?.o || r.child.node
-  //           r.node.t = cn
-  //           r.child.node = null
-  //         }
-  //       },
-  //       {}
-  //     ])
-  //     .ac((r: Rule) => {
-  //       // child values may be normal or expr metas
-  //       let cn = r.child.node?.o || r.child.node
-  //       if (cn) {
-  //         if (r.node.o instanceof DisjunctVal) {
-  //           r.node.o.append(cn)
-  //         }
-  //         else {
-  //           // this rule was just a pass-through
-  //           r.node.o = cn
-  //         }
-  //       }
-  //     })
-  // })
-
-
-
-  // jsonic.rule('conjunct', (rs: RuleSpec) => {
-  //   rs
-  //     .open([
-  //       {
-  //         s: [CJ, [NR, TX, ST, VL, OB, OS, FS]], b: 1,
-  //         p: 'val',
-  //         a: (r: Rule) => {
-  //           r.node = {
-  //             o: r.node.o instanceof ConjunctVal ?
-  //               r.node.o : new ConjunctVal([r.node.t])
-  //           }
-  //         }
-  //       },
-  //     ])
-  //     .close([
-  //       {
-  //         s: [CJ], r: 'conjunct', b: 1
-  //       },
-  //       {}
-  //     ])
-  //     .ac((r: Rule) => {
-  //       let cn = r.child.node?.o || r.child.node
-  //       if (cn) {
-  //         if (r.node.o instanceof ConjunctVal) {
-  //           r.node.o.append(cn)
-  //         }
-  //         else {
-  //           r.node.o = cn
-  //         }
-  //       }
-  //     })
-  // })
-
-
-  // jsonic.rule('path', (rs: RuleSpec) => {
-  //   rs
-  //     .open([
-  //       { s: [FS, [TX, ST, NR, VL]], p: 'part', b: 2 }
-  //     ])
-  //     .bo((r: Rule) => r.node = new RefVal('/'))
-  // })
-
-
-  // jsonic.rule('part', (rs: RuleSpec) => {
-  //   rs.
-  //     open([
-  //       {
-  //         s: [FS, [TX, ST, NR, VL]], r: 'part', a: (r: Rule) => {
-  //           r.node.append(r.o1.src)
-  //         }
-  //       },
-  //       {}, // no more parts
-  //     ])
-  // })
-
-
-
-  //   // rs.def.open.unshift({
-  //   //   s: [[CJ, DJ], EQ], p: 'val', u: { spread: true }
-  //   // })
-
-  //   // // TODO: make before/after function[]
-  //   // let orig_bc: any = rs.def.bc
-  //   // rs.def.bc = function(rule: Rule, ctx: Context) {
-  //   //   let out = orig_bc.call(this, rule, ctx)
-
-  //   //   if (rule.use.spread) {
-  //   //     rule.node[MapVal.SPREAD] =
-  //   //       (rule.node[MapVal.SPREAD] || { o: rule.o0.src, v: [] })
-  //   //     rule.node[MapVal.SPREAD].v.push(rule.child.node)
-  //   //   }
-
-  //   //   return out
-  //   // }
-
-  //   return rs
-  // })
-
-
-  // jsonic.rule('pref', (rs: RuleSpec) => {
-  //   rs
-  //     .open([
-  //       {
-  //         s: [AK, [NR, TX, ST, VL, OB, OS, FS]], b: 1,
-  //         p: 'val',
-  //       },
-  //     ])
-  //     .close([
-  //       // Can't be in a conjunct
-  //       { s: [CJ], e: (r: Rule) => r.o1 },
-  //       {}
-  //     ])
-  //     .ac((r: Rule) => {
-  //       r.node = new PrefVal(r.child.node)
-  //     })
-  // })
-
-
 
   jsonic.rule('val', (rs: RuleSpec) => {
-    // rs.def.open.unshift(
-    //   // Prefs are always within an expression
-    //   { s: [AK, [NR, TX, ST, VL, OB, OS, FS]], p: 'expr', b: 2 },
-    //   { s: [FS, [TX, ST, NR, VL]], p: 'path', b: 2 },
-    // )
-    // rs.def.close.unshift(
-    //   {
-    //     s: [[CJ, DJ]], p: 'expr', b: 1, c: (r: Rule) => {
-    //       return null == r.n.expr || 0 === r.n.expr
-    //     }
-    //   },
-    // )
-
 
     // TODO: wrap utility needed for jsonic to do this?
-    let orig_bc: any = rs.def.bc
-    rs.def.bc = function(rule: Rule, ctx: Context) {
-      let out = orig_bc.call(this, rule, ctx)
+    // let orig_bc: any = rs.def.bc
+    // rs.def.bc = function(rule: Rule, ctx: Context) {
+    //   let out = orig_bc.call(this, rule, ctx)
+
+    rs.bc(false, (r: Rule, ctx: Context) => {
 
-      let valnode: Val = rule.node
+      let valnode: Val = r.node
       let valtype = typeof valnode
 
+      // console.log('VAL RULE', rule.use, rule.node)
+
       if ('string' === valtype) {
-        valnode = new StringVal(rule.node)
+        valnode = addpath(new StringVal(r.node), r.keep.path)
       }
       else if ('number' === valtype) {
-        if (Number.isInteger(rule.node)) {
-          valnode = new IntegerVal(rule.node)
+        if (Number.isInteger(r.node)) {
+          valnode = addpath(new IntegerVal(r.node), r.keep.path)
         }
         else {
-          valnode = new NumberVal(rule.node)
+          valnode = addpath(new NumberVal(r.node), r.keep.path)
         }
       }
       else if ('boolean' === valtype) {
-        valnode = new BooleanVal(rule.node)
+        valnode = addpath(new BooleanVal(r.node), r.keep.path)
       }
 
-      let st = rule.o0
+      let st = r.o0
       valnode.row = st.rI
       valnode.col = st.cI
 
       // JSONIC-UPDATE: still valid? check multisource
       valnode.url = ctx.meta.multisource && ctx.meta.multisource.path
 
-      rule.node = valnode
+      r.node = valnode
+
+      // return out
+      return undefined
+    })
 
-      return out
-    }
     return rs
   })
 
 
 
   jsonic.rule('map', (rs: RuleSpec) => {
-    let orig_bc = rs.def.bc
-    rs.def.bc = function(rule: Rule, ctx: Context) {
-      let out = orig_bc ? orig_bc.call(this, rule, ctx) : undefined
+    // let orig_bc = rs.def.bc
+    // rs.def.bc = function(rule: Rule, ctx: Context) {
+    //   let out = orig_bc ? orig_bc.call(this, rule, ctx) : undefined
 
-      rule.node = new MapVal(rule.node)
+    rs.bc(false, (r: Rule) => {
+
+      // console.log('MAP RULE', rule.use, rule.node)
+      r.node = addpath(new MapVal(r.node), r.keep.path)
+
+      // return out
+      return undefined
+    })
+
+    return rs
+  })
+
+
+  jsonic.rule('list', (rs: RuleSpec) => {
+    // let orig_bc = rs.def.bc
+    // rs.def.bc = function(rule: Rule, ctx: Context) {
+    //   let out = orig_bc ? orig_bc.call(this, rule, ctx) : undefined
+
+    rs.bc(false, (r: Rule) => {
+      r.node = addpath(new ListVal(r.node), r.keep.path)
+
+      // return out
+      return undefined
+    })
 
-      return out
-    }
     return rs
   })
 
 
+
   jsonic.rule('pair', (rs: RuleSpec) => {
-    let orig_bc: any = rs.def.bc
+    // let orig_bc: any = rs.def.bc
     rs
       .open([{ s: [CJ, CL], p: 'val', u: { spread: true }, g: 'spread' }])
-      .bc((...rest: any) => {
-        orig_bc(...rest)
 
-        let rule = rest[0]
+      // .bc((...rest: any) => {
+      //   orig_bc(...rest)
+
+
+      .bc(false, (rule: Rule) => {
+        // let rule = rest[0]
+        // console.log('PAIR RULE', rule.use, rule.node,
+        //  rule.parent.name, rule.parent.use)
+
+        // TRAVERSE PARENTS TO GET PATH
+
         if (rule.use.spread) {
           rule.node[MapVal.SPREAD] =
             (rule.node[MapVal.SPREAD] || { o: rule.o0.src, v: [] })
           rule.node[MapVal.SPREAD].v.push(rule.child.node)
         }
+
+        return undefined
       })
+
     return rs
   })
 
@@ -489,6 +330,8 @@ class Lang {
       jm.log = opts.log
     }
 
+    // jm.log = -1
+
     let val = this.jsonic(src, jm)
 
     return val

package/lib/op/op.ts

@@ -8,10 +8,11 @@ import { disjunct } from './disjunct'
 import { unite } from './unite'
 
 
-type Operation = (ctx: Context, a?: Val, b?: Val) => Val
+type Operation = (ctx: Context, a?: Val, b?: Val, whence?: string) => Val
 
 export {
   Operation,
   disjunct,
   unite,
 }
+

package/lib/op/unite.ts

@@ -5,7 +5,6 @@
 import { Context } from '../unify'
 import {
   Val,
-  MapVal,
   ConjunctVal,
   DisjunctVal,
   RefVal,
@@ -19,10 +18,13 @@ import { Operation } from './op'
 
 // Vals should only have to unify downwards (in .unify) over Vals they understand.
 // and for complex Vals, TOP, which means self unify if not yet done
-const unite: Operation = (ctx: Context, a?: Val, b?: Val) => {
+const unite: Operation = (ctx: Context, a?: Val, b?: Val, whence?: string) => {
   let out = a
 
-  //console.log('Ua', a && a.canon, b && b.canon)
+  // console.log('AA OP unite  IN', a?.canon, b?.canon,
+  //   'W', whence,
+  //   'E', 0 < ctx?.err?.length ? ctx.err.map((e: Val) => e.canon) : '')
+
 
   if (b && (TOP === a || !a)) {
     //console.log('Utb', b.canon)
@@ -51,15 +53,18 @@ const unite: Operation = (ctx: Context, a?: Val, b?: Val) => {
       //console.log('U', a.canon, b.canon)
       return b.unify(a, ctx)
     }
+
+    // Exactly equal scalars.
     else if (a.constructor === b.constructor && a.peg === b.peg) {
       out = update(a, b)
     }
+
     else {
       out = a.unify(b, ctx)
     }
   }
 
-  if (!out) {
+  if (!out || !out.unify) {
     out = Nil.make(ctx, 'unite', a, b)
   }
 
@@ -67,6 +72,9 @@ const unite: Operation = (ctx: Context, a?: Val, b?: Val) => {
     out = out.unify(TOP, ctx)
   }
 
+  // console.log('AA OP unite OUT', a?.canon, b?.canon, '->', out && out.canon,
+  //   0 < ctx?.err?.length ? ctx.err.map((e: Val) => e.canon) : '')
+
   return out
 }
 

package/lib/unify.ts

@@ -30,7 +30,6 @@ class Context {
   err: Nil[]  // Nil error log of current unify.
   vc: number  // Val counter to create unique val ids.
 
-
   constructor(cfg: {
     root: Val
     err?: Nil[],
@@ -46,12 +45,13 @@ class Context {
 
 
   clone(cfg: {
-    root: Val,
-    path?: Path
+    root?: Val,
+    path?: Path,
+    err?: Nil[],
   }): Context {
     return new Context({
-      root: cfg.root,
-      err: this.err,
+      root: cfg.root || this.root,
+      err: cfg.err || this.err,
       vc: this.vc,
     })
   }
@@ -66,6 +66,7 @@ class Context {
 
 
   find(ref: RefVal) {
+    // console.log('FIND', ref.path, ref.peg)
 
     // TODO: relative paths
     if (this.root instanceof MapVal && ref.absolute) {
@@ -112,11 +113,8 @@ class Unify {
     // perhaps parse should count intial vals, paths, etc?
 
 
-
-
     let maxdc = 999
     for (this.dc = 0; this.dc < maxdc && DONE !== res.done; this.dc++) {
-      //res = res.unify(TOP, ctx)
       res = unite(ctx, res, TOP)
       ctx = ctx.clone({ root: res })
     }