Allow parsing errors

Author: P0lip

lib/index.js

@@ -135,13 +135,17 @@ $RefParser.prototype.parse = async function (path, schema, options, callback) {
   try {
     let result = await promise;
 
-    if (!result || typeof result !== "object" || Buffer.isBuffer(result)) {
-      throw ono.syntax(`"${me.$refs._root$Ref.path || result}" is not a valid JSON Schema`);
-    }
-    else {
+    if (result !== null && typeof result === "object" && !Buffer.isBuffer(result)) {
       me.schema = result;
       return maybe(args.callback, Promise.resolve(me.schema));
     }
+    else if (!args.options.failFast) {
+      me.schema = null; // it's already set to null at line 79, but let's set it again for the sake of readability
+      return maybe(args.callback, Promise.resolve(me.schema));
+    }
+    else {
+      throw ono.syntax(`"${me.$refs._root$Ref.path || result}" is not a valid JSON Schema`);
+    }
   }
   catch (err) {
     if (args.options.failFast || !isHandledError(err)) {

lib/parse.js

@@ -18,21 +18,21 @@ module.exports = parse;
  * The promise resolves with the parsed file contents, NOT the raw (Buffer) contents.
  */
 async function parse (path, $refs, options) {
-  try {
-    // Remove the URL fragment, if any
-    path = url.stripHash(path);
+  // Remove the URL fragment, if any
+  path = url.stripHash(path);
 
-    // Add a new $Ref for this file, even though we don't have the value yet.
-    // This ensures that we don't simultaneously read & parse the same file multiple times
-    let $ref = $refs._add(path);
+  // Add a new $Ref for this file, even though we don't have the value yet.
+  // This ensures that we don't simultaneously read & parse the same file multiple times
+  let $ref = $refs._add(path);
 
-    // This "file object" will be passed to all resolvers and parsers.
-    let file = {
-      url: path,
-      extension: url.getExtension(path),
-    };
+  // This "file object" will be passed to all resolvers and parsers.
+  let file = {
+    url: path,
+    extension: url.getExtension(path),
+  };
 
-    // Read the file and then parse the data
+  // Read the file and then parse the data
+  try {
     const resolver = await readFile(file, options, $refs);
     $ref.pathType = resolver.plugin.name;
     file.data = resolver.result;
@@ -42,8 +42,14 @@ async function parse (path, $refs, options) {
 
     return parser.result;
   }
-  catch (e) {
-    return Promise.reject(e);
+  catch (ex) {
+    if (!("error" in ex)) {
+      throw ex;
+    }
+    else {
+      $ref.value = ex.error;
+      throw ex.error;
+    }
   }
 }
 
@@ -113,7 +119,7 @@ function parseFile (file, options, $refs) {
       .then(onParsed, onError);
 
     function onParsed (parser) {
-      if (!parser.plugin.allowEmpty && isEmpty(parser.result)) {
+      if ((!options.failFast || !parser.plugin.allowEmpty) && isEmpty(parser.result)) {
         reject(ono.syntax(`Error parsing "${file.url}" as ${parser.plugin.name}. \nParsed value is empty`));
       }
       else {
@@ -122,12 +128,15 @@ function parseFile (file, options, $refs) {
     }
 
     function onError (err) {
-      if (err) {
-        err = err instanceof Error ? err : new Error(err);
-        reject(ono.syntax(err, `Error parsing ${file.url}`));
+      if (!err || !("error" in err)) {
+        reject(ono.syntax(`Unable to parse ${file.url}`));
+      }
+      else if (err.error instanceof ParserError || err.error instanceof StoplightParserError) {
+        reject(err);
       }
       else {
-        reject(ono.syntax(`Unable to parse ${file.url}`));
+        err.error = new ParserError(err.error.message, file.url);
+        reject(err);
       }
     }
   }));

lib/parsers/binary.js

@@ -41,7 +41,7 @@ module.exports = {
    * @param {string} file.url       - The full URL of the referenced file
    * @param {string} file.extension - The lowercased file extension (e.g. ".txt", ".html", etc.)
    * @param {*}      file.data      - The file contents. This will be whatever data type was returned by the resolver
-   * @returns {Promise<Buffer>}
+   * @returns {Buffer}
    */
   parse (file) {
     if (Buffer.isBuffer(file.data)) {

lib/parsers/json.js

@@ -1,5 +1,9 @@
 "use strict";
 
+const { parseWithPointers } = require("@stoplight/json");
+const { StoplightParserError } = require("../util/errors");
+
+
 module.exports = {
   /**
    * The order that this parser will run, in relation to other parsers.
@@ -21,7 +25,7 @@ module.exports = {
    * Parsers that don't match will be skipped, UNLESS none of the parsers match, in which case
    * every parser will be tried.
    *
-   * @type {RegExp|string[]|function}
+   * @type {RegExp|string|string[]|function}
    */
   canParse: ".json",
 
@@ -34,25 +38,31 @@ module.exports = {
    * @param {*}      file.data      - The file contents. This will be whatever data type was returned by the resolver
    * @returns {Promise}
    */
-  parse (file) {
-    return new Promise(((resolve, reject) => {
-      let data = file.data;
-      if (Buffer.isBuffer(data)) {
-        data = data.toString();
-      }
+  async parse (file) {
+    let data = file.data;
+    if (Buffer.isBuffer(data)) {
+      data = data.toString();
+    }
 
-      if (typeof data === "string") {
-        if (data.trim().length === 0) {
-          resolve(undefined);  // This mirrors the YAML behavior
-        }
-        else {
-          resolve(JSON.parse(data));
-        }
+    if (typeof data === "string") {
+      if (data.trim().length === 0) {
+        return;
       }
       else {
-        // data is already a JavaScript value (object, array, number, null, NaN, etc.)
-        resolve(data);
+        let result = parseWithPointers(data, {
+          ignoreDuplicateKeys: false,
+        });
+
+        if (StoplightParserError.hasErrors(result.diagnostics)) {
+          throw new StoplightParserError(result.diagnostics, file.url);
+        }
+
+        return result.data;
       }
-    }));
+    }
+    else {
+      // data is already a JavaScript value (object, array, number, null, NaN, etc.)
+      return data;
+    }
   }
 };

lib/parsers/text.js

@@ -1,5 +1,7 @@
 "use strict";
 
+const { ParserError } = require("../util/errors");
+
 let TEXT_REGEXP = /\.(txt|htm|html|md|xml|js|min|map|css|scss|less|svg)$/i;
 
 module.exports = {
@@ -48,7 +50,7 @@ module.exports = {
    * @param {string} file.url       - The full URL of the referenced file
    * @param {string} file.extension - The lowercased file extension (e.g. ".txt", ".html", etc.)
    * @param {*}      file.data      - The file contents. This will be whatever data type was returned by the resolver
-   * @returns {Promise<string>}
+   * @returns {string}
    */
   parse (file) {
     if (typeof file.data === "string") {
@@ -58,7 +60,7 @@ module.exports = {
       return file.data.toString(this.encoding);
     }
     else {
-      throw new Error("data is not text");
+      throw new ParserError("data is not text", file.url);
     }
   }
 };

lib/parsers/yaml.js

@@ -1,6 +1,7 @@
 "use strict";
 
 const YAML = require("../util/yaml");
+const { StoplightParserError } = require("../util/errors");
 
 module.exports = {
   /**
@@ -36,20 +37,23 @@ module.exports = {
    * @param {*}      file.data      - The file contents. This will be whatever data type was returned by the resolver
    * @returns {Promise}
    */
-  parse (file) {
-    return new Promise(((resolve, reject) => {
-      let data = file.data;
-      if (Buffer.isBuffer(data)) {
-        data = data.toString();
-      }
+  async parse (file) {
+    let data = file.data;
+    if (Buffer.isBuffer(data)) {
+      data = data.toString();
+    }
 
-      if (typeof data === "string") {
-        resolve(YAML.parse(data));
-      }
-      else {
-        // data is already a JavaScript value (object, array, number, null, NaN, etc.)
-        resolve(data);
+    if (typeof data === "string") {
+      let result = YAML.parse(data);
+      if (StoplightParserError.hasErrors(result.diagnostics)) {
+        throw new StoplightParserError(result.diagnostics, file.url);
       }
-    }));
+
+      return result.data;
+    }
+    else {
+      // data is already a JavaScript value (object, array, number, null, NaN, etc.)
+      return data;
+    }
   }
 };

lib/util/errors.js

@@ -18,25 +18,54 @@ const GenericErrorGroup = exports.GenericErrorGroup = class GenericErrorGroup ex
   constructor (errors, source) {
     super();
 
-    this.source = source;
+    this._path = undefined;
+    this._source = source;
     this.errors = errors;
   }
+
+  get source () {
+    return this._source;
+  }
+
+  set source (source) {
+    this._source = source;
+
+    for (let error of this.errors) {
+      error.source = source;
+    }
+  }
+
+  get path () {
+    return this.path;
+  }
+
+  set path (path) {
+    this._path = path;
+
+    for (let error of this.errors) {
+      error.path = path;
+    }
+  }
 };
 
 exports.StoplightParserError = class StoplightParserError extends GenericErrorGroup {
-  constructor (errors, source) {
-    super(errors.filter(error => error.severity === 0).map(error => {
-      const parsingError = new ParserError(error.message, source);
-      parsingError.message = error.message;
-      if (error.path) {
-        parsingError.path = error.path;
-      }
-
-      return parsingError;
+  constructor (diagnostics, source) {
+    super(diagnostics.filter(StoplightParserError.pickError).map(error => {
+      let parserError = new ParserError(error.message, source);
+      parserError.message = error.message;
+      return parserError;
     }));
 
     this.message = `Error parsing ${source}`;
   }
+
+  static pickError (diagnostic) {
+    return diagnostic.severity === 0;
+  }
+
+  static hasErrors (diagnostics) {
+    return diagnostics.some(StoplightParserError.pickError);
+  }
 };
 
 const ParserError = exports.ParserError = class ParserError extends GenericError {

lib/util/plugins.js

@@ -108,9 +108,12 @@ exports.run = function (plugins, method, file, $refs) {
       });
     }
 
-    function onError (err) {
+    function onError (error) {
       // console.log('    %s', err.message || err);
-      lastError = err;
+      lastError = {
+        plugin,
+        error,
+      };
       runNextPlugin();
     }
   }));

lib/util/yaml.js

@@ -1,8 +1,7 @@
 /* eslint lines-around-comment: [2, {beforeBlockComment: false}] */
 "use strict";
 
-const yaml = require("js-yaml");
-const { ono } = require("ono");
+const { parseWithPointers, safeStringify } = require("@stoplight/yaml");
 
 /**
  * Simple YAML parsing functions, similar to {@link JSON.parse} and {@link JSON.stringify}
@@ -16,18 +15,11 @@ module.exports = {
    * @returns {*}
    */
   parse (text, reviver) {
-    try {
-      return yaml.safeLoad(text);
-    }
-    catch (e) {
-      if (e instanceof Error) {
-        throw e;
-      }
-      else {
-        // https://github.com/nodeca/js-yaml/issues/153
-        throw ono(e, e.message);
-      }
-    }
+    return parseWithPointers(text, {
+      json: true,
+      mergeKeys: true,
+      ignoreDuplicateKeys: false,
+    });
   },
 
   /**
@@ -39,18 +31,7 @@ module.exports = {
    * @returns {string}
    */
   stringify (value, replacer, space) {
-    try {
-      let indent = (typeof space === "string" ? space.length : space) || 2;
-      return yaml.safeDump(value, { indent });
-    }
-    catch (e) {
-      if (e instanceof Error) {
-        throw e;
-      }
-      else {
-        // https://github.com/nodeca/js-yaml/issues/153
-        throw ono(e, e.message);
-      }
-    }
+    let indent = (typeof space === "string" ? space.length : space) || 2;
+    return safeStringify(value, { indent });
   }
 };