fix: map paths in results back to filesystem (#231)

Fixes #166.  This updates the returned paths in the results to map to the filesystem if a local path was given.

Author: JustinBeckwith

src/index.ts

@@ -1,13 +1,14 @@
 import {EventEmitter} from 'events';
 import {URL} from 'url';
 import * as http from 'http';
+import * as path from 'path';
 
 import {request, GaxiosResponse} from 'gaxios';
 
 import {Queue} from './queue';
 import {getLinks} from './links';
 import {startWebServer} from './server';
-import {CheckOptions, processOptions} from './options';
+import {CheckOptions, InternalCheckOptions, processOptions} from './options';
 
 export {CheckOptions};
 
@@ -92,6 +93,7 @@ export class LinkChecker extends EventEmitter {
         }
         options.path[i] = `http://localhost:${port}/${options.path[i]}`;
       }
+      options.staticHttpServerHost = `http://localhost:${port}/`;
     }
 
     if (process.env.LINKINATOR_DEBUG) {
@@ -146,10 +148,10 @@ export class LinkChecker extends EventEmitter {
     const proto = opts.url.protocol;
     if (proto !== 'http:' && proto !== 'https:') {
       const r: LinkResult = {
-        url: opts.url.href,
+        url: mapUrl(opts.url.href, opts.checkOptions),
         status: 0,
         state: LinkState.SKIPPED,
-        parent: opts.parent,
+        parent: mapUrl(opts.parent, opts.checkOptions),
       };
       opts.results.push(r);
       this.emit('link', r);
@@ -162,7 +164,7 @@ export class LinkChecker extends EventEmitter {
       (await opts.checkOptions.linksToSkip(opts.url.href))
     ) {
       const result: LinkResult = {
-        url: opts.url.href,
+        url: mapUrl(opts.url.href, opts.checkOptions),
         state: LinkState.SKIPPED,
         parent: opts.parent,
       };
@@ -181,9 +183,9 @@ export class LinkChecker extends EventEmitter {
 
       if (skips.length > 0) {
         const result: LinkResult = {
-          url: opts.url.href,
+          url: mapUrl(opts.url.href, opts.checkOptions),
           state: LinkState.SKIPPED,
-          parent: opts.parent,
+          parent: mapUrl(opts.parent, opts.checkOptions),
         };
         opts.results.push(result);
         this.emit('link', result);
@@ -285,10 +287,10 @@ export class LinkChecker extends EventEmitter {
     }
 
     const result: LinkResult = {
-      url: opts.url.href,
+      url: mapUrl(opts.url.href, opts.checkOptions),
       status,
       state,
-      parent: opts.parent,
+      parent: mapUrl(opts.parent, opts.checkOptions),
       failureDetails: failures,
     };
     opts.results.push(result);
@@ -303,10 +305,10 @@ export class LinkChecker extends EventEmitter {
         // creating a new URL obj, treat it as a broken link.
         if (!result.url) {
           const r = {
-            url: result.link,
+            url: mapUrl(result.link, opts.checkOptions),
             status: 0,
             state: LinkState.BROKEN,
-            parent: opts.url.href,
+            parent: mapUrl(opts.url.href, opts.checkOptions),
           };
           opts.results.push(r);
           this.emit('link', r);
@@ -427,3 +429,35 @@ function isHtml(response: GaxiosResponse): boolean {
     !!contentType.match(/application\/xhtml\+xml/g)
   );
 }
+
+/**
+ * When running a local static web server for the user, translate paths from
+ * the Url generated back to something closer to a local filesystem path.
+ * @example
+ *    http://localhost:0000/test/route/README.md => test/route/README.md
+ * @param url The url that was checked
+ * @param options Original CheckOptions passed into the client
+ */
+function mapUrl(url?: string, options?: InternalCheckOptions): string {
+  if (!url) {
+    return url!;
+  }
+  let newUrl = url;
+
+  // trim the starting http://localhost:0000 if we stood up a local static server
+  if (
+    options?.staticHttpServerHost?.length &&
+    url?.startsWith(options.staticHttpServerHost)
+  ) {
+    newUrl = url.slice(options.staticHttpServerHost.length);
+
+    // add the full filesystem path back if we trimmed it
+    if (options?.syntheticServerRoot?.length) {
+      newUrl = path.join(options.syntheticServerRoot, newUrl);
+    }
+    if (newUrl === '') {
+      newUrl = `.${path.sep}`;
+    }
+  }
+  return newUrl!;
+}

src/options.ts

@@ -19,14 +19,19 @@ export interface CheckOptions {
   retry?: boolean;
 }
 
+export interface InternalCheckOptions extends CheckOptions {
+  syntheticServerRoot?: string;
+  staticHttpServerHost?: string;
+}
+
 /**
  * Validate the provided flags all work with each other.
  * @param options CheckOptions passed in from the CLI (or API)
  */
 export async function processOptions(
   opts: CheckOptions
-): Promise<CheckOptions> {
-  const options = Object.assign({}, opts);
+): Promise<InternalCheckOptions> {
+  const options = Object.assign({}, opts) as InternalCheckOptions;
 
   // ensure at least one path is provided
   if (options.path.length === 0) {
@@ -131,6 +136,7 @@ export async function processOptions(
         options.serverRoot = options.path[0];
         options.path = '/';
       }
+      options.syntheticServerRoot = options.serverRoot;
     }
   }
   return options;

test/test.cli.ts

@@ -75,7 +75,7 @@ describe('cli', function () {
       'csv',
       'test/fixtures/markdown/README.md',
     ]);
-    assert.match(res.stdout, /\/README.md,200,OK,/);
+    assert.match(res.stdout, /README.md,200,OK,/);
   });
 
   it('should provide JSON if asked nicely', async () => {

test/test.index.ts

@@ -395,6 +395,9 @@ describe('linkinator', () => {
     });
     assert.ok(results.passed);
     assert.strictEqual(results.links.length, 6);
+    const licenseLink = results.links.find(x => x.url.endsWith('LICENSE.md'));
+    assert.ok(licenseLink);
+    assert.strictEqual(licenseLink.url, 'test/fixtures/markdown/LICENSE.md');
   });
 
   it('should autoscan markdown if specifically in path', async () => {
@@ -497,4 +500,27 @@ describe('linkinator', () => {
     assert.ok(!results.passed);
     assert.strictEqual(results.links.length, 3);
   });
+
+  it('should provide a relative path in the results', async () => {
+    const scope = nock('http://fake.local').head('/').reply(200);
+    const results = await check({path: 'test/fixtures/basic'});
+    assert.strictEqual(results.links.length, 2);
+    const [rootLink, fakeLink] = results.links;
+    assert.strictEqual(rootLink.url, path.join('test', 'fixtures', 'basic'));
+    assert.strictEqual(fakeLink.url, 'http://fake.local/');
+    scope.done();
+  });
+
+  it('should provide a server root relative path in the results', async () => {
+    const scope = nock('http://fake.local').head('/').reply(200);
+    const results = await check({
+      path: '.',
+      serverRoot: 'test/fixtures/basic',
+    });
+    assert.strictEqual(results.links.length, 2);
+    const [rootLink, fakeLink] = results.links;
+    assert.strictEqual(rootLink.url, `.${path.sep}`);
+    assert.strictEqual(fakeLink.url, 'http://fake.local/');
+    scope.done();
+  });
 });