gina 0.1.1-alpha.132 → 0.1.1-alpha.135

package/framework/{v0.1.1-alpha.132 → v0.1.1-alpha.135}/helpers/context.js

@@ -141,6 +141,92 @@ function ContextHelper(contexts) {
         }
     }
 
+    /**
+     * resetContext
+     *
+     * Mostly used by logger container definitions orout of context threads (workers ?)
+     *
+     * TODO - Check if it can be called in `gna.js` & remove at the same time useless calls of setPath() & setContext()
+     */
+    resetContext = function() {
+        setPath('gina.root', getEnvVar('GINA_DIR'));
+        var frameworkPath = getEnvVar('GINA_FRAMEWORK_DIR');
+        setPath('framework', frameworkPath);
+        setPath('gina.core', getEnvVar('GINA_CORE'));
+        setPath('gina.lib', _(frameworkPath +'/lib'));
+        setPath('gina.helpers', _(frameworkPath +'/helpers'));
+        setPath( 'node', _(process.argv[0]), true);
+        var projects    = require( _(getEnvVar('GINA_HOMEDIR') + '/projects.json', true) );
+        var projectName = getContext('projectName');
+        var root        = projects[projectName].path;
+        setPath('project', root);
+        var env         = getContext('env');
+        var isDev       = (env === projects[projectName]['dev_env']) ? true: false;
+        var bundlesPath = projects[projectName]['path'] + '/bundles'; // by default
+        var isProductionScope = ('production' === projects[projectName]['def_scope']) ? true: false;
+        if (isDev) {
+            bundlesPath = projects[projectName]['path'] + '/src'
+        } else if (isProductionScope) {
+            bundlesPath = projects[projectName]['path'] + '/releases'
+        }
+        setPath('bundles', _(bundlesPath, true));
+        var bundle = getContext('bundle');
+        var bundlePath = getPath('project') + '/';
+
+        var modulesPackage = _(root + '/manifest.json');
+        var project     = {}
+            , bundles   = []
+        ;
+
+        if ( fs.existsSync(modulesPackage) ) {
+            try {
+                var dep = require(modulesPackage);
+                if ( typeof(dep['bundles']) == "undefined") {
+                    dep['bundles'] = {};
+                }
+
+                if (
+                    typeof(dep['bundles']) != "undefined"
+                    && typeof(project['bundles']) != "undefined"
+                ) {
+
+                    for (let d in dep) {
+                        if (d == 'bundles') {
+                            for (var p in dep[d]) {
+                                project['bundles'][p] = dep['bundles'][p];
+                            }
+                        } else {
+                            project[d] = dep[d];
+                        }
+
+                    }
+                } else {
+                    project = dep;
+                }
+
+                for (let b in project.bundles) {
+                    bundles.push(b)
+                }
+            } catch (err) {
+                throw err
+            }
+        }
+
+        bundlePath += ( isDev ) ? project.bundles[ bundle ].src : project.bundles[ bundle ].link;
+        setPath('bundle', _(bundlePath, true));
+        setPath('helpers', _(bundlePath+'/helpers', true));
+        setPath('lib', _(bundlePath+'/lib', true));
+        setPath('models', _(bundlePath+'/models', true));
+        setPath('controllers', _(bundlePath+'/controllers', true));
+
+        setContext('envs', projects[projectName].envs);
+        setContext('bundles', bundles);
+        // setContext('gina.utils', lib);
+        // setContext('gina.Config', Config);
+        // setContext('gina.locales', locales);
+        // setContext('gina.plugins', plugins);
+    }
+
 
     var throwError = function(code, err, isFatal) {
         var router      = getContext('router');
@@ -255,7 +341,7 @@ function ContextHelper(contexts) {
             }
         }
 
-        var env = ctx.env || GINA_ENV;
+        var env = ctx.env || getEnvVar('GINA_ENV');
         var envIsDev = ( /^true$/i.test(process.env.NODE_ENV_IS_DEV) ) ? true : false;
         var Config = ctx.gina.Config;
         var conf = null;

package/framework/{v0.1.1-alpha.132 → v0.1.1-alpha.135}/helpers/index.js

@@ -43,7 +43,7 @@ var helpers         = {}
 
 var PrototypesHelper = null, PluginsHelper = null;
 // loading main helpers
-for (; f < len; ++f) {            
+for (; f < len; ++f) {
     if ( ! /^\./.test(files[f]) && files[f] != 'index.js') {
         helper          = files[f].replace(/.js/, '');
         if (/prototypes/i.test(helper)) {
@@ -63,11 +63,11 @@ new PrototypesHelper({
 });
 
 // loading plugins helpers
-if ( 
+if (
     typeof(getContext) != 'undefined'
-    && typeof(getContext().gina) != 'undefined' 
+    && typeof(getContext().gina) != 'undefined'
 ) {
-    new PluginsHelper(getContext('gina').plugins);    
+    new PluginsHelper(getContext('gina').plugins);
 }
 // adding ApiError to helper in case Validator plugin is not loaded
 if ( typeof(getContext) != 'undefined' && typeof(ApiError) == 'undefined' /*&& typeof(helpers.ApiError) == 'undefined'*/ ) {
@@ -75,5 +75,10 @@ if ( typeof(getContext) != 'undefined' && typeof(ApiError) == 'undefined' /*&& t
     ApiError = require('./plugins/src/api-error');
 }
 
+// loading `gina/utils/helper` if not yet loaded
+if ( typeof(getTmpDir) == 'undefined' ) {
+    _require(__dirname + '/../../../utils/helper')
+}
+
 // Publish as node.js module
 module.exports = helpers;

package/framework/{v0.1.1-alpha.132 → v0.1.1-alpha.135}/helpers/path.js

@@ -139,10 +139,12 @@ function PathHelper() {
      * myPathObj.toString()
      * */
     _.prototype.toString = function() {
-        var self = this;
-        var path = self.value;
-        var i = _this.paths.indexOf(path);
-        return ( i > -1 ) ? _this.paths[i] : path
+        // var self = this;
+        // var path = self.value;
+        // var i = _this.paths.indexOf(path);
+        // return ( i > -1 ) ? _this.paths[i] : path
+
+        return (process.platform != "win32") ? toUnixStyle(this) : toWin32Style(this)
     }
 
     /**
@@ -226,14 +228,42 @@ function PathHelper() {
         return self
     }
 
+    var isSymlinkSync = function(value) {
+        try {
+            if ( fs.lstatSync(value).isSymbolicLink() ) {
+                return true
+            }
+        } catch (linkErr) {}
+
+        return false;
+    }
+    _.prototype.isSymlinkSync = function() {
+        return isSymlinkSync(this.value)
+    }
+
+    _.prototype.getSymlinkSourceSync = function() {
+        if ( !isSymlinkSync(this.value) ) {
+            throw new Error('Path `'+ this.value +'` is not a symbolic link !')
+        }
+        return fs.readlinkSync(this.value)
+    }
+
     var existsSync = function(value) {
         if ( typeof(fs.accessSync) != 'undefined' ) {
             try {
                 fs.accessSync(value, fs.constants.F_OK);
                 return true;
             } catch (err) {
+                // to handle symlinks
+                try {
+                    if ( fs.lstatSync(value).isSymbolicLink() ) {
+                        return true
+                    }
+                } catch (linkErr) {}
+
                 return false;
             }
+
         } else { // support for old version of nodejs
             return fs.existsSync(value);
         }
@@ -242,9 +272,17 @@ function PathHelper() {
         return existsSync(this.value);
     }
 
+
     var exists = function(value, callback) {
         if ( typeof(fs.access) != 'undefined' ) {
             fs.access(value, fs.constants.F_OK, (err) => {
+                // to handle symlinks
+                try {
+                    if ( fs.lstatSync(value).isSymbolicLink() ) {
+                        return callback(true)
+                    }
+                } catch (linkErr) {}
+
                 callback( (err) ? false: true )
             });
         } else { // support for old version of nodejs
@@ -1149,7 +1187,7 @@ function PathHelper() {
         cleanSlashes(this);
 
         try {
-
+            // console.debug('rmSync() of ['+ this.value +'] : symlink ? '+ fs.lstatSync(this.value).isSymbolicLink());
             if ( fs.lstatSync(this.value).isSymbolicLink() ) {
                 fs.unlinkSync(this.value);
                 return this;
@@ -1466,17 +1504,27 @@ function PathHelper() {
         })
     }
 
-    _.prototype.toUnixStyle = function() {
-        var self = this;
+    var toUnixStyle = function(self) {
         var i = _this.paths.indexOf(self.value);
         return ( i > -1 ) ? _this.paths[i].replace(/\\/g, "/") : self.value;
     }
+    _.prototype.toUnixStyle = function() {
+        // var self = this;
+        // var i = _this.paths.indexOf(self.value);
+        // return ( i > -1 ) ? _this.paths[i].replace(/\\/g, "/") : self.value;
+        return toUnixStyle(this)
+    }
 
-    _.prototype.toWin32Style = function() {
-        var self = this;
+    var toWin32Style = function(self) {
         var i = _this.paths.indexOf(self.value);
         return ( i > -1 ) ? _this.paths[i].replace(/\//g, "\\") : self.value;
     }
+    _.prototype.toWin32Style = function() {
+        // var self = this;
+        // var i = _this.paths.indexOf(self.value);
+        // return ( i > -1 ) ? _this.paths[i].replace(/\//g, "\\") : self.value;
+        return toWin32Style(this)
+    }
 
     /**
      * Check if a given path is valid

package/framework/{v0.1.1-alpha.132 → v0.1.1-alpha.135}/lib/cmd/aliases.json

@@ -8,6 +8,8 @@
         "-r" : "restart",
         "--restart" : "restart",
         "-v" : "version",
-        "--version" : "version"
+        "--version" : "version",
+        "-ln" : "link",
+        "--link" : "link"
     }
 }

package/framework/{v0.1.1-alpha.132 → v0.1.1-alpha.135}/lib/cmd/bundle/start.js

@@ -241,9 +241,17 @@ function Start(opt, cmd) {
                         if (!debuggerOn) {
                             debuggerOn = ''
                         }
+
+                        // resume logging
+                        process.emit('gina#bundle-logging', GINA_MQ_PORT, GINA_HOST_V4, bundle + '@' + self.projectName);
+                        console.debug('Sent:  gina#bundle-logging');
+
+
                         opt.client.write('  [ ' + bundle + '@' + self.projectName + ' ] started V(-.o)V'+ url + debuggerOn);
 
 
+
+
                         end(opt, cmd, isBulkStart, bundleIndex);
                         return;
                     }

package/framework/{v0.1.1-alpha.132 → v0.1.1-alpha.135}/lib/cmd/bundle/stop.js

@@ -91,6 +91,10 @@ function Stop(opt, cmd) {
                     }
                     if (!err) {
                         ++opt.offlineCount;
+
+                        // resume logging
+                        process.emit('gina#bundle-logging', GINA_MQ_PORT, GINA_HOST_V4, bundle + '@' + self.projectName);
+
                         //console.info('Bundle [ ' + bundle + '@' + self.projectName + ' ] with PID [ ' + proc + ' ] stopped !');
                         opt.client.write('  [ ' + bundle + '@' + self.projectName + ' ] with PID [ ' + proc + ' ] stopped !\n');
 

package/framework/v0.1.1-alpha.135/lib/cmd/framework/link.js

@@ -0,0 +1,89 @@
+var fs          = require('fs');
+const {spawn}       = require('child_process');
+const {execSync}    = require('child_process');
+var CmdHelper   = require('./../helper');
+var console     = lib.logger;
+
+/**
+ * Framework link
+ *
+ * e.g.
+ *  gina framework:link @<project>
+ *  or
+ *  gina link @<project>
+ *
+ * */
+ function Link(opt, cmd) {
+
+    var self    = {};
+
+    var init = function(opt, cmd) {
+        var err = false;
+        if ( !/^true$/i.test(GINA_GLOBAL_MODE) ) {
+            err = new Error('Gina is not installed globally: cannot proceed with linking.');
+            return end(err, 'error', true);
+        }
+
+        // import CMD helpers
+        new CmdHelper(self, opt.client, { port: opt.debugPort, brkEnabled: opt.debugBrkEnabled });
+
+        // check CMD configuration
+        if (!isCmdConfigured()) return false;
+
+        link(opt, cmd);
+    }
+
+    var link = function(opt, cmd) {
+        console.debug('Linking framework');
+
+        var err = null, folder = new _(self.projectLocation);
+
+        if ( folder.isValidPath() && isValidName(self.projectName) ) {
+
+            var destination = new _(self.projectLocation + '/node_modules');
+
+            if ( !destination.existsSync() ) {
+                err = destination.mkdirSync();
+                if (err instanceof Error) {
+                    return end(err, 'error')
+                }
+            }
+            destination = new _(destination.toString() +'/gina');
+            var source = new _(GINA_PREFIX + '/lib/node_modules/gina');
+
+            console.debug('Link '+ source + ' -> '+destination + ' [ exists ] ? '+ destination.existsSync() );
+            if ( destination.existsSync() ) {
+                if ( destination.isSymlinkSync() && destination.getSymlinkSourceSync() == source.toString() ) {
+                    console.debug('Skipping symlink: same source, not overriding.');
+                    return end();
+                }
+                destination.rmSync()
+            }
+
+            err = source.symlinkSync(destination.toString());
+
+            if (err instanceof Error) {
+                return end(err, 'error')
+            }
+        }
+
+        end()
+    }
+
+    var end = function (err, type, messageOnly) {
+        if ( typeof(err) != 'undefined') {
+            var out = ( typeof(messageOnly) != 'undefined' && /^true$/i.test(messageOnly) ) ? err.message : (err.stack||err.message);
+            if ( typeof(type) != 'undefined' ) {
+                console[type](out)
+            } else {
+                console.error(out);
+            }
+        }
+
+        process.exit( err ? 1:0 )
+    }
+
+    init(opt, cmd)
+ }
+
+ module.exports = Link;