gina 0.0.9-p91c → 0.1.1-alpha.11

package/script/post_install.js

@@ -1,24 +1,25 @@
 /**
  * This file is part of the gina package.
- * Copyright (c) 2016 Rhinostone <gina@rhinostone.com>
+ * Copyright (c) 2017 Rhinostone <contact@gina.io>
  *
  * For the full copyright and license information, please view the LICENSE
  * file that was distributed with this source code.
  */
-process.env.IS_SCRIPT_MODE = true;
-//Imports
-var fs      = require('fs');
-var os      = require('os');
 
-// var helpers = require('./../core/utils/helpers');
-// var utils   = {
-//     logger      : require('./../core/utils/lib/logger'),
-//     generator   : require('./../core/utils/lib/generator')
-// };
+//Imports
+var fs          = require('fs');
+var util        = require('util');
+var promisify   = util.promisify;
+const { execSync } = require('child_process');
 
-var utils = require('./../core/utils');
-var console = utils.logger;
+var lib         = require('./lib');
+var console     = lib.logger;
 
+var scriptPath = __dirname;
+var ginaPath = (scriptPath.replace(/\\/g, '/')).replace('/script', '');
+var help        = require(ginaPath + '/utils/helper.js');
+var pack        = ginaPath + '/package.json';
+pack =  (isWin32()) ? pack.replace(/\//g, '\\') : pack;
 
 
 /**
@@ -27,47 +28,191 @@ var console = utils.logger;
  * */
 function PostInstall() {
 
-    var self = this;
+    var self = {}, _this = this;
 
     //Initialize post installation scripts.
     var init = function() {
-        self.isWin32 = ( os.platform() == 'win32' ) ? true : false;
-        self.path = _( __dirname.substring(0, (__dirname.length - "script".length)-1 ) );
-        self.root = process.cwd().toString();
+        self.isWin32 = isWin32();//getEnvVar('GINA_IS_WIN32');
+        self.path = getEnvVar('GINA_FRAMEWORK');
+        self.gina = getEnvVar('GINA_DIR');
+        self.root = self.gina; // by default
+        self.isGlobalInstall = false;
+        self.prefix = execSync('npm config get prefix');
+        self.isCustomPrefix = false;
+
+        var args = process.argv, i = 0, len = args.length;
+        for (; i < len; ++i) {
+            if (args[i] == '-g' ) {
+                self.isGlobalInstall = true;
+                continue;
+            }
+            if (args[i] == '--prefix' ) {
+                self.isCustomPrefix = true;
+                self.prefix = args[i].split(/\=/)[1];
+                continue;
+            }
+        }
+
+        console.debug('Is this for Windows ? ' +  self.isWin32);
+
+        if ( !self.isGlobalInstall ) { //global install
+            self.root = process.cwd(); // project path
+            console.error('local installation is not supported for this version at the moment.');
+            console.info('please use `npm install -g gina`');
+            process.exit(1);
+        }
+
+        console.debug('prefix path: ' + self.prefix);
+        console.debug('framework path: ' + self.gina);
+        console.debug('framework version path: ' + self.path);
+        console.debug('cwd path: ' + self.root );
+        console.debug('this is a global install ...');
+
+        begin(0);
+    }
 
+    /**
+     * Bebin - Will run checking tasks in order of declaration
+     * */
+     var begin = async function(i) {
+        //console.debug('i is ', i);
+        var n = 0, funct = null, functName = null;
+        for (let t in self) {
+            if ( typeof(self[t]) == 'function') {
+                if (n == i) {
+                    //let func = 'self.' + t + '()';
+                    let func = 'self.' + t;
+                    console.debug('Running [ ' + func + '() ]');
+                    funct       = func;
+                    functName   = t;
+                    break;
+                }
+                n++;
+            }
+        }
 
-        createVersionFile();
-        //console.log('[ debug ] createVersionFile()');
-        createGinaFileForPlatform();
-        //console.log('[ debug ] createGinaFileForPlatform()');
+        // to handle sync vs async to allow execution in order of declaration
+        if (funct) {
+            eval('async function on'+functName+'(){ await promisify('+ funct + ')().catch(function(e){ console.error(e.toString()); process.exit(-1);}).then(function(){ begin('+(i+1)+')});}; on'+functName+'();'); // jshint ignore:line
+        } else {
+            process.exit(0);
+        }
     }
 
-    var createVersionFile = function(callback) {
-        var version = require( _(self.path + '/package.json') ).version;
+    // self.checkIfIsContributorEnv = function(done) {
+    //     var isContribEnv = false;
+    //     if ( new _(self.gina + '/.git', true).existsSync() ) {
+    //         isContribEnv = true;
+    //     }
+    //     var homeDir = getUserHome() || null;
+    //     if (!homeDir) {
+    //         return done(new Error('No $HOME path found !'))
+    //     }
+    //     var ginaHomeDir = homeDir.replace(/\n/g, '') + '/.gina';
+    //     setEnvVar('GINA_HOMEDIR', ginaHomeDir);
+
+    //     var npmGlobal = homeDir.replace(/\n/g, '') + '/.npm-global';
+    //     var IsNpmGlobalFound = false;
+    //     if ( new _(npmGlobal, true).existsSync() ) {
+    //         IsNpmGlobalFound = true;
+
+    //         if ( ! new _(npmGlobal +'/bin', true).existsSync() ) {
+    //             new _(npmGlobal +'/bin', true).mkdirSync()
+    //         }
+    //         if ( ! new _(npmGlobal +'/lib/node_modules', true).existsSync() ) {
+    //             new _(npmGlobal +'/lib/node_modules', true).mkdirSync()
+    //         }
+    //     }
+
+    //     console.debug(self.gina, ' | ', ginaHomeDir);
+    //     console.debug('Is contributor‘s env ? : '+ isContribEnv);
+
+    //     // Fixing `npm link` VS `.npm-global` issue on contributors env
+    //     /**
+    //      * Patch designed to use `npm link gina` in your project
+    //      * without taking the risk to get the wrong package version
+    //      *
+    //      * See.:
+    //      * 4 reasons to avoid using `npm link`  - https://hirok.io/posts/avoid-npm-link
+    //      * */
+    //     if (isContribEnv && IsNpmGlobalFound) {
+    //         console.debug('Contributor case detected ...\n', JSON.stringify(process.env, null, 2));
+
+    //         lib.generator.createFileFromDataSync(isContribEnv +'\n'+ '\n'+ IsNpmGlobalFound +'\n'+ JSON.stringify(process.env, null, 2), npmGlobal+'/npm_out.txt');
+
+    //         // symlink the lib
+    //         // ln -s /usr/local/lib/node_modules/gina ~/.npm-global/lib/node_modules/gina
+    //         // symlink the bin
+    //         // ln -s ~/.npm-global/lib/node_modules/gina/bin/gina ~/.npm-global/bin/gina
+    //     }
+
+    //     done();
+    // }
+
+
+    self.createVersionFile = function(done) {
+        var version = require( _(self.gina + '/package.json') ).version;
+        console.debug('writting version number: '+ version);
+
         var target = _(self.path + '/VERSION');
         try {
             if ( fs.existsSync(target) ) {
-                fs.unlinkSync(target);
-                setTimeout(function(){
-                    if (callback) {
+                fs.unlinkSync(target)
+            }
+            fs.writeFileSync(target, version);
+        } catch(err) {
+            return done(err)
+        }
 
+        done();
+    }
 
+    var configureGina = function() {
+        // link to ./bin/cli to binaries dir
+        if (!self.isWin32) {
+            var binPath     = _(self.prefix+'/bin', true);
+            var cli         = _(binPath +'/gina');
+            // TODO - remove this part for the next version
+            var cliDebug    = _(binPath +'/gina-debug');
 
-                            fs.writeFileSync(target, version);
-                            callback()
+            if ( fs.existsSync(cli) ) {
+                fs.unlinkSync(cli)
+            }
+            // TODO - remove this part for the next version
+            if ( fs.existsSync(cliDebug) ) {
+                fs.unlinkSync(cliDebug)
+            }
 
-                    } else {
-                        fs.writeFileSync(target, version);
+            var cmd = 'ln -s '+ self.gina +'/bin/gina '+ binPath +'/gina';
+            console.debug('running: '+ cmd);
+            run(cmd, { cwd: _(self.path), tmp: _(self.root +'/tmp'), outToProcessSTD: true })
+                .onData(function(data){
+                    console.info(data)
+                })
+                .onComplete( function onDone(err, data){
+                    if (err) {
+                        console.error(err);
+                        console.warn('try to run : sudo ' + cmd);
                     }
-                }, 1000)
-
-            } else {
-                fs.writeFileSync(target, version);
-            }
+                });
+            // To debug, you just need to run:
+            //          gina <topic>:<task> --inspect-gina
+            //
+            // TODO - remove this part for the next version
+            // cmd = 'ln -s '+ self.gina +'/bin/cli-debug '+ binPath +'/gina-debug';
+            // run(cmd, { cwd: _(self.path), tmp: _(self.root +'/tmp'), outToProcessSTD: true })
+            //     .onData(function(data){
+            //         console.info(data)
+            //     })
+            //     .onComplete( function onDone(err, data){
+            //         if (err) {
+            //             console.error(err);
+            //             console.warn('try to run : sudo ' + cmd);
+            //         }
+            //     });
 
-        } catch(err) {
-            throw err;
-            process.exit(0)
+        } else {
+            console.warn('linking gina binary is not supported yet for Windows.');
         }
     }
 
@@ -80,55 +225,78 @@ function PostInstall() {
         if ( typeof(win32Name) != 'undefined') {
             target = _(appPath +'/'+ win32Name)
         }
-
         //Will override.
+        console.info('linking to binaries dir ... ');
         if ( typeof(callback) != 'undefined') {
+            if ( !self.isGlobalInstall ) { // local install only
+                lib.generator.createFileFromTemplate(source, target, function onGinaFileCreated(err) {
+                    callback(err)
 
-            try {
-                utils.generator.createFileFromTemplateSync(source, target);
-                setTimeout(function () {
-                    callback(false)
-                }, 1000)
-            } catch (err) {
-                callback(err)
+                })
+            } else {
+
+                // configureGina();
+                callback(false)
             }
         } else {
-            utils.generator.createFileFromTemplateSync(source, target)
+            if ( !self.isGlobalInstall ) {
+                lib.generator.createFileFromTemplate(source, target)
+            }
+            // else {
+            //     configureGina();
+            // }
         }
     }
 
-    var createGinaFileForPlatform = function() {
-        console.log('creating platform file');
-        //console.log('[ debug ] about to open ' + _(self.path + '/package.json'));
+    self.createGinaFileForPlatform = async function(done) {
+        console.info('Creating platform file');
         var name = require( _(self.path + '/package.json') ).name;
 
         var filename = ( (self.isWin32) ? '.' : '' ) + name;
 
         var keepGoing = function(filename) {
 
-
-
-            createGinaFile(filename, function onGinaFileCreated(err){
-
+            createGinaFile(filename, function onFileCreated(err) {
                 if (err) {
-                    throw err;
-                    return false
+                    return done(err)
                 }
+
                 // this is done to allow multiple calls of post_install.js
                 var filename = _(self.path + '/SUCCESS');
                 var installed = fs.existsSync( filename );
-                if (!installed /**&& /node_modules\/gina/.test( new _(process.cwd()).toUnixStyle() ) */ ) {
-                    fs.writeFileSync(filename, true )
+                if (installed) {
+                    fs.unlinkSync( filename );
                 }
 
-                // old NPM : < 3 & compatible 3+
-                console.log('> now installing dependencies, please wait ...\n\r');
-                var dependencies = require( _(self.path + '/package.json') ).ginaDependencies;
-
-                // starting from NodeJS v5.x, it is done automatically
-                npmInstall(dependencies);
+                // if ( /node_modules\/gina/.test( new _(process.cwd()).toUnixStyle() ) ) {
+                //     var msg = "Gina's command line tool has been installed.";
+                //     console.info(msg);
+                //     process.exit(0)
+                // }
+
+                console.debug('Writting '+ filename);
+                fs.writeFileSync(filename, 'true' );
+
+                // do something that can be called after the first time installation
+
+
+                // Check if npm install has been done
+                if ( !hasNodeModulesSync() ) {
+                    return npmInstall(done)
+                } else {
+                    var target = new _(self.path + '/node_modules');
+                    console.debug('replacing: ', target.toString() );
+                    return target
+                        .rm( function onRemove(err) {
+                            if (err) {
+                                return done(err);
+                            } else {
+                                return npmInstall(done)
+                            }
+                        })
+                }
 
-            });
+            })
         }
 
         if (self.isWin32) {
@@ -138,147 +306,279 @@ function PostInstall() {
             if ( fs.existsSync(target) ) {
                 fs.unlinkSync(target);
                 // have to wait for windows to complete this
-                setTimeout( function(){
-                    utils.generator.createFileFromTemplateSync(source, target);
-                    keepGoing(filename)
+                setTimeout( async function(){
+                    lib.generator.createFileFromTemplate(source, target);
+                    await keepGoing(filename)
                 }, 1000)
             } else {
-                utils.generator.createFileFromTemplateSync(source, target);
-                keepGoing(filename)
+                lib.generator.createFileFromTemplate(source, target);
+                await keepGoing(filename)
             }
+
         } else {
-            filename += '.sh';// patch for latest npm release
-            keepGoing(filename)
+            await keepGoing(filename)
         }
     }
 
 
-    var npmInstall = function(modules) {
-        if ( modules.count() == 0 ) {
-            console.log("\nGina's command line tool has been installed !\n");
-            process.exit(0)
-        }
+    var hasNodeModulesSync = function() {
+        return fs.existsSync( _(self.path + '/node_modules') )
+    }
 
+
+    var npmInstall = function(done) {
+        console.info('now installing modules: please, wait ...');
+        console.info('Prefix ('+ self.isCustomPrefix +'): '+ self.prefix);
         var cmd = ( isWin32() ) ? 'npm.cmd install' : 'npm install';
-        var key = null;
-        for (var m in modules) {
-            key = m;
-            if ( modules[m] != '') {
-                cmd += ' '+ m +'@'+ modules[m];
-                console.log('installing [ '+ m +'@'+ modules[m] +' ]');
-            } else {
-                cmd += ' '+ m + '@latest';
-                console.log('installing [ '+ m + '@latest ]');
+        cmd = self.prefix +'/'+ cmd
+        run(cmd, { cwd: _(self.path), tmp: _(self.root +'/tmp'), outToProcessSTD: true })
+            .onData(function onData(data){
+                console.info(data)
+            })
+            .onComplete( function onDone(err, data){
+                if (!err) {
+                    return done()
+                }
+                done(err)
+            })
+    }
+
+    self.cleanupIfNeeded = function(done) {
+
+        var frameworkPath = self.gina;
+        console.debug('Framework path is: ' + frameworkPath);
+
+        // Let's cleanup `colors` from `GINA_DIR`
+        if ( new _(frameworkPath +'/node_modules/colors', true).existsSync() ) {
+            var initialDir = process.cwd();
+            process.chdir(frameworkPath);
+            var cmd = ( isWin32() ) ? 'npm.cmd rm colors' : 'npm rm colors';
+            cmd = self.prefix +'/'+ cmd
+            try {
+                execSync(cmd);
+                console.debug('Removed default `colors` module from `GINA_DIR`... This is normal ;)');
+            } catch (npmErr) {
+                return done(npmErr);
             }
 
-            break
+            process.chdir(initialDir);
         }
 
-        delete modules[key];
+        done()
+    }
+
+    self.checkUserExtensions = async function(done) {
+
+        var userDir = _(getUserHome() + '/.gina/user', true);
+        // var userDirObj = new _(userDir);
+        // if ( ! userDirObj.existsSync() ) {
+        //     userDirObj.mkdirSync();
+        // }
+        // var extDir = _(userDir +'/extensions', true);
+        // var extDirObj = new _(extDir);
+        // if ( ! extDirObj.existsSync() ) {
+        //     extDirObj.mkdirSync();
+        // }
+
+        // // logger
+        // var extLogger = _(extDir +'/logger', true);
+
+        // reading default extensions
+        var ext = _(self.gina +'/resources/home/user/extensions', true);
+        var folders = [];
+        try {
+            console.debug('Reading : '+ ext + ' - isDirectory ? '+ fs.lstatSync( ext ).isDirectory() );
+            folders = fs.readdirSync(ext);
 
-        if ( !fs.existsSync(self.path) ) {
-            fs.mkdirSync(self.path)
+        } catch(readErr) {
+            throw readErr
         }
 
-        if ( !fs.existsSync(self.path +'/node_modules') ) {
-            fs.mkdirSync(self.path +'/node_modules')
+        for (let i = 0, len = folders.length; i < len; i++) {
+            let dir = folders[i];
+            // skip junk
+            if ( /^\./i.test(dir) || /(\s+copy|\.old)$/i.test(dir) ) {
+                continue;
+            }
+
+            // skip symlinks
+            try {
+                console.debug('Checking: '+ _(ext +'/'+ dir, true) + ' - isSymbolicLink ? '+ fs.lstatSync( _(ext +'/'+ dir, true) ).isSymbolicLink() );
+                if ( fs.lstatSync( _(ext +'/'+ dir, true) ).isSymbolicLink() ) {
+                    continue;
+                }
+            } catch (e) {
+                continue;
+            }
+
+            let userExtPath = _(userDir +'/extensions/'+ dir, true);
+            let userExtPathObj = new _(userExtPath)
+            if ( !userExtPathObj.existsSync() ) {
+                userExtPathObj.mkdirSync()
+            }
+
+            let files = []
+                , extDir = _(ext +'/'+ dir, true)
+                , extDirObj = new _(extDir)
+            ;
+            try {
+
+                console.debug('Reading extDir: '+ extDir + ' - isDirectory ? '+ fs.lstatSync( extDir ).isDirectory() );
+                if ( !fs.lstatSync( extDir ).isDirectory() ) {
+                    continue;
+                }
+
+
+                files = fs.readdirSync( extDir );
+
+            } catch(fileReadErr) {}
+
+            console.debug("What about files ? " + files);
+
+            for (let n = 0, nLen = files.length; n < nLen; n++) {
+                let file = files[n];
+                console.debug('file --> ', file);
+                let extentionPath   = _(extDir +'/'+ file, true);
+                let extensionPathObj =  new _(extentionPath);
+                // redefined
+                let userExtPathObj = new _(userExtPath + '/'+ file, true);
+                if ( !userExtPathObj.existsSync() ) {
+                    let f = function(destination, cb) {// jshint ignore:line
+                        extensionPathObj.cp(destination, cb);
+                    };
+                    let err = false;
+                    await promisify(f)( _(userExtPath + '/'+ file, true) )
+                        .catch( function onCopyError(_err) {// jshint ignore:line
+                            err = _err;
+                        })
+                        .then( function onCopy(_destination) {// jshint ignore:line
+                            console.info('Copy '+ extentionPath +' to '+ _destination +' done !');
+                        });
+
+                    if (err) {
+                        throw err;
+                    }
+                }
+            }
         }
 
-        if ( !fs.existsSync(self.path +'/tmp') ) {
-            fs.mkdirSync(self.path +'/tmp')
+
+        done()
+    }
+
+    var restoreSymlinks = function() {
+        var archivesPath = _(getUserHome() + '/.gina/archives/framework', true);
+        var frameworkPath = _(self.gina +'/framework', true);
+
+        if ( !new _(archivesPath).existsSync() ) {
+            return;
         }
+        // get current framework version
+        var package = require(pack);
+        var currentVersion = 'v'+ package.version.replace(/^v/, '');
+
+        // cleanup first
+        var versionsFolders = fs.readdirSync(frameworkPath);
+        for (let i = 0, len = versionsFolders.length; i < len; i++) {
+            let dir = versionsFolders[i];
+            // skip junk
+            if ( /^\./i.test(dir) || /(\s+copy|\.old)$/i.test(dir) ) {
+                continue;
+            }
 
-        //console.debug('cwd: ' + _(self.path));
-        //console.debug('tmp: ' +  _(self.root +'/tmp'));
+            // intercept & remove existing symlinks or old versions dir
+            try {
+                if ( fs.lstatSync( _(frameworkPath +'/'+ dir, true) ).isSymbolicLink() ) {
+                    new _(frameworkPath +'/'+ dir, true).rmSync();
+                    console.debug('Removing Symlink: '+ dir);
+                    continue;
+                }
+                else if (
+                    dir != currentVersion
+                    && fs.lstatSync( _(frameworkPath +'/'+ dir, true) ).isDirectory()
+                ) {
+                    console.debug('Removing old version: '+ dir);
+                    new _(frameworkPath +'/'+ dir, true).rmSync()
+                }
+            } catch (e) {
+                continue;
+            }
+        }
 
-        run(cmd, { cwd: _(self.path), tmp: _(self.root +'/tmp')  })
-            .onData(function(data){
-                //console.info(data)
-            })
-            .onComplete( function done(err, data){
-                if (err && err != 'false') {
-                    console.error(err);
-                    //console.debug('\nCommand was: \n'+ cmd)
-                } //else {
-                    //console.info(data);
-                    //end()
-                //}
-
-                npmInstall(modules)
-            })
+        // restoring symlinks from archives
+        versionsFolders = fs.readdirSync(archivesPath);
+        for (let i = 0, len = versionsFolders.length; i < len; i++) {
+            let dir = versionsFolders[i];
+            // skip junk
+            if ( /^\./i.test(dir) || /(\s+copy|\.old)$/i.test(dir) ) {
+                continue;
+            }
+
+            // skip selected - for dev team only
+            if ( new _(frameworkPath +'/'+ dir, true).existsSync() ) {
+                continue;
+            }
+
+            // creating symlinks
+            try {
+                console.debug( 'Creating symlink: '+ _(archivesPath +'/'+ dir, true) +' -> '+ _(frameworkPath +'/'+ dir, true));
+                new _(archivesPath +'/'+ dir, true).symlinkSync(_(frameworkPath +'/'+ dir, true) );
+            } catch (e) {
+                throw e
+            }
+        }
     }
 
-    var end = function() {
+    self.end = function(done) {
+
+        restoreSymlinks();
+
         // Update middleware file
         var filename = _(self.path) + '/MIDDLEWARE';
-        var msg = "Gina's command line tool has been installed.\n\r";
+        var msg = "Gina's command line tool has been installed.";
 
         var deps = require(_(self.path) + '/package.json').dependecies;
 
+        var version = require( _(self.gina + '/package.json') ).version;
+        var middleware = 'isaac@'+version; // by default
 
-        for (var d in deps) {
+        for (let d in deps) {
             if (d === 'express' && deps[d] != '') {
-                var middleware = d +'@'+ deps[d]
+                middleware = d +'@'+ deps[d]
             }
         }
 
         var expressPackage = _(self.path + '/node_modules/express/package.json');
         if ( typeof(middleware) == 'undefined' && fs.existsSync(expressPackage) ) {
-            var middleware = require(expressPackage).version;
+            middleware = require(expressPackage).version;
             middleware = 'express@' + middleware;
         } else if (typeof(middleware) == 'undefined') {
-            throw new Error('No middleware found !!');
-            process.exit(0)
+            return done( new Error('No middleware found !!') );
         }
 
         if ( fs.existsSync(filename) ) { // update
             var def = fs.readFileSync(filename).toString;
             // TODO - uninstall old if installed ??
             if (def !== middleware) {
-
-                try {
-
-                    fs.writeFileSync(filename, middleware);
-                    console.log(msg)
-                } catch (err) {
-                    throw new Error(err.stack||err.message||err);
-                    process.exit(0)
-                }
-
-                // fs.writeFile(filename, middleware, function onWrote(err){
-                //     if (err) {
-                //         throw new Error(err.stack||err.message||err);
-                //         process.exit(1)
-                //     } else {
-                //         console.log(msg)
-                //     }
-                // })
+                fs.writeFile(filename, middleware, function onWrote(err){
+                    if (err) {
+                        return done(err)
+                    }
+                    console.info(msg);
+                    done()
+                })
             } // else, nothing to do
         } else { // create
-
-            try {
-
-                fs.writeFileSync(filename, middleware);
-                console.log(msg)
-            } catch (err) {
-                throw new Error(err.stack||err.message||err);
-                process.exit(0)
-            }
-
-            // fs.writeFile(filename, middleware, function onWrote(err){
-            //     if (err) {
-            //         throw new Error(err.stack||err.message||err);
-            //         process.exit(1)
-            //     } else {
-            //         console.log(msg)
-            //     }
-            // })
+            fs.writeFile(filename, middleware, function onWrote(err){
+                if (err) {
+                    return done(err)
+                }
+                console.info(msg);
+                done()
+            })
         }
     }
 
-    //var createGinaHome = function() { };
-
-
     init()
-};
+}
 new PostInstall()