Update import hook to provide path to callback

This lets us move all path resolution into the import hook, making it
independent of Node's `fs` module.

lib/files.js

@@ -13,15 +13,18 @@ let fs = require('fs'),
 /** Default (asynchronous) file loading function for assembling IDLs. */
 function createImportHook() {
   let imports = {};
-  return function ({path: fpath}, cb) {
-    fpath = path.resolve(fpath);
+  return function ({path: fpath, parentPath}, cb) {
+    fpath = path.resolve(path.dirname(parentPath), fpath);
     if (imports[fpath]) {
       // Already imported, return nothing to avoid duplicating attributes.
       process.nextTick(cb);
       return;
     }
     imports[fpath] = true;
-    fs.readFile(fpath, {encoding: 'utf8'}, cb);
+    fs.readFile(fpath, {encoding: 'utf8'}, (err, data) => {
+      if (err) return cb(err);
+      return cb(null, {contents: data, path: fpath});
+    });
   };
 }
 
@@ -35,13 +38,16 @@ function createImportHook() {
  */
 function createSyncImportHook() {
   let imports = {};
-  return function ({path: fpath}, cb) {
-    fpath = path.resolve(fpath);
+  return function ({path: fpath, parentPath}, cb) {
+    fpath = path.resolve(path.dirname(parentPath), fpath);
     if (imports[fpath]) {
       cb();
     } else {
       imports[fpath] = true;
-      cb(null, fs.readFileSync(fpath, {encoding: 'utf8'}));
+      cb(null, {
+        contents: fs.readFileSync(fpath, {encoding: 'utf8'}),
+        path: fpath
+      });
     }
   };
 }

lib/specs.js

@@ -31,7 +31,7 @@ function assembleProtocol(fpath, opts, cb) {
     opts.importHook = files.createImportHook();
   }
 
-  importFile(fpath, (err, protocol) => {
+  importFile(fpath, '', (err, protocol) => {
     if (err) {
       cb(err);
       return;
@@ -57,19 +57,20 @@ function assembleProtocol(fpath, opts, cb) {
     cb(null, protocol);
   });
 
-  function importFile(fpath, cb) {
-    opts.importHook({path: fpath, kind: 'idl'}, (err, str) => {
+  function importFile(fpath, parentPath, cb) {
+    opts.importHook({path: fpath, parentPath, kind: 'idl'}, (err, params) => {
       if (err) {
         cb(err);
         return;
       }
-      if (str === undefined) {
+      if (!params) {
         // This signals an already imported file by the default import hooks.
         // Implementors who wish to disallow duplicate imports should provide a
         // custom hook which throws an error when a duplicate is detected.
         cb();
         return;
       }
+      const {contents: str, path: fpath} = params;
       let obj;
       try {
         let reader = new Reader(str, opts);
@@ -79,11 +80,11 @@ function assembleProtocol(fpath, opts, cb) {
         cb(err);
         return;
       }
-      fetchImports(obj.protocol, obj.imports, path.dirname(fpath), cb);
+      fetchImports(obj.protocol, obj.imports, fpath, cb);
     });
   }
 
-  function fetchImports(protocol, imports, dpath, cb) {
+  function fetchImports(protocol, imports, fpath, cb) {
     let importedProtocols = [];
     next();
 
@@ -104,9 +105,8 @@ function assembleProtocol(fpath, opts, cb) {
         cb(null, protocol);
         return;
       }
-      let importPath = path.join(dpath, info.name);
       if (info.kind === 'idl') {
-        importFile(importPath, (err, imported) => {
+        importFile(info.name, fpath, (err, imported) => {
           if (err) {
             cb(err);
             return;
@@ -118,24 +118,28 @@ function assembleProtocol(fpath, opts, cb) {
         });
       } else {
         // We are importing a protocol or schema file.
-        opts.importHook({path: importPath, kind: info.kind}, (err, str) => {
+        opts.importHook({
+          path: info.name,
+          parentPath: fpath,
+          kind: info.kind
+        }, (err, params) => {
           if (err) {
             cb(err);
             return;
           }
           switch (info.kind) {
             case 'protocol':
             case 'schema': {
-              if (str === undefined) {
+              if (!params) {
                 // Skip duplicate import (see related comment above).
                 next();
                 return;
               }
               let obj;
               try {
-                obj = JSON.parse(str);
+                obj = JSON.parse(params.contents);
               } catch (err) {
-                err.path = importPath;
+                err.path = params.path;
                 cb(err);
                 return;
               }

test/test_specs.js

@@ -451,7 +451,10 @@ suite('specs', () => {
     test('import hook error', (done) => {
       let hook = function ({path: fpath}, cb) {
         if (path.basename(fpath) === 'A.avdl') {
-          cb(null, 'import schema "hi"; protocol A {}');
+          cb(null, {
+            contents: 'import schema "hi"; protocol A {}',
+            path: fpath
+          });
         } else {
           cb(new Error('foo'));
         }
@@ -465,7 +468,10 @@ suite('specs', () => {
     test('import hook idl error', (done) => {
       let hook = function ({path: fpath}, cb) {
         if (path.basename(fpath) === 'A.avdl') {
-          cb(null, 'import idl "hi"; protocol A {}');
+          cb(null, {
+            contents: 'import idl "hi"; protocol A {}',
+            path: fpath
+          });
         } else {
           cb(new Error('bar'));
         }
@@ -624,11 +630,14 @@ suite('specs', () => {
 
     // Import hook from strings.
     function createImportHook(imports) {
-      return function ({path: fpath}, cb) {
-        let key = path.normalize(fpath);
+      return function ({path: fpath, parentPath}, cb) {
+        let key = path.normalize(path.join(path.dirname(parentPath), fpath));
         let str = imports[key];
         delete imports[key];
-        process.nextTick(() => { cb(null, str); });
+        process.nextTick(() => { cb(null, typeof str === 'string' ? {
+          contents: str,
+          path: key
+        } : undefined); });
       };
     }
 

types/index.d.ts

@@ -133,6 +133,10 @@ interface ImportHookParams {
   type: 'idl' | 'protocol' | 'schema';
 }
 
+type ImportHookCallback = (err: any, params?: {contents: string, path: string}) => void;
+
+type ImportHook = (params: ImportHookParams, cb: ImportHookCallback) => void;
+
 interface AssembleOptions {
   importHook: (params: ImportHookParams, callback: Callback<object>) => void;
 }