yaml 2.0.0-3 → 2.0.0-7

package/dist/test-events.js

@@ -1,158 +1,134 @@
 'use strict';
 
-var parse = require('./cst/parse.js');
-var Document = require('./doc/Document.js');
-
-function testEvents(src, options) {
-  const opt = Object.assign({
-    keepCstNodes: true,
-    keepNodeTypes: true,
-    version: '1.2'
-  }, options);
-  const docs = parse.parse(src).map(cstDoc => new Document.Document(null, opt).parse(cstDoc));
-  const errDoc = docs.find(doc => doc.errors.length > 0);
-  const error = errDoc ? errDoc.errors[0].message : null;
-  const events = ['+STR'];
-
-  try {
-    for (let i = 0; i < docs.length; ++i) {
-      const doc = docs[i];
-      let root = doc.contents;
-      if (Array.isArray(root)) root = root[0];
-      const [rootStart, rootEnd] = doc.range || [0, 0];
-      let e = doc.errors[0] && doc.errors[0].source;
-      if (e && e.type === 'SEQ_ITEM') e = e.node;
-      if (e && (e.type === 'DOCUMENT' || e.range.start < rootStart)) throw new Error();
-      let docStart = '+DOC';
-      const pre = src.slice(0, rootStart);
-      const explicitDoc = /---\s*$/.test(pre);
-      if (explicitDoc) docStart += ' ---';else if (!doc.contents) continue;
-      events.push(docStart);
-      addEvents(events, doc, e, root);
-      if (doc.contents && doc.contents.length > 1) throw new Error();
-      let docEnd = '-DOC';
-
-      if (rootEnd) {
-        const post = src.slice(rootEnd);
-        if (/^\.\.\./.test(post)) docEnd += ' ...';
-      }
-
-      events.push(docEnd);
+var Node = require('./nodes/Node.js');
+var publicApi = require('./public-api.js');
+var visit = require('./visit.js');
+
+const scalarChar = {
+    BLOCK_FOLDED: '>',
+    BLOCK_LITERAL: '|',
+    PLAIN: ':',
+    QUOTE_DOUBLE: '"',
+    QUOTE_SINGLE: "'"
+};
+function anchorExists(doc, anchor) {
+    let found = false;
+    visit.visit(doc, {
+        Value(_key, node) {
+            if (node.anchor === anchor) {
+                found = true;
+                return visit.visit.BREAK;
+            }
+        }
+    });
+    return found;
+}
+// test harness for yaml-test-suite event tests
+function testEvents(src) {
+    var _a;
+    const docs = publicApi.parseAllDocuments(src);
+    const errDoc = docs.find(doc => doc.errors.length > 0);
+    const error = errDoc ? errDoc.errors[0].message : null;
+    const events = ['+STR'];
+    try {
+        for (let i = 0; i < docs.length; ++i) {
+            const doc = docs[i];
+            let root = doc.contents;
+            if (Array.isArray(root))
+                root = root[0];
+            // eslint-disable-next-line no-sparse-arrays
+            const [rootStart, , rootEnd] = doc.range || [0, , 0];
+            const error = doc.errors[0];
+            if (error && (!error.pos || error.pos[0] < rootStart))
+                throw new Error();
+            let docStart = '+DOC';
+            if (doc.directives.marker)
+                docStart += ' ---';
+            else if (doc.contents && doc.contents.range[2] === doc.contents.range[0])
+                continue;
+            events.push(docStart);
+            addEvents(events, doc, (_a = error === null || error === void 0 ? void 0 : error.pos[0]) !== null && _a !== void 0 ? _a : -1, root);
+            let docEnd = '-DOC';
+            if (rootEnd) {
+                const post = src.slice(rootStart, rootEnd);
+                if (/^\.\.\.($|\s)/m.test(post))
+                    docEnd += ' ...';
+            }
+            events.push(docEnd);
+        }
     }
-  } catch (e) {
-    return {
-      events,
-      error: error || e
-    };
-  }
-
-  events.push('-STR');
-  return {
-    events,
-    error
-  };
+    catch (e) {
+        return { events, error: error || e };
+    }
+    events.push('-STR');
+    return { events, error };
 }
-
-function addEvents(events, doc, e, node) {
-  if (!node) {
-    events.push('=VAL :');
-    return;
-  }
-
-  if (e && node.cstNode === e) throw new Error();
-  let props = '';
-  let anchor = doc.anchors.getName(node);
-
-  if (anchor) {
-    if (/\d$/.test(anchor)) {
-      const alt = anchor.replace(/\d$/, '');
-      if (doc.anchors.getNode(alt)) anchor = alt;
+function addEvents(events, doc, errPos, node) {
+    if (!node) {
+        events.push('=VAL :');
+        return;
     }
-
-    props = ` &${anchor}`;
-  }
-
-  if (node.cstNode && node.cstNode.tag) {
-    const {
-      handle,
-      suffix
-    } = node.cstNode.tag;
-    props += handle === '!' && !suffix ? ' <!>' : ` <${node.tag}>`;
-  }
-
-  let scalar = null;
-
-  switch (node.type) {
-    case 'ALIAS':
-      {
-        let alias = doc.anchors.getName(node.source);
-
-        if (/\d$/.test(alias)) {
-          const alt = alias.replace(/\d$/, '');
-          if (doc.anchors.getNode(alt)) alias = alt;
+    if (errPos !== -1 && Node.isNode(node) && node.range[0] >= errPos)
+        throw new Error();
+    let props = '';
+    let anchor = Node.isScalar(node) || Node.isCollection(node) ? node.anchor : undefined;
+    if (anchor) {
+        if (/\d$/.test(anchor)) {
+            const alt = anchor.replace(/\d$/, '');
+            if (anchorExists(doc, alt))
+                anchor = alt;
+        }
+        props = ` &${anchor}`;
+    }
+    if (Node.isNode(node) && node.tag)
+        props += ` <${node.tag}>`;
+    if (Node.isMap(node)) {
+        events.push(`+MAP${props}`);
+        node.items.forEach(({ key, value }) => {
+            addEvents(events, doc, errPos, key);
+            addEvents(events, doc, errPos, value);
+        });
+        events.push('-MAP');
+    }
+    else if (Node.isSeq(node)) {
+        events.push(`+SEQ${props}`);
+        node.items.forEach(item => {
+            addEvents(events, doc, errPos, item);
+        });
+        events.push('-SEQ');
+    }
+    else if (Node.isPair(node)) {
+        events.push(`+MAP${props}`);
+        addEvents(events, doc, errPos, node.key);
+        addEvents(events, doc, errPos, node.value);
+        events.push('-MAP');
+    }
+    else if (Node.isAlias(node)) {
+        let alias = node.source;
+        if (alias && /\d$/.test(alias)) {
+            const alt = alias.replace(/\d$/, '');
+            if (anchorExists(doc, alt))
+                alias = alt;
         }
-
         events.push(`=ALI${props} *${alias}`);
-      }
-      break;
-
-    case 'BLOCK_FOLDED':
-      scalar = '>';
-      break;
-
-    case 'BLOCK_LITERAL':
-      scalar = '|';
-      break;
-
-    case 'PLAIN':
-      scalar = ':';
-      break;
-
-    case 'QUOTE_DOUBLE':
-      scalar = '"';
-      break;
-
-    case 'QUOTE_SINGLE':
-      scalar = "'";
-      break;
-
-    case 'PAIR':
-      events.push(`+MAP${props}`);
-      addEvents(events, doc, e, node.key);
-      addEvents(events, doc, e, node.value);
-      events.push('-MAP');
-      break;
-
-    case 'FLOW_SEQ':
-    case 'SEQ':
-      events.push(`+SEQ${props}`);
-      node.items.forEach(item => {
-        addEvents(events, doc, e, item);
-      });
-      events.push('-SEQ');
-      break;
-
-    case 'FLOW_MAP':
-    case 'MAP':
-      events.push(`+MAP${props}`);
-      node.items.forEach(({
-        key,
-        value
-      }) => {
-        addEvents(events, doc, e, key);
-        addEvents(events, doc, e, value);
-      });
-      events.push('-MAP');
-      break;
-
-    default:
-      throw new Error(`Unexpected node type ${node.type}`);
-  }
-
-  if (scalar) {
-    const value = node.cstNode.strValue.replace(/\\/g, '\\\\').replace(/\0/g, '\\0').replace(/\x07/g, '\\a').replace(/\x08/g, '\\b').replace(/\t/g, '\\t').replace(/\n/g, '\\n').replace(/\v/g, '\\v').replace(/\f/g, '\\f').replace(/\r/g, '\\r').replace(/\x1b/g, '\\e');
-    events.push(`=VAL${props} ${scalar}${value}`);
-  }
+    }
+    else {
+        const scalar = scalarChar[String(node.type)];
+        if (!scalar)
+            throw new Error(`Unexpected node type ${node.type}`);
+        const value = node.source
+            .replace(/\\/g, '\\\\')
+            .replace(/\0/g, '\\0')
+            .replace(/\x07/g, '\\a')
+            .replace(/\x08/g, '\\b')
+            .replace(/\t/g, '\\t')
+            .replace(/\n/g, '\\n')
+            .replace(/\v/g, '\\v')
+            .replace(/\f/g, '\\f')
+            .replace(/\r/g, '\\r')
+            .replace(/\x1b/g, '\\e');
+        events.push(`=VAL${props} ${scalar}${value}`);
+    }
 }
 
 exports.testEvents = testEvents;

package/dist/util.d.ts

@@ -0,0 +1,6 @@
+export { debug, LogLevelId, warn } from './log.js';
+export { findPair } from './nodes/YAMLMap.js';
+export { toJS, ToJSContext } from './nodes/toJS.js';
+export { foldFlowLines } from './stringify/foldFlowLines';
+export { stringifyNumber } from './stringify/stringifyNumber.js';
+export { stringifyString } from './stringify/stringifyString.js';

package/dist/util.js

@@ -1,21 +1,18 @@
 'use strict';
 
+var log = require('./log.js');
+var YAMLMap = require('./nodes/YAMLMap.js');
+var toJS = require('./nodes/toJS.js');
+var foldFlowLines = require('./stringify/foldFlowLines.js');
 var stringifyNumber = require('./stringify/stringifyNumber.js');
 var stringifyString = require('./stringify/stringifyString.js');
-var constants = require('./constants.js');
-var errors = require('./errors.js');
-var YAMLMap = require('./ast/YAMLMap.js');
-var toJS = require('./ast/toJS.js');
 
 
 
-exports.stringifyNumber = stringifyNumber.stringifyNumber;
-exports.stringifyString = stringifyString.stringifyString;
-exports.Type = constants.Type;
-exports.YAMLError = errors.YAMLError;
-exports.YAMLReferenceError = errors.YAMLReferenceError;
-exports.YAMLSemanticError = errors.YAMLSemanticError;
-exports.YAMLSyntaxError = errors.YAMLSyntaxError;
-exports.YAMLWarning = errors.YAMLWarning;
+exports.debug = log.debug;
+exports.warn = log.warn;
 exports.findPair = YAMLMap.findPair;
 exports.toJS = toJS.toJS;
+exports.foldFlowLines = foldFlowLines.foldFlowLines;
+exports.stringifyNumber = stringifyNumber.stringifyNumber;
+exports.stringifyString = stringifyString.stringifyString;

package/dist/visit.d.ts

@@ -0,0 +1,63 @@
+import type { Document } from './doc/Document.js';
+import type { Alias } from './nodes/Alias.js';
+import { Node } from './nodes/Node.js';
+import type { Pair } from './nodes/Pair.js';
+import type { Scalar } from './nodes/Scalar.js';
+import type { YAMLMap } from './nodes/YAMLMap.js';
+import type { YAMLSeq } from './nodes/YAMLSeq.js';
+export declare type visitorFn<T> = (key: number | 'key' | 'value' | null, node: T, path: readonly (Document | Node | Pair)[]) => void | symbol | number | Node | Pair;
+export declare type visitor = visitorFn<unknown> | {
+    Alias?: visitorFn<Alias>;
+    Collection?: visitorFn<YAMLMap | YAMLSeq>;
+    Map?: visitorFn<YAMLMap>;
+    Node?: visitorFn<Alias | Scalar | YAMLMap | YAMLSeq>;
+    Pair?: visitorFn<Pair>;
+    Scalar?: visitorFn<Scalar>;
+    Seq?: visitorFn<YAMLSeq>;
+    Value?: visitorFn<Scalar | YAMLMap | YAMLSeq>;
+};
+/**
+ * Apply a visitor to an AST node or document.
+ *
+ * Walks through the tree (depth-first) starting from `node`, calling a
+ * `visitor` function with three arguments:
+ *   - `key`: For sequence values and map `Pair`, the node's index in the
+ *     collection. Within a `Pair`, `'key'` or `'value'`, correspondingly.
+ *     `null` for the root node.
+ *   - `node`: The current node.
+ *   - `path`: The ancestry of the current node.
+ *
+ * The return value of the visitor may be used to control the traversal:
+ *   - `undefined` (default): Do nothing and continue
+ *   - `visit.SKIP`: Do not visit the children of this node, continue with next
+ *     sibling
+ *   - `visit.BREAK`: Terminate traversal completely
+ *   - `visit.REMOVE`: Remove the current node, then continue with the next one
+ *   - `Node`: Replace the current node, then continue by visiting it
+ *   - `number`: While iterating the items of a sequence or map, set the index
+ *     of the next step. This is useful especially if the index of the current
+ *     node has changed.
+ *
+ * If `visitor` is a single function, it will be called with all values
+ * encountered in the tree, including e.g. `null` values. Alternatively,
+ * separate visitor functions may be defined for each `Map`, `Pair`, `Seq`,
+ * `Alias` and `Scalar` node. To define the same visitor function for more than
+ * one node type, use the `Collection` (map and seq), `Value` (map, seq & scalar)
+ * and `Node` (alias, map, seq & scalar) targets. Of all these, only the most
+ * specific defined one will be used for each node.
+ */
+export declare function visit(node: Node | Document | null, visitor: visitorFn<unknown> | {
+    Alias?: visitorFn<Alias>;
+    Collection?: visitorFn<YAMLMap | YAMLSeq>;
+    Map?: visitorFn<YAMLMap>;
+    Node?: visitorFn<Alias | Scalar | YAMLMap | YAMLSeq>;
+    Pair?: visitorFn<Pair>;
+    Scalar?: visitorFn<Scalar>;
+    Seq?: visitorFn<YAMLSeq>;
+    Value?: visitorFn<Scalar | YAMLMap | YAMLSeq>;
+}): void;
+export declare namespace visit {
+    var BREAK: symbol;
+    var SKIP: symbol;
+    var REMOVE: symbol;
+}

package/dist/visit.js

@@ -1,85 +1,148 @@
 'use strict';
 
-var Alias = require('./ast/Alias.js');
-var Node = require('./ast/Node.js');
-var Pair = require('./ast/Pair.js');
-var Scalar = require('./ast/Scalar.js');
-var YAMLMap = require('./ast/YAMLMap.js');
-var YAMLSeq = require('./ast/YAMLSeq.js');
-var Document = require('./doc/Document.js');
+var Node = require('./nodes/Node.js');
 
 const BREAK = Symbol('break visit');
 const SKIP = Symbol('skip children');
 const REMOVE = Symbol('remove node');
-
-function _visit(key, node, visitor, path) {
-  let ctrl = undefined;
-  if (typeof visitor === 'function') ctrl = visitor(key, node, path);else if (node instanceof YAMLMap.YAMLMap) {
-    if (visitor.Map) ctrl = visitor.Map(key, node, path);
-  } else if (node instanceof YAMLSeq.YAMLSeq) {
-    if (visitor.Seq) ctrl = visitor.Seq(key, node, path);
-  } else if (node instanceof Pair.Pair) {
-    if (visitor.Pair) ctrl = visitor.Pair(key, node, path);
-  } else if (node instanceof Scalar.Scalar) {
-    if (visitor.Scalar) ctrl = visitor.Scalar(key, node, path);
-  } else if (node instanceof Alias.Alias) {
-    if (visitor.Scalar) ctrl = visitor.Alias(key, node, path);
-  }
-
-  if (ctrl instanceof Node.Node) {
-    const parent = path[path.length - 1];
-
-    if (parent instanceof YAMLMap.YAMLMap || parent instanceof YAMLSeq.YAMLSeq) {
-      parent.items[key] = ctrl;
-    } else if (parent instanceof Pair.Pair) {
-      if (key === 'key') parent.key = ctrl;else parent.value = ctrl;
-    } else if (parent instanceof Document.Document) {
-      parent.contents = ctrl;
-    } else {
-      const pt = parent && parent.type;
-      throw new Error(`Cannot replace node with ${pt} parent`);
+/**
+ * Apply a visitor to an AST node or document.
+ *
+ * Walks through the tree (depth-first) starting from `node`, calling a
+ * `visitor` function with three arguments:
+ *   - `key`: For sequence values and map `Pair`, the node's index in the
+ *     collection. Within a `Pair`, `'key'` or `'value'`, correspondingly.
+ *     `null` for the root node.
+ *   - `node`: The current node.
+ *   - `path`: The ancestry of the current node.
+ *
+ * The return value of the visitor may be used to control the traversal:
+ *   - `undefined` (default): Do nothing and continue
+ *   - `visit.SKIP`: Do not visit the children of this node, continue with next
+ *     sibling
+ *   - `visit.BREAK`: Terminate traversal completely
+ *   - `visit.REMOVE`: Remove the current node, then continue with the next one
+ *   - `Node`: Replace the current node, then continue by visiting it
+ *   - `number`: While iterating the items of a sequence or map, set the index
+ *     of the next step. This is useful especially if the index of the current
+ *     node has changed.
+ *
+ * If `visitor` is a single function, it will be called with all values
+ * encountered in the tree, including e.g. `null` values. Alternatively,
+ * separate visitor functions may be defined for each `Map`, `Pair`, `Seq`,
+ * `Alias` and `Scalar` node. To define the same visitor function for more than
+ * one node type, use the `Collection` (map and seq), `Value` (map, seq & scalar)
+ * and `Node` (alias, map, seq & scalar) targets. Of all these, only the most
+ * specific defined one will be used for each node.
+ */
+function visit(node, visitor) {
+    if (typeof visitor === 'object' &&
+        (visitor.Collection || visitor.Node || visitor.Value)) {
+        visitor = Object.assign({
+            Alias: visitor.Node,
+            Map: visitor.Node,
+            Scalar: visitor.Node,
+            Seq: visitor.Node
+        }, visitor.Value && {
+            Map: visitor.Value,
+            Scalar: visitor.Value,
+            Seq: visitor.Value
+        }, visitor.Collection && {
+            Map: visitor.Collection,
+            Seq: visitor.Collection
+        }, visitor);
     }
-
-    return _visit(key, ctrl, visitor, path);
-  }
-
-  if (typeof ctrl !== 'symbol') {
-    if (node instanceof YAMLMap.YAMLMap || node instanceof YAMLSeq.YAMLSeq) {
-      path = Object.freeze(path.concat(node));
-
-      for (let i = 0; i < node.items.length; ++i) {
-        const ci = _visit(i, node.items[i], visitor, path);
-
-        if (typeof ci === 'number') i = ci - 1;else if (ci === BREAK) return BREAK;else if (ci === REMOVE) {
-          node.items.splice(i, 1);
-          i -= 1;
-        }
-      }
-    } else if (node instanceof Pair.Pair) {
-      path = Object.freeze(path.concat(node));
-
-      const ck = _visit('key', node.key, visitor, path);
-
-      if (ck === BREAK) return BREAK;else if (ck === REMOVE) node.key = null;
-
-      const cv = _visit('value', node.value, visitor, path);
-
-      if (cv === BREAK) return BREAK;else if (cv === REMOVE) node.value = null;
+    if (Node.isDocument(node)) {
+        const cd = _visit(null, node.contents, visitor, Object.freeze([node]));
+        if (cd === REMOVE)
+            node.contents = null;
     }
-  }
-
-  return ctrl;
-}
-
-function visit(node, visitor) {
-  if (node instanceof Document.Document) {
-    const cd = _visit(null, node.contents, visitor, Object.freeze([node]));
-
-    if (cd === REMOVE) node.contents = null;
-  } else _visit(null, node, visitor, Object.freeze([]));
+    else
+        _visit(null, node, visitor, Object.freeze([]));
 }
+// Without the `as symbol` casts, TS declares these in the `visit`
+// namespace using `var`, but then complains about that because
+// `unique symbol` must be `const`.
+/** Terminate visit traversal completely */
 visit.BREAK = BREAK;
+/** Do not visit the children of the current node */
 visit.SKIP = SKIP;
+/** Remove the current node */
 visit.REMOVE = REMOVE;
+function _visit(key, node, visitor, path) {
+    let ctrl = undefined;
+    if (typeof visitor === 'function')
+        ctrl = visitor(key, node, path);
+    else if (Node.isMap(node)) {
+        if (visitor.Map)
+            ctrl = visitor.Map(key, node, path);
+    }
+    else if (Node.isSeq(node)) {
+        if (visitor.Seq)
+            ctrl = visitor.Seq(key, node, path);
+    }
+    else if (Node.isPair(node)) {
+        if (visitor.Pair)
+            ctrl = visitor.Pair(key, node, path);
+    }
+    else if (Node.isScalar(node)) {
+        if (visitor.Scalar)
+            ctrl = visitor.Scalar(key, node, path);
+    }
+    else if (Node.isAlias(node)) {
+        if (visitor.Alias)
+            ctrl = visitor.Alias(key, node, path);
+    }
+    if (Node.isNode(ctrl) || Node.isPair(ctrl)) {
+        const parent = path[path.length - 1];
+        if (Node.isCollection(parent)) {
+            parent.items[key] = ctrl;
+        }
+        else if (Node.isPair(parent)) {
+            if (key === 'key')
+                parent.key = ctrl;
+            else
+                parent.value = ctrl;
+        }
+        else if (Node.isDocument(parent)) {
+            parent.contents = ctrl;
+        }
+        else {
+            const pt = Node.isAlias(parent) ? 'alias' : 'scalar';
+            throw new Error(`Cannot replace node with ${pt} parent`);
+        }
+        return _visit(key, ctrl, visitor, path);
+    }
+    if (typeof ctrl !== 'symbol') {
+        if (Node.isCollection(node)) {
+            path = Object.freeze(path.concat(node));
+            for (let i = 0; i < node.items.length; ++i) {
+                const ci = _visit(i, node.items[i], visitor, path);
+                if (typeof ci === 'number')
+                    i = ci - 1;
+                else if (ci === BREAK)
+                    return BREAK;
+                else if (ci === REMOVE) {
+                    node.items.splice(i, 1);
+                    i -= 1;
+                }
+            }
+        }
+        else if (Node.isPair(node)) {
+            path = Object.freeze(path.concat(node));
+            const ck = _visit('key', node.key, visitor, path);
+            if (ck === BREAK)
+                return BREAK;
+            else if (ck === REMOVE)
+                node.key = null;
+            const cv = _visit('value', node.value, visitor, path);
+            if (cv === BREAK)
+                return BREAK;
+            else if (cv === REMOVE)
+                node.value = null;
+        }
+    }
+    return ctrl;
+}
 
 exports.visit = visit;