nucleo-amd/nucleo-amd.nodejs.js

var helpers = {};

var nucleoAMD = function(options){

    this.registry = {};
    this.Mocked = options && options.isMocked ? null : nucleoAMD.create({isMocked:true});
    this.seen = {};
    this._config = {};
    this.UID = helpers.get_uid({append: this.Mocked ? 'AMD':'MOCK'});
    this.defaultConfig = {
        relativePaths: true,
        defaultFile: 'main',
        paths: null
    };

    this.config({});

};

nucleoAMD.create = function(options){
    return new nucleoAMD(options);
};

var extend = function(moduleName, definition){
    nucleoAMD.prototype[moduleName] = definition;
};

var _extend = function(moduleName, definition){
    helpers[moduleName] = definition;
};
extend("config", function(data) {

    if(data === undefined){

        return helpers.cloneObject(this._config);

    } else if(helpers.isString(data)) {

        return helpers.cloneObject(this._config[data]);

    } else if(helpers.isObject(data)){

        this._config = helpers.extend(this.defaultConfig, data);

    }

});
extend("define", function(name, deps, callback) {

    var value = {};

    if (!callback) {

        value.deps = [];
        value.callback = deps;

    } else {

        value.deps = deps;
        value.callback = callback;

    }

    if(this.registry[name]){
        helpers.throwError('duplicatedModule ' + name);
    }

    this.registry[name] = value;

});
extend("has_entries", function(){

    var hasModules = false;

    for (var moduleName in this.registry) {

        hasModules = true;
        break;

    }

    return hasModules;

});
extend("list_entries", function(options){

    var names = [];
    var moduleName;
    var regex = options && options.regex ? options.regex : '';
    var shouldAddModule;

    for (moduleName in this.registry) {

        shouldAddModule = (regex && moduleName.match(regex)) || !regex;

        if(shouldAddModule){

            names.push(moduleName);

        }

    };

    return names;

});
extend("markAsUnseen", function(moduleName){
    this.seen[moduleName] = undefined;
});
extend("mock", function(name, deps, callback){

    this.Mocked.define(name, deps, callback);

});
extend("require", function(name, submodule) {

    var module = helpers.internalRequire.call(this, name, null);
    var sub_module = module.isMock ? module.mocked : module[submodule || 'default'];
    var result = helpers.cloneObject(sub_module);

    return result;

});
extend("reset", function() {

    this.registry = {};
    this.Mocked = nucleoAMD.create({isMocked:true});
    this.seen = {};
    this._config = {};
    this.UID = helpers.get_uid({append: this.Mocked ? 'AMD':'MOCK'});
    this.defaultConfig = {
        relativePaths: true,
        defaultFile: 'main',
        paths: null
    };

    this.config({});

});
_extend("cloneObject", function(source) {
    
    var name, s, empty = {}, dest = {};
    var isNotObject = !helpers.isObject(source);
    
    if(isNotObject){
        return source;
    }

    for(name in source){
        /*jshint -W089 */
        // the (!(name in empty) || empty[name] !== s) condition avoids copying properties in "source"
        // inherited from Object.prototype.  For example, if dest has a custom toString() method,
        // don't overwrite it with the toString() method that source inherited from Object.prototype
        s = source[name];
        if(!(name in dest) || (dest[name] !== s && (!(name in empty) || empty[name] !== s))){
            dest[name] = helpers.cloneObject ? helpers.cloneObject(s) : s;
        }
    }

    return dest;

});
_extend("extend", function(obj1, obj2) {

    var obj3 = {};
    var isObject = helpers.isObject;
    var cloneObject = helpers.cloneObject;
    var extend = helpers.extend;

    if (isObject(obj1)) {

        for (var attrname in obj1) {

            obj3[attrname] = cloneObject(obj1[attrname]);

        }

    }

    if (isObject(obj2)) {

        for (var attrname in obj2) {

            if (isObject(obj1) && isObject(obj1[attrname]) && isObject(obj2[attrname])) {

                obj3[attrname] = cloneObject(extend(obj1[attrname], obj2[attrname]));

            } else {

                obj3[attrname] = obj2[attrname];

            }

        }

    }

    return cloneObject(obj3);

});
_extend("getIgnoredPatterns", function() {

    var prefixExitsOnConfig = this._config && this._config.paths && typeof this._config.paths.prefix === 'string';
    var hasIgnore = prefixExitsOnConfig && this._config.paths.ignore;
    var ignoreIsString = hasIgnore && typeof this._config.paths.ignore === 'string';
    var ignorePatterns = [];

    if (hasIgnore) {

        if (ignoreIsString) {

            ignorePatterns.push(this._config.paths.ignore);

        } else if (helpers.isArray(this._config.paths.ignore)) {

            ignorePatterns = this._config.paths.ignore;

        }

    }

    return ignorePatterns;

});
_extend("getNameWithPrefix", function(path) {

    var prefixExitsOnConfig = this._config && this._config.paths && typeof this._config.paths.prefix === 'string';
    var prefix = prefixExitsOnConfig ? this._config.paths.prefix : '';
    var ignorePatterns = helpers.getIgnoredPatterns.call(this);
    var shouldIgnore = helpers.shouldIgnorePrefix(path, ignorePatterns);
    var shouldAddPrefix = prefixExitsOnConfig && !shouldIgnore;

    prefix = prefix.length && prefix.slice(-1) !== '/' ? prefix + '/' : prefix;

    var name = shouldAddPrefix ? prefix + path : path;

    return name;

});
_extend("get_dependencies_values", function(exports, name) {

    var mod = this.registry[name];
    var deps = mod.deps;
    var callback = mod.callback;
    var reified = [];
    var length = deps.length;
    var dep_name, dep;

    for (var i = 0; i < length; i++) {

        if (deps[i] === 'exports') {

            reified.push(exports);

        } else {

            dep_name = helpers.resolve.call(this, deps[i], name);
            dep = helpers.internalRequire.call(this, dep_name, name);

            reified.push(dep);

        }

    }

    return reified;

});
_extend("get_mocked_module", function(name) {

    var hasMocks = this.Mocked && this.Mocked.has_entries();
    var mocked_module;

    if (hasMocks) {

        try {

            mocked_module = this.Mocked.require(name);

        } catch (err) {}

    }

    if (mocked_module !== undefined) {

        // TODO make tests for non-default exported in the module. don't assume that module is 'default' 
        var result = {
            'default': mocked_module
        };

        return result;

    }

    return undefined;

});
_extend("get_uid", function(options){

	// for the moment, it's purpose is not to be a real UID generator
	var now = new Date();
	var appended = options && options.append ? options.append : '';
	var uid = helpers.random() + '.' + 
			  now.getMinutes() + '.' + 
			  now.getSeconds() + '.' + 
			  now.getMilliseconds() + '/' + 
			  appended;

	return uid;

});
_extend("handle_default_filename", function(name, referrerName){

    if (!this.registry[name]) {

        var hasEndingSlash = name.slice(-1) === '/';
        var slash = hasEndingSlash ? '' : '/';
        var indexFileName = name + slash + this._config.defaultFile;

        if (this.registry[indexFileName]) {

            name = indexFileName;

        } else if (referrerName) {

            helpers.throwError('Could not find module ' + name + ' required by: ' + referrerName);

        } else {

            helpers.throwError('Could not find module ' + name);

        }

    }

    return name;

});
_extend("internalRequire", function(name, referrerName) {

    name = helpers.getNameWithPrefix.call(this, name);

    var mocked_module = helpers.get_mocked_module.call(this, name);

    if(mocked_module){

        return mocked_module;

    }

    var exports = this.seen[name];
    var oldName = name;

    if (exports !== undefined) {
        return exports;
    }

    name = helpers.handle_default_filename.call(this, name, referrerName);

    exports = this.seen[name] = this.seen[oldName] = {};

    var reified = helpers.get_dependencies_values.call(this, exports, name);

    // test "instances of objects: should export method" exposes global variable
    // "this" sent as context in callback.apply is the cause of the pollution of globalnamespace
    // TODO fix the pollution or find a way to restrict that kind of methods by throwing errors
    this.registry[name].callback.apply(this, reified);

    return exports;

});
_extend("isArray", function(myArray) {
    return Object.prototype.toString.call(myArray).indexOf("Array") > -1;
});
_extend("isFunction", function(func){
  return Object.prototype.toString.call(func) === '[object Function]';
});
_extend("isObject", function(obj){
  return Object.prototype.toString.call(obj) === '[object Object]';
});
_extend("isString", function(string){
  return Object.prototype.toString.call(string) === '[object String]';
});
_extend("random", function() {

    var random = Math.round(Math.random() * 100, 2);

    return random;

});
_extend("reset_amd", function() {

    AMD = nucleoAMD.create();

});
_extend("resolve", function(child, name) {

    if (child.charAt(0) === '.') {

        if (!this._config.relativePaths) {

            helpers.throwError('Relative paths are not allowed: ' + child + ' required by ' + name);

        }

    } else {

        return child;

    }

    var parts = child.split('/');
    var parentBase = name.split('/').slice(0, -1);

    for (var i = 0, l = parts.length; i < l; i++) {

        var part = parts[i];

        if (part === '..') {

            parentBase.pop();

        } else if (part === '.') {

            continue;

        } else {

            parentBase.push(part);

        }

    }

    return parentBase.join('/');

});
_extend("shouldIgnorePrefix", function(path, ignorePatterns) {

    var shouldIgnore = false;

    for (var i = 0; i < ignorePatterns.length; i++) {

        var containsInvalidChars = /[^\w\d/_-]/.test(ignorePatterns[i]);

        if (containsInvalidChars) {

            helpers.throwError('Ignored prefixes contains invalid chars');

        }

        var ignorePattern = new RegExp('^' + ignorePatterns[i] + '(\/)?(\w+)*');

        if (shouldIgnore === false && ignorePattern.test(path)) {

            shouldIgnore = true;

        }

    };

    return shouldIgnore;

});
_extend("throwError", function(msg) {

    throw new Error(msg);

});
var AMD = nucleoAMD.create();
 module.exports = AMD;