@bablr/language-en-spamex 0.5.0 → 0.7.0

package/lib/grammar.macro.js

@@ -1,130 +1,146 @@
-import { i } from '@bablr/boot/shorthand.macro';
-import { Node, CoveredBy, InjectFrom } from '@bablr/helpers/decorators';
+import { re, spam as m } from '@bablr/boot';
+import { Node, CoveredBy, InjectFrom, UnboundAttributes } from '@bablr/helpers/decorators';
 import * as productions from '@bablr/helpers/productions';
+import { o, eat, eatMatch, match, bindAttribute, fail } from '@bablr/helpers/grammar';
 import * as Regex from '@bablr/language-en-regex-vm-pattern';
 import * as CSTML from '@bablr/language-en-cstml';
+import * as JSON from '@bablr/language-en-cstml-json';
 import * as Space from '@bablr/language-en-blank-space';
 import { notNull } from '@bablr/agast-helpers/tree';
 
 export const canonicalURL = 'https://bablr.org/languages/core/en/spamex';
 
-export const dependencies = { Regex, CSTML, Space };
+export const dependencies = { Regex, CSTML, JSON, Space };
 
 const { eatMatchTrivia } = CSTML;
 
 export const grammar = class SpamexGrammar {
+  @CoveredBy('Expression')
+  *Matcher() {
+    yield eat(m`<Any />`, [m`<PropertyMatcher /[a-zA-Z.@#<]/ />`, m`<StringMatcher /[/'"]/ />`]);
+  }
+
+  *NodeMatcher() {
+    yield eat(m`<Any />`, [
+      m`<GapNodeMatcher '<//>' />`,
+      m`<BasicNodeMatcher '<' />`,
+      m`<ArrayNodeMatcher '[' />`,
+      m`<NullNodeMatcher 'null' />`,
+    ]);
+  }
+
   @Node
-  *Pattern() {
-    yield i`eat(<Matcher /> 'matcher')`;
+  @CoveredBy('NodeMatcher')
+  *GapNodeMatcher() {
+    yield eat(m`sigilToken: <*Punctuator '<//>' />`);
   }
 
-  @CoveredBy('Expression')
-  *Matcher() {
-    yield i`eat(<Any /> null [
-        <NodeMatcher '<' />
-        <CSTML:String /['"]/ />
-        <Regex:Pattern '/' />
-      ])`;
+  @Node
+  @CoveredBy('NodeMatcher')
+  *ArrayNodeMatcher() {
+    yield eat(m`sigilToken: <*Punctuator '[]' />`);
+  }
+
+  @Node
+  @CoveredBy('NodeMatcher')
+  *NullNodeMatcher() {
+    yield eat(m`sigilToken: <*Punctuator 'null' />`);
   }
 
   @Node
   @CoveredBy('Matcher')
-  *NodeMatcher() {
-    let open = yield i`eat(<OpenNodeMatcher /> 'open')`;
+  *PropertyMatcher() {
+    yield eatMatch(m`refMatcher: <ReferenceMatcher />`);
+    yield* eatMatchTrivia();
+    yield eat(m`nodeMatcher: <NodeMatcher />`);
+  }
+
+  @Node
+  *ReferenceMatcher() {
+    let name;
+    if (yield match(re`/[.#@]/`)) {
+      name = yield eatMatch(m`name$: <*Punctuator /[.#@]/ />`);
+    } else {
+      name = yield eatMatch(m`name$: <*CSTML:Identifier />`);
+    }
+
+    if (name && (yield eatMatch(m`openIndexToken: <*Punctuator '[' { balanced: ']' } />`))) {
+      yield* eatMatchTrivia();
+      yield eatMatch(m`closeIndexToken: <*Punctuator ']' { balancer: true } />`);
+    } else {
+      yield eatMatch(m`closeIndexToken: null`);
+    }
+
+    yield* eatMatchTrivia();
+    yield eatMatch(m`flags: <CSTML:ReferenceFlags />`);
+    yield* eatMatchTrivia();
+    yield eat(m`sigilToken: <*Punctuator ':' />`);
+  }
+
+  @Node
+  @CoveredBy('NodeMatcher')
+  *BasicNodeMatcher() {
+    let open = yield eat(m`open: <OpenNodeMatcher />`);
 
-    // Problem: not handling gaps
-    //   gaps have a non-nullish representation
-    //
-    const { selfClosingTagToken } = open.properties;
-    const selfClosing = notNull(selfClosingTagToken);
+    const selfClosing = notNull(open.get('selfClosingTagToken'));
 
     if (selfClosing) {
-      yield i`eat([] 'children[]')`;
-      yield i`eat(null 'close')`;
+      yield eat(m`children[]$: []`);
+      yield eat(m`close: null`);
     } else {
       // TODO
       yield* eatMatchTrivia();
 
-      yield i`eat(<CloseNodeMatcher /> 'close')`;
+      yield eat(m`close: <CloseNodeMatcher />`);
     }
   }
 
   @Node
   *OpenNodeMatcher() {
-    yield i`eat(<~*Punctuator '<' balancedSpan='Tag' balanced='>' /> 'open')`;
-    yield i`eat(<CSTML:Flags /> 'flags')`;
-    if (yield i`match(/[a-zA-Z]+:/)`) {
-      yield i`eat(<*CSTML:Identifier /> 'language')`;
-      yield i`eat(<~*Punctuator ':' /> 'namespaceOperator')`;
-      yield i`eat(<*CSTML:Identifier /> 'type')`;
-    } else if (yield i`match(/[a-zA-Z]/)`) {
-      yield i`eat(null 'language')`;
-      yield i`eat(null 'namespaceOperator')`;
-      yield i`eatMatch(<*CSTML:Identifier /> 'type')`;
-    } else if (yield i`match('?')`) {
-      yield i`eat(<~*Punctuator '?' /> 'type')`;
-    } else if (yield i`match(/[ \t]/)`) {
-      yield i`eatMatch(<~*Punctuator /[ \t]+/ /> 'type')`;
+    yield eat(m`open: <*Punctuator '<' { balancedSpan: 'Tag', balanced: '>' } />`);
+    yield eat(m`flags: <CSTML:NodeFlags />`);
+
+    if (yield eatMatch(m`<CSTML:TagType /[a-zA-Z'"\g]/ />`)) {
+      // continue
+    } else if (yield eatMatch(m`type$: <*Punctuator /[ \t]+|?/ />`)) {
+      // continue
+    } else {
+      yield fail();
     }
+
     let sp = yield* eatMatchTrivia();
 
-    if (sp && (yield i`eatMatch(<StringMatcher /> 'intrinsicValue')`)) {
+    if (
+      sp &&
+      !(yield match(re`/\/$/`)) &&
+      (yield eatMatch(m`intrinsicValue$: <StringMatcher />`))
+    ) {
       sp = yield* eatMatchTrivia();
     }
 
-    while (sp && (yield i`match(/!?[a-zA-Z]/)`)) {
-      yield i`eat(<Attribute /> 'attributes[]')`;
+    while (sp && (yield match('{'))) {
+      yield eat(m`attributes: <JSON:Object />`);
       sp = yield* eatMatchTrivia();
     }
 
-    yield i`eatMatch(<~*Punctuator '/' /> 'selfClosingTagToken')`;
-    yield i`eat(<~*Punctuator '>' balancer /> 'close')`;
+    yield eatMatch(m`selfClosingTagToken: <*Punctuator '/' />`);
+    yield eat(m`close: <*Punctuator '>' { balancer: true } />`);
   }
 
   @Node
   @CoveredBy('Matcher')
   *CloseNodeMatcher() {
-    yield i`eat(<~*Punctuator '</' balanced='>' /> 'openToken')`;
-    yield i`eatMatch(<TagType />)`;
-    yield i`eat(<~*Punctuator '>' balancer /> 'closeToken')`;
-  }
-
-  *Attributes() {
-    yield i`eatMatch(<List /> null {
-        element: <Attribute />
-        allowTrailingSeparator: false
-      })`;
-  }
-
-  *Attribute() {
-    if (yield i`match(/[a-zA-Z]+\s*=/)`) {
-      yield i`eat(<MappingAttribute />)`;
-    } else {
-      yield i`eat(<BooleanAttribute />)`;
-    }
-  }
-
-  @CoveredBy('Attribute')
-  @Node
-  *BooleanAttribute() {
-    yield i`eat(<*CSTML:Identifier /> 'key')`;
-  }
-
-  @CoveredBy('Attribute')
-  @Node
-  *MappingAttribute() {
-    yield i`eat(<*CSTML:Identifier /> 'key')`;
-    yield i`eat(<~*Punctuator '=' /> 'mapOperator')`;
-    yield i`eat(<CSTML:AttributeValue /> 'value')`;
+    yield eat(m`openToken: <*Punctuator '</' { balanced: '>' } />`);
+    yield eat(m`closeToken: <*Punctuator '>' { balancer: true } />`);
   }
 
   @CoveredBy('Matcher')
   @CoveredBy('Expression')
   *StringMatcher() {
-    if (yield i`match(/['"]/)`) {
-      yield i`eat(<CSTML:String />)`;
+    if (yield match(re`/['"]/`)) {
+      yield eat(m`<String />`);
     } else {
-      yield i`eat(<Regex:Pattern />)`;
+      yield eat(m`<Regex />`);
     }
   }
 
@@ -133,7 +149,7 @@ export const grammar = class SpamexGrammar {
   @CoveredBy('Expression')
   @Node
   *String() {
-    yield i`eat(<CSTML:String />)`;
+    yield eat(m`<JSON:String />`, null, o({ suppressNode: true }));
   }
 
   @CoveredBy('StringMatcher')
@@ -141,10 +157,7 @@ export const grammar = class SpamexGrammar {
   @CoveredBy('Expression')
   @Node
   *Regex() {
-    yield i`eat(<~*Punctuator '/' balanced='/' /> 'open')`;
-    yield i`eat(<Regex:Alternatives /> 'alternatives[]')`;
-    yield i`eat(<~*Punctuator '/' balancer /> 'close')`;
-    yield i`eat(<Regex:Flags /> 'flags')`;
+    yield eat(m`<Regex:Pattern />`, null, o({ suppressNode: true }));
   }
 
   @InjectFrom(productions)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bablr/language-en-spamex",
-  "version": "0.5.0",
+  "version": "0.7.0",
   "description": "A BABLR language for SPAM Expressions",
   "engines": {
     "node": ">=12.0.0"
@@ -22,18 +22,19 @@
   },
   "dependencies": {
     "@babel/runtime": "^7.23.2",
-    "@bablr/agast-helpers": "0.4.0",
-    "@bablr/agast-vm-helpers": "0.4.0",
-    "@bablr/helpers": "0.19.0",
-    "@bablr/language-en-blank-space": "0.4.0",
-    "@bablr/language-en-cstml": "0.5.0",
-    "@bablr/language-en-regex-vm-pattern": "0.6.0"
+    "@bablr/agast-helpers": "0.6.0",
+    "@bablr/agast-vm-helpers": "0.6.0",
+    "@bablr/helpers": "0.21.1",
+    "@bablr/language-en-blank-space": "0.6.0",
+    "@bablr/language-en-cstml": "0.8.0",
+    "@bablr/language-en-cstml-json": "0.1.0",
+    "@bablr/language-en-regex-vm-pattern": "0.8.0"
   },
   "devDependencies": {
-    "@bablr/boot": "0.5.0",
+    "@bablr/boot": "^0.7.0",
     "@bablr/eslint-config-base": "github:bablr-lang/eslint-config-base#49f5952efed27f94ee9b94340eb1563c440bf64e",
-    "@bablr/macrome": "0.1.3",
-    "@bablr/macrome-generator-bablr": "0.3.2",
+    "@bablr/macrome": "^0.1.3",
+    "@bablr/macrome-generator-bablr": "^0.3.2",
     "enhanced-resolve": "^5.12.0",
     "eslint": "^7.32.0",
     "eslint-import-resolver-enhanced-resolve": "^1.0.5",