gina 0.0.9-p91b → 0.1.1-alpha.2

package/utils/helper.js

@@ -0,0 +1,438 @@
+var fs = require('fs');
+var os = require('os');
+
+var lib         = null;
+var console     = null;
+merge           = null;
+
+function MainHelper(opt) {
+    var self = {
+        protectedVars : [],
+        config : {}
+    };
+
+
+    var init = function(opt) {
+        //Load prototypes.
+        require('./prototypes');
+
+        //Load librairies.
+        var isWin32 = (process.platform === 'win32') ? true : false;
+        var scriptPath = __dirname;
+        var ginaPath = (scriptPath.replace(/\\/g, '/')).replace('/utils', '');
+        var pack        = ginaPath + '/package.json';
+        pack =  (isWin32) ? pack.replace(/\//g, '\\') : pack;
+        var packObj = require(pack);
+        var version =  getEnvVar('GINA_VERSION') || packObj.version;
+        var frameworkPath = ginaPath + '/framework/v' + version;
+        
+        try {
+            lib         = require(frameworkPath + '/lib');
+            console     = lib.logger;
+            merge       = lib.merge;
+        } catch (err) {
+            // this can happen in certain conditions
+            // like scripts running out of the framework context
+            // we'll just ignore it
+        }
+        
+        
+    }
+
+    /**
+     * Check if object before extending.
+     * */
+    // var isObject = function(obj) {
+    //     if (
+    //         !obj ||
+    //         {}.toString.call(obj) !== '[object Object]' ||
+    //         obj.nodeType ||
+    //         obj.setInterval
+    //     ) {
+    //         return false
+    //     }
+
+    //     var hasOwn              = {}.hasOwnProperty;
+    //     var hasOwnConstructor   = hasOwn.call( obj, 'constructor');
+    //     var hasMethodPrototyped = hasOwn.call( obj.constructor.prototype, 'isPrototypeOf');
+
+
+    //     if (
+    //         obj.constructor &&
+    //         !hasOwnConstructor &&
+    //         !hasMethodPrototyped
+    //     ) {
+    //         return false
+    //     }
+
+    //     //Own properties are enumerated firstly, so to speed up,
+    //     //if last one is own, then all properties are own.
+    //     var key;
+    //     return key === undefined || hasOwn.call( obj, key )
+    // }
+
+
+
+
+    isWin32 = function() {
+        return ( os.platform() == 'win32' ) ? true : false;
+    }
+
+
+    /**
+     *
+     * @param {boolean} deep - Deep copy
+     * @param {boolean} [override] - Override when copying
+     * @param {object} target - Target object
+     * @param {object} source - Source object
+     *
+     * @returns {object} [result]
+     * */
+    // extend = function() {
+    //     var target = arguments[ 0 ] || {};
+    //     var i      = 1;
+    //     var length = arguments.length;
+    //     var deep   = false;
+    //     var override = false;
+    //     var options, name, src, copy, copy_is_array, clone;
+
+    //     // Handle a deep copy situation
+    //     if ( typeof target === 'boolean' ) {
+    //         deep   = target;
+    //         target = arguments[ 1 ] || {};
+    //         // skip the boolean and the target
+    //         i = 2
+    //     }
+    //     // Handle an override copy situation
+    //     if ( typeof target === 'boolean' ) {
+    //         override   = target;
+    //         target = arguments[ 2 ] || {};
+    //         // skip the boolean and the target
+    //         i = 3
+    //     }
+
+
+    //     // Handle case when target is a string or something (possible in deep copy)
+    //     if ( typeof target !== 'object' && typeof target !== 'function' ) {
+    //         target = {};
+    //     }
+
+    //     for ( ; i < length; i++ ) {
+    //         // Only deal with non-null/undefined values
+    //         if (( options = arguments[ i ]) != null ) {
+    //             // Extend the base object
+    //             for (var name in options ) {
+    //                 src  = target[ name ];
+    //                 copy = options[ name ];
+
+    //                 // Prevent never-ending loop
+    //                 if ( target === copy ) {
+    //                     continue
+    //                 }
+
+    //                 // Recurse if we're merging plain objects or arrays
+    //                 if (
+    //                     deep &&
+    //                     copy &&
+    //                     (
+    //                         isObject( copy ) ||
+    //                         ( copy_is_array = Array.isArray( copy ) )
+    //                     )
+    //                 ) {
+
+    //                     if ( copy_is_array ) {
+    //                         copy_is_array = false;
+    //                         clone = src && Array.isArray( src ) ? src : []
+    //                     } else {
+    //                         clone = src && isObject( src) ? src : {}
+    //                     }
+
+    //                     //[propose] Supposed to go deep... deep... deep...
+    //                     if (!override) {
+    //                         for (var prop in copy) {
+    //                             if( typeof(clone[ prop ]) != "undefined" ){
+    //                                 copy[ prop ] = clone[ prop ];
+    //                             }
+    //                         }
+    //                     }
+
+    //                     // Never move original objects, clone them
+    //                     if (typeof(src) != "boolean") {//if property is not boolean
+    //                         target[ name ] = extend( deep, override, clone, copy )
+    //                     }
+    //                     // Don't bring in undefined values
+    //                 } else if ( copy !== undefined ) {
+    //                     //[propose]Don't override existing if prop defined or override @ false
+    //                     if (
+    //                         typeof(src) != "undefined" &&
+    //                         src != copy &&
+    //                         !override
+    //                     ) {
+    //                         target[ name ] = src
+    //                     } else {
+    //                         target[ name ] = copy
+    //                     }
+
+    //                 }
+    //             }
+    //         }
+    //     }
+    //     // Return the modified object
+    //     return target
+    // }
+
+    // isEmpty = function(obj) {
+    //     return Object.keys(obj).length === 0;
+    // }
+
+    filterArgs = function() {
+
+        var setget  = ( typeof(process.argv[2]) != 'undefined'
+                            && /(\:set$|\:get$|[-v]|\:version$|[--version])/.test(process.argv[2]))
+                            ? true : false
+            , evar  = ''
+            , err   = null
+        ;
+
+        if ( typeof(process.env['gina']) == 'undefined') {
+            process.env['gina'] = {}
+        }
+
+        var newArgv = {};
+        for (var a in process.argv) {            
+            if ( /\-\-/.test(process.argv[a]) && process.argv[a].indexOf('=') > -1 ) {
+                evar = ( (process.argv[a].replace(/--/, ''))
+                    .replace(/-/, '_') )
+                    .split(/=/);
+
+                evar[0] = evar[0].toUpperCase();
+                if (
+                    evar[0].substr(0, 5) !== 'GINA_' &&
+                    evar[0].substr(0, 7) !== 'VENDOR_' &&
+                    evar[0].substr(0, 5) !== 'USER_'
+                    ) {
+                    evar[0] = 'GINA_' + evar[0]
+                }
+                //Boolean values.
+                if (evar[1] === "true") {
+                    evar[1] = true
+                }
+                if (evar[1] === "false") {
+                    evar[1] = false
+                }
+                //Avoid protected.
+                if (self.protectedVars.indexOf(evar[0]) == -1 ) {
+                    process.gina[evar[0]] = evar[1];
+                } else {
+                    //throw new Error('gina won\'t override protected env var [ ' +evar[0]+ ' ] or constant.')
+                    err = new Error('gina won\'t override protected env var [ ' +evar[0]+ ' ] or constant.');
+                    console.error(err.stack||err.message);
+                    return;
+                }
+
+            } else {
+                newArgv[a] = process.argv[a]
+            }
+        }
+
+        //Cleaning argv.
+        if (!setget)
+            process.argv = newArgv;
+
+        //Cleaning the rest.
+        for (var e in process.env) {
+            if (
+                e.substr(0, 5) === 'GINA_' || // 6?
+                e.substr(0, 7) === 'VENDOR_' ||
+                e.substr(0, 5) === 'USER_'
+                ) {
+                process['gina'][e] = process.env[e];
+                delete process.env[e]
+            }
+        }
+
+        setContext('envVars', process['gina']);
+    }
+
+    getEnvVar = function(key) {
+        if (
+            typeof(process['gina']) != 'undefined' &&
+            typeof(process['gina'][key]) != 'undefined' &&
+            process['gina'][key] != ''
+            ) {
+            return process['gina'][key]
+        }
+        return undefined
+    }
+
+    getEnvVars = function() {
+        return process.gina
+    }
+
+    /**
+     * Get log path - %SystemRoot%\system32\winevt\logs or /
+     *
+     * @returns {string} logPath
+     * */
+    getLogDir = function() {
+        // Trying to retrieve original value if already defined
+        var logDir = getEnvVar('GINA_LOGDIR') || null;
+        if ( logDir ) {
+            if ( !/gina$/.test(logDir) ) {
+                logDir += ( isWin32() ) ? '\\gina' : '/gina'
+            }
+            return logDir
+        }
+        if ( isWin32() ) {
+            logDir = process.env.LOG ||
+                process.env.LOGS ||
+                (process.env.SystemRoot || process.env.windir) + '\\System32\\Winevt\\Logs'
+            ;
+            if ( !/gina$/.test(logDir) ) {
+                logDir += '\\gina'
+            }
+        } else {
+            logDir = process.env.LOGDIR ||
+                process.env.LOG ||
+                process.env.LOGS ||
+                '/usr/local/var/log'
+            ;
+            if ( !/gina$/.test(logDir) ) {
+                logDir += '/gina'
+            }
+        }
+        
+        return logDir;
+    }
+
+    getProtected = function() {
+        return self.protectedVars
+    }
+
+    /**
+     * Get run\lock path
+     * @returns {string} rundir
+     * */
+    getRunDir = function() {
+        // Trying to retrieve original value if already defined
+        var runDir = getEnvVar('GINA_RUNDIR') || null;
+        if ( runDir ) {
+            if ( !/gina$/.test(runDir) ) {
+                runDir += ( isWin32() ) ? '\\gina' : '/gina'
+            }
+            return runDir
+        }
+        
+        if ( isWin32() ) {
+            console.debug('check /gina/utils/helper.js around on getRunDir()')
+        } else {                        
+            // Means `/usr/local/var/lock` or `/usr/local/var/run` by default.
+            runDirObj = new _('/usr/local/var/lock', true);
+            if ( runDirObj.existsSync() ) {
+                return _( runDirObj.toUnixStyle() +'/gina', true );
+            }
+            // by default
+            return _('/usr/local/var/run/gina', true)//by default.
+        }
+    }
+
+    getTmpDir = function() {
+        // support for node 0.10.x & 0.11.x
+        var tmp = os.tmpdir || function() {
+            if ( isWin32() ) {
+                return process.env.TEMP ||
+                    process.env.TMP ||
+                    (process.env.SystemRoot || process.env.windir) + '\\Temp'
+            } else {
+                return process.env.TMPDIR ||
+                    process.env.TMP ||
+                    process.env.TEMP ||
+                    '/usr/local/var/tmp'
+            }
+        };
+
+        return ( typeof(tmp) == 'function') ?  tmp() : tmp
+    }
+
+    getUserHome = function() {
+        return process.env[(isWin32()) ? 'USERPROFILE' : 'HOME']
+    }
+
+    getVendorsConfig = function(vendor) {
+        var msg = 'Helper could not load ['+ vendor +'] config.';
+        if ( typeof(vendor) != 'undefined' ) {
+            try {
+                return self.config[vendor]
+            } catch (err) {
+                //throw new Error(msg);
+                console.error(err.stack||err.message);
+                return;
+            }
+        } else {
+            return self.config
+        }
+    }
+
+    setVendorsConfig = function(dir) {
+        if ( !fs.existsSync(dir) ) {
+            console.debug('Directory [' + dir + '] is missing !')
+        } else {
+            var files = fs.readdirSync(dir), filename = "";
+            var file = '', a = [];
+            for (var f = 0; f < files.length; ++f) {
+                filename = dir + '/' + files[f];
+                file = ( a = files[f].split('.'), a.splice(0, a.length-1)).join('.');
+                self.config[file] = require(filename)
+            }
+        }
+    }
+
+    setEnvVar = function(key, val, isProtected) {        
+        key = key.toUpperCase();
+        var err                     = null
+            // related task `framework:set` & framework/v.xxx/lib/cmd/framework/init.js 
+            , specialCases          = ['GINA_PORT', 'GINA_DEBUG_PORT', 'GINA_CULTURE', 'GINA_TIMEZONE']
+            , isOverrrideAllowed    = (specialCases.indexOf(key) > -1) ? true : false
+        ;
+        
+        if (
+            key.substr(0, 5) !== 'GINA_' &&
+            key.substr(0, 7) !== 'VENDOR_' &&
+            key.substr(0, 5) !== 'USER_'
+            ) {
+            key = 'USER_' + key
+        }
+        if (
+            typeof(process['gina']) != 'undefined' &&
+            typeof(process['gina'][key]) != 'undefined' &&
+            process['gina'][key] !== '' &&
+            // exceptions
+            !isOverrrideAllowed
+        ) {
+            err = new Error('Env variable [ '+ key + ' ] is already set');
+            console.warn(err.message);
+            return
+        } else {
+            //Write env var.
+            if ( typeof(process['gina']) == 'undefined') {
+                process['gina'] = {}
+            }
+            process['gina'][key] = val;
+            if ( typeof(isProtected) != 'undefined' && isProtected == true) {                
+                self.protectedVars.push(key)
+            }            
+        }        
+    }
+
+    defineDefault = function(obj) {
+        for (let c in obj) {
+            define(c, obj[c])
+        }
+        delete  obj
+    }
+
+    init(opt)
+
+};
+
+module.exports = MainHelper()

package/utils/prototypes.js

@@ -0,0 +1,239 @@
+/**
+ * clone array
+ * 
+ * @returns {array} Return cloned array
+ * @supress {misplacedTypeAnnotation}
+ **/
+Object.defineProperty( Array.prototype, 'clone', {
+    writable:   false,
+    enumerable: false,
+    //If loaded several times, it can lead to an exception. That's why I put this.
+    configurable: true,
+    value: function(){ return this.slice(0); }
+});
+
+
+if ( typeof(JSON.clone) == 'undefined' ) {
+    JSON.clone = require(__dirname + '/prototypes.json_clone');
+}
+
+if ( typeof(JSON.escape) == 'undefined' ) {
+    /**
+     * JSON.escape
+     * Escape special characters
+     * 
+     * Changes made here must be reflected in: 
+     *  - gina/utils/prototypes.js
+     *  - gina/framework/version/helpers/prototypes.js
+     *  - gina/framework/version/core/asset/js/plugin/src/gina/utils/polyfill.js
+     * 
+     * @param {object} jsonStr
+     * 
+     * @returns {object} escaped JSON string
+     **/
+     var escape = function(jsonStr){
+        try {
+            return jsonStr
+                       .replace(/\n/g, "\\n")
+                       .replace(/\r/g, "\\r")
+                       .replace(/\t/g, "\\t")
+                   ;
+        } catch (err) {         
+           throw err;
+        }
+    };
+    
+    JSON.escape = escape;
+}
+
+Array.prototype.toString = function(){
+    return this.join();
+};
+
+
+Object.defineProperty( Array.prototype, 'inArray', {
+    writable:   false,
+    enumerable: false,
+    //If loaded several times, it can lead to an exception. That's why I put this.
+    configurable: true,
+    value: function(o){ return this.indexOf(o)!=-1 }
+});
+
+Object.defineProperty( Object.prototype, 'count', {
+    writable:   true,
+    enumerable: false,
+    //If loaded several times, it can lead to an exception. That's why I put this.
+    configurable: true,
+    value: function(){
+        try {
+            var self = this;
+            if (this instanceof String) self = JSON.parse(this);
+            var i = 0;
+            for (var prop in this)
+                if (this.hasOwnProperty(prop)) ++i;
+
+            return i;
+        } catch (err) {
+            return i
+        }
+    }
+});
+
+Object.defineProperty( Object.prototype, 'functionCount', {
+    writable:   true,
+    enumerable: false,
+    //If loaded several times, it can lead to an exception. That's why I put this.
+    configurable: true,
+    value: function(){
+        var self = this;
+        if (this instanceof String) self = JSON.parse(this);
+        var i = 0;
+        for (var prop in this)
+            if (this.hasOwnProperty(prop) && typeof(this[prop]) == 'function') ++i;
+
+        return i;
+    }
+});
+
+/**
+ * __stack Get current stack
+ * @returns {Object} stack Current stack
+ * 
+ * @suppress {es5Strict}
+ **/
+Object.defineProperty(global, '__stack', {
+    //If loaded several times, it can lead to an exception. That's why I put this.
+    configurable: true,
+    get: function(){
+        var orig = Error.prepareStackTrace;
+        Error.prepareStackTrace = function(_, stack){
+            return stack;
+        };
+        var err = new Error;
+        /** @suppress {es5Strict} */
+        Error.captureStackTrace(err, arguments.callee);
+        var stack = err.stack;
+        Error.prepareStackTrace = orig;
+        return stack;
+    }
+});
+
+
+
+/**
+ * __line Get current line number
+ * @returns {Number} stack Current line number
+ * */
+Object.defineProperty(global, '__line', {
+    //If loaded several times, it can lead to an exception. That's why I put this.
+    configurable: true,
+    get: function() {
+        return __stack[1].getLineNumber();
+    }
+});
+
+
+/**
+ * __function Get current function name
+ * @returns {String} function Current function name
+ * */
+Object.defineProperty(global, '__function', {
+    //If loaded several times, it can lead to an exception. That's why I put this.
+    configurable: true,
+    get: function() {
+        return __stack[1].getFunctionName();
+    }
+});
+
+/**
+ * __module Get current module name
+ * @returns {String} module Current module name
+ * */
+Object.defineProperty(global, '__module', {
+    //If loaded several times, it can lead to an exception. That's why I put this.
+    configurable: true,
+    get: function() {
+        return __stack[1].getFunctionName().split('.')[0];
+    }
+});
+
+/**
+ * __filename Get current file path
+ * @returns {String} stack Current file path
+ * */
+Object.defineProperty(global, '__filename', {
+    //If loaded several times, it can lead to an exception. That's why I put this.
+    configurable: true,
+    get: function() {
+        return __stack[1].getFileName();
+    }
+});
+
+/**
+ * __file Get current file name
+ * @returns {Integer} stack Current file name
+ * */
+Object.defineProperty(global, '__file', {
+    //If loaded several times, it can lead to an exception. That's why I put this.
+    configurable: true,
+    get: function() {
+        var filename = __stack[1].getFileName();
+        if (filename) {
+            return filename.split(/[\\/]/)[filename.length-1];
+        }
+        return filename
+    }
+});
+
+/**
+ * __column Get current column number
+ * @returns {Integer} stack Current column number
+ * */
+Object.defineProperty(global, '__column', {
+    //If loaded several times, it can lead to an exception. That's why I put this.
+    configurable: true,
+    get: function() {
+        return  __stack[1].getColumnNumber();
+    }
+});
+
+
+
+// remove this ... in conflict with lodash
+//Object.defineProperty( Object.prototype, 'toArray', {
+//    writable:   true,
+//    enumerable: false,
+//    //If loaded several times, it can lead to an exception. That's why I put this.
+//    configurable: true,
+//    value: function(force) {
+//        var arr = [],i = 0;
+//        for (var prop in this) {
+//            if ( this.hasOwnProperty(prop) ) {
+//                if (force) {
+//                    arr[i] = this[prop]
+//                } else {
+//                    arr[prop] = this[prop]
+//                }
+//                ++i
+//            }
+//        }
+//        return arr
+//    }
+//});
+// remove this ... in conflict with lodash
+///**
+// * String.toArray() Convert string path to array
+// * @param {String} delimiter Delimiter caracter for implode
+// * @returns {Array} array Imploded Array
+// * */
+//String.prototype.toArray = function(delimiter) {
+//    if (typeof(delimiter) != "undefined") {
+//        var str = this.toString(), reg = new RegExp(delimiter, "g");
+//        //Removing delimiter at the begining & at the end.
+//        if (str.substring(str.length-1) == delimiter)
+//            str = str.substring(0, str.length-1);
+//        if (str.substring(0,1) == delimiter) str = str.substring(1);
+//
+//        return str.split(reg);
+//    }
+//};