kni 4.0.3 → 5.0.0

package/kni.js

@@ -1,316 +1,323 @@
 #!/usr/bin/env node
-'use strict';
-
-var fs = require('fs');
-var tee = require('tee');
-var Console = require('./console');
-var Readline = require('./readline');
-var Engine = require('./engine');
-var Scanner = require('./scanner');
-var OutlineLexer = require('./outline-lexer');
-var InlineLexer = require('./inline-lexer');
-var Parser = require('./parser');
-var Story = require('./story');
-var Path = require('./path');
-var grammar = require('./grammar');
-var link = require('./link');
-var verify = require('./verify');
-var exec = require('shon/exec');
-var usage = require('./kni.json');
-var xorshift = require('xorshift');
-var table = require('table').default;
-var getBorderCharacters = require('table').getBorderCharacters;
-var describe = require('./describe');
-var makeHtml = require('./html');
-
-function main() {
-    var config = exec(usage);
-
-    if (!config) {
-        return;
+
+import {pathToFileURL} from 'url';
+import tee from 'tee';
+import Console from './console.js';
+import Readline from './readline.js';
+import Engine from './engine.js';
+import Scanner from './scanner.js';
+import OutlineLexer from './outline-lexer.js';
+import InlineLexer from './inline-lexer.js';
+import Parser from './parser.js';
+import Story from './story.js';
+import * as Path from './path.js';
+import start from './grammar.js';
+import link from './link.js';
+import verify from './verify.js';
+import exec from 'shon/exec.js';
+import usage from './kni.json' with {type: 'json'};
+import xorshift from 'xorshift';
+import table from 'table';
+import describe from './describe.js';
+import makeHtml from './html.js';
+
+const {default: tableDefault, getBorderCharacters} = table;
+
+const run = (args, out, done) => {
+  const config = exec(usage, args);
+  if (!config) {
+    done(null);
+    return;
+  }
+
+  serial(config.scripts, readAndKeep, (err, kniscripts) => {
+    if (err) {
+      done(err);
+      return;
     }
 
-    serial(config.scripts, readAndKeep, onKniscripts);
+    let interactive = true;
 
-    function onKniscripts(err, kniscripts) {
-        if (err) {
-            console.error(err.message);
-            process.exit(-1);
-            return;
-        }
+    if (config.transcript === out) {
+      config.transcript = null;
+    }
+    if (config.transcript) {
+      out = tee(config.transcript, out);
+    }
 
-        var interactive = true;
+    let states;
+    if (config.fromJson) {
+      states = JSON.parse(kniscripts[0].content); // TODO test needed
+    } else {
+      const story = new Story();
 
-        var out = process.stdout;
-        if (config.transcript === process.stdout) {
-            config.transcript = null;
-        }
-        if (config.transcript) {
-            out = tee(config.transcript, out);
-        }
+      for (let i = 0; i < kniscripts.length; i++) {
+        const kniscript = kniscripts[i].content;
 
-        var states;
-        if (config.fromJson) {
-            states = JSON.parse(knicript);
-
-        } else {
-            var story = new Story();
-
-            for (var i = 0; i < kniscripts.length; i++) {
-                var kniscript = kniscripts[i].content;
-
-                if (config.debugInput) {
-                    console.log(kniscript);
-                }
-
-                var path = Path.start();
-                var base = [];
-                if (kniscripts.length > 1) {
-                    path = kniscripts[i].stream.path;
-                    path = [path.split('/').pop().split('.').shift()];
-                    base = path;
-                }
-
-                var p = new Parser(grammar.start(story, path, base));
-                var il = new InlineLexer(p);
-                var ol = new OutlineLexer(il);
-                var s = new Scanner(ol, kniscripts[i].stream.path);
-
-                // Kick off each file with a fresh paragraph.
-                p.next('token', '', '//', s);
-
-                if (config.debugParser) {
-                    p.debug = true;
-                    interactive = false;
-                }
-                if (config.debugInlineLexer) {
-                    il.debug = true;
-                    interactive = false;
-                }
-                if (config.debugOutlineLexer) {
-                    ol.debug = true;
-                    interactive = false;
-                }
-                if (config.debugScanner) {
-                    s.debug = true;
-                    interactive = false;
-                }
-
-                s.next(kniscript);
-                s.return();
-            }
-
-            link(story);
-
-            states = story.states;
-            if (story.errors.length) {
-                dump(story.errors, process.stderr);
-                if (config.transcript != null) {
-                    dump(story.errors, config.transcript);
-                }
-                process.exitCode = -1;
-                return;
-            }
+        if (config.debugInput) {
+          console.log(kniscript);
         }
 
-        if (config.describe) {
-            describeStory(states);
-            interactive = false;
-
-        } else if (config.toJson) {
-            console.log(JSON.stringify(states, null, 4));
-            interactive = false;
-
-        } else if (config.toHtml) {
-            makeHtml(states, config.toHtml, {
-                title: config.htmlTitle,
-                color: config.htmlColor,
-                backgroundColor: config.htmlBackgroundColor,
-            });
-            interactive = false;
+        let path = Path.start();
+        let base = [];
+        if (kniscripts.length > 1) {
+          path = kniscripts[i].stream.path;
+          path = [path.split('/').pop().split('.').shift()];
+          base = path;
         }
 
-        var randomer = xorshift;
+        const p = new Parser(start(story, path, base));
+        const il = new InlineLexer(p);
+        const ol = new OutlineLexer(il);
+        const s = new Scanner(ol, kniscripts[i].stream.path);
 
-        if (config.transcript || config.seed) {
-            // I rolled 4d64k this morning.
-            randomer = new xorshift.constructor([
-                37615 ^ config.seed,
-                54552 ^ config.seed,
-                59156 ^ config.seed,
-                24695 ^ config.seed
-            ]);
-        }
+        // Kick off each file with a fresh paragraph.
+        p.next('token', '', '//', s);
 
-        if (config.expected) {
-            read(config.expected, function onTypescript(err, typescript) {
-                if (err) {
-                    console.error(err.message);
-                    process.exitCode = -1;
-                    return;
-                }
-                test(kniscript, typescript);
-            });
-            return;
+        if (config.debugParser) {
+          p.debug = true;
+          interactive = false;
         }
-
-        if (interactive) {
-            var readline = new Readline(config.transcript);
-            var render = new Console(out);
-            var engine = new Engine({
-                story: states,
-                start: config.start,
-                render: render,
-                dialog: readline,
-                randomer: randomer
-            });
-
-            if (config.debugRuntime) {
-                engine.debug = true;
-            }
-
-            if (config.waypoint) {
-                read(config.waypoint, function onWaypoint(err, waypoint) {
-                    if (err) {
-                        console.error(err.message);
-                        process.exitCode = -1;
-                        return;
-                    }
-                    waypoint = JSON.parse(waypoint);
-                    engine.continue(waypoint);
-                });
-            } else {
-                engine.continue();
-            }
+        if (config.debugInlineLexer) {
+          il.debug = true;
+          interactive = false;
+        }
+        if (config.debugOutlineLexer) {
+          ol.debug = true;
+          interactive = false;
+        }
+        if (config.debugScanner) {
+          s.debug = true;
+          interactive = false;
         }
-    }
 
-}
+        s.next(kniscript);
+        s.return();
+      }
 
-function test(kniscript, typescript) {
-    var result = verify(kniscript, typescript);
-    if (!result.pass) {
-        console.log(result.actual);
-        process.exit(1);
-    }
-}
+      link(story);
 
-function describeStory(states) {
-    var keys = Object.keys(states);
-    var cells = [['L:C', 'AT', 'DO', 'S', 'USING', 'S', 'GO']];
-    for (var i = 0; i < keys.length; i++) {
-        var key = keys[i];
-        var node = states[key];
-        var next;
-        if (i === keys.length - 1) {
-            next = null;
-        } else {
-            next = keys[i + 1];
+      states = story.states;
+      if (story.errors.length) {
+        if (config.transcript != null) {
+          dump(story.errors, config.transcript);
         }
-        cells.push([
-            stripe(i, node.position),
-            stripe(i, key),
-            stripe(i, node.mode || node.type),
-            stripe(i, node.lift ? '-' : ' '),
-            stripe(i, describe(node)),
-            stripe(i, node.drop ? '-' : ' '),
-            stripe(i, describeNext(node.next, next))
-        ]);
+        const storyError = new Error('internal story error');
+        storyError.story = story;
+        done(storyError);
+        return;
+      }
     }
-    console.log(table(cells, {
-        border: getBorderCharacters('void'),
-        columnDefault: {
-            paddingLeft: 0,
-            paddingRight: 2
-        },
-        columns: {
-            4: {
-                width: 40,
-                wrapWord: true
-            }
-        },
-        drawHorizontalLine: no
-    }));
-}
 
-function stripe(index, text) {
-    if (index % 2 === 1) {
-        return text;
-    } else {
-        return '\x1b[90m' + text + '\x1b[0m';
+    if (config.describe) {
+      describeStory(states, out, done);
+      return;
     }
-}
 
-function describeNext(jump, next) {
-    if (jump === undefined) {
-        return '';
-    } else if (jump === next) {
-        return '';
-    } else if (jump == 'RET') {
-        return '<-';
-    } else if (jump == 'ESC') {
-        return '<<';
-    } else {
-        return '-> ' + jump;
+    if (config.toJson) {
+      console.log(JSON.stringify(states, null, 4), done);
+      interactive = false;
+    } else if (config.toHtml) {
+      makeHtml(states, config.toHtml, {
+        title: config.htmlTitle,
+        color: config.htmlColor,
+        backgroundColor: config.htmlBackgroundColor,
+      });
+      interactive = false;
     }
-}
-
-function no() {
-    return false;
-}
 
-function readAndKeep(stream, callback) {
-    read(stream, function onRead(err, content) {
-        if (err != null) {
-            return callback(err);
-        }
-        callback(null, {stream: stream, content: content});
-    });
-}
+    let randomer = xorshift;
 
-function read(stream, callback) {
-    stream.setEncoding('utf8');
-    var string = '';
-    stream.on('data', onData);
-    stream.on('end', onEnd);
-    stream.on('error', onEnd);
-    function onData(chunk) {
-        string += chunk;
+    if (config.transcript || config.seed) {
+      // I rolled 4d64k this morning.
+      randomer = new xorshift.constructor([
+        37615 ^ config.seed,
+        54552 ^ config.seed,
+        59156 ^ config.seed,
+        24695 ^ config.seed,
+      ]);
     }
-    function onEnd(err) {
+
+    if (config.expected) {
+      read(config.expected, (err, typescript) => {
         if (err) {
-            callback(err);
-            return;
+          done(err);
+          return;
         }
-        callback(null, string);
-    }
-}
-
-function serial(array, eachback, callback) {
-    var values = [];
-    next(0);
 
-    function next(i) {
-        if (i >= array.length) {
-            return callback(null, values);
+        const result = verify(kniscripts[0].content, typescript);
+        if (!result.pass) {
+          console.log(result.actual);
+          done(new Error('verification failed'));
+          return;
         }
+      });
+      done(null);
+      return;
+    }
 
-        eachback(array[i], onEach);
-
-        function onEach(err, value) {
-            if (err != null) {
-                return callback(err, null);
-            }
-            values.push(value);
-            next(i+1);
-        }
+    if (interactive) {
+      const readline = new Readline(config.transcript);
+      const render = new Console(out);
+      const engine = new Engine({
+        story: states,
+        start: config.start,
+        render: render,
+        dialog: readline,
+        randomer: randomer,
+      });
+
+      if (config.debugRuntime) {
+        engine.debug = true;
+      }
+
+      if (config.waypoint) {
+        read(config.waypoint, (err, waypoint) => {
+          if (err) {
+            done(err);
+            return;
+          }
+          waypoint = JSON.parse(waypoint);
+          engine.continue(waypoint);
+        });
+      } else {
+        engine.continue();
+      }
+    }
+  });
+
+  done(null);
+};
+
+const describeStory = (states, out, done) => {
+  const keys = Object.keys(states);
+  const cells = [['L:C', 'AT', 'DO', 'S', 'USING', 'S', 'GO']];
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i];
+    const node = states[key];
+    let next;
+    if (i === keys.length - 1) {
+      next = null;
+    } else {
+      next = keys[i + 1];
+    }
+    cells.push([
+      stripe(i, node.position),
+      stripe(i, key),
+      stripe(i, node.mode || node.type),
+      stripe(i, node.lift ? '-' : ' '),
+      stripe(i, describe(node)),
+      stripe(i, node.drop ? '-' : ' '),
+      stripe(i, describeNext(node.next, next)),
+    ]);
+  }
+  out.write(
+    tableDefault(cells, {
+      border: getBorderCharacters('void'),
+      columnDefault: {
+        paddingLeft: 0,
+        paddingRight: 2,
+      },
+      columns: {
+        4: {
+          width: 40,
+          wrapWord: true,
+        },
+      },
+      drawHorizontalLine: no,
+    }),
+    done
+  );
+};
+
+const stripe = (index, text) => {
+  if (index % 2 === 1) {
+    return text;
+  } else {
+    return `\x1b[90m${text}\x1b[0m`;
+  }
+};
+
+const describeNext = (jump, next) => {
+  if (jump === undefined) {
+    return '';
+  } else if (jump === next) {
+    return '';
+  } else if (jump == 'RET') {
+    return '<-';
+  } else if (jump == 'ESC') {
+    return '<<';
+  } else {
+    return `-> ${jump}`;
+  }
+};
+
+const no = () => {
+  return false;
+};
+
+const readAndKeep = (stream, callback) => {
+  read(stream, (err, content) => {
+    if (err != null) {
+      return callback(err);
+    }
+    callback(null, {stream: stream, content: content});
+  });
+};
+
+const read = (stream, callback) => {
+  stream.setEncoding('utf8');
+  let string = '';
+  const onData = chunk => {
+    string += chunk;
+  };
+  const onEnd = err => {
+    if (err) {
+      callback(err);
+      return;
+    }
+    callback(null, string);
+  };
+  stream.on('data', onData);
+  stream.on('end', onEnd);
+  stream.on('error', onEnd);
+};
+
+const serial = (array, eachback, callback) => {
+  const values = [];
+  const next = i => {
+    if (i >= array.length) {
+      return callback(null, values);
     }
-}
 
-function dump(errors, writer) {
-    for (var i = 0; i < errors.length; i++) {
-        writer.write(errors[i] + '\n');
+    eachback(array[i], (err, value) => {
+      if (err != null) {
+        return callback(err, null);
+      }
+      values.push(value);
+      next(i + 1);
+    });
+  };
+  next(0);
+};
+
+const dump = (errors, writer) => {
+  for (let i = 0; i < errors.length; i++) {
+    writer.write(`${errors[i]}\n`);
+  }
+};
+
+if (import.meta.url === pathToFileURL(process.argv[1]).href) {
+  run(null, process.stdout, err => {
+    if (err) {
+      console.error(typeof err === 'object' && err.message ? err.message : err);
+      if (typeof err.story === 'object' && err.story) {
+        const story = err.story;
+        dump(story.errors, process.stderr);
+      }
+      process.exit(-1);
     }
+  });
 }
 
-main();
+export default run;