aontu 0.2.0 → 0.5.0

package/lib/lang.ts

@@ -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,53 +71,68 @@ 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),
   }
 
 
@@ -147,307 +166,138 @@ 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((r: Rule, ctx: Context) => {
 
-      let valnode: Val = rule.node
+      let valnode: Val = r.node
       let valtype = typeof valnode
 
+      // console.log('VAL RULE', valtype, r.use, r.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((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((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
     rs
       .open([{ s: [CJ, CL], p: 'val', u: { spread: true }, g: 'spread' }])
-      .bc((...rest: any) => {
-        orig_bc(...rest)
 
-        let rule = rest[0]
+      .bc((rule: Rule) => {
+        // 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
+  })
+
+
+  jsonic.rule('elem', (rs: RuleSpec) => {
+    rs
+      .open([{ s: [CJ, CL], p: 'val', u: { spread: true }, g: 'spread' }])
+
+      .bc((rule: Rule) => {
+        // TRAVERSE PARENTS TO GET PATH
+
+        if (rule.use.spread) {
+          rule.node[ListVal.SPREAD] =
+            (rule.node[ListVal.SPREAD] || { o: rule.o0.src, v: [] })
+          rule.node[ListVal.SPREAD].v.push(rule.child.node)
+        }
+
+        return undefined
+      })
+
     return rs
   })
 
@@ -491,6 +341,8 @@ class Lang {
       jm.log = opts.log
     }
 
+    // jm.log = -1
+
     let val = this.jsonic(src, jm)
 
     return val

package/lib/op/unite.ts

@@ -64,7 +64,7 @@ const unite: Operation = (ctx: Context, a?: Val, b?: Val, whence?: string) => {
     }
   }
 
-  if (!out) {
+  if (!out || !out.unify) {
     out = Nil.make(ctx, 'unite', a, b)
   }
 

package/lib/unify.ts

@@ -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) {