@bablr/cli 0.1.1 → 0.1.3

package/README.md

@@ -0,0 +1,97 @@
+# @bablr/cli
+
+This is the CLI runner for BABLR. If you have a BABLR grammar for a computer language, this tool allows you to use it to do streaming parsing. Parse results are presented in CSTML.
+
+## Usage
+
+This package has no built-in language support, but rather expects you to supply a valid import specifier referring to a BABLR language. This likely means that you will likely need to start by installing both the parser and the language you wish to use.
+
+```
+Usage: bablr [options]
+
+Options:
+  -l, --language [URL]     The URL of the BABLR language to parse with
+  -p, --production [type]  The top-level type for the parse
+  -f, --format             Pretty-format CSTML output
+  -F, --no-format          Produce machine-readable CSTML output
+  -v, --verbose            Prints debugging information to stderr
+  -c, --color              Force colored output (default: true)
+  -C, --no-color           Do not color output
+  -e, --embedded           Requires quoted input but enables gap parsing
+  -h, --help               display help for command
+```
+
+## Example
+
+```bash
+bablr -l @bablr/language-json -p Expression -f << 'EOF'
+[
+  1,
+  true,
+  "3"
+]
+EOF
+```
+
+Running the above command produces the following output. Note that this is a stream parse so lines of output will appear one by one as fast as the input can be read and parsed.
+
+```cstml
+<!0:cstml bablr-language='https://github.com/bablr-lang/language-json'>
+<>
+  <Array>
+    openToken:
+    <*Punctuator '[' balanced=']' />
+    <#*Space:Space>
+      '\n  '
+    </>
+    elements[]:
+    <Number span='Number'>
+      wholePart:
+      <Integer>
+        digits[]:
+        <*Digit>
+          '1'
+        </>
+      </>
+      fractionalPart:
+        null
+      exponentPart:
+        null
+    </>
+    separators[]:
+    <*Punctuator ',' />
+    <#*Space:Space>
+      '\n  '
+    </>
+    elements[]:
+    <Boolean>
+      sigilToken:
+      <*Keyword 'true' />
+    </>
+    separators[]:
+    <*Punctuator ',' />
+    <#*Space:Space>
+      '\n  '
+    </>
+    elements[]:
+    <String>
+      openToken:
+      <*Punctuator '"' balanced='"' balancedSpan='String' />
+      content:
+      <*StringContent>
+        '3'
+      </>
+      closeToken:
+      <*Punctuator '"' balancer />
+      <#*Space:Space>
+        '\n'
+      </>
+    </>
+    closeToken:
+    <*Punctuator ']' balancer />
+    <#*Space:Space>
+      '\n'
+    </>
+  </>
+</>
+```

package/bin/index.js

@@ -4,22 +4,28 @@
 
 import { program } from 'commander';
 import { streamParse } from 'bablr';
-import { sourceFromReadStream } from '@bablr/helpers/source';
+import { embeddedSourceFromReadStream, sourceFromReadStream } from '@bablr/helpers/source';
 import { buildDebugEnhancers } from '@bablr/helpers/enhancers';
-import { printTerminal } from '@bablr/agast-helpers/stream';
+import colorSupport from 'color-support';
+import { pipeline } from 'node:stream/promises';
+import { generateCSTML, generateColorfulCSTML } from '../lib/syntax.js';
 
 program
   .option('-l, --language [URL]', 'The URL of the BABLR language to parse with')
   .option('-p, --production [type]', 'The top-level type for the parse')
-  .option('-f, --formatted', 'Whether to pretty-format the CSTML output')
-  .option('-v, --verbose', 'Whether to print debug logging to stderr during parsing')
+  .option('-f, --format', 'Pretty-format CSTML output')
+  .option('-F, --no-format', 'Produce machine-readable CSTML output')
+  .option('-v, --verbose', 'Prints debugging information to stderr')
+  .option('-c, --color', 'Force colored output', true)
+  .option('-C, --no-color', 'Do not color output')
+  .option('-e, --embedded', 'Requires quoted input but enables gap parsing')
   .parse(process.argv);
 
 const options = program.opts();
 
-const language = await import(options.language);
+const enableAnsi = colorSupport.hasBasic && options.color;
 
-let indentAmt = 0;
+const language = await import(options.language);
 
 const logStderr = (...args) => {
   process.stderr.write(args.join(' ') + '\n');
@@ -27,30 +33,19 @@ const logStderr = (...args) => {
 
 const enhancers = options.verbose ? { ...buildDebugEnhancers(logStderr), agastStrategy: null } : {};
 
-for await (const token of streamParse(
-  language,
-  options.production,
-  sourceFromReadStream(process.stdin.setEncoding('utf-8')),
-  {},
-  enhancers,
-)) {
-  if (token.type === 'OpenNodeTag') {
-    indentAmt++;
-  }
-
-  const offset =
-    token.type === 'Null' ? 2 : ['Literal', 'Gap', 'Reference'].includes(token.type) ? 1 : 0;
-
-  const out = options.formatted
-    ? `${'  '.repeat(indentAmt + offset)}${printTerminal(token)}`
-    : printTerminal(token);
-
-  if (
-    token.type === 'CloseNodeTag' ||
-    (token.type === 'OpenNodeTag' && token.value.flags.intrinsic)
-  ) {
-    indentAmt--;
-  }
-
-  process.stdout.write(out + '\n');
-}
+const rawStream = process.stdin.setEncoding('utf-8');
+
+const generateCSTML_ = enableAnsi ? generateColorfulCSTML : generateCSTML;
+
+pipeline(
+  generateCSTML_(
+    streamParse(
+      language,
+      options.production,
+      options.embedded ? embeddedSourceFromReadStream(rawStream) : sourceFromReadStream(rawStream),
+      {},
+      enhancers,
+    ),
+  ),
+  process.stdout,
+);

package/lib/syntax.js

@@ -0,0 +1,83 @@
+/* global process Promise */
+
+import { i } from '@bablr/boot';
+import * as cstml from '@bablr/language-cstml';
+import { streamParse } from 'bablr/enhanceable';
+import { Coroutine } from '@bablr/coroutine';
+import {
+  StreamIterable,
+  getStreamIterator,
+  generatePrettyCSTML as generatePrettyCSTMLStream,
+} from '@bablr/agast-helpers/stream';
+import { evaluate } from '@bablr/ansi-vm';
+import { buildString } from '@bablr/agast-vm-helpers';
+
+function* __higlightStrategy(tokens) {
+  const co = new Coroutine(
+    getStreamIterator(streamParse(cstml, 'Document', generatePrettyCSTMLStream(tokens))),
+  );
+
+  let currentType;
+  let currentRef;
+
+  co.advance();
+
+  for (;;) {
+    if (co.current instanceof Promise) {
+      co.current = yield co.current;
+    }
+
+    if (co.done) break;
+
+    const token = co.value;
+
+    if (token.type === 'OpenNodeTag') {
+      if (
+        currentType === 'Literal' ||
+        (token.value.type === 'String' && currentRef.name === 'intrinsicValue')
+      ) {
+        yield i`push(bold green)`;
+      } else if (token.value.type === 'String') {
+        yield i`push(bold white)`;
+      } else if (token.value.type === 'Identifier') {
+        if (currentType === 'Punctuator' && currentRef.name === 'type') {
+          yield i`push(whiteBright bold)`;
+        } else if (currentType === 'Reference') {
+          yield i`push(gray)`;
+        } else {
+          yield i`push()`;
+        }
+      } else {
+        yield i`push()`;
+      }
+      currentType = token.value.type;
+    }
+
+    if (token.type === 'Reference') {
+      currentRef = token.value;
+    }
+
+    if (token.type === 'CloseNodeTag') {
+      yield i`pop()`;
+    }
+
+    if (token.type === 'Literal') {
+      yield i`write(${buildString(token.value)})`;
+    } else if (token.type === 'OpenNodeTag' && token.value.flags.intrinsic) {
+      yield i`write(${buildString(token.value.intrinsicValue)})`;
+      yield i`pop()`;
+    }
+
+    co.advance();
+  }
+
+  yield i`write('\n')`;
+}
+
+export const higlightStrategy = (tokens) => {
+  return () => new StreamIterable(__higlightStrategy(tokens));
+};
+
+export const generateColorfulCSTML = (tokens) => evaluate(higlightStrategy(tokens));
+
+export const generateCSTML = (tokens) => generatePrettyCSTMLStream(tokens);

package/package.json

@@ -1,23 +1,31 @@
 {
   "name": "@bablr/cli",
   "description": "CLI for running BABLR parsers",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "author": "Conrad Buck<conartist6@gmail.com>",
   "type": "module",
   "files": [
-    "bin"
+    "bin",
+    "lib"
   ],
   "bin": {
     "bablr": "./bin/index.js"
   },
   "exports": {
-    ".": "./bin/index.js"
+    ".": "./bin/index.js",
+    "./syntax": "./lib/syntax.js"
   },
   "sideEffects": false,
   "dependencies": {
-    "@bablr/agast-helpers": "0.1.0",
-    "@bablr/helpers": "0.15.0",
-    "bablr": "0.1.1",
+    "@bablr/agast-helpers": "0.1.1",
+    "@bablr/agast-vm-helpers": "0.1.1",
+    "@bablr/ansi-vm": "0.1.0",
+    "@bablr/boot": "0.2.1",
+    "@bablr/coroutine": "0.1.0",
+    "@bablr/helpers": "0.15.1",
+    "@bablr/language-cstml": "0.2.1",
+    "bablr": "0.1.2",
+    "color-support": "1.1.3",
     "commander": "12.0.0"
   },
   "devDependencies": {