@bablr/language-en-json 0.8.0 → 0.10.0

package/lib/grammar.macro.js

@@ -1,50 +1,51 @@
-import { i } from '@bablr/boot/shorthand.macro';
+import { re, spam as m } from '@bablr/boot';
 import { triviaEnhancer } from '@bablr/helpers/trivia';
 import * as productions from '@bablr/helpers/productions';
-import { buildString, buildBoolean } from '@bablr/helpers/builders';
-import {
-  Node,
-  CoveredBy,
-  AllowEmpty,
-  InjectFrom,
-  UnboundAttributes,
-} from '@bablr/helpers/decorators';
+import { o, eat, eatMatch, match, fail } from '@bablr/helpers/grammar';
+import { buildString, buildIdentifier } from '@bablr/helpers/builders';
+import { Node, CoveredBy, AllowEmpty, InjectFrom, Literal } from '@bablr/helpers/decorators';
 import * as Space from '@bablr/language-en-blank-space';
 
 export const dependencies = { Space };
 
-export const canonicalURL = 'https://github.com/bablr-lang/language-en-json';
+export const canonicalURL = 'https://bablr.org/languages/core/en/json';
 
-export const escapables = new Map(
+const escapables = new Map(
   Object.entries({
-    b: '\b',
-    f: '\f',
+    b: '\b', // these two escapes are antiquated
+    f: '\f', // but giving their meaning away could be confusing
     n: '\n',
     r: '\r',
     t: '\t',
-    '\\': '\\',
-    '/': '/',
+    0: '\0',
   }),
 );
 
+function first(iter) {
+  for (let value of iter) return value;
+}
+
 export const getCooked = (escapeNode, span, ctx) => {
   let cooked;
   const codeNode = escapeNode.get('code');
-  const type = ctx.sourceTextFor(codeNode.get('typeToken'));
-  const value = ctx.sourceTextFor(codeNode.get('value'));
-
-  if (!span.startsWith('String')) {
-    throw new Error('not implemented');
-  }
 
-  if (!type) {
+  if (first(codeNode.children)?.value.flags.token) {
     const match_ = ctx.sourceTextFor(codeNode);
 
     cooked = escapables.get(match_) || match_;
-  } else if (type === 'u') {
-    cooked = parseInt(value, 16);
   } else {
-    throw new Error();
+    const type = ctx.sourceTextFor(codeNode.get('typeToken'));
+    const value = ctx.sourceTextFor(codeNode.get('value'));
+
+    if (!span.startsWith('String')) {
+      throw new Error('not implemented');
+    }
+
+    if (type === 'u') {
+      cooked = String.fromCharCode(parseInt(value, 16));
+    } else {
+      throw new Error();
+    }
   }
 
   return cooked.toString(10);
@@ -53,167 +54,233 @@ export const getCooked = (escapeNode, span, ctx) => {
 export const grammar = triviaEnhancer(
   {
     triviaIsAllowed: (s) => s.span === 'Bare',
-    *eatMatchTrivia() {
-      if (yield i`match(/[ \n\r\t]/)`) {
-        yield i`eat(<#*Space:Space />)`;
-      }
-    },
+    triviaMatcher: m`#: <*Space:Space /[ \n\r\t]/ />`,
   },
   class JSONGrammar {
-    *[Symbol.for('@bablr/fragment')]() {
+    *[Symbol.for('@bablr/fragment')]({ props: { rootMatcher } }) {
       // needed for the trivia plugin
-      yield i`eat(< />)`;
+      yield eat(rootMatcher);
     }
 
     @CoveredBy('Element')
     *Expression() {
-      yield i`eat(<Any /> null [
-        <Array '[' />
-        <Object '{' />
-        <String '"' />
-        <Number /-?\d/ span='Number' />
-        <Null 'null' />
-        <Boolean /true|false/ />
-      ])`;
+      yield eat(m`<_Any />`, [
+        m`<Array '[' />`,
+        m`<Object '{' />`,
+        m`<String /['"]/ />`,
+        m`<Number /\d|-[\d\g]/ {span: 'Number'} />`,
+        m`<Infinity /-?Infinity/ />`,
+        m`<Null 'null' />`,
+        m`<Boolean /true|false/ />`,
+      ]);
     }
 
     @CoveredBy('Expression')
     @Node
     *Array() {
-      yield i`eat(<*Punctuator '[' balanced=']' /> 'openToken')`;
-      yield i`eat(<List /> 'elements[]$' {
-        element: <Expression />
-        separator: <*Punctuator ',' />
-        allowTrailingSeparator: false
-      })`;
-      yield i`eat(<*Punctuator ']' balancer /> 'closeToken')`;
+      yield eat(m`openToken: <*Punctuator '[' { balanced: ']' } />`);
+      yield eat(
+        m`<_List />`,
+        o({
+          element: m`elements[]+$: <__Expression />`,
+          separator: m`separatorTokens[]: <*Punctuator ',' />`,
+          allowTrailingSeparator: false,
+        }),
+      );
+      yield eat(m`closeToken: <*Punctuator ']' { balancer: true } />`);
     }
 
     @CoveredBy('Expression')
     @Node
     *Object() {
-      yield i`eat(<*Punctuator '{' balanced='}' /> 'openToken')`;
-      yield i`eat(<List /> 'properties[]$' {
-        element: <Property />
-        separator: <*Punctuator ',' />
-        allowTrailingSeparator: false
-      })`;
-      yield i`eat(<*Punctuator '}' balancer /> 'closeToken')`;
+      yield eat(m`openToken: <*Punctuator '{' { balanced: '}' } />`);
+      let sep = true;
+
+      yield eatMatch(m`separatorTokens[]: []`);
+      yield eatMatch(m`properties[]$: []`);
+
+      while (sep && (yield match(re`/.|\g/s`))) {
+        let suppressGap = !!(yield match(m`<_All />`, [
+          m`key: <//>`,
+          m`sigilToken: <*Punctuator ':' />`,
+        ]));
+        yield eat(m`properties[]$: <Property />`, null, o({ suppressGap }));
+        sep = yield eatMatch(m`separatorTokens[]: <*Punctuator ',' />`);
+      }
+      yield eat(m`closeToken: <*Punctuator '}' { balancer: true } />`);
     }
 
     @Node
     *Property() {
-      yield i`eat(<String /> 'key$')`;
-      yield i`eat(<*Punctuator ':' /> 'sigilToken')`;
-      yield i`eat(<Expression /> 'value$')`;
+      yield eat(m`key$: <*Identifier />`);
+      yield eat(m`sigilToken: <*Punctuator ':' />`);
+      yield eat(m`value+$: <__Expression />`);
     }
 
-    @CoveredBy('Language')
     @Node
-    *String() {
-      yield i`eat(<*Punctuator '"' balanced='"' balancedSpan='String' /> 'openToken')`;
-      yield i`eat(<*StringContent /> 'content')`;
-      yield i`eat(<*Punctuator '"' balancer /> 'closeToken')`;
+    *Identifier() {
+      yield eat(re`/[a-zA-Z][a-zA-Z_-]*/`);
+    }
+
+    @CoveredBy('Expression')
+    @Node
+    *String({ ctx }) {
+      let q = yield match(re`/['"]/`);
+
+      if (!q) yield fail();
+
+      const q_ = ctx.sourceTextFor(q);
+
+      yield q_ === "'"
+        ? eat(m`openToken: <*Punctuator "'" { balanced: "'", balancedSpan: 'String:Single' } />`)
+        : eat(m`openToken: <*Punctuator '"' { balanced: '"', balancedSpan: 'String:Double' } />`);
+
+      yield eat(m`content$: <*StringContent />`);
+
+      yield q_ === "'"
+        ? eat(m`closeToken: <*Punctuator "'" { balancer: true } />`)
+        : eat(m`closeToken: <*Punctuator '"' { balancer: true } />`);
     }
 
     @AllowEmpty
     @Node
-    *StringContent() {
+    *StringContent({ state: { span } }) {
       let esc, lit;
       do {
-        esc = (yield i`match('\\')`) && (yield i`eat(<@EscapeSequence />)`);
-        lit = yield i`eatMatch(/[^\r\n\\"\g]+/)`;
+        esc = (yield match('\\')) && (yield eat(m`@: <EscapeSequence />`));
+        lit =
+          span === 'String:Single'
+            ? yield eatMatch(re`/[^\r\n\\'\g]+/`)
+            : yield eatMatch(re`/[^\r\n\\"\g]+/`);
       } while (esc || lit);
     }
 
     @Node
     *EscapeSequence({ state: { span }, ctx }) {
       if (!span.startsWith('String')) {
-        yield i`fail()`;
+        yield fail();
       }
 
-      yield i`eat(<*Punctuator '\\' openSpan='Escape' /> 'sigilToken')`;
+      yield eat(m`sigilToken: <*Punctuator '\\' { openSpan: 'Escape' } />`);
 
-      let match;
+      let match_;
 
-      if ((match = yield i`match(/[\\/bfnrt"]/)`)) {
-        const match_ = ctx.sourceTextFor(match);
-        yield i`eat(<*Keyword ${buildString(match_)} closeSpan='Escape' /> 'code')`;
-      } else if (yield i`match('u')`) {
-        yield i`eat(<EscapeCode closeSpan='Escape' /> 'code')`;
+      if (
+        (match_ =
+          span === 'String:Single' ? yield match(re`/[\\/nrt0']/`) : yield match(re`/[\\/nrt0"]/`))
+      ) {
+        const matchText = ctx.sourceTextFor(match_);
+        yield eat(m`code: <*Keyword ${buildString(matchText)} { closeSpan: 'Escape' } />`);
+      } else if (yield match('u')) {
+        yield eat(m`code: <EscapeCode { closeSpan: 'Escape' } />`);
       } else {
-        yield i`fail()`;
+        yield fail();
       }
     }
 
     @Node
     *EscapeCode() {
-      yield i`eat(<*Keyword 'u' /> 'typeToken')`;
-      yield i`eat(<*UnsignedInteger /> 'value$')`;
+      if (yield eatMatch(m`typeToken: <*Keyword 'u' />`)) {
+        if (
+          yield eatMatch(
+            m`openToken: <*Punctuator '{' { balanced: '}' } />`,
+            null,
+            o({ bind: true }),
+          )
+        ) {
+          yield eat(m`value$: <*UnsignedHexInteger />`);
+          yield eat(m`closeToken: <*Punctuator '}' { balancer: true } />`);
+        } else {
+          yield eat(m`value$: <*UnsignedHexInteger /[\da-fA-F]{4}/ />`);
+          yield eat(m`closeToken: null`);
+        }
+      }
     }
 
     @CoveredBy('Expression')
     @Node
     *Number() {
-      yield i`eat(<Integer /> 'wholePart' { noDoubleZero: true matchSign: '-' })`;
+      yield eat(m`wholePart$: <Integer />`, o({ noDoubleZero: true, matchSign: '-' }));
 
-      let fs = yield i`eatMatch(<*Punctuator '.' /> 'fractionalSeparatorToken')`;
+      let fs = yield eatMatch(
+        m`fractionalSeparatorToken: <*Punctuator '.' />`,
+        null,
+        o({ bind: true }),
+      );
 
       if (fs) {
-        yield i`eat(<Integer /> 'fractionalPart')`;
+        yield eat(m`fractionalPart$: <*UnsignedInteger />`);
       } else {
-        yield i`eat(null 'fractionalPart')`;
+        yield eat(m`fractionalPart$: null`);
       }
 
-      let es = yield i`eatMatch(<*Punctuator /[eE]/ /> 'exponentSeparatorToken')`;
+      let es = yield eatMatch(
+        m`exponentSeparatorToken: <*Punctuator /[eE]/ />`,
+        null,
+        o({ bind: true }),
+      );
 
       if (es) {
-        yield i`eat(<Integer /> 'exponentPart' { matchSign: /[+-]/ })`;
+        yield eat(m`exponentPart$: <Integer />`, { matchSign: /[+-]/ });
       } else {
-        yield i`eat(null 'exponentPart')`;
+        yield eat(m`exponentPart$: null`);
       }
     }
 
     @Node
-    *Integer({ value: props, ctx }) {
-      const { matchSign = null, noDoubleZero = false } = (props && ctx.unbox(props)) || {};
-
+    *Integer({ props: { matchSign = null, noDoubleZero = false } }) {
       if (matchSign) {
-        yield i`eatMatch(<*Punctuator ${matchSign} /> 'signToken')`;
+        yield eatMatch(
+          m`signToken: <*Punctuator ${buildString(matchSign)} />`,
+          null,
+          o({ bind: true }),
+        );
       } else {
-        yield i`eat(null 'signToken')`;
+        yield eat(m`signToken: null`);
       }
 
-      yield i`eat(<*UnsignedInteger noDoubleZero=${buildBoolean(noDoubleZero)} /> 'value')`;
+      yield eat(m`value$: <*UnsignedInteger />`, o({ noDoubleZero }));
     }
 
     @Node
-    *UnsignedInteger({ value: props, ctx }) {
-      const { noDoubleZero = false } = (props && ctx.unbox(props)) || {};
-
-      let [firstDigit] = ctx.allTagsFor(yield i`eat(/\d/)`);
+    *UnsignedInteger({ props: { noDoubleZero = false }, ctx }) {
+      let firstDigit = ctx.sourceTextFor(yield eat(re`/\d/`));
 
       if (!noDoubleZero || firstDigit.value !== '0') {
-        yield i`eatMatch(/\d+/)`;
+        yield eatMatch(re`/\d+/`);
       }
     }
 
+    @Node
+    *UnsignedHexInteger() {
+      yield eatMatch(re`/[\da-fA-F]+/`);
+    }
+
+    @CoveredBy('Expression')
+    @Node
+    *Infinity() {
+      yield eatMatch(m`signToken: <*Punctuator '-' />`, null, o({ bind: true }));
+      yield eat(m`sigilToken: <*Keyword 'Infinity' />`);
+    }
+
     @CoveredBy('Expression')
     @Node
     *Boolean() {
-      yield i`eat(<*Keyword /true|false/ /> 'sigilToken')`;
+      yield eat(m`sigilToken: <*Keyword /true|false/ />`);
     }
 
     @CoveredBy('Expression')
     @Node
     *Null() {
-      yield i`eat(<*Keyword 'null' /> 'sigilToken')`;
+      yield eat(m`sigilToken: <*Keyword 'null' />`);
     }
 
+    @Literal
     @Node
     @InjectFrom(productions)
     *Keyword() {}
 
+    @Literal
     @Node
     @InjectFrom(productions)
     *Punctuator() {}
@@ -224,5 +291,8 @@ export const grammar = triviaEnhancer(
 
     @InjectFrom(productions)
     *Any() {}
+
+    @InjectFrom(productions)
+    *All() {}
   },
 );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bablr/language-en-json",
-  "version": "0.8.0",
+  "version": "0.10.0",
   "description": "A BABLR language for JSON",
   "engines": {
     "node": ">=12.0.0"
@@ -10,7 +10,9 @@
     ".": "./lib/grammar.js",
     "./package.json": "./package.json"
   },
-  "files": ["lib/**/*.js"],
+  "files": [
+    "lib/**/*.js"
+  ],
   "scripts": {
     "build": "macrome build",
     "watch": "macrome watch",
@@ -19,11 +21,11 @@
   },
   "sideEffects": false,
   "dependencies": {
-    "@bablr/agast-helpers": "^0.5.3",
-    "@bablr/agast-vm-helpers": "^0.5.0",
-    "@bablr/boot": "^0.6.0",
-    "@bablr/helpers": "^0.20.5",
-    "@bablr/language-en-blank-space": "^0.5.0",
+    "@bablr/agast-helpers": "0.7.1",
+    "@bablr/agast-vm-helpers": "0.7.1",
+    "@bablr/boot": "0.8.1",
+    "@bablr/helpers": "0.22.1",
+    "@bablr/language-en-blank-space": "0.7.0",
     "@babel/runtime": "^7.22.15"
   },
   "devDependencies": {
@@ -31,7 +33,7 @@
     "@bablr/macrome": "^0.1.3",
     "@bablr/macrome-generator-bablr": "^0.3.2",
     "@qnighy/dedent": "0.1.1",
-    "bablr": "^0.6.0",
+    "bablr": "^0.7.0",
     "enhanced-resolve": "^5.12.0",
     "eslint": "^7.32.0",
     "eslint-import-resolver-enhanced-resolve": "^1.0.5",
@@ -41,7 +43,11 @@
     "mocha": "^10.4.0",
     "prettier": "^2.0.5"
   },
-  "keywords": ["bablr-language", "grammar", "english", "json"],
+  "keywords": [
+    "bablr-language",
+    "grammar",
+    "english"
+  ],
   "repository": "git@github.com:bablr-lang/language-en-json.git",
   "homepage": "https://github.com/bablr-lang/language-en-json",
   "author": "Conrad Buck <conartist6@gmail.com>",