yaml 1.6.0 → 1.8.0

package/dist/cst/BlockValue.js

@@ -50,7 +50,7 @@ class BlockValue extends _Node.default {
       end -= 1;
 
       if (end <= start) {
-        if (this.chomping === Chomp.KEEP) break;else return '';
+        if (this.chomping === Chomp.KEEP) break;else return ''; // probably never happens
       }
 
       if (ch === '\n') lastNewLine = end;

package/dist/cst/CollectionItem.js

@@ -49,12 +49,15 @@ class CollectionItem extends _Node.default {
     let offset = _Node.default.endOfWhiteSpace(src, start + 1);
 
     let ch = src[offset];
+    const inlineComment = ch === '#';
+    const comments = [];
+    let blankLine = null;
 
     while (ch === '\n' || ch === '#') {
       if (ch === '#') {
         const end = _Node.default.endOfLine(src, offset + 1);
 
-        this.props.push(new _Range.default(offset, end));
+        comments.push(new _Range.default(offset, end));
         offset = end;
       } else {
         atLineStart = true;
@@ -62,13 +65,11 @@ class CollectionItem extends _Node.default {
 
         const wsEnd = _Node.default.endOfWhiteSpace(src, lineStart);
 
-        if (src[wsEnd] === '\n') {
-          const blankLine = new _BlankLine.default();
+        if (src[wsEnd] === '\n' && comments.length === 0) {
+          blankLine = new _BlankLine.default();
           lineStart = blankLine.parse({
             src
           }, lineStart);
-          const items = context.parent.items || context.parent.contents;
-          items.push(blankLine);
         }
 
         offset = _Node.default.endOfIndent(src, lineStart);
@@ -85,11 +86,31 @@ class CollectionItem extends _Node.default {
         lineStart,
         parent: this
       }, offset);
-      if (this.node) offset = this.node.range.end;
     } else if (ch && lineStart > start + 1) {
       offset = lineStart - 1;
     }
 
+    if (this.node) {
+      if (blankLine) {
+        // Only blank lines preceding non-empty nodes are captured. Note that
+        // this means that collection item range start indices do not always
+        // increase monotonically. -- eemeli/yaml#126
+        const items = context.parent.items || context.parent.contents;
+        if (items) items.push(blankLine);
+      }
+
+      if (comments.length) Array.prototype.push.apply(this.props, comments);
+      offset = this.node.range.end;
+    } else {
+      if (inlineComment) {
+        const c = comments[0];
+        this.props.push(c);
+        offset = c.end;
+      } else {
+        offset = _Node.default.endOfLine(src, start + 1);
+      }
+    }
+
     const end = this.node ? this.node.valueRange.end : offset;
     this.valueRange = new _Range.default(start, end);
     return offset;

package/dist/cst/Directive.js

@@ -14,22 +14,6 @@ var _Range = _interopRequireDefault(require("./Range"));
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 class Directive extends _Node.default {
-  static endOfDirective(src, offset) {
-    let ch = src[offset];
-
-    while (ch && ch !== '\n' && ch !== '#') ch = src[offset += 1]; // last char can't be whitespace
-
-
-    ch = src[offset - 1];
-
-    while (ch === ' ' || ch === '\t') {
-      offset -= 1;
-      ch = src[offset - 1];
-    }
-
-    return offset;
-  }
-
   constructor() {
     super(_constants.Type.DIRECTIVE);
     this.name = null;

package/dist/cst/Node.js

@@ -7,7 +7,7 @@ exports.default = void 0;
 
 var _constants = require("../constants");
 
-var _getLinePos = _interopRequireDefault(require("./getLinePos"));
+var _sourceUtils = require("./source-utils");
 
 var _Range = _interopRequireDefault(require("./Range"));
 
@@ -114,11 +114,6 @@ class Node {
     return ch === '\n' || ch === '\t' || ch === ' ' || endAsBlank && !ch;
   }
 
-  static atCollectionItem(src, offset) {
-    const ch = src[offset];
-    return (ch === '?' || ch === ':' || ch === '-') && Node.atBlank(src, offset + 1, true);
-  }
-
   static nextNodeIsIndented(ch, indentDiff, indicatorAsIndent) {
     if (!ch || indentDiff < 0) return false;
     if (indentDiff > 0) return true;
@@ -171,7 +166,10 @@ class Node {
   }
 
   constructor(type, props, context) {
-    this.context = context || null;
+    Object.defineProperty(this, 'context', {
+      value: context || null,
+      writable: true
+    });
     this.error = null;
     this.range = null;
     this.valueRange = null;
@@ -260,9 +258,9 @@ class Node {
 
   get rangeAsLinePos() {
     if (!this.range || !this.context) return undefined;
-    const start = (0, _getLinePos.default)(this.range.start, this.context.root);
+    const start = (0, _sourceUtils.getLinePos)(this.range.start, this.context.root);
     if (!start) return undefined;
-    const end = (0, _getLinePos.default)(this.range.end, this.context.root);
+    const end = (0, _sourceUtils.getLinePos)(this.range.end, this.context.root);
     return {
       start,
       end

package/dist/cst/ParseContext.js

@@ -33,6 +33,41 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
 
 function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 
+function createNewNode(type, props) {
+  switch (type) {
+    case _constants.Type.ALIAS:
+      return new _Alias.default(type, props);
+
+    case _constants.Type.BLOCK_FOLDED:
+    case _constants.Type.BLOCK_LITERAL:
+      return new _BlockValue.default(type, props);
+
+    case _constants.Type.FLOW_MAP:
+    case _constants.Type.FLOW_SEQ:
+      return new _FlowCollection.default(type, props);
+
+    case _constants.Type.MAP_KEY:
+    case _constants.Type.MAP_VALUE:
+    case _constants.Type.SEQ_ITEM:
+      return new _CollectionItem.default(type, props);
+
+    case _constants.Type.COMMENT:
+    case _constants.Type.PLAIN:
+      return new _PlainValue.default(type, props);
+
+    case _constants.Type.QUOTE_DOUBLE:
+      return new _QuoteDouble.default(type, props);
+
+    case _constants.Type.QUOTE_SINGLE:
+      return new _QuoteSingle.default(type, props);
+
+    /* istanbul ignore next */
+
+    default:
+      return null;
+    // should never happen
+  }
+}
 /**
  * @param {boolean} atLineStart - Node starts at beginning of line
  * @param {boolean} inFlow - true if currently in a flow context
@@ -42,6 +77,8 @@ function _defineProperty(obj, key, value) { if (key in obj) { Object.definePrope
  * @param {Node} parent - The parent of the node
  * @param {string} src - Source of the YAML document
  */
+
+
 class ParseContext {
   static parseType(src, offset, inFlow) {
     switch (src[offset]) {
@@ -96,52 +133,14 @@ class ParseContext {
         type,
         valueStart
       } = context.parseProps(start);
-      let node;
-
-      switch (type) {
-        case _constants.Type.ALIAS:
-          node = new _Alias.default(type, props);
-          break;
-
-        case _constants.Type.BLOCK_FOLDED:
-        case _constants.Type.BLOCK_LITERAL:
-          node = new _BlockValue.default(type, props);
-          break;
-
-        case _constants.Type.FLOW_MAP:
-        case _constants.Type.FLOW_SEQ:
-          node = new _FlowCollection.default(type, props);
-          break;
-
-        case _constants.Type.MAP_KEY:
-        case _constants.Type.MAP_VALUE:
-        case _constants.Type.SEQ_ITEM:
-          node = new _CollectionItem.default(type, props);
-          break;
-
-        case _constants.Type.COMMENT:
-        case _constants.Type.PLAIN:
-          node = new _PlainValue.default(type, props);
-          break;
-
-        case _constants.Type.QUOTE_DOUBLE:
-          node = new _QuoteDouble.default(type, props);
-          break;
-
-        case _constants.Type.QUOTE_SINGLE:
-          node = new _QuoteSingle.default(type, props);
-          break;
-
-        default:
-          node.error = new _errors.YAMLSyntaxError(node, `Unknown node type: ${JSON.stringify(type)}`);
-          node.range = new _Range.default(start, start + 1);
-          return node;
-      }
-
+      const node = createNewNode(type, props);
       let offset = node.parse(context, valueStart);
       node.range = new _Range.default(start, offset);
+      /* istanbul ignore if */
 
       if (offset <= start) {
+        // This should never happen, but if it does, let's make sure to at least
+        // step one character forward to avoid a busy loop.
         node.error = new Error(`Node#parse consumed no characters`);
         node.error.parseEnd = offset;
         node.error.source = node;
@@ -170,19 +169,6 @@ class ParseContext {
     this.parent = parent != null ? parent : orig.parent || {};
     this.root = orig.root;
     this.src = orig.src;
-  } // for logging
-
-
-  get pretty() {
-    const obj = {
-      start: `${this.lineStart} + ${this.indent}`,
-      in: [],
-      parent: this.parent.type
-    };
-    if (!this.atLineStart) obj.start += ' + N';
-    if (this.inCollection) obj.in.push('collection');
-    if (this.inFlow) obj.in.push('flow');
-    return obj;
   }
 
   nodeStartsCollection(node) {

package/dist/cst/PlainValue.js

@@ -19,7 +19,7 @@ class PlainValue extends _Node.default {
     while (ch && ch !== '\n') {
       if (inFlow && (ch === '[' || ch === ']' || ch === '{' || ch === '}' || ch === ',')) break;
       const next = src[offset + 1];
-      if (ch === ':' && (next === '\n' || next === '\t' || next === ' ' || inFlow && next === ',')) break;
+      if (ch === ':' && (!next || next === '\n' || next === '\t' || next === ' ' || inFlow && next === ',')) break;
       if ((ch === ' ' || ch === '\t') && next === '#') break;
       offset += 1;
       ch = next;

package/dist/cst/source-utils.js

@@ -0,0 +1,178 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getLinePos = getLinePos;
+exports.getLine = getLine;
+exports.getPrettyContext = getPrettyContext;
+
+function findLineStarts(src) {
+  const ls = [0];
+  let offset = src.indexOf('\n');
+
+  while (offset !== -1) {
+    offset += 1;
+    ls.push(offset);
+    offset = src.indexOf('\n', offset);
+  }
+
+  return ls;
+}
+
+function getSrcInfo(cst) {
+  let lineStarts, src;
+
+  if (typeof cst === 'string') {
+    lineStarts = findLineStarts(cst);
+    src = cst;
+  } else {
+    if (Array.isArray(cst)) cst = cst[0];
+
+    if (cst && cst.context) {
+      if (!cst.lineStarts) cst.lineStarts = findLineStarts(cst.context.src);
+      lineStarts = cst.lineStarts;
+      src = cst.context.src;
+    }
+  }
+
+  return {
+    lineStarts,
+    src
+  };
+}
+/**
+ * @typedef {Object} LinePos - One-indexed position in the source
+ * @property {number} line
+ * @property {number} col
+ */
+
+/**
+ * Determine the line/col position matching a character offset.
+ *
+ * Accepts a source string or a CST document as the second parameter. With
+ * the latter, starting indices for lines are cached in the document as
+ * `lineStarts: number[]`.
+ *
+ * Returns a one-indexed `{ line, col }` location if found, or
+ * `undefined` otherwise.
+ *
+ * @param {number} offset
+ * @param {string|Document|Document[]} cst
+ * @returns {?LinePos}
+ */
+
+
+function getLinePos(offset, cst) {
+  if (typeof offset !== 'number' || offset < 0) return null;
+  const {
+    lineStarts,
+    src
+  } = getSrcInfo(cst);
+  if (!lineStarts || !src || offset > src.length) return null;
+
+  for (let i = 0; i < lineStarts.length; ++i) {
+    const start = lineStarts[i];
+
+    if (offset < start) {
+      return {
+        line: i,
+        col: offset - lineStarts[i - 1] + 1
+      };
+    }
+
+    if (offset === start) return {
+      line: i + 1,
+      col: 1
+    };
+  }
+
+  const line = lineStarts.length;
+  return {
+    line,
+    col: offset - lineStarts[line - 1] + 1
+  };
+}
+/**
+ * Get a specified line from the source.
+ *
+ * Accepts a source string or a CST document as the second parameter. With
+ * the latter, starting indices for lines are cached in the document as
+ * `lineStarts: number[]`.
+ *
+ * Returns the line as a string if found, or `null` otherwise.
+ *
+ * @param {number} line One-indexed line number
+ * @param {string|Document|Document[]} cst
+ * @returns {?string}
+ */
+
+
+function getLine(line, cst) {
+  const {
+    lineStarts,
+    src
+  } = getSrcInfo(cst);
+  if (!lineStarts || !(line >= 1) || line > lineStarts.length) return null;
+  const start = lineStarts[line - 1];
+  let end = lineStarts[line]; // undefined for last line; that's ok for slice()
+
+  while (end && end > start && src[end - 1] === '\n') --end;
+
+  return src.slice(start, end);
+}
+/**
+ * Pretty-print the starting line from the source indicated by the range `pos`
+ *
+ * Trims output to `maxWidth` chars while keeping the starting column visible,
+ * using `…` at either end to indicate dropped characters.
+ *
+ * Returns a two-line string (or `null`) with `\n` as separator; the second line
+ * will hold appropriately indented `^` marks indicating the column range.
+ *
+ * @param {Object} pos
+ * @param {LinePos} pos.start
+ * @param {LinePos} [pos.end]
+ * @param {string|Document|Document[]*} cst
+ * @param {number} [maxWidth=80]
+ * @returns {?string}
+ */
+
+
+function getPrettyContext({
+  start,
+  end
+}, cst, maxWidth = 80) {
+  let src = getLine(start.line, cst);
+  if (!src) return null;
+  let {
+    col
+  } = start;
+
+  if (src.length > maxWidth) {
+    if (col <= maxWidth - 10) {
+      src = src.substr(0, maxWidth - 1) + '…';
+    } else {
+      const halfWidth = Math.round(maxWidth / 2);
+      if (src.length > col + halfWidth) src = src.substr(0, col + halfWidth - 1) + '…';
+      col -= src.length - maxWidth;
+      src = '…' + src.substr(1 - maxWidth);
+    }
+  }
+
+  let errLen = 1;
+  let errEnd = '';
+
+  if (end) {
+    if (end.line === start.line && col + (end.col - start.col) <= maxWidth + 1) {
+      errLen = end.col - start.col;
+    } else {
+      errLen = Math.min(src.length + 1, maxWidth) - col;
+      errEnd = '…';
+    }
+  }
+
+  const offset = col > 1 ? ' '.repeat(col - 1) : '';
+  const err = '^'.repeat(errLen);
+  return `${src}\n${offset}${err}${errEnd}`;
+}

package/dist/errors.js

@@ -7,6 +7,10 @@ exports.YAMLWarning = exports.YAMLSyntaxError = exports.YAMLSemanticError = expo
 
 var _Node = _interopRequireDefault(require("./cst/Node"));
 
+var _sourceUtils = require("./cst/source-utils");
+
+var _Range = _interopRequireDefault(require("./cst/Range"));
+
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 class YAMLError extends Error {
@@ -19,12 +23,42 @@ class YAMLError extends Error {
   }
 
   makePretty() {
-    if (this.source) {
-      this.nodeType = this.source.type;
+    if (!this.source) return;
+    this.nodeType = this.source.type;
+    const cst = this.source.context && this.source.context.root;
+
+    if (typeof this.offset === 'number') {
+      this.range = new _Range.default(this.offset, this.offset + 1);
+      const start = cst && (0, _sourceUtils.getLinePos)(this.offset, cst);
+
+      if (start) {
+        const end = {
+          line: start.line,
+          col: start.col + 1
+        };
+        this.linePos = {
+          start,
+          end
+        };
+      }
+
+      delete this.offset;
+    } else {
       this.range = this.source.range;
       this.linePos = this.source.rangeAsLinePos;
-      delete this.source;
     }
+
+    if (this.linePos) {
+      const {
+        line,
+        col
+      } = this.linePos.start;
+      this.message += ` at line ${line}, column ${col}`;
+      const ctx = cst && (0, _sourceUtils.getPrettyContext)(this.linePos, cst);
+      if (ctx) this.message += `:\n\n${ctx}\n`;
+    }
+
+    delete this.source;
   }
 
 }

package/dist/index.js

@@ -13,9 +13,10 @@ var _errors = require("./errors");
 
 var _schema = _interopRequireDefault(require("./schema"));
 
+var _warnings = require("./warnings");
+
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-/* global console */
 const defaultOptions = {
   anchorPrefix: 'a',
   customTags: null,
@@ -26,6 +27,7 @@ const defaultOptions = {
   maxAliasCount: 100,
   prettyErrors: false,
   // TODO Set true in v2
+  simpleKeys: false,
   version: '1.2'
 };
 
@@ -74,9 +76,8 @@ function parseDocument(src, options) {
 }
 
 function parse(src, options) {
-  const doc = parseDocument(src, options); // eslint-disable-next-line no-console
-
-  doc.warnings.forEach(warning => console.warn(warning));
+  const doc = parseDocument(src, options);
+  doc.warnings.forEach(warning => (0, _warnings.warn)(warning));
   if (doc.errors.length > 0) throw doc.errors[0];
   return doc.toJSON();
 }

package/dist/schema/Alias.js

@@ -77,8 +77,9 @@ class Alias extends _Node.default {
       maxAliasCount
     } = ctx;
     const anchor = anchors.find(a => a.node === this.source);
+    /* istanbul ignore if */
 
-    if (!anchor || !anchor.res) {
+    if (!anchor || anchor.res === undefined) {
       const msg = 'This should not happen: Alias anchor was not resolved?';
       if (this.cstNode) throw new _errors.YAMLReferenceError(this.cstNode, msg);else throw new ReferenceError(msg);
     }

package/dist/schema/Collection.js

@@ -17,23 +17,38 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
 
 function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 
-// null, undefined, or an empty non-string iterable (e.g. [])
+function collectionFromPath(schema, path, value) {
+  let v = value;
+
+  for (let i = path.length - 1; i >= 0; --i) {
+    const k = path[i];
+    const o = Number.isInteger(k) && k >= 0 ? [] : {};
+    o[k] = v;
+    v = o;
+  }
+
+  return schema.createNode(v, false);
+} // null, undefined, or an empty non-string iterable (e.g. [])
+
+
 const isEmptyPath = path => path == null || typeof path === 'object' && path[Symbol.iterator]().next().done;
 
 exports.isEmptyPath = isEmptyPath;
 
 class Collection extends _Node.default {
-  constructor(...args) {
-    super(...args);
+  constructor(schema) {
+    super();
 
     _defineProperty(this, "items", []);
+
+    this.schema = schema;
   }
 
   addIn(path, value) {
     if (isEmptyPath(path)) this.add(value);else {
       const [key, ...rest] = path;
       const node = this.get(key, true);
-      if (node instanceof Collection) node.addIn(rest, value);else throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`);
+      if (node instanceof Collection) node.addIn(rest, value);else if (node === undefined && this.schema) this.set(key, collectionFromPath(this.schema, rest, value));else throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`);
     }
   }
 
@@ -67,10 +82,12 @@ class Collection extends _Node.default {
       this.set(key, value);
     } else {
       const node = this.get(key, true);
-      if (node instanceof Collection) node.setIn(rest, value);else throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`);
+      if (node instanceof Collection) node.setIn(rest, value);else if (node === undefined && this.schema) this.set(key, collectionFromPath(this.schema, rest, value));else throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`);
     }
   } // overridden in implementations
 
+  /* istanbul ignore next */
+
 
   toJSON() {
     return null;

package/dist/schema/Map.js

@@ -28,11 +28,19 @@ function findPair(items, key) {
 }
 
 class YAMLMap extends _Collection.default {
-  add(pair) {
+  add(pair, overwrite) {
     if (!pair) pair = new _Pair.default(pair);else if (!(pair instanceof _Pair.default)) pair = new _Pair.default(pair.key || pair, pair.value);
     const prev = findPair(this.items, pair.key);
-    if (prev) throw new Error(`Key ${pair.key} already set`);
-    this.items.push(pair);
+    const sortEntries = this.schema && this.schema.sortMapEntries;
+
+    if (prev) {
+      if (overwrite) prev.value = pair.value;else throw new Error(`Key ${pair.key} already set`);
+    } else if (sortEntries) {
+      const i = this.items.findIndex(item => sortEntries(pair, item) < 0);
+      if (i === -1) this.items.push(pair);else this.items.splice(i, 0, pair);
+    } else {
+      this.items.push(pair);
+    }
   }
 
   delete(key) {
@@ -53,8 +61,7 @@ class YAMLMap extends _Collection.default {
   }
 
   set(key, value) {
-    const prev = findPair(this.items, key);
-    if (prev) prev.value = value;else this.items.push(new _Pair.default(key, value));
+    this.add(new _Pair.default(key, value), true);
   }
   /**
    * @param {*} arg ignored

package/dist/schema/Merge.js

@@ -46,10 +46,9 @@ class Merge extends _Pair.default {
 
 
   addToJSMap(ctx, map) {
-    for (const _ref of this.value.items) {
-      const {
-        source
-      } = _ref;
+    for (const {
+      source
+    } of this.value.items) {
       if (!(source instanceof _Map.default)) throw new Error('Merge sources must be maps');
       const srcMap = source.toJSON(null, ctx, Map);
 
@@ -59,7 +58,7 @@ class Merge extends _Pair.default {
         } else if (map instanceof Set) {
           map.add(key);
         } else {
-          if (!map.hasOwnProperty(key)) map[key] = value;
+          if (!Object.prototype.hasOwnProperty.call(map, key)) map[key] = value;
         }
       }
     }