kni 4.0.2 → 5.0.0

package/readline.js

@@ -1,143 +1,153 @@
-'use strict';
+import readline from 'readline';
+import fs from 'fs';
 
-var readline = require('readline');
-var fs = require('fs');
-
-module.exports = Readline;
-
-function Readline(transcript, filename) {
-    var self = this;
+export default class Readline {
+  constructor(transcript, filename) {
+    const self = this;
     this.readline = readline.createInterface({
-        input: process.stdin,
-        output: process.stdout
+      input: process.stdin,
+      output: process.stdout,
     });
     this.engine = null;
-    this.boundAnswer = answer;
+    this.boundAnswer = text => {
+      self.answer(text);
+    };
     this.transcript = transcript;
     this.history = [];
     this.state = new Play(this, filename);
     Object.seal(this);
-    function answer(text) {
-        self.answer(text);
-    }
-}
+  }
+
+  meterFault() {
+    this.readline.question(`Enter any command to continue... `, (answer) => {
+      if (answer === 'quit') {
+        this.close();
+      } else {
+        this.engine.clearMeterFault();
+      }
+    });
+  }
 
-Readline.prototype.ask = function ask(cue) {
-    this.readline.question((cue || '') + '> ', this.boundAnswer);
-};
+  ask(cue) {
+    this.readline.question(`${cue || ''}> `, this.boundAnswer);
+  }
 
-Readline.prototype.answer = function answer(text) {
+  answer(text) {
     if (this.transcript) {
-        this.transcript.write('> ' + text + '\n');
+      this.transcript.write(`> ${text}\n`);
     }
     this.state = this.state.answer(text);
-};
+  }
 
-Readline.prototype.close = function close() {
+  close() {
     if (this.transcript) {
-        this.transcript.write('\n');
+      this.transcript.write('\n');
     }
     this.readline.close();
-};
+  }
+}
 
-function Play(readline, filename) {
+class Play {
+  constructor(readline, filename) {
     this.readline = readline;
     this.filename = filename || 'kni.waypoint';
-}
+  }
 
-Play.prototype.answer = function answer(text) {
-    var engine = this.readline.engine;
+  answer(text) {
+    const engine = this.readline.engine;
 
     if (text === 'quit') {
-        console.log('');
-        engine.dialog.close();
-    // istanbul ignore next
+      console.log('');
+      engine.dialog.close();
     } else if (text === 'bt' || text === 'trace') {
-        engine.log();
-        engine.ask();
-    // istanbul ignore next
+      engine.log();
+      engine.ask();
     } else if (text === 'capture' || text === 'cap') {
-        console.log(JSON.stringify(engine.waypoint));
-        console.log('');
-        engine.ask();
-    // istanbul ignore next
+      console.log(JSON.stringify(engine.waypoint));
+      console.log('');
+      engine.ask();
     } else if (text === 'save') {
-        console.log('');
-        engine.dialog.ask('file name [' + this.filename + ']> ');
-        return new Save(this, engine.waypoint, this.filename);
+      console.log('');
+      engine.dialog.ask(`file name [${this.filename}]> `);
+      return new Save(this, engine.waypoint, this.filename);
     } else if (text === 'load') {
-        console.log('');
-        engine.dialog.ask('file name [' + this.filename + ']> ');
-        return new Load(this, this.filename);
+      console.log('');
+      engine.dialog.ask(`file name [${this.filename}]> `);
+      return new Load(this, this.filename);
     } else if (text === 'back') {
-        console.log('');
-        if (this.readline.transcript) {
-            this.readline.transcript.write('\n');
-        }
-        if (this.readline.history.length <= 1) {
-            console.log('Meanwhile, at the beginning of recorded history...');
-        }
-        engine.waypoint = this.readline.history.pop();
-        engine.resume(engine.waypoint);
+      console.log('');
+      if (this.readline.transcript) {
+        this.readline.transcript.write('\n');
+      }
+      if (this.readline.history.length <= 1) {
+        console.log('Meanwhile, at the beginning of recorded history...');
+      }
+      engine.waypoint = this.readline.history.pop();
+      engine.resume(engine.waypoint);
     } else if (text === 'replay') {
-        console.log('');
-        if (this.readline.transcript) {
-            this.readline.transcript.write('\n');
-        }
-        engine.resume(engine.waypoint);
+      console.log('');
+      if (this.readline.transcript) {
+        this.readline.transcript.write('\n');
+      }
+      engine.resume(engine.waypoint);
     } else {
-        this.readline.history.push(engine.waypoint);
-        engine.answer(text);
+      this.readline.history.push(engine.waypoint);
+      engine.answer(text);
     }
     return this;
-};
+  }
 
-Play.prototype.saved = function saved(filename) {
-    var engine = this.readline.engine;
+  saved(filename) {
+    const engine = this.readline.engine;
 
     this.filename = filename;
     engine.ask();
     return this;
-};
+  }
 
-Play.prototype.loaded = function loaded(waypoint) {
-    var engine = this.readline.engine;
+  loaded(waypoint) {
+    const engine = this.readline.engine;
 
     engine.resume(waypoint);
     return this;
-};
+  }
+}
 
-function Save(parent, waypoint, filename) {
+class Save {
+  constructor(parent, waypoint, filename) {
     this.parent = parent;
     this.waypoint = waypoint;
     this.filename = filename;
-}
+  }
 
-Save.prototype.answer = function answer(filename) {
-    var waypoint = JSON.stringify(this.waypoint);
+  answer(filename) {
+    const waypoint = JSON.stringify(this.waypoint);
     filename = filename || this.filename;
     fs.writeFileSync(filename, waypoint, 'utf8');
 
     console.log('');
-    console.log('Waypoint written to ' + filename);
+    console.log(`Waypoint written to ${filename}`);
     console.log(waypoint);
     console.log('');
     return this.parent.saved(filename);
-};
+  }
+}
 
-function Load(parent, filename) {
+class Load {
+  constructor(parent, filename) {
     this.parent = parent;
     this.filename = filename;
-}
+  }
 
-Load.prototype.answer = function answer(filename) {
+  answer(filename) {
     filename = filename || this.filename;
 
-    var waypoint = fs.readFileSync(filename, 'utf8');
+    const waypoint = fs.readFileSync(filename, 'utf8');
     console.log('');
-    console.log('Loaded from ' + filename);
+    console.log(`Loaded from ${filename}`);
     console.log(waypoint);
     console.log('');
 
     return this.parent.loaded(JSON.parse(waypoint));
-};
+  }
+}

package/scanner.js

@@ -1,4 +1,4 @@
-'use strict';
+// @ts-check
 
 // Transforms a stream of text into a sequence of 'lines', tracking each line's
 // level of indentation.
@@ -7,86 +7,111 @@
 //
 // The scanner feeds into an outline lexer.
 
-var tabWidth = 4;
-var leaders = '-+*!>';
-var debug = typeof process === 'object' && process.env.DEBUG_SCANNER;
+const tabWidth = 4;
 
-module.exports = Scanner;
+/**
+ * @param {number} columnNo -- screen column number (logical X coord)
+ * @returns {number} -- column number where the next tab stop starts
+ */
+const nextTabStop = columnNo => {
+  // TODO simplify with modulo arithmetic
+  return Math.floor((columnNo + tabWidth) / tabWidth) * tabWidth;
+};
+
+const leaders = '-+*!>';
+
+export default class Scanner {
+  debug = typeof process === 'object' && process.env.DEBUG_SCANNER;
+
+  indent = 0;
+  lineStart = 0;
+  indentStart = 0;
+  itemStart = 0;
+  lineNo = 0;
+  columnNo = 0;
+  columnStart = 0;
+  leading = true;
+  leader = '';
+
+  /** An Iterator-like object that has text pushed into it by a Scanner.
+   *
+   * Its biggest difference from an Iterator<string> is that the Scanner
+   * object itself is passed along as an additional next agument
+   *
+   * @typedef {object} ScanIt
+   * @prop {(text: string, sc: Scanner) => void} next
+   * @prop {(sc: Scanner) => void} return
+   */
 
-function Scanner(generator, fileName) {
+  /**
+   * @param {ScanIt} generator
+   * @param {string} fileName
+   */
+  constructor(generator, fileName) {
     this.generator = generator;
     this.fileName = fileName || '-';
-    this.indent = 0;
-    this.lineStart = 0;
-    this.indentStart = 0;
-    this.itemStart = 0;
-    this.lineNo = 0;
-    this.columnNo = 0;
-    this.columnStart = 0;
-    this.leading = true;
-    this.leader = '';
-    this.debug = debug;
-    Object.seal(this);
-}
+  }
 
-Scanner.prototype.next = function next(text) {
-    for (var i = 0; i < text.length; i++) {
-        var c = text[i];
-        var d = text[i + 1];
-        // istanbul ignore if
-        if (this.debug) {
-            console.error('SCN', this.position() + ':' + i, JSON.stringify(c + (d || '')));
-        }
-        if (
-            ((c === '\t' || c === ' ') && d === '#') ||
-            (this.columnNo === 0 && c === '#')
-        ) {
-            this.newLine(text, i);
-            for (i++; i < text.length; i++) {
-                c = text[i];
-                if (c === '\n') {
-                    break;
-                }
-            }
-        } else if (c === '\t') {
-            this.columnNo = nextTabStop(this.columnNo);
-        } else if (c === '\n') {
-            this.newLine(text, i);
-        } else if (c === ' ') {
-            this.columnNo++;
-        } else if (
-            this.leading && leaders.indexOf(c) >= 0 &&
-            (d === ' ' || d === '\t')
-        ) {
-            this.leader += c;
-            this.columnNo++;
-        } else if (this.leading && leaders.indexOf(c) >= 0 && d === '\n') {
-            this.leader += c;
-            this.indentStart = i;
-            this.columnStart = this.columnNo;
-            this.lineStart = this.lineNo;
-            this.indent = this.columnNo + 2;
-        } else if (this.leading) {
-            this.indent = this.columnNo;
-            this.indentStart = i;
-            this.columnStart = this.columnNo;
-            this.lineStart = this.lineNo;
-            this.columnNo++;
-            this.leading = false;
+  /**
+   * @param {string} text
+   * @returns {void}
+   */
+  next(text) {
+    let i = 0;
+    for (; i < text.length; i++) {
+      let c = text[i];
+      const d = text[i + 1];
+      if (this.debug) {
+        console.error('SCN', `${this.position()}:${i}`, JSON.stringify(c + (d || '')));
+      }
+      if (((c === '\t' || c === ' ') && d === '#') || (this.columnNo === 0 && c === '#')) {
+        this.newLine(text, i);
+        for (i++; i < text.length; i++) {
+          c = text[i];
+          if (c === '\n') {
+            break;
+          }
         }
+      } else if (c === '\t') {
+        this.columnNo = nextTabStop(this.columnNo);
+      } else if (c === '\n') {
+        this.newLine(text, i);
+      } else if (c === ' ') {
+        this.columnNo++;
+      } else if (this.leading && leaders.indexOf(c) >= 0 && (d === ' ' || d === '\t')) {
+        this.leader += c;
+        this.columnNo++;
+      } else if (this.leading && leaders.indexOf(c) >= 0 && d === '\n') {
+        this.leader += c;
+        this.indentStart = i;
+        this.columnStart = this.columnNo;
+        this.lineStart = this.lineNo;
+        this.indent = this.columnNo + 2;
+      } else if (this.leading) {
+        this.indent = this.columnNo;
+        this.indentStart = i;
+        this.columnStart = this.columnNo;
+        this.lineStart = this.lineNo;
+        this.columnNo++;
+        this.leading = false;
+      }
     }
 
     // TODO To exercise the following block, you need a file with no final
     // newline.
-    // istanbul ignore if
     if (!this.leading) {
-        this.generator.next(text.slice(this.indentStart, i), this);
+      this.generator.next(text.slice(this.indentStart, i), this);
     }
-};
+  }
 
-Scanner.prototype.newLine = function newLine(text, i) {
+  /**
+   * @param {string} text
+   * @param {number} i
+   * @returns {void}
+   */
+  newLine(text, i) {
     if (this.leading) {
-        this.indentStart = i;
+      this.indentStart = i;
     }
     this.leading = true;
     this.generator.next(text.slice(this.indentStart, i), this);
@@ -94,18 +119,16 @@ Scanner.prototype.newLine = function newLine(text, i) {
     this.lineNo++;
     this.lineStart = i + 1;
     this.leader = '';
-};
+  }
 
-Scanner.prototype.return = function _return() {
+  /**
+   * @returns {void}
+   */
+  return() {
     this.generator.return(this);
-};
-
-// istanbul ignore next
-Scanner.prototype.position = function position() {
-    return this.fileName + ':' + (this.lineNo + 1) + ':' + (this.columnStart + 1);
-};
+  }
 
-function nextTabStop(columnNo) {
-    // TODO simplify with modulo arithmetic
-    return Math.floor((columnNo + tabWidth) / tabWidth) * tabWidth;
+  position() {
+    return `${this.fileName}:${this.lineNo + 1}:${this.columnStart + 1}`;
+  }
 }

package/scope.js

@@ -1,57 +1,53 @@
-'use strict';
-
-var Path = require('./path');
-
-module.exports = Scope;
+import * as Path from './path.js';
+
+export default class Scope {
+  static tie(ends, name) {
+    for (let i = 0; i < ends.length; i++) {
+      const end = ends[i];
+      if (end.type === 'branch') {
+        end.node.branch = name;
+      } else {
+        end.next = name;
+      }
+    }
+  }
 
-function Scope(story, path, base) {
+  constructor(story, path, base) {
     this.story = story;
     this.path = path;
     this.base = base;
     Object.seal(this);
-}
+  }
 
-Scope.prototype.name = function name() {
+  name() {
     return Path.toName(this.path);
-};
+  }
 
-Scope.prototype.create = function create(type, arg, position) {
+  create(type, arg, position) {
     return this.story.create(this.path, type, arg, position);
-};
+  }
 
-Scope.prototype.next = function next() {
+  next() {
     return new Scope(this.story, Path.next(this.path), this.base);
-};
+  }
 
-Scope.prototype.zerothChild = function zerothChild() {
+  zerothChild() {
     return new Scope(this.story, Path.zerothChild(this.path), this.base);
-};
+  }
 
-Scope.prototype.firstChild = function firstChild() {
+  firstChild() {
     return new Scope(this.story, Path.firstChild(this.path), this.base);
-};
+  }
 
-Scope.prototype.label = function label(label) {
+  label(label) {
     return new Scope(this.story, this.base.concat([label, 0]), this.base);
-};
+  }
 
-Scope.prototype.tie = function _tie(nodes) {
-    tie(nodes, this.name());
-};
+  tie(nodes) {
+    Scope.tie(nodes, this.name());
+  }
 
-// istanbul ignore next
-Scope.prototype.error = function (message) {
+  error(message) {
     this.story.error(message);
-};
-
-Scope.tie = tie;
-function tie(ends, name) {
-    for (var i = 0; i < ends.length; i++) {
-        var end = ends[i];
-        if (end.type === 'branch') {
-            end.node.branch = name;
-        } else {
-            end.next = name;
-        }
-    }
+  }
 }