nap-cli/lib/install.js

a new package cli

var http = require('http');
var MAC = require('getmac');
var pkg = require('../package.json');
var fs = require('fs-extra');
var path = require('path');
var clc = require('cli-color');
var jszip = require('node-zip');
var child = require('child_process');

var Resolvemodules = {};

module.exports = function(name, options){
    var modulename = name;
    var doSave = false;
    var moduleversion = '';
    if ( options.save ){
        modulename = options.save;
        doSave = true;
    }

    if ( options.which ){
        moduleversion = options.which;
    }

    var querys = {};
    var pather = require('./me');
    if ( fs.existsSync(pather) ){
        var c = require(pather);
        querys.guid = c.guid;
        querys.token = c.token;
    }
    MAC.getMac(function(err, macAddress){
        if (err){
            querys.mac = '';
        }else{
            querys.mac = macAddress;
        }
        if ( moduleversion ){
            querys.version = moduleversion;
        }else{
            querys.version = 'lastest';
        }
        querys.name = modulename;
        Resolvemodules = {};
        var mist = null;


        if ( !modulename ){
            return installAll(querys, process.cwd(), options);
        }

        console.log(clc.red('➜ Getting modules from remote ......'));
        getModule(querys, process.cwd(), options, function(err){
            if ( err ){
                console.log(clc.red('➜ ' + err.message))
            }else{
                var j = 0;
                for ( var i in Resolvemodules ){
                    if ( j === 0 ){
                        console.log(clc.magenta('+ ' + i + '@' + Resolvemodules[i]));
                        mist = {
                            name: i,
                            version: Resolvemodules[i],
                            dir: 'node_modules/' + i
                        }
                    }else{
                        console.log(clc.yellow('  - ' + i + '@' + Resolvemodules[i]));
                    }
                    j++;
                }
                if ( mist ){
                    if ( doSave ){
                        var pct = path.resolve(process.cwd(), 'package.json');
                        if ( fs.existsSync(pct) ){
                            var dck = require(pct);
                            if ( !dck.napDependencies ){
                                dck.napDependencies = {};
                            }
                            dck.napDependencies[mist.name] = '^' + mist.version;
                            fs.writeFileSync(pct, JSON.stringify(dck, null, 2));
                        }
                    }
                    if ( !options.npm ){
                        var worker = path.resolve(process.cwd(), 'node_modules', modulename);
                        child.execSync('npm install --registry=https://registry.npm.taobao.org', {cwd: worker});
                        console.log(clc.green('➜ ' + mist.name + '@' + mist.version + ' : ' + mist.dir));
                        //var result = child.spawnSync('npm', ['install', '--registry=https://registry.npm.taobao.org'], {stdio: 'inherit', cwd: worker});
                        //if (result.status == 0) {
                        //    console.log(clc.green('➜ ' + mist.name + '@' + mist.version + ' : ' + mist.dir));
                        //}
                    }else{
                        console.log(clc.green('➜ ' + mist.name + '@' + mist.version + ' : ' + mist.dir));
                    }
                }
            }
        });
    });
};

function getModule(querys, dir, options, callback){
    var querystrings = [];
    var url = pkg.remotehost + '/install';
    for ( var i in querys ){
        querystrings.push(i + '=' + querys[i]);
    }
    url += '?' + querystrings.join('&');

    http.get(url, function(res){
        var body = [];
        res.on('data', function(chunk){
            body.push(chunk);
        });
        res.on('end', function(){
            if (res.statusCode === 200){
                body = Buffer.concat(body);
                savePackage(body, dir, querys, options, callback);
            }else{
                var ret = JSON.parse(body);
                callback(ret);
            }
        });
    }).on('error', callback);
}

function savePackage(body, dir, querys, options, callback){
    var zip = new jszip();
    zip.load(body);
    var dpkg = JSON.parse(zip.file('package.json').asText());
    var nodemoduledir = path.resolve(dir, 'node_modules');
    if ( !fs.existsSync(nodemoduledir) ){
        fs.mkdirSync(nodemoduledir);
    }
    var moduledir = path.resolve(nodemoduledir, dpkg.name);
    if ( !fs.existsSync(moduledir) ){
        fs.mkdirSync(moduledir);
    }
    var fls = zip.file(/.+/);
    var pm = function(p){
        return path.resolve(moduledir, p);
    };

    fls.forEach(function(file){
        file = file.name;
        var buf = zip.file(file).asNodeBuffer();
        fs.outputFileSync(pm(file), buf);
    });

    if ( !Resolvemodules[dpkg.name] ){
        Resolvemodules[dpkg.name] = dpkg.version;
    }

    var deps = dpkg.napDependencies;
    if ( deps ){
        var keys = Object.keys(deps);
        if ( keys.length ){
            resolveDeps(0, keys, deps, querys, moduledir, options, callback);
        }else{
            callback(null);
        }
    }else{
        callback(null);
    }

}

function resolveDeps(i, keys, deps, querys, dir, options, callback){
    var name = keys[i];
    var version = deps[keys[i]];
    if ( name && version ){
        if ( version === '*' ){
            version = 'lastest';
        }else{
            version = version.replace(/^\D+/, '');
        }
        querys.name = name;
        querys.version = version;
        getModule(querys, dir, options, function(err){
            if ( err ){
                callback(err);
            }else{
                if ( !options.npm ){
                    var worker = path.resolve(dir, 'node_modules', name);
                    child.execSync('npm install --registry=https://registry.npm.taobao.org', {cwd: worker});
                    resolveDeps(++i, keys, deps, querys, dir, options, callback);
                    //var result = child.spawnSync('npm', ['install', '--registry=https://registry.npm.taobao.org'], {stdio: 'inherit', cwd: worker});
                    //if (result.status == 0) {
                    //    resolveDeps(++i, keys, deps, querys, dir, options, callback);
                    //}
                }else{
                    resolveDeps(++i, keys, deps, querys, dir, options, callback);
                }

            }
        })
    }else{
        callback(null);
    }
}

function installAll(querys, dir, options){
    var pct = path.resolve(process.cwd(), 'package.json');
    if ( fs.existsSync(pct) ){
        var dck = require(pct);
        if ( !dck.napDependencies ){
            return console.log(clc.red('➜ Nothing to install!'));
        }
        var total = Object.keys(dck.napDependencies);
        if ( total.length ){
            resolveDeps(0, total, dck.napDependencies, querys, dir, options, function(err){
                if ( err ){
                    return console.log(clc.red('➜ ' + err.message));
                }

                for ( var i in Resolvemodules ){
                    console.log(clc.magenta('+ ' + i + '@' + Resolvemodules[i]));
                }
            });
        }else{
            console.log(clc.red('➜ Nothing to install!'));
        }
    }else{
        console.log(clc.red('➜ Nothing to install!'));
    }
}