apeman-commons-invocating/lib/invocation_loader.js

/**
 * Loader for `$invoke`.
 * Using `findout` package to findout modules.
 * @memberof module:apeman-commons-invocating/lib
 * @inner
 * @constructor InvocationLoader
 * @param {object} config - Loader configuration.
 * @see https://github.com/okunishinishi/node-findout
 */

"use strict";

var findout = require('findout'),
    extend = require('extend');

/** @lends InvocationLoader */
function InvocationLoader() {
    var s = this;
    s.init.apply(s, arguments);
}

InvocationLoader.prototype = {
    /** @construct InvocationLoader */
    init: function (config) {
        var s = this;
        extend(s, config);
    },
    /**
     * Base directory path.
     * @type {string}
     */
    basedir: process.cwd(),
    /**
     * Load a module.
     * Works like `require()`, but has a lot more locations to search.
     * @param {string} name - Name to module.
     * @param {function} callback - Callback when done.
     */
    load: function (name, callback) {
        var s = this;
        var module = s.resolve(name);
        if (module) {
            callback(null, require(module));
        } else {
            callback(new Error('Module not found: ' + name));
        }
    },
    /**
     * Resolve a module.
     * Works like `require.resolve()`, but has a lot more locations to search.
     * @param {string} name - Name to module.
     * @returns {*}
     */
    resolve: function (name) {
        var s = this;
        var dirnames = [s.basedir, null];
        for (var i = 0, len = dirnames.length; i < len; i++) {
            try {
                var resolved = findout.resolve(name, {
                    cwd: dirnames[i]
                });
                if (resolved) {
                    return resolved;
                }
            } catch (e) {
                // Do nothing.
            }
        }
        return null;
    }
};

/**
 * Define a module loader.
 * @param {object} properties - Prototype properties.
 * @returns {function} - Module loader constructor.
 */
InvocationLoader.define = function (properties) {
    function Defined() {

    }

    Defined.prototype = new InvocationLoader(properties);

    return Defined;
};

module.exports = InvocationLoader;