Changes from PR-220, ISSUE-200.

Author: danielfcollier

lib/bundle.js

@@ -95,7 +95,7 @@ function crawl (parent, key, path, pathFromRoot, indirections, inventory, $refs,
  */
 function inventory$Ref ($refParent, $refKey, path, pathFromRoot, indirections, inventory, $refs, options) {
   let $ref = $refKey === null ? $refParent : $refParent[$refKey];
-  let $refPath = url.resolve(path, $ref.$ref);
+  let $refPath = url.resolve(pathFromRoot, $ref.$ref);
   let pointer = $refs._resolve($refPath, pathFromRoot, options);
   if (pointer === null) {
     return;

lib/resolve-external.js

@@ -44,34 +44,34 @@ function resolveExternal (parser, options) {
  * @param {string} path - The full path of `obj`, possibly with a JSON Pointer in the hash
  * @param {$Refs} $refs
  * @param {$RefParserOptions} options
- * @param {Set} seen - Internal.
+ * @param {boolean} external - Whether `obj` was found in an external document.
  *
  * @returns {Promise[]}
  * Returns an array of promises. There will be one promise for each JSON reference in `obj`.
  * If `obj` does not contain any JSON references, then the array will be empty.
  * If any of the JSON references point to files that contain additional JSON references,
  * then the corresponding promise will internally reference an array of promises.
  */
-function crawl (obj, path, $refs, options, seen) {
+function crawl (obj, path, $refs, options, seen, external) {
   seen = seen || new Set();
   let promises = [];
 
-  if (obj && typeof obj === "object" && !ArrayBuffer.isView(obj) && !seen.has(obj)) {
-    seen.add(obj); // Track previously seen objects to avoid infinite recursion
+  if (obj && typeof obj === "object" && !ArrayBuffer.isView(obj)) {
     if ($Ref.isExternal$Ref(obj)) {
       promises.push(resolve$Ref(obj, path, $refs, options));
     }
     else {
+      if (external && $Ref.is$Ref(obj)) {
+        /* Correct the reference in the external document so we can resolve it */
+        const withoutHash = url.stripHash(path);
+        obj.$ref = withoutHash + obj.$ref;
+      }
+
       for (let key of Object.keys(obj)) {
         let keyPath = Pointer.join(path, key);
         let value = obj[key];
 
-        if ($Ref.isExternal$Ref(value)) {
-          promises.push(resolve$Ref(value, keyPath, $refs, options));
-        }
-        else {
-          promises = promises.concat(crawl(value, keyPath, $refs, options, seen));
-        }
+        promises = promises.concat(crawl(value, keyPath, $refs, options, seen, external));
       }
     }
   }
@@ -97,6 +97,12 @@ async function resolve$Ref ($ref, path, $refs, options) {
   let resolvedPath = url.resolve(path, $ref.$ref);
   let withoutHash = url.stripHash(resolvedPath);
 
+  /* Correct the $ref to use a path relative to the root, so that $Refs._resolve can resolve it,
+     otherwise transitive relative external references will be incorrect if the second external
+     relative ref doesn't work relative to the root document.
+   */
+  $ref.$ref = url.relative($refs._root$Ref.path, resolvedPath);
+
   // Do we already have this $ref?
   $ref = $refs._$refs[withoutHash];
   if ($ref) {
@@ -110,7 +116,7 @@ async function resolve$Ref ($ref, path, $refs, options) {
 
     // Crawl the parsed value
     // console.log('Resolving $ref pointers in %s', withoutHash);
-    let promises = crawl(result, withoutHash + "#", $refs, options);
+    let promises = crawl(result, withoutHash + "#", $refs, options, null, true);
 
     return Promise.all(promises);
   }

lib/util/url.js

@@ -1,7 +1,6 @@
 "use strict";
 
 const nodePath = require("path");
-const projectDir = nodePath.resolve(__dirname, "..", "..");
 
 let isWindows = /^win/.test(globalThis.process?.platform),
     forwardSlashPattern = /\//g,
@@ -193,14 +192,7 @@ exports.fromFileSystemPath = function fromFileSystemPath (path) {
   // Step 1: On Windows, replace backslashes with forward slashes,
   // rather than encoding them as "%5C"
   if (isWindows) {
-    const hasProjectDir = path.toUpperCase().includes(projectDir.replace(/\\/g, "\\").toUpperCase());
-    const hasProjectUri = path.toUpperCase().includes(projectDir.replace(/\\/g, "/").toUpperCase());
-    if (hasProjectDir || hasProjectUri) {
-      path = path.replace(/\\/g, "/");
-    }
-    else {
-      path = `${projectDir}/${path}`.replace(/\\/g, "/");
-    }
+    path = path.replace(/\\/g, "/");
   }
 
   // Step 2: `encodeURI` will take care of MOST characters
@@ -293,3 +285,22 @@ exports.safePointerToPath = function safePointerToPath (pointer) {
         .replace(jsonPointerTilde, "~");
     });
 };
+
+/**
+ * Like path.relative(from, to) but for URLs. It will return a relative
+ * URL if it can, otherwise an absolute URL is returned.
+ * @param {string} from
+ * @param {string} to
+ * @returns {string}
+ */
+exports.relative = function relative (from, to) {
+  if (!exports.isFileSystemPath(from) || !exports.isFileSystemPath(to)) {
+    return exports.resolve(from, to);
+  }
+
+  const fromDir = nodePath.dirname(exports.stripHash(from));
+  const toPath = exports.stripHash(to);
+
+  const result = nodePath.relative(fromDir, toPath);
+  return result + exports.getHash(to);
+};