@graffiticode/basis 1.0.9 → 1.0.12

package/package.json

@@ -1,10 +1,12 @@
 {
   "name": "@graffiticode/basis",
   "type": "module",
-  "version": "1.0.9",
+  "version": "1.0.12",
   "description": "The basis library for creating Graffiticode languages",
-  "main": "compiler.js",
-  "scripts": {},
+  "main": "index.js",
+  "scripts": {
+    "test": "jest"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/graffiticode/basis.git"
@@ -19,6 +21,7 @@
     "d3": "^6.6.2",
     "hashids": "^2.2.8",
     "https": "^1.0.0",
+    "jest": "^27.0.1",
     "react": "^17.0.2"
   }
 }

package/src/compiler.js

@@ -6,11 +6,23 @@ messages[1002] = "Invalid tag in node with Node ID %1.";
 messages[1003] = "No async callback provided.";
 messages[1004] = "No visitor method defined for '%1'.";
 
+function error(msg, arg) {
+  return msg + arg;
+}
+
+function newNode(tag, elts) {
+  return {
+    tag: tag,
+    elts: elts,
+  };
+}
+
 const ASYNC = true;
 
 class Visitor {
-  constructor(nodePool) {
-    this.nodePool = nodePool;
+  constructor(code) {
+    this.nodePool = code;
+    this.root = code.root;
   }
   visit(nid, options, resume) {
     assert(nid);
@@ -29,6 +41,34 @@ class Visitor {
       this[node.tag](node, options, resume);
     }
   }
+  node(nid) {
+    var n = this.nodePool[nid];
+    if (!nid) {
+      return null;
+    } else if (!n) {
+      return {};
+    }
+    var elts = [];
+    switch (n.tag) {
+    case "NULL":
+      break;
+    case "NUM":
+    case "STR":
+    case "IDENT":
+    case "BOOL":
+      elts[0] = n.elts[0];
+      break;
+    default:
+      for (var i=0; i < n.elts.length; i++) {
+        elts[i] = this.node(n.elts[i]);
+      }
+      break;
+    }
+    return {
+      tag: n.tag,
+      elts: elts,
+    };
+  }
 }
 
 export class Checker extends Visitor {
@@ -36,7 +76,7 @@ export class Checker extends Visitor {
     super(nodePool);
   }
   check(options, resume) {
-    const nid = this.nodePool.root;
+    const nid = this.root;
     this.visit(nid, options, (err, data) => {
       resume(err, data);
     });
@@ -102,8 +142,8 @@ export class Checker extends Visitor {
     });
   }
   ADD(node, options, resume) {
-    this.visit(node.elts[0], options, function (err1, val1) {
-      this.visit(node.elts[1], options, function (err2, val2) {
+    this.visit(node.elts[0], options, (err1, val1) => {
+      this.visit(node.elts[1], options, (err2, val2) => {
         if (isNaN(+val1)) {
           err1 = err1.concat(error("Argument must be a number.", node.elts[0]));
         }
@@ -121,6 +161,11 @@ export class Checker extends Visitor {
     const val = node;
     resume(err, val);
   }
+  NULL(node, options, resume) {
+    const err = [];
+    const val = node;
+    resume(err, val);
+  }
   RECORD(node, options, resume) {
     const err = [];
     const val = node;
@@ -132,8 +177,8 @@ export class Checker extends Visitor {
     resume(err, val);
   }
   MUL(node, options, resume) {
-    this.visit(node.elts[0], options, function (err1, val1) {
-      this.visit(node.elts[1], options, function (err2, val2) {
+    this.visit(node.elts[0], options, (err1, val1) => {
+      this.visit(node.elts[1], options, (err2, val2) => {
         if (isNaN(+val1)) {
           err1 = err1.concat(error("Argument must be a number.", node.elts[0]));
         }
@@ -147,8 +192,8 @@ export class Checker extends Visitor {
     });
   }
   POW(node, options, resume) {
-    this.visit(node.elts[0], options, function (err1, val1) {
-      this.visit(node.elts[1], options, function (err2, val2) {
+    this.visit(node.elts[0], options, (err1, val1) => {
+      this.visit(node.elts[1], options, (err2, val2) => {
         if (isNaN(+val1)) {
           err1 = err1.concat(error("Argument must be a number.", node.elts[0]));
         }
@@ -257,17 +302,96 @@ function addWord(ctx, lexeme, entry) {
 function topEnv(ctx) {
   return ctx.env[ctx.env.length-1]
 }
-
 export class Transformer extends Visitor {
   constructor(nodePool) {
     super(nodePool);
+    this.patternNodePool = ['unused'];
+    this.patternNodeMap = {};
   }
   transform(options, resume) {
-    const nid = this.nodePool.root;
+    const nid = this.root;
     this.visit(nid, options, (err, data) => {
       resume(err, data);
     });
   }
+  internPattern(n) {
+    if (!n) {
+      return 0;
+    }
+    const nodeMap = this.patternNodeMap;
+    const nodePool = this.patternNodePool;
+    const tag = n.tag;
+    const elts_nids = [];
+    const count = n.elts.length;
+    let elts = "";
+    for (let i = 0; i < count; i++) {
+      if (typeof n.elts[i] === "object") {
+        n.elts[i] = this.internPattern(n.elts[i]);
+      }
+      elts += n.elts[i];
+    }
+    const key = tag+count+elts;
+    let nid = nodeMap[key];
+    if (nid === void 0) {
+      nodePool.push({tag: tag, elts: n.elts});
+      nid = nodePool.length - 1;
+      nodeMap[key] = nid;
+      if (n.coord) {
+        ctx.state.coords[nid] = n.coord;
+      }
+    }
+    return nid;
+  }
+  match(options, patterns, node) {
+    if (patterns.size === 0 || node === undefined) {
+      return false;
+    }
+    let matches = patterns.filter((pattern) => {
+      if (pattern.tag === undefined || node.tag === undefined) {
+        return false;
+      }
+      const patternNid = this.internPattern(pattern); 
+      if (patternNid === this.internPattern(node) ||
+          patternNid === this.internPattern(newNode('IDENT', ['_']))) {
+        return true;
+      }
+      if (pattern.tag === node.tag) {
+        if (pattern.elts.length === node.elts.length) {
+          // Same number of args, so see if each matches.
+          return pattern.elts.every((arg, i) => {
+            if (pattern.tag === 'VAR') {
+              if (arg === node.elts[i]) {
+                return true;
+              }
+              return false;
+            }
+            let result = this.match(options, [arg], node.elts[i]);
+            return result.length === 1;
+          });
+        } else if (pattern.elts.length < node.elts.length) {
+          // Different number of args, then see if there is a wildcard match.
+          let nargs = node.elts.slice(1);
+          if (pattern.elts.length === 2) {
+            // Binary node pattern
+            let result = (
+              this.match(options, [pattern.elts[0]], node.elts[0]).length > 0 &&
+              this.match(options, [pattern.elts[1]], newNode(node.tag, nargs)).length > 0
+              // Match rest of the node against the second pattern argument.
+            );
+            return result;
+          }
+        }
+      }
+      return false;
+    });
+    // if (true || matches.length > 0) {
+    //   console.log("match() node: " + JSON.stringify(node, null, 2));
+    //   console.log("match() matches: " + JSON.stringify(matches, null, 2));
+    // }
+    return matches;
+  }
+
+
   PROG(node, options, resume) {
     if (!options) {
       options = {};
@@ -319,7 +443,7 @@ export class Transformer extends Visitor {
         //   });
         }
       });
-      this.visit(node.elts[1], options, function (err, val) {
+      this.visit(node.elts[1], options, (err, val) => {
         exitEnv(options);
         resume([].concat(err0).concat(err).concat(err), val)
       });
@@ -374,6 +498,11 @@ export class Transformer extends Visitor {
     const val = node;
     resume(err, val);
   }
+  NULL(node, options, resume) {
+    const err = [];
+    const val = null;
+    resume(err, val);
+  }
   BINDING(node, options, resume) {
     const err = [];
     const val = node;
@@ -403,8 +532,8 @@ export class Transformer extends Visitor {
     }
   }
   MUL(node, options, resume) {
-    this.visit(node.elts[0], options, function (err1, val1) {
-      this.visit(node.elts[1], options, function (err2, val2) {
+    this.visit(node.elts[0], options, (err1, val1) => {
+      this.visit(node.elts[1], options, (err2, val2) => {
         if (isNaN(+val1)) {
           err1 = err1.concat(error("Argument must be a number.", node.elts[0]));
         }
@@ -412,14 +541,14 @@ export class Transformer extends Visitor {
           err2 = err2.concat(error("Argument must be a number.", node.elts[1]));
         }
         const err = [].concat(err1).concat(err2);
-        const val = node;
+        const val = +val1 * +val2;
         resume(err, val);
       });
     });
   }
   POW(node, options, resume) {
-    this.visit(node.elts[0], options, function (err1, val1) {
-      this.visit(node.elts[1], options, function (err2, val2) {
+    this.visit(node.elts[0], options, (err1, val1) => {
+      this.visit(node.elts[1], options, (err2, val2) => {
         if (isNaN(+val1)) {
           err1 = err1.concat(error("Argument must be a number.", node.elts[0]));
         }
@@ -433,9 +562,13 @@ export class Transformer extends Visitor {
     });
   }
   VAL(node, options, resume) {
-    const err = [];
-    const val = node;
-    resume(err, val);
+    this.visit(node.elts[0], options, (e0, v0) => {
+      this.visit(node.elts[1], options, (e1, v1) => {
+        const err = [].concat(e0).concat(e1);
+        const val = v1[v0];
+        resume(err, val);
+      });
+    });
   }
   KEY(node, options, resume) {
     const err = [];
@@ -460,7 +593,7 @@ export class Transformer extends Visitor {
       resume(err, val);
     } else {
       // Otherwise, use the default data.
-      this.visit(node.elts[0], options, function (e0, v0) {
+      this.visit(node.elts[0], options, (e0, v0) => {
         const err = e0;
         const val = v0;
         resume(err, val);
@@ -468,7 +601,7 @@ export class Transformer extends Visitor {
     }
   }
   PAREN(node, options, resume) {
-    this.visit(node.elts[0], options, function (e0, v0) {
+    this.visit(node.elts[0], options, (e0, v0) => {
       const err = [].concat(e0);
       const val = v0;
       resume(err, val);
@@ -511,11 +644,14 @@ export class Transformer extends Visitor {
   CASE(node, options, resume) {
     // FIXME this isn't ASYNC compatible
     options.SYNC = true;
-    this.visit(node.elts[0], options, (err, expr) => {
+    this.visit(node.elts[0], options, (err, e0) => {
+      const e0Node = this.node(node.elts[0]);
+      const expr = (e0Node.tag === 'NUM' || e0Node.tag === 'NUM') && e0Node || {tag: 'STR', elts: [`${e0}`]};
       let foundMatch = false;
+      const patterns = [];
       for (var i = 1; i < node.elts.length; i++) {
         this.visit(node.elts[i], options, (err, val) => {
-          if (expr === val.pattern) {
+          if (this.match(options, [this.node(node.elts[i]).elts[0]], expr).length) {
             this.visit(val.exprElt, options, resume);
             foundMatch = true;
           }
@@ -531,7 +667,7 @@ export class Transformer extends Visitor {
     options.SYNC = false;
   }
   OF(node, options, resume) {
-    this.visit(node.elts[0], options, function (err0, pattern) {
+    this.visit(node.elts[0], options, (err0, pattern) => {
       resume([].concat(err0), {
         pattern: pattern,
         exprElt: node.elts[1],
@@ -579,7 +715,6 @@ export class Compiler {
           } else {
             const renderer = new this.Renderer(val);
             renderer.render(options, (err, val) => {
-              val = !(val instanceof Array) && [val] || val;
               resume(err, val);
             });
           }