@bablr/language-en-json 0.5.4 → 0.7.0

package/lib/grammar.macro.js

@@ -2,7 +2,13 @@ import { i } from '@bablr/boot/shorthand.macro';
 import { triviaEnhancer } from '@bablr/helpers/trivia';
 import * as productions from '@bablr/helpers/productions';
 import { buildString, buildBoolean } from '@bablr/agast-vm-helpers';
-import { Node, CoveredBy, AllowEmpty, InjectFrom, Attributes } from '@bablr/helpers/decorators';
+import {
+  Node,
+  CoveredBy,
+  AllowEmpty,
+  InjectFrom,
+  UnboundAttributes,
+} from '@bablr/helpers/decorators';
 import * as Space from '@bablr/language-en-blank-space';
 
 export const dependencies = { Space };
@@ -21,69 +27,93 @@ export const escapables = new Map(
   }),
 );
 
+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) {
+    const match_ = ctx.sourceTextFor(codeNode);
+
+    cooked = escapables.get(match_) || match_;
+  } else if (type === 'u') {
+    cooked = parseInt(value, 16);
+  } else {
+    throw new Error();
+  }
+
+  return cooked.toString(10);
+};
+
 export const grammar = triviaEnhancer(
   {
     triviaIsAllowed: (s) => s.span === 'Bare',
     *eatMatchTrivia() {
       if (yield i`match(/[ \n\r\t]/)`) {
-        yield i`eat(<#*Space:Space>)`;
+        yield i`eat(<#*Space:Space />)`;
       }
     },
   },
   class JSONGrammar {
     *[Symbol.for('@bablr/fragment')]() {
-      yield i`eat(<> 'root')`;
+      // needed for the trivia plugin
+      yield i`eat(< />)`;
     }
 
     @CoveredBy('Element')
     *Expression() {
-      yield i`eat(<Any> null [
-        <Array '['>
-        <Object '{'>
-        <String '"'>
-        <Number /-?\d/ span='Number'>
-        <Null 'null'>
-        <Boolean /true|false/>
+      yield i`eat(<Any /> null [
+        <Array '[' />
+        <Object '{' />
+        <String '"' />
+        <Number /-?\d/ span='Number' />
+        <Null 'null' />
+        <Boolean /true|false/ />
       ])`;
     }
 
     @CoveredBy('Expression')
     @Node
     *Array() {
-      yield i`eat(<~*Punctuator '[' balanced=']'> 'openToken')`;
-      yield i`eat(<List> 'elements[]' {
-        element: <Expression>
-        separator: <~*Punctuator ','>
+      yield i`eat(<*Punctuator '[' balanced=']' /> 'openToken')`;
+      yield i`eat(<List /> 'elements[]$' {
+        element: <Expression />
+        separator: <*Punctuator ',' />
         allowTrailingSeparator: false
       })`;
-      yield i`eat(<~*Punctuator ']' balancer> 'closeToken')`;
+      yield i`eat(<*Punctuator ']' balancer /> 'closeToken')`;
     }
 
     @CoveredBy('Expression')
     @Node
     *Object() {
-      yield i`eat(<~*Punctuator '{' balanced='}'> 'openToken')`;
-      yield i`eat(<List> 'properties[]' {
-        element: <Property>
-        separator: <~*Punctuator ','>
+      yield i`eat(<*Punctuator '{' balanced='}' /> 'openToken')`;
+      yield i`eat(<List /> 'properties[]$' {
+        element: <Property />
+        separator: <*Punctuator ',' />
         allowTrailingSeparator: false
       })`;
-      yield i`eat(<~*Punctuator '}' balancer> 'closeToken')`;
+      yield i`eat(<*Punctuator '}' balancer /> 'closeToken')`;
     }
 
     @Node
     *Property() {
-      yield i`eat(<String> 'key')`;
-      yield i`eat(<~*Punctuator ':'> 'sigilToken')`;
-      yield i`eat(<Expression> 'value')`;
+      yield i`eat(<String /> 'key$')`;
+      yield i`eat(<*Punctuator ':' /> 'sigilToken')`;
+      yield i`eat(<Expression /> 'value$')`;
     }
 
     @CoveredBy('Language')
     @Node
     *String() {
-      yield i`eat(<~*Punctuator '"' balanced='"' balancedSpan='String'> 'openToken')`;
-      yield i`eat(<*StringContent> 'content')`;
-      yield i`eat(<~*Punctuator '"' balancer> 'closeToken')`;
+      yield i`eat(<*Punctuator '"' balanced='"' balancedSpan='String' /> 'openToken')`;
+      yield i`eat(<*StringContent /> 'content')`;
+      yield i`eat(<*Punctuator '"' balancer /> 'closeToken')`;
     }
 
     @AllowEmpty
@@ -91,62 +121,54 @@ export const grammar = triviaEnhancer(
     *StringContent() {
       let esc, lit;
       do {
-        esc = (yield i`match('\\')`) && (yield i`eat(<@EscapeSequence>)`);
-        lit = yield i`eatMatch(/[^\r\n\\"]+/)`;
+        esc = (yield i`match('\\')`) && (yield i`eat(<@EscapeSequence />)`);
+        lit = yield i`eatMatch(/[^\r\n\\"\g]+/)`;
       } while (esc || lit);
     }
 
-    @Attributes(['cooked'])
     @Node
     *EscapeSequence({ state: { span }, ctx }) {
       if (!span.startsWith('String')) {
         yield i`fail()`;
       }
 
-      yield i`eat(<~*Punctuator '\\' openSpan='Escape'> 'sigilToken')`;
+      yield i`eat(<*Punctuator '\\' openSpan='Escape' /> 'sigilToken')`;
 
-      let match, cooked;
+      let match;
 
       if ((match = yield i`match(/[\\/bfnrt"]/)`)) {
         const match_ = ctx.sourceTextFor(match);
-        yield i`eat(<~*Keyword ${buildString(match_)} closeSpan='Escape'> 'value')`;
-        cooked = escapables.get(match_) || match_;
+        yield i`eat(<*Keyword ${buildString(match_)} closeSpan='Escape' /> 'code')`;
       } else if (yield i`match('u')`) {
-        const codeNode = yield i`eat(<EscapeCode closeSpan='Escape'> 'value')`;
-        cooked = parseInt(
-          codeNode.properties.digits.map((digit) => ctx.sourceTextFor(digit)).join(''),
-          16,
-        );
+        yield i`eat(<EscapeCode closeSpan='Escape' /> 'code')`;
       } else {
         yield i`fail()`;
       }
-
-      yield i`bindAttribute(cooked ${buildString(cooked.toString(10))})`;
     }
 
     @Node
     *EscapeCode() {
-      yield i`eat(<~*Keyword 'u'> 'typeToken')`;
-      yield i`eat(<Digits> 'digits[]')`;
+      yield i`eat(<*Keyword 'u' /> 'typeToken')`;
+      yield i`eat(<*UnsignedInteger /> 'value$')`;
     }
 
     @CoveredBy('Expression')
     @Node
     *Number() {
-      yield i`eat(<Integer> 'wholePart' { noDoubleZero: true matchSign: '-' })`;
+      yield i`eat(<Integer /> 'wholePart' { noDoubleZero: true matchSign: '-' })`;
 
-      let fs = yield i`eatMatch(<~*Punctuator '.'> 'fractionalSeparatorToken')`;
+      let fs = yield i`eatMatch(<*Punctuator '.' /> 'fractionalSeparatorToken')`;
 
       if (fs) {
-        yield i`eat(<Integer> 'fractionalPart')`;
+        yield i`eat(<Integer /> 'fractionalPart')`;
       } else {
         yield i`eat(null 'fractionalPart')`;
       }
 
-      let es = yield i`eatMatch(<~*Punctuator /[eE]/> 'exponentSeparatorToken')`;
+      let es = yield i`eatMatch(<*Punctuator /[eE]/ /> 'exponentSeparatorToken')`;
 
       if (es) {
-        yield i`eat(<Integer> 'exponentPart' { matchSign: /[+-]/ })`;
+        yield i`eat(<Integer /> 'exponentPart' { matchSign: /[+-]/ })`;
       } else {
         yield i`eat(null 'exponentPart')`;
       }
@@ -157,19 +179,19 @@ export const grammar = triviaEnhancer(
       const { matchSign = null, noDoubleZero = false } = (props && ctx.unbox(props)) || {};
 
       if (matchSign) {
-        yield i`eatMatch(<~*Punctuator ${matchSign}> 'signToken')`;
+        yield i`eatMatch(<*Punctuator ${matchSign} /> 'signToken')`;
       } else {
         yield i`eat(null 'signToken')`;
       }
 
-      yield i`eat(<*UnsignedInteger noDoubleZero=${buildBoolean(noDoubleZero)}> 'value')`;
+      yield i`eat(<*UnsignedInteger noDoubleZero=${buildBoolean(noDoubleZero)} /> 'value')`;
     }
 
     @Node
     *UnsignedInteger({ value: props, ctx }) {
       const { noDoubleZero = false } = (props && ctx.unbox(props)) || {};
 
-      let [firstDigit] = ctx.allTerminalsFor(yield i`eat(/\d/)`);
+      let [firstDigit] = ctx.allTagsFor(yield i`eat(/\d/)`);
 
       if (!noDoubleZero || firstDigit.value !== '0') {
         yield i`eatMatch(/\d+/)`;
@@ -179,13 +201,13 @@ export const grammar = triviaEnhancer(
     @CoveredBy('Expression')
     @Node
     *Boolean() {
-      yield i`eat(<~*Keyword /true|false/> 'sigilToken')`;
+      yield i`eat(<*Keyword /true|false/ /> 'sigilToken')`;
     }
 
     @CoveredBy('Expression')
     @Node
     *Null() {
-      yield i`eat(<~*Keyword 'null'> 'sigilToken')`;
+      yield i`eat(<*Keyword 'null' /> 'sigilToken')`;
     }
 
     @Node

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bablr/language-en-json",
-  "version": "0.5.4",
+  "version": "0.7.0",
   "description": "A BABLR language for JSON",
   "engines": {
     "node": ">=12.0.0"
@@ -21,26 +21,26 @@
   },
   "sideEffects": false,
   "dependencies": {
-    "@bablr/agast-helpers": "0.3.2",
-    "@bablr/agast-vm-helpers": "0.3.2",
-    "@bablr/boot": "0.4.0",
-    "@bablr/helpers": "0.18.2",
-    "@bablr/language-en-blank-space": "0.3.1",
+    "@bablr/agast-helpers": "^0.5.0",
+    "@bablr/agast-vm-helpers": "^0.5.0",
+    "@bablr/boot": "^0.6.0",
+    "@bablr/helpers": "^0.20.0",
+    "@bablr/language-en-blank-space": "^0.5.0",
     "@babel/runtime": "^7.22.15"
   },
   "devDependencies": {
     "@bablr/eslint-config-base": "github:bablr-lang/eslint-config-base#49f5952efed27f94ee9b94340eb1563c440bf64e",
-    "@bablr/macrome": "0.1.3",
-    "@bablr/macrome-generator-bablr": "0.3.1",
+    "@bablr/macrome": "^0.1.3",
+    "@bablr/macrome-generator-bablr": "^0.3.2",
     "@qnighy/dedent": "0.1.1",
-    "bablr": "0.4.1",
+    "bablr": "^0.6.0",
     "enhanced-resolve": "^5.12.0",
     "eslint": "^7.32.0",
     "eslint-import-resolver-enhanced-resolve": "^1.0.5",
     "eslint-plugin-import": "^2.27.5",
     "expect": "29.7.0",
     "iter-tools-es": "^7.5.3",
-    "mocha": "10.4.0",
+    "mocha": "^10.4.0",
     "prettier": "^2.0.5"
   },
   "keywords": [