Merge pull request #2 from bendemboski/fix-index

Fix index require path :(

Author: pichfl

index.js

@@ -1,4 +1,5 @@
-const createHandler = require('./lib/create-handler');
+const { join } = require('path');
+const createHandler = require('./lib/handler');
 
 function requiredParam(param, errorMessage) {
   if (!param) {
@@ -16,8 +17,7 @@ function requiredParam(param, errorMessage) {
  * @param  {Object} options.protocol           electron.protocol
  * @param  {String} options.name               name of your protocol, defaults to `serve`
  * @param  {String} options.endpoint           endpoint of your protocol, defaults to `dist`
- * @param  {String} options.directoryIndexFile directory index. usally the default, `index.html`
- * @param  {String} options.indexPath          defaults to cwd + directoryIndexFile
+ * @param  {String} options.indexPath          defaults to 'index.html' in cwd
  *
  * @return {String}                            name of your protocol
  */
@@ -27,15 +27,16 @@ module.exports = function protocolServe({
   protocol,
   name = 'serve',
   endpoint = 'dist',
-  directoryIndexFile = 'index.html',
   indexPath = undefined,
 }) {
   requiredParam(cwd, 'cwd must be specified, should be a valid path');
   requiredParam(protocol, 'protocol must be specified, should be electron.protocol');
   requiredParam(app, 'app must be specified, should be electron.app');
 
+  indexPath = indexPath || join(cwd, 'index.html');
+
   app.on('ready', () => {
-    const options = { cwd, name, endpoint, directoryIndexFile, indexPath };
+    const options = { cwd, name, endpoint, indexPath };
     protocol.registerFileProtocol(name, createHandler(options), error => {
       if (error) {
         console.error('Failed to register protocol');

lib/handler.js

@@ -1,51 +1,46 @@
 const { join } = require('path');
 const fs = require('fs');
-const url = require('url');
+const { parse: urlParse } = require('url');
 
 module.exports = function createHandler({
   cwd,
   name,
   endpoint,
-  directoryIndexFile,
   indexPath,
 }) {
-  indexPath = indexPath || join(cwd, directoryIndexFile);
   const cache = {};
 
-  return (request, callback) => {
+  return ({ url }, callback) => {
     let {
       host,
       pathname,
-    } = url.parse(request.url);
+    } = urlParse(url);
 
     pathname = pathname || '';
 
     if (host !== endpoint) {
       callback({ error: `Unrecognized ${name}:// endpoint: '${host}'` });
-      
+
       return;
     }
 
     const pathSegments = pathname.split('/').filter(segment => segment !== '');
-
-    if (pathSegments.length === 0) {
-      pathSegments.push(directoryIndexFile);
-    }
-
     const filepath = join(cwd, ...pathSegments);
 
     // Basic request caching
     if (!cache[url]) {
       try {
         fs.accessSync(filepath);
 
-        cache[url] = filepath;
+        if (fs.statSync(filepath).isFile()) {
+          cache[url] = filepath;
+        }
       } catch (err) {
         //
       }
     }
 
-    // redirect unmet requests to directoryIndexFile
+    // redirect unmet requests to indexPath
     callback({ path: cache[url] || indexPath });
   };
 };

package.json

@@ -18,5 +18,7 @@
     "mocha": "^3.2.0",
     "sinon": "^1.17.7"
   },
-  "dependencies": {}
+  "dependencies": {
+    "mock-require": "^2.0.1"
+  }
 }

tests/unit/handler-test.js

@@ -3,20 +3,26 @@ const sinon = require('sinon');
 const Promise = require('bluebird');
 const fs = require('fs');
 const { join, resolve } = require('path');
-const createHandler = require('../../lib/handler');
+const subject = require('../../lib/handler');
 
 describe('handler', () => {
   let sandbox;
   let mockFiles;
+  let mockDirs;
 
   before(() => {
     sandbox = sinon.sandbox.create();
     // Stub accessSync to act like only files in mockFiles exist
     sandbox.stub(fs, 'accessSync', path => {
-      if (mockFiles.indexOf(path) === -1) {
+      if (mockFiles.indexOf(path) === -1 && mockDirs.indexOf(path) === -1) {
         throw new Error('Doesn\'t exist');
       }
     });
+    sandbox.stub(fs, 'statSync', path => ({
+      isFile() {
+        return mockFiles.indexOf(path) !== -1;
+      },
+    }));
   });
 
   after(() => {
@@ -25,19 +31,22 @@ describe('handler', () => {
 
   beforeEach(() => {
     mockFiles = [];
+    mockDirs = [];
   });
 
-  // Create a handler with the specified options and call it with the given URL
-  function handlerExec(url, options = {}) {
-    return new Promise((resolve, reject) => {
-      let handler = createHandler(Object.assign({
-        cwd: '.',
-        name: 'serve',
-        endpoint: 'dist',
-        directoryIndexFile: 'index.html',
-        indexPath: undefined,
-      }, options));
+  // Create a handler with the specified options
+  function createHandler(options) {
+    return subject(Object.assign({
+      cwd: '.',
+      name: 'serve',
+      endpoint: 'dist',
+      indexPath: join('.', 'index.html'),
+    }, options));
+  }
 
+  // Call the handler with the given URL
+  function callHandler(handler, url) {
+    return new Promise((resolve, reject) => {
       handler({ url }, ({ path, error }) => {
         if (path !== undefined) {
           resolve(path);
@@ -48,32 +57,47 @@ describe('handler', () => {
     });
   }
 
+  // Create a handler with the specified options and call it with the given URL
+  function handlerExec(url, options = {}) {
+    return callHandler(createHandler(options), url);
+  }
+
   it('works', () => {
+    mockDirs.push('.');
     mockFiles.push('script.js');
     return handlerExec('serve://dist/script.js').then(path => {
       assert.equal(path, 'script.js');
     });
   });
 
-  it('serves directoryIndexFile from the root', () => {
-    mockFiles.push('foo.html');
-    return handlerExec('serve://dist', {
-      directoryIndexFile: 'foo.html',
+  it('works with multiple requests', () => {
+    mockDirs.push('.');
+    mockFiles.push('script1.js');
+    mockFiles.push('script2.js');
+
+    let handler = createHandler();
+    return callHandler(handler, 'serve://dist/script1.js').then(path => {
+      assert.equal(path, 'script1.js');
+
+      return callHandler(handler, 'serve://dist/script2.js');
     }).then(path => {
-      assert.equal(path, 'foo.html');
+      assert.equal(path, 'script2.js');
     });
   });
 
-  it('serves directoryIndexFile for missing files', () => {
+  it('serves indexPath from the root', () => {
+    mockDirs.push('.');
     mockFiles.push('foo.html');
-    return handlerExec('serve://dist/missing.js', {
-      directoryIndexFile: 'foo.html',
+    return handlerExec('serve://dist', {
+      cwd: '.',
+      indexPath: join('.', 'foo.html'),
     }).then(path => {
-      assert.equal(path, 'foo.html');
+      assert.equal(path, join('.', 'foo.html'));
     });
   });
 
   it('respects relative cwd', () => {
+    mockDirs.push(join('foo', 'bar'));
     mockFiles.push(join('foo', 'bar', 'script.js'));
     return handlerExec('serve://dist/script.js', {
       cwd: join('foo', 'bar'),
@@ -83,6 +107,7 @@ describe('handler', () => {
   });
 
   it('respects absolute cwd', () => {
+    mockDirs.push(resolve('foo', 'bar'));
     mockFiles.push(resolve('foo', 'bar', 'script.js'));
     return handlerExec('serve://dist/script.js', {
       cwd: resolve('foo', 'bar'),
@@ -92,6 +117,7 @@ describe('handler', () => {
   });
 
   it('respects endpoint', () => {
+    mockDirs.push('.');
     mockFiles.push('script.js');
     return handlerExec('serve://custom/script.js', {
       endpoint: 'custom',
@@ -101,22 +127,26 @@ describe('handler', () => {
   });
 
   it('respects indexPath for missing files', () => {
+    mockDirs.push('bar');
     mockFiles.push(join('foo', 'bar.html'));
     return handlerExec('serve://dist/missing.js', {
+      cwd: 'bar',
       indexPath: join('foo', 'bar.html'),
     }).then(path => {
       assert.equal(path, join('foo', 'bar.html'));
     });
   });
 
   it('ignores hashes', () => {
+    mockDirs.push('.');
     mockFiles.push('script.js');
     return handlerExec('serve://dist/script.js#hash').then(path => {
       assert.equal(path, 'script.js');
     });
   });
 
   it('ignores query params', () => {
+    mockDirs.push('.');
     mockFiles.push('script.js');
     return handlerExec('serve://dist/script.js?query=param').then(path => {
       assert.equal(path, 'script.js');

tests/unit/index-test.js

@@ -0,0 +1,104 @@
+const { assert } = require('chai');
+const mock = require('mock-require');
+const { join } = require('path');
+
+describe('index', () => {
+  let app;
+  let protocol;
+  let onAppReady;
+  let protocolName;
+  let handlerOptions;
+
+  function register(options) {
+    require('../..')(Object.assign({
+      cwd: '.',
+      app,
+      protocol,
+    }, options));
+  }
+
+  before(() => {
+    mock('../../lib/handler', options => handlerOptions = options);
+  });
+
+  after(() => {
+    mock.stop('../../lib/handler');
+  });
+
+  beforeEach(() => {
+    app = {
+      on(evt, cb) {
+        if (evt === 'ready') {
+          onAppReady = cb;
+        }
+      },
+    };
+
+    protocol = {
+      registerFileProtocol(name/*, handler, errorHandler*/) {
+        protocolName = name;
+      },
+    };
+  });
+
+  it('works', () => {
+    register();
+    assert.ok(onAppReady);
+    onAppReady();
+
+    assert.equal(protocolName, 'serve');
+    assert.deepEqual(handlerOptions, {
+      cwd: '.',
+      name: 'serve',
+      endpoint: 'dist',
+      indexPath: join('.', 'index.html'),
+    });
+  });
+
+  it('works with a custom cwd', () => {
+    register({
+      cwd: join('foo', 'bar'),
+    });
+    assert.ok(onAppReady);
+    onAppReady();
+
+    assert.equal(protocolName, 'serve');
+    assert.deepEqual(handlerOptions, {
+      cwd: join('foo', 'bar'),
+      name: 'serve',
+      endpoint: 'dist',
+      indexPath: join('foo', 'bar', 'index.html'),
+    });
+  });
+
+  it('works with non-default arguments', () => {
+    register({
+      cwd: join('my', 'old'),
+      name: 'friend',
+      endpoint: 'so',
+      indexPath: join('we', 'meet', 'again.html'),
+    });
+    assert.ok(onAppReady);
+    onAppReady();
+
+    assert.equal(protocolName, 'friend');
+    assert.deepEqual(handlerOptions, {
+      cwd: join('my', 'old'),
+      name: 'friend',
+      endpoint: 'so',
+      indexPath: join('we', 'meet', 'again.html'),
+    });
+  });
+
+  it('required a cwd', () => {
+    assert.throws(() => register({ cwd: undefined }));
+  });
+
+  it('required an app', () => {
+    assert.throws(() => register({ app: undefined }));
+  });
+
+  it('required a protocol', () => {
+    assert.throws(() => register({ protocol: undefined }));
+  });
+});