@bablr/helpers 0.1.4 → 0.1.6

package/lib/decorators.js

@@ -1 +1,8 @@
 export * from '@bablr/boot-helpers/decorators';
+
+export const UnboundAttributes = (attributes) => (desc, context) => {
+  context.addInitializer(function () {
+    this.unboundAttributes = this.unboundAttributes || new Map();
+    this.unboundAttributes.set(context.name, attributes);
+  });
+};

package/lib/productions.generated.js

@@ -1,30 +1,37 @@
 import { interpolateString as _interpolateString } from "@bablr/boot-helpers/template";
 import { interpolateArray as _interpolateArray } from "@bablr/boot-helpers/template";
 import * as _t from "@bablr/boot-helpers/types";
-export function* List({
-  props: {
+export function* List(props, s, ctx) {
+  const {
     element,
     separator,
     allowHoles = false,
     allowTrailingSeparator = true
-  }
-}) {
+  } = ctx.unbox(props);
   let sep, it;
   for (;;) {
     it = yield _t.node("Instruction", "Call", [_t.ref`verb`, _t.ref`arguments`], {
       verb: _t.node("Instruction", "Identifier", [_t.lit`eatMatch`], {}, {}),
-      arguments: _t.node("Instruction", "Tuple", [_t.ref`open`, _t.ref`values[]`, _t.ref`close`], {
+      arguments: _t.node("Instruction", "Tuple", [_t.ref`open`, _t.ref`values[]`, _t.trivia` `, _t.ref`values[]`, _t.ref`close`], {
         open: _t.node("Instruction", "Punctuator", [_t.lit`(`], {}, {}),
-        values: [..._interpolateArray(element)],
+        values: [..._interpolateArray(element), _t.node("String", "String", [_t.ref`open`, _t.ref`content`, _t.ref`close`], {
+          open: _t.node("String", "Punctuator", [_t.lit`'`], {}, {}),
+          content: _t.node("String", "Content", [_t.lit`elements[]`], {}, {}),
+          close: _t.node("String", "Punctuator", [_t.lit`'`], {}, {})
+        }, {})],
         close: _t.node("Instruction", "Punctuator", [_t.lit`)`], {}, {})
       }, {})
     }, {});
     if (it || allowTrailingSeparator) {
       sep = yield _t.node("Instruction", "Call", [_t.ref`verb`, _t.ref`arguments`], {
         verb: _t.node("Instruction", "Identifier", [_t.lit`eatMatch`], {}, {}),
-        arguments: _t.node("Instruction", "Tuple", [_t.ref`open`, _t.ref`values[]`, _t.ref`close`], {
+        arguments: _t.node("Instruction", "Tuple", [_t.ref`open`, _t.ref`values[]`, _t.trivia` `, _t.ref`values[]`, _t.ref`close`], {
           open: _t.node("Instruction", "Punctuator", [_t.lit`(`], {}, {}),
-          values: [..._interpolateArray(separator)],
+          values: [..._interpolateArray(separator), _t.node("String", "String", [_t.ref`open`, _t.ref`content`, _t.ref`close`], {
+            open: _t.node("String", "Punctuator", [_t.lit`'`], {}, {}),
+            content: _t.node("String", "Content", [_t.lit`separators[]`], {}, {}),
+            close: _t.node("String", "Punctuator", [_t.lit`'`], {}, {})
+          }, {})],
           close: _t.node("Instruction", "Punctuator", [_t.lit`)`], {}, {})
         }, {})
       }, {});
@@ -32,12 +39,8 @@ export function* List({
     if (!(sep || allowHoles)) break;
   }
 }
-export function* Any({
-  props: {
-    matchers
-  }
-}) {
-  for (const matcher of matchers) {
+export function* Any(matchers, s, ctx) {
+  for (const matcher of ctx.unbox(matchers)) {
     if (yield _t.node("Instruction", "Call", [_t.ref`verb`, _t.ref`arguments`], {
       verb: _t.node("Instruction", "Identifier", [_t.lit`eatMatch`], {}, {}),
       arguments: _t.node("Instruction", "Tuple", [_t.ref`open`, _t.ref`values[]`, _t.ref`close`], {
@@ -48,12 +51,8 @@ export function* Any({
     }, {})) break;
   }
 }
-export function* All({
-  props: {
-    matchers
-  }
-}) {
-  for (const matcher of matchers) {
+export function* All(matchers, s, ctx) {
+  for (const matcher of ctx.unbox(matchers)) {
     yield _t.node("Instruction", "Call", [_t.ref`verb`, _t.ref`arguments`], {
       verb: _t.node("Instruction", "Identifier", [_t.lit`eat`], {}, {}),
       arguments: _t.node("Instruction", "Tuple", [_t.ref`open`, _t.ref`values[]`, _t.ref`close`], {
@@ -64,19 +63,60 @@ export function* All({
     }, {});
   }
 }
-export function* Optional({
-  props: {
-    matchers
+export function* Match(cases, s, ctx) {
+  for (const case_ of ctx.unbox(cases)) {
+    const {
+      0: matcher,
+      1: guard
+    } = ctx.unbox(case_);
+    if (yield _t.node("Instruction", "Call", [_t.ref`verb`, _t.ref`arguments`], {
+      verb: _t.node("Instruction", "Identifier", [_t.lit`match`], {}, {}),
+      arguments: _t.node("Instruction", "Tuple", [_t.ref`open`, _t.ref`values[]`, _t.ref`close`], {
+        open: _t.node("Instruction", "Punctuator", [_t.lit`(`], {}, {}),
+        values: [..._interpolateArray(guard)],
+        close: _t.node("Instruction", "Punctuator", [_t.lit`)`], {}, {})
+      }, {})
+    }, {})) {
+      yield _t.node("Instruction", "Call", [_t.ref`verb`, _t.ref`arguments`], {
+        verb: _t.node("Instruction", "Identifier", [_t.lit`eat`], {}, {}),
+        arguments: _t.node("Instruction", "Tuple", [_t.ref`open`, _t.ref`values[]`, _t.ref`close`], {
+          open: _t.node("Instruction", "Punctuator", [_t.lit`(`], {}, {}),
+          values: [..._interpolateArray(matcher)],
+          close: _t.node("Instruction", "Punctuator", [_t.lit`)`], {}, {})
+        }, {})
+      }, {});
+      break;
+    }
   }
-}) {
-  if (matchers.length > 1) {
+}
+export function* Punctuator(obj, s, ctx) {
+  const {
+    value,
+    attrs
+  } = ctx.unbox(obj);
+  yield _t.node("Instruction", "Call", [_t.ref`verb`, _t.ref`arguments`], {
+    verb: _t.node("Instruction", "Identifier", [_t.lit`eat`], {}, {}),
+    arguments: _t.node("Instruction", "Tuple", [_t.ref`open`, _t.ref`values[]`, _t.ref`close`], {
+      open: _t.node("Instruction", "Punctuator", [_t.lit`(`], {}, {}),
+      values: [..._interpolateArray(value)],
+      close: _t.node("Instruction", "Punctuator", [_t.lit`)`], {}, {})
+    }, {})
+  }, {});
+  return {
+    attrs
+  };
+}
+export const Keyword = Punctuator;
+export function* Optional(matchers, s, ctx) {
+  const matchers_ = ctx.unbox(matchers);
+  if (matchers_.length > 1) {
     throw new Error('Optional only allows one matcher');
   }
   yield _t.node("Instruction", "Call", [_t.ref`verb`, _t.ref`arguments`], {
     verb: _t.node("Instruction", "Identifier", [_t.lit`eatMatch`], {}, {}),
     arguments: _t.node("Instruction", "Tuple", [_t.ref`open`, _t.ref`values[]`, _t.ref`close`], {
       open: _t.node("Instruction", "Punctuator", [_t.lit`(`], {}, {}),
-      values: [..._interpolateArray(matchers[0])],
+      values: [..._interpolateArray(matchers_[0])],
       close: _t.node("Instruction", "Punctuator", [_t.lit`)`], {}, {})
     }, {})
   }, {});

package/lib/productions.js

@@ -1,33 +1,58 @@
 import { i } from '@bablr/boot/shorthand.macro';
 
-export function* List({
-  props: { element, separator, allowHoles = false, allowTrailingSeparator = true },
-}) {
+export function* List(props, s, ctx) {
+  const {
+    element,
+    separator,
+    allowHoles = false,
+    allowTrailingSeparator = true,
+  } = ctx.unbox(props);
+
   let sep, it;
   for (;;) {
-    it = yield i`eatMatch(${element})`;
+    it = yield i`eatMatch(${element} 'elements[]')`;
     if (it || allowTrailingSeparator) {
-      sep = yield i`eatMatch(${separator})`;
+      sep = yield i`eatMatch(${separator} 'separators[]')`;
     }
     if (!(sep || allowHoles)) break;
   }
 }
 
-export function* Any({ props: { matchers } }) {
-  for (const matcher of matchers) {
+export function* Any(matchers, s, ctx) {
+  for (const matcher of ctx.unbox(matchers)) {
     if (yield i`eatMatch(${matcher})`) break;
   }
 }
 
-export function* All({ props: { matchers } }) {
-  for (const matcher of matchers) {
+export function* All(matchers, s, ctx) {
+  for (const matcher of ctx.unbox(matchers)) {
     yield i`eat(${matcher})`;
   }
 }
 
-export function* Optional({ props: { matchers } }) {
-  if (matchers.length > 1) {
+export function* Match(cases, s, ctx) {
+  for (const case_ of ctx.unbox(cases)) {
+    const { 0: matcher, 1: guard } = ctx.unbox(case_);
+    if (yield i`match(${guard})`) {
+      yield i`eat(${matcher})`;
+      break;
+    }
+  }
+}
+
+export function* Punctuator(obj, s, ctx) {
+  const { value, attrs } = ctx.unbox(obj);
+  yield i`eat(${value})`;
+
+  return { attrs };
+}
+
+export const Keyword = Punctuator;
+
+export function* Optional(matchers, s, ctx) {
+  const matchers_ = ctx.unbox(matchers);
+  if (matchers_.length > 1) {
     throw new Error('Optional only allows one matcher');
   }
-  yield i`eatMatch(${matchers[0]})`;
+  yield i`eatMatch(${matchers_[0]})`;
 }

package/lib/symbols.js

@@ -1,6 +1 @@
 export const node = Symbol.for('@bablr/node');
-
-export const active = Symbol.for('@bablr/active');
-export const suspended = Symbol.for('@bablr/suspended');
-export const accepted = Symbol.for('@bablr/accepted');
-export const rejected = Symbol.for('@bablr/rejected');

package/lib/trivia.js

@@ -75,6 +75,8 @@ export const triviaEnhancer = ({ triviaIsAllowed, eatMatchTrivia }, grammar) =>
             matchedResults.add(s.result);
           }
         }
+
+        return co.value;
       } catch (e) {
         co.throw(e);
         throw e;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@bablr/helpers",
   "description": "Command helpers for use in writing BABLR grammars",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "author": "Conrad Buck<conartist6@gmail.com>",
   "type": "module",
   "files": [
@@ -25,7 +25,7 @@
     "clean": "rm lib/productions.generated.js"
   },
   "dependencies": {
-    "@bablr/boot": "0.1.8",
+    "@bablr/boot": "0.1.9",
     "@bablr/boot-helpers": "0.1.3",
     "iter-tools-es": "^7.5.3"
   },