aontu 0.0.9 → 0.2.0

package/lib/lang.ts

@@ -6,12 +6,22 @@ import {
   Rule,
   RuleSpec,
   Context,
-} from 'jsonic'
+} from '@jsonic/jsonic-next'
 
 import {
   MultiSource
 } from '@jsonic/multisource'
 
+import {
+  makeFileResolver
+} from '@jsonic/multisource/dist/resolver/file'
+
+import {
+  Expr,
+  Op,
+} from '@jsonic/expr'
+
+
 
 import {
   Options
@@ -59,28 +69,33 @@ let AontuJsonic: Plugin = function aontu(jsonic: Jsonic) {
 
   jsonic.options({
     value: {
-      src: {
+      // 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': () => new ScalarTypeVal(String),
-        'number': () => new ScalarTypeVal(Number),
-        'integer': () => new ScalarTypeVal(Integer),
-        'boolean': () => new ScalarTypeVal(Boolean),
-        'nil': () => new Nil('literal'),
-        'top': () => TOP,
+        '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') },
+        'top': { val: () => TOP },
       }
     },
 
-    token: {
-      '#A&': { c: '&' },
-      '#A|': { c: '|' },
-      '#A/': { c: '/' },
-      '#A*': { c: '*' }, // TODO: REVIEW char as * is a bit overloaded
-      '#A=': { c: '=' },
-    },
-
+    // // 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)
@@ -91,230 +106,284 @@ let AontuJsonic: Plugin = function aontu(jsonic: Jsonic) {
   })
 
 
-  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 CJ = jsonic.token['#A&']
-  let DJ = jsonic.token['#A|']
-  let FS = jsonic.token['#A/']
-  let AK = jsonic.token['#A*']
-  let EQ = jsonic.token['#A=']
-
-
-  jsonic.rule('expr', () => {
-    return new RuleSpec({
-      open: [
-        { s: [[CJ, DJ, AK]], p: 'disjunct', b: 1, n: { expr: 1 } },
-      ],
-      close: [
-        { s: [] }
-      ],
+  let opmap: any = {
+    'conjunct-infix': (_op: Op, terms: any) => new ConjunctVal(terms),
+    'disjunct-infix': (_op: Op, terms: any) => new DisjunctVal(terms),
 
-      // 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 },
+    'dot-prefix': (_op: Op, terms: any) => new RefVal(terms, true),
+    'dot-infix': (_op: Op, terms: any) => new RefVal(terms),
 
-      ac: (r: Rule) => {
-        let cn = r.child.node.o
-
-        if (cn instanceof PrefVal) {
-          return { err: 'single-pref' }
-        }
-
-        // replace first val with expr val
-        r.node = cn
-      },
-    })
-  })
+    'star-prefix': (_op: Op, terms: any) => new PrefVal(terms[0]),
+  }
 
 
-  jsonic.rule('disjunct', () => {
-    return new RuleSpec({
-      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])
-          }
+  jsonic
+    .use(Expr, {
+      op: {
+        // disjunct > conjunct: c & b|a -> c & (b|a)
+        'conjunct': {
+          infix: true, src: '&', left: 14000, right: 15000
         },
-        {
-          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])
-          }
+        'disjunct': {
+          // infix: true, src: '|', left: 14000, right: 15000
+          infix: true, src: '|', left: 16000, right: 17000
         },
-      ],
-      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', () => {
-    return new RuleSpec({
-      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])
-            }
-          }
+        'dot-infix': {
+          src: '.',
+          infix: true,
+          left: 15_000_000,
+          right: 14_000_000,
         },
-      ],
-      close: [
-        {
-          s: [CJ], r: 'conjunct', b: 1
+        'dot-prefix': {
+          src: '.',
+          prefix: true,
+          right: 14_000_000,
         },
-        {}
-      ],
-      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', () => {
-    return new RuleSpec({
-      open: [
-        { s: [FS, [TX, ST, NR, VL]], p: 'part', b: 2 }
-      ],
-      bo: (r: Rule) => r.node = new RefVal('/')
-    })
-  })
-
-
-  jsonic.rule('part', () => {
-    return new RuleSpec({
-      open: [
-        {
-          s: [FS, [TX, ST, NR, VL]], r: 'part', a: (r: Rule) => {
-            r.node.append(r.open[1].src)
-          }
+        'star': {
+          src: '*',
+          prefix: true,
+          right: 14_000_000,
         },
-        {}, // no more parts
-      ],
-    })
-  })
-
-
-  jsonic.rule('pair', (rs: RuleSpec) => {
-    rs.def.open.unshift({
-      s: [[CJ, DJ], EQ], p: 'val', u: { spread: true }
-    })
-
-    // TODO: make before/after function[]
-    let orig_bc = 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.open[0].src, v: [] })
-        rule.node[MapVal.SPREAD].v.push(rule.child.node)
-      }
-
-      return out
-    }
-
-    return rs
-  })
-
-
-  jsonic.rule('pref', () => {
-    return new RuleSpec({
-      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.open[1] },
-        {}
-      ],
-      ac: (r: Rule) => {
-        r.node = new PrefVal(r.child.node)
+      },
+      evaluate: (op: Op, terms: any) => {
+        // console.log('LANG EVAL', op, terms)
+        return opmap[op.name](op, terms)
       }
     })
-  })
+
+  // 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
-        }
-      },
-    )
+    // 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 = rs.def.bc
+    let orig_bc: any = rs.def.bc
     rs.def.bc = function(rule: Rule, ctx: Context) {
       let out = orig_bc.call(this, rule, ctx)
 
@@ -336,12 +405,12 @@ let AontuJsonic: Plugin = function aontu(jsonic: Jsonic) {
         valnode = new BooleanVal(rule.node)
       }
 
-      let st = rule.open[0]
-      valnode.row = st.row
-      valnode.col = st.col
-      valnode.url = ctx.meta.multisource && ctx.meta.multisource.path
+      let st = rule.o0
+      valnode.row = st.rI
+      valnode.col = st.cI
 
-      // console.log('VAL META', valnode.canon, valnode.url)
+      // JSONIC-UPDATE: still valid? check multisource
+      valnode.url = ctx.meta.multisource && ctx.meta.multisource.path
 
       rule.node = valnode
 
@@ -351,6 +420,7 @@ let AontuJsonic: Plugin = function aontu(jsonic: Jsonic) {
   })
 
 
+
   jsonic.rule('map', (rs: RuleSpec) => {
     let orig_bc = rs.def.bc
     rs.def.bc = function(rule: Rule, ctx: Context) {
@@ -363,9 +433,30 @@ let AontuJsonic: Plugin = function aontu(jsonic: Jsonic) {
     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]
+        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 rs
+  })
+
 }
 
 
+const includeFileResolver = makeFileResolver((spec: any) => {
+  return 'string' === typeof spec ? spec : spec?.peg
+})
 
 
 class Lang {
@@ -380,14 +471,13 @@ class Lang {
     this.jsonic = Jsonic.make()
       .use(AontuJsonic)
       .use(MultiSource, {
-        resolver: options ? options.resolver : undefined
+        resolver: options?.resolver || includeFileResolver
       })
-
-    // console.log('AL options', this.options)
   }
 
   parse(src: string, opts?: any): Val {
 
+    // JSONIC-UPDATE - check meta
     let jm: any = {
       multisource: {
         // NOTE: multisource has property `path` NOT `base`
@@ -401,8 +491,6 @@ class Lang {
       jm.log = opts.log
     }
 
-    // console.log('ALp jm', jm)
-
     let val = this.jsonic(src, jm)
 
     return val
@@ -412,4 +500,5 @@ class Lang {
 export {
   Lang,
   Site,
+  includeFileResolver,
 }

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,
 }
+