gina 0.0.9-p91b → 0.1.1-alpha.2

package/framework/v0.1.1-alpha.2/helpers/plugins/README.md

@@ -0,0 +1,4 @@
+# Plugings helpers
+
+## ValidatorError
+Used to format errors passed from the backend to the frontend

package/framework/v0.1.1-alpha.2/helpers/plugins/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "json",
+  "version": "1.0.0",
+  "description": "JSON helper",
+
+  "author": {
+    "name": "Maritn-Luther ETOUMAN",
+    "email": "martinluther@gina.io"
+  },
+  "copyright": "Copyright (c) 2009-2022 Rhinostone <contact@gina.io>",
+  "engines": {
+    "node": ">=0.10.22"
+  },
+  "main": "src/main",
+  "scripts": {
+    "test": "nodeunit test"
+  },
+  "license": "MIT",
+  "readmeFilename": "README.md"
+}

package/framework/v0.1.1-alpha.2/helpers/plugins/src/api-error.js

@@ -0,0 +1,160 @@
+//var console = require('./../../../lib/logger');
+var merge = require('./../../../lib/merge');
+var statusCodes = requireJSON(__dirname + '/../../../core/status.codes');
+//var statusCodes = requireJSON( _( getPath('gina').core + '/status.codes') );
+/**
+ * 
+ * Usage:
+ *  var e = null;
+ *  // Server errors
+ *  e = new ApiError('This is a generic server error.'); // default error.status -> 500
+ *  e = new ApiError('This a server specific server error.', 501);
+ * 
+ *  // Client errors
+ *  e = new ApiError('This is client error.', 498);
+ *  e = new ApiError('This is client error.', 'token', 498); // where `token` is the frontend field: <input type="hiden" name="token">
+ *  or
+ *  e = new ApiError('This is client error.', 'token');
+ *  e.status = 498;
+ * 
+ *  // Client bundled error
+ *  e = new ApiError(['This is preconditioned #1 client error.', 'This is preconditioned #2 client error.'], ['firstName', 'lastName']);
+ * 
+ * @param {string|array} errorMessage
+ * @param {string} [fieldName]
+ * @param {number} [errorStatus] - 500 by default for the server and 412 for the client
+ * 
+ * @returns {object} errorObject
+ */
+function ApiError(errorMessage, fieldName, errorStatus) {
+    var e = null;
+    
+    if ( typeof(merge) != 'function' ) {
+        merge = require('./../../../lib/merge');
+    }    
+    if ( typeof(statusCodes) == 'undefined' ) {
+        var statusCodes = requireJSON(__dirname + '/../../../core/status.codes');
+    }
+    
+    if ( typeof(errorMessage) == 'object' && errorMessage instanceof Error ) {
+        e = JSON.clone(errorMessage);
+        errorMessage = e.message || e.stack;
+    } else {
+        e = new Error(errorMessage);   
+    }
+     
+    var isClientError = (arguments.length == 3) ? true : false;
+    if ( arguments.length == 2 ) {
+        // server error
+        if ( typeof(arguments[1]) == 'number' ) {
+            errorStatus = arguments[1];
+            if (!e.status) {
+                e.status = errorStatus;
+            }
+            fieldName = null;
+        }
+        // client error 
+        else if ( Array.isArray(arguments[1]) || typeof(arguments[1]) == 'string' ) {
+            isClientError = true;
+            errorStatus = 412; // by default
+        }
+        else {
+            throw new Error('ApiError: Bad usage.');
+        }
+    } else if (arguments.length == 1) {
+        fieldName   = null;
+        errorStatus = null;
+    }
+    // Server Error
+    if (!isClientError) {
+        // TODO - Reformat stack to remove the first lines
+        if (!e.status)
+            e.status    = errorStatus || 500;
+            
+        if ( typeof(statusCodes[e.status]) != 'undefined' ) {
+            e.error = statusCodes[e.status];
+        } else {
+            console.warn('[ ApiValidator ] statusCode `'+ e.status +'` not matching any definition in `'+_( getPath('gina').core + '/status.codes')+'`\nPlease contact the Gina dev team to add one if required');
+        }
+        if (!e.message)
+            e.message   = errorMessage;
+        
+        return e;
+    }
+    // Client Error
+    e.status = errorStatus || 412;
+    if ( typeof(statusCodes[e.status]) != 'undefined' ) {
+        e.error = statusCodes[e.status];
+    } else {
+        console.warn('[ ApiValidator ] statusCode `'+ e.status +'` not matching any definition in `'+_( corePath + '/status.codes')+'`\nPlease contact the Gina dev team to add one if required');
+    }
+    if (!fieldName) { // Client error without defined field
+        e.message   = errorMessage;
+        return e;
+    }
+    var ctx             = getContext();
+    var clientError     = merge({
+        tag     : '', // internal framework reference
+        fields  : {},
+        path    : ''
+    }, e);
+    
+    
+    var formatClientError = function(ctx, error, errorMessage, fieldName) {
+        error.fields[fieldName] = errorMessage;
+        var bundleName      = ctx.bundle
+            , stackObj      = __stack[2]
+        ;
+        if ( typeof(stackObj) == 'object' ) {
+            try {
+                error.tag += bundleName +':';
+                var filename    = stackObj.getFileName();
+                var re          = new RegExp('('+bundleName+'\/)(model|controller)');
+                if ( re.test(filename) ) {
+                    var paths = getPaths(), path = null;
+                    // model
+                    if ( /model/i.test(filename) ) {
+                        path = paths.models.substr(paths.models.lastIndexOf(bundleName)) +'/'+ filename.substr(filename.lastIndexOf(bundleName+'\/models'));
+                        error.tag += 'model:'
+                    }
+                    // controller 
+                    else {
+                        path = paths.controllers.substr(paths.controllers.lastIndexOf(bundleName)) +'/'+ filename.substr(filename.lastIndexOf(bundleName+'\/controllers'));
+                        error.tag += 'controller:';
+                        var controllerInstanceString = path.match(/controller\.(.*)\.js/)[1] || null;
+                        error.tag += (controllerInstanceString) ? controllerInstanceString : 'controller:';
+                    }
+                    error.path = path;
+                }
+                var funcName = stackObj.getFunctionName();
+                error.tag += funcName.replace(/\./g, ':') +'  :'+stackObj.getLineNumber()+':'+stackObj.getColumnNumber();
+                //error.fields[fieldName][funcName] = errorMessage;
+            } catch (err) {
+                error.tag   = 'N/A';
+                error.stack = err.stack;
+            }        
+        } else {
+            //error.fields[fieldName]['isApiError'] = errorMessage;
+            error.tag   = 'N/A';
+        }     
+         
+        return error;
+    }
+    
+    if ( Array.isArray(fieldName) ) {
+        for (let i = 0, len = errorMessage.length; i < len; i++) {
+            clientError = formatClientError(ctx, clientError, errorMessage[i], fieldName[i]);
+        }
+    } else {
+        clientError = formatClientError(ctx, clientError, errorMessage, fieldName);
+    }
+    
+    return clientError;
+}
+if ( ( typeof(module) !== 'undefined' ) && module.exports ) {
+    // Publish as node.js module
+    module.exports = ApiError;
+} else if ( typeof(define) === 'function' && define.amd) {
+    // Publish as AMD module
+    define( function() { return ApiError });
+}

package/framework/v0.1.1-alpha.2/helpers/plugins/src/main.js

@@ -0,0 +1,32 @@
+/*
+ * This file is part of the gina package.
+ * Copyright (c) 2009-2022 Rhinostone <contact@gina.io>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+ var fs = require('fs');
+/**
+ * PluginsHelper
+ *
+ * @package     Gina.Utils.Helpers
+ * @author      Rhinostone <contact@gina.io>
+ * @api public
+ * */
+
+module.exports = function(loadedPlugins){
+    for (let plugin in loadedPlugins) {
+        switch (plugin) {
+            case 'Validator':
+                // Global
+                // TODO - load from `loadedPlugins[plugin].helpers { 'ApiError': 'api-error'}
+                if ( typeof(ApiError) == 'undefined')
+                    ApiError = require('./api-error');
+                break;
+        
+            default:
+                break;
+        }
+    }
+};//EO JSONHelper.

package/framework/v0.1.1-alpha.2/helpers/prototypes.js

@@ -0,0 +1,218 @@
+function PrototypesHelper(instance) {
+    
+    var isGFFCtx        = ( ( typeof(module) !== 'undefined' ) && module.exports ) ? false : true;
+    
+    var local = instance || null;
+    var envVars = null;
+    // since for some cases we cannot use gina envVars directly
+    if (        
+        typeof(GINA_DIR) == 'undefined'
+        && !isGFFCtx
+        && typeof(process) != 'undefined' 
+        && process.argv.length > 3
+    ) {
+        if ( /^\{/.test(process.argv[2]) ) {
+            envVars = JSON.parse(process.argv[2]).envVars;
+        }
+        // minions case
+        else if ( /\.ctx$/.test(process.argv[2]) ) {
+            var fs = require('fs');
+            var envVarFile = process.argv[2].split(/\-\-argv\-filename\=/)[1];
+            envVars = JSON.parse(fs.readFileSync(envVarFile).toString()).envVars;
+        }
+        
+    }
+    // else if (isGFFCtx) {
+    //     envVars = window;
+    // }
+     
+    
+    // dateFormat proto
+    if ( local && typeof(local) != 'undefined' && typeof(local.dateFormat) != 'undefined' ) {
+        for (let method in local.dateFormat) {
+            
+            if ( typeof(Date[method]) != 'undefined' )
+                continue;
+            
+            Object.defineProperty( Date.prototype, method, {
+                writable:   false,
+                enumerable: false,
+                //If loaded several times, it can lead to an exception. That's why I put this.
+                configurable: true,
+                value: function() { 
+                    
+                    var newArgs = { 0: this }, i = 1;
+                    for (var a in arguments) {
+                        newArgs[i] = arguments[a];
+                        ++i
+                    }
+                    newArgs.length = i;
+                    // don't touch this, we need the name
+                    const name = method;
+                    
+                    return local.dateFormat[name].apply(this, newArgs );
+                }
+            });
+            
+        }
+    }
+    
+    
+
+    if ( typeof(Array.clone) == 'undefined' ) {
+        /**
+         * 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' && !isGFFCtx ) {
+        if ( typeof(envVars) != 'undefined' ) {
+            JSON.clone = require( envVars.GINA_DIR +'/utils/prototypes.json_clone');
+        } else {
+            JSON.clone = require( GINA_DIR +'/utils/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;
+    }
+        
+
+    if ( typeof(Array.toString) == 'undefined' ) {
+        Array.prototype.toString = function(){
+            return this.join();
+        };
+    }
+
+    if ( typeof(Array.inArray) == 'undefined' ) {
+        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 }
+        });
+    }
+        
+    if ( typeof(Array.from) == 'undefined' ) { // if not under ES6
+
+        Object.defineProperty( Array.prototype, 'from', {
+            writable:   false,
+            enumerable: false,
+            //If loaded several times, it can lead to an exception. That's why I put this.
+            configurable: true,
+            value: function(a){
+                var seen    = {}
+                    , out   = []
+                    , len   = a.length
+                    , j     = 0;
+
+                for(var i = 0; i < len; i++) {
+                    var item = a[i];
+                    if(seen[item] !== 1) {
+                        seen[item] = 1;
+                        out[j++] = item
+                    }
+                }
+
+                return out
+            }
+        });
+    }
+    
+    if ( typeof(Object.count) == 'undefined' ) {
+        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(){
+                var i = 0;
+                try {
+                    var self = this;
+                    if (this instanceof String) self = JSON.parse(this);
+                    
+                    for (var prop in this)
+                        if (this.hasOwnProperty(prop)) ++i;
+
+                    return i;
+                } catch (err) {
+                    return i;
+                }
+
+            }
+        });
+    }        
+
+    
+        
+    if ( typeof(global) != 'undefined' && typeof(global.__stack) == 'undefined' ) {
+        /**
+         * __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;
+            }
+        });
+    }
+    
+    
+}
+
+if ( ( typeof(module) !== 'undefined' ) && module.exports ) {
+    // Publish as node.js module
+    module.exports = PrototypesHelper
+} else if ( typeof(define) === 'function' && define.amd) {
+    // Publish as AMD module
+    define( function() { return PrototypesHelper })
+}
+    

package/{core/utils → framework/v0.1.1-alpha.2}/helpers/task.js

@@ -8,13 +8,18 @@ module.exports = function () {
 
 	 /**
      * Run commande on local cli
+     * 
+     * Could also be used to open an url but need some tweaking
+     * // sample of a cross platform `open` command
+     *  e.g.: var openCmd = (process.platform == 'darwin'? 'open': process.platform == 'win32'? 'start': 'xdg-open');
      *
      * @param cmdLine {array|string}
      * @param opt {object}
      *
      *
      * */
-	run = function(cmdline, opt) {
+	run = function(cmdline, opt, cb) {
+        
 		var pathArr = (new _(__dirname).toUnixStyle().split(/\//g));
 		var root =  pathArr.splice(0, pathArr.length-6).join('/');
 
@@ -36,6 +41,22 @@ module.exports = function () {
         var result, error = false;
         var hasCalledBack = false;
         var e = new EventEmitter();
+        
+        e.onData = function(callback) {
+            e.once('run#data', callback);
+
+            e.once('run#err', callback);
+
+            return e
+        }
+
+        e.onComplete = function(callback) {
+            e.once('run#complete', function(err, data) {
+                callback(err, data);
+            });
+
+            return e
+        };
 
         //console.log( opt.cwd );
         //console.log( 'running ', cmdline);
@@ -45,14 +66,20 @@ module.exports = function () {
         if (typeof(cmdline) == 'string') {
             cmdline = cmdline.split(' ')
         }
-        cmd = spawn(cmdline.splice(0,1).toString(), cmdline, { cwd: opt.cwd, stdio: [ 'ignore', out, err ] });
-
-
+        
+        console.debug('opt.outToProcessSTD => ', opt.outToProcessSTD);
+        if ( typeof(opt) != 'undefined' && typeof(opt.outToProcessSTD) != 'undefined' && /^true$/i.test(opt.outToProcessSTD) ) {
+            // mainly used for task like `npm install`. This is not the default setup
+            cmd = spawn(cmdline.splice(0,1).toString(), cmdline, { cwd: opt.cwd, stdio: [ process.stdin, process.stdout, process.stderr ] });
+        } else {
+            cmd = spawn(cmdline.splice(0,1).toString(), cmdline, { cwd: opt.cwd, stdio: [ 'ignore', out, err ] });
+        }   
         cmd.on('stdout', function(data) {
             var str = data.toString();
             var lines = str.split(/(\r?\n)/g);
             result = lines.join('');
-            //console.info('out: ', result);
+            console.log('out: ', result);
+            
             e.emit('run#data', result)
         });
 
@@ -60,9 +87,14 @@ module.exports = function () {
         cmd.on('stderr', function (err) {
             var str = err.toString();
             error = str || false;
-            //console.error('err: ', error);
+            console.log('err: ', error);
+            
             e.emit('run#err', error)
         });
+        
+        // cmd.on('exit', function (code){
+        //     console.debug('exiting with code '+ code +' ....');
+        // });
 
         cmd.on('close', function (code) {
 
@@ -73,7 +105,7 @@ module.exports = function () {
                 if ( fs.existsSync(errFile) ) fs.unlinkSync(errFile);
 
                 if (error) {
-                    cmd.emit('stderr', new Buffer(error))
+                    cmd.emit('stderr', Buffer.from(error))
                 }
 
 
@@ -83,7 +115,7 @@ module.exports = function () {
                 if (fs.existsSync(outFile) ) fs.unlinkSync(outFile);
 
                 if ( data ) {
-                    cmd.emit('stdout', new Buffer(data))
+                    cmd.emit('stdout', Buffer.from(data))
                 }
 
 
@@ -92,8 +124,16 @@ module.exports = function () {
                 }
 
                 if (code == 0 ) {
+                    if (cb) {
+                        cb(error, result);
+                        return;
+                    }
                     e.emit('run#complete', error, result)
                 } else {
+                    if (cb) {
+                        cb('task::run encountered an error: ' + error, result);
+                        return;
+                    }
                     e.emit('run#complete', 'task::run encountered an error: ' + error, result)
                 }
 
@@ -103,27 +143,7 @@ module.exports = function () {
             }
         });
 
-        e.onData = function(callback) {
-
-            e.once('run#data', function(data) {
-                callback(data)
-            });
-
-            e.once('run#err', function(err, data) {
-                callback(err, data)
-            });
-
-            return e
-
-        }
-
-        e.onComplete = function(callback) {
-            e.once('run#complete', function(err, data) {
-                callback(err, data)
-            });
-
-            return e
-        };
+        
 
         return e
 	};

package/{core/utils → framework/v0.1.1-alpha.2}/helpers/text.js

@@ -1,6 +1,6 @@
 /*
  * This file is part of the gina package.
- * Copyright (c) 2016 Rhinostone <gina@rhinostone.com>
+ * Copyright (c) 2009-2022 Rhinostone <contact@gina.io>
  *
  * For the full copyright and license information, please view the LICENSE
  * file that was distributed with this source code.
@@ -10,7 +10,7 @@
  * TextHelper
  *
  * @package     Gina.Utils.Helpers
- * @author      Rhinostone <gina@rhinostone.com>
+ * @author      Rhinostone <contact@gina.io>
  * @api public
  * */
 
@@ -20,7 +20,7 @@ module.exports = function(){
      * @todo
      * __ Translate a given string into the i18n for local value
      *
-     * @return {string} i18nValue Return the translated string
+     * @returns {string} i18nValue Return the translated string
      * */
     __ = function(str){
         var self = __;
@@ -41,7 +41,7 @@ module.exports = function(){
 /**
  * trim prototype
  *
- * @return {string} result
+ * @returns {string} result
  * */
 if (!String.prototype.trim) {
     String.prototype.trim = function(){
@@ -52,20 +52,20 @@ if (!String.prototype.trim) {
 /**
  * ltrim prototype
  *
- * @return {string} result
+ * @returns {string} result
  * */
 String.prototype.ltrim=function(){return this.replace(/^\s+/,'');};
 
 /**
  * rtrim prototype
  *
- * @return {string} result
+ * @returns {string} result
  * */
 String.prototype.rtrim=function(){return this.replace(/\s+$/,'');};
 
 /**
  * gtrim prototype - Global / full trim
  *
- * @return {string} result
+ * @returns {string} result
  * */
 String.prototype.gtrim=function(){return this.replace(/(?:(?:^|\n)\s+|\s+(?:$|\n))/g,'').replace(/\s+/g,' ');};

package/framework/v0.1.1-alpha.2/lib/archiver/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "archiver",
+  "version": "1.0.0",
+  "description": "Archiver lib",
+
+  "author": {
+    "name": "Maritn-Luther ETOUMAN",
+    "email": "contact@gina.io"
+  },
+  "copyright": "Copyright (c) 2009-2022 Rhinostone <contact@gina.io>",
+  "engines": {
+    "node": ">=0.10.22"
+  },
+  "main": "src/main",
+  "scripts": {
+    "test": "nodeunit test"
+  },
+  "license": "MIT",
+  "readmeFilename": "README.md"
+}