@bablr/language-en-json 0.4.0

package/lib/grammar.macro.js

@@ -0,0 +1,209 @@
+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 * 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 escapables = new Map(
+  Object.entries({
+    b: '\b',
+    f: '\f',
+    n: '\n',
+    r: '\r',
+    t: '\t',
+    '\\': '\\',
+    '/': '/',
+  }),
+);
+
+export const grammar = triviaEnhancer(
+  {
+    triviaIsAllowed: (s) => s.span === 'Bare',
+    *eatMatchTrivia() {
+      if (yield i`match(/[ \n\r\t]/)`) {
+        yield i`eat(<#*Space:Space>)`;
+      }
+    },
+  },
+  class JSONGrammar {
+    *[Symbol.for('@bablr/fragment')]() {
+      yield i`eat(<> 'root')`;
+    }
+
+    @CoveredBy('Element')
+    *Expression() {
+      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 ','>
+        allowTrailingSeparator: false
+      })`;
+      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 ','>
+        allowTrailingSeparator: false
+      })`;
+      yield i`eat(<~*Punctuator '}' balancer> 'closeToken')`;
+    }
+
+    @Node
+    *Property() {
+      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')`;
+    }
+
+    @AllowEmpty
+    @Node
+    *StringContent() {
+      let esc, lit;
+      do {
+        esc = (yield i`match('\\')`) && (yield i`eat(<@EscapeSequence>)`);
+        lit = yield i`eatMatch(/[^\r\n\\"]+/)`;
+      } while (esc || lit);
+    }
+
+    @Attributes(['cooked'])
+    @Node
+    *EscapeSequence({ state: { span }, ctx }) {
+      if (!span.startsWith('String')) {
+        yield i`fail()`;
+      }
+
+      yield i`eat(<~*Punctuator '\\'> 'sigilToken')`;
+
+      let match, cooked;
+
+      if ((match = yield i`match(/[\\/bfnrt"]/)`)) {
+        const match_ = ctx.sourceTextFor(match);
+        yield i`eat(<~*Keyword ${buildString(match_)}> 'value')`;
+        cooked = escapables.get(match_) || match_;
+      } else if (yield i`match('u')`) {
+        const codeNode = yield i`eat(<EscapeCode> 'value')`;
+        cooked = parseInt(
+          ctx
+            .getProperty(codeNode, 'digits')
+            .map((digit) => ctx.sourceTextFor(digit))
+            .join(''),
+          16,
+        );
+      } 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[]')`;
+    }
+
+    @CoveredBy('Expression')
+    @Node
+    *Number() {
+      yield i`eat(<Integer> 'wholePart' { noDoubleZero: true matchSign: '-' })`;
+
+      let fs = yield i`eatMatch(<~*Punctuator '.'> 'fractionalSeparatorToken')`;
+
+      if (fs) {
+        yield i`eat(<Integer> 'fractionalPart')`;
+      } else {
+        yield i`eat(null 'fractionalPart')`;
+      }
+
+      let es = yield i`eatMatch(<~*Punctuator /[eE]/> 'exponentSeparatorToken')`;
+
+      if (es) {
+        yield i`eat(<Integer> 'exponentPart' { matchSign: /[+-]/ })`;
+      } else {
+        yield i`eat(null 'exponentPart')`;
+      }
+    }
+
+    @Node
+    *Integer({ value: props, ctx }) {
+      const { matchSign = null, noDoubleZero = false } = (props && ctx.unbox(props)) || {};
+
+      if (matchSign) {
+        yield i`eatMatch(<~*Punctuator ${matchSign}> 'signToken')`;
+      } else {
+        yield i`eat(null 'signToken')`;
+      }
+
+      yield i`eat(<*UnsignedInteger noDoubleZero=${buildBoolean(noDoubleZero)}> 'value')`;
+    }
+
+    @Node
+    *UnsignedInteger({ value: props, ctx }) {
+      const { noDoubleZero = false } = (props && ctx.unbox(props)) || {};
+
+      let [firstDigit] = ctx.ownTerminalsFor(yield i`eat(/\d/)`);
+
+      if (!noDoubleZero || firstDigit.value !== '0') {
+        yield i`eatMatch(/\d+/)`;
+      }
+    }
+
+    @CoveredBy('Expression')
+    @Node
+    *Boolean() {
+      yield i`eat(<~*Keyword /true|false/> 'sigilToken')`;
+    }
+
+    @CoveredBy('Expression')
+    @Node
+    *Null() {
+      yield i`eat(<~*Keyword 'null'> 'sigilToken')`;
+    }
+
+    @Node
+    @InjectFrom(productions)
+    *Keyword() {}
+
+    @Node
+    @InjectFrom(productions)
+    *Punctuator() {}
+
+    @AllowEmpty
+    @InjectFrom(productions)
+    *List() {}
+
+    @InjectFrom(productions)
+    *Any() {}
+  },
+);

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@bablr/language-en-json",
+  "version": "0.4.0",
+  "description": "A BABLR language for JSON",
+  "engines": {
+    "node": ">=12.0.0"
+  },
+  "type": "module",
+  "exports": {
+    ".": "./lib/grammar.js",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib/**/*.js"
+  ],
+  "scripts": {
+    "build": "macrome build",
+    "watch": "macrome watch",
+    "clean": "macrome clean",
+    "test": "mocha"
+  },
+  "sideEffects": false,
+  "dependencies": {
+    "@bablr/agast-vm-helpers": "0.2.0",
+    "@bablr/boot": "0.3.0",
+    "@bablr/helpers": "0.17.0",
+    "@bablr/language-en-blank-space": "0.2.0",
+    "@babel/runtime": "^7.22.15"
+  },
+  "devDependencies": {
+    "@bablr/agast-helpers": "0.2.0",
+    "@bablr/eslint-config-base": "github:bablr-lang/eslint-config-base#49f5952efed27f94ee9b94340eb1563c440bf64e",
+    "@bablr/macrome": "0.1.3",
+    "@bablr/macrome-generator-bablr": "0.3.1",
+    "@qnighy/dedent": "0.1.1",
+    "bablr": "0.3.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",
+    "prettier": "^2.0.5"
+  },
+  "keywords": [
+    "bablr-language",
+    "grammar",
+    "english",
+    "json"
+  ],
+  "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>",
+  "license": "MIT"
+}