npm.commands.install([], function(err) {
if (err) return logger.error(err);
npm.commands.shrinkwrap([], true, function(err) {
if (err) {
return cb('Shrinkwrapping failed. :( Try manually doing it by cd\'ing to the directory and running `npm shrinkwrap`.', null);
}
return cb(null, 'I reinstalled and shrinkwrapped your dependencies for you.');
});
});
npm.load({}, function() {
npm.commands.show([name, 'version'], true, function(err, version) {
if (err || !version) {
return callback();
}
var obj = Object.keys(version);
callback(null, Array.isArray(obj) && obj.length ? obj[0] : null);
});
});
getLocalHarpVersion(function(er, data) {
if (er) return handleError(er);
if (data === false) {
npm.commands.install(["harp@latest"], function (er, data) {
if (er) return handleError(er);
callback(null, data)
});
}
});
npm.load({}, function (er) {
if (er) return console.log(er);
npm.commands.view(["harp","version"], true, function (er, data) {
if (er) return handleError(er);
var version = Object.keys(data)[0];
callback(null, semver.clean(version));
});
});
npm.load(function(err, npm) {
if (err) {
grunt.log.error(err);
return;
}
for (var i = 0; i < installPath.length; i++) {
npm.commands.install(installPath[i], modules, errorHandler);
}
});
npm.load(function(err, npm) {
npm.commands.uninstall([module], function(err) {
if (err) {
console.log(chalk.red('Error: npm install failed'));
return console.error(err);
}
console.log(chalk.green(' npm uninstall complete'));
});
});
npm.load({cache: tempdir, registry: address}, function () {
npm.commands.install(tempdir, "test-package-with-one-dep", function (err) {
var exists = fs.existsSync(tempdir + "/node_modules/test-package-with-one-dep/" +
"node_modules/test-package/package.json")
assert.ok(exists)
s.close()
done()
})
})
remove_installed_periodic_from_node_modules({prefixpath:prefixpath},(err)=>{
if(err){callback(err);}
else{
npm.commands.i(
currentConfig.node_modules,
callback
);
}
});
npm.load([], function (err, npm) {
npm.commands.search(search, function(err, res){
if (err){
console.log('NPM Search Error ' + err);
return;
}
callback(res);
});
});
npm.load({cache: tempdir, registry: address}, function () {
npm.commands.install(tempdir, "underscore", function (err) {
require.cache[path] = null
var version = require(path).version
assert.equal(version, "1.5.1")
s.close()
done()
})
})
npm.load(function(err, npm) {
npm.localPrefix = __dirname;
npm.commands.install(['express@~3.1.0'], function() {
// run tests
require('./app');
require('./async_helpers');
done();
});
});
var npmInstall = function (target) {
winston.info("Installing module: " + target);
npm.commands.install(npm.prefix, [target], function (err) {
if (err)
return cb(Error.create("'npm install' command failed.", { target: target }, err));
winston.info("Module installed: " + target);
cb();
});
};
var npmLink = function (target) {
winston.info("Linking module: " + target);
npm.commands.link([target], function (err) {
if (err)
return cb(Error.create("'npm link' command failed.", { target: target }, err));
winston.info("Module linked: " + target);
cb();
});
};
npm.load(npmOptions, function() {
npm.commands.install([ module ], function(error) {
if (quiet) {
stdout.restore();
}
callback(error);
});
});
npm.load(function(err) {
if (err) return cb(err)
npm.commands[command](args, function errBack(err, data) {
if (err) return cb(err)
if (!command || ['install', 'uninstall'].indexOf(command) === false) return cb("invalid command")
if (data.length > 0) checkInstalled(installedArrayToObject(data))
else cb(false, "lunny installed 0 plugins")
})
})
npm.load(opts.npm || {} , function (er) {
if (er) return cb(er)
npm.commands.view([name, "versions", "time"], true, function (er, data) {
if (er) {
if (opts.warn.E404 && er.code === "E404") {
return cb(null, { name: name, warn: { msg: er.toString(), code: er.code } })
}
return cb(er)
}
var stable = Object.keys(data)[0]
, versions = null
// `npm view 0 versions` returns {}
if (!stable) {
return cb(new Error("Failed to get latest version info for " + name))
}
// Some packages simply don't have a time object
if (data[stable].time) {
versions = data[stable].versions.sort(function (a, b) {
a = data[stable].time[a]
b = data[stable].time[b]
return (a < b ? -1 : (a > b ? 1 : 0))
})
} else {
versions = data[stable].versions
}
var latest = versions[versions.length - 1]
if (!isStable(stable)) {
stable = getLatestStable(versions)
}
// getLatestStable might not have found a stable version
if (stable) {
// Latest is the most recent version with higher version than stable
for (var i = versions.length - 1; i >= 0; i--) {
try {
// If !opts.loose then this may throw
if (semver.gt(versions[i], stable, opts.loose)) {
latest = versions[i]
break
}
} catch (er) {
return cb(er)
}
}
}
cb(null, {name: name, latest: latest, stable: stable})
})
})
}, function(err) {
if (err) return handleError(err);
npm.commands.install(packages, function(err, message) {
if (err) return handleError(err);
console.log("NPM POSTINALL: %s", message);
});
npm.on("log", function(message) {
console.log("NPM POSTINALL: %s", message);
});
});
publishPackage: function(callback) {
var packedPackagePath = this.filePath.getAbsolutePath();
npm.commands.publish([packedPackagePath], function (error, data) {
if (!error) {
callback();
} else {
callback(new Exception("NpmError", {}, "Error occurred in NPM", [error]));
}
});
}
npm.load({}, function(err, npm) {
npm.commands.list([], true, function(err, pkgInfo) {
Object.keys(pkgInfo._dependencies).forEach(name => {
const requiredVersion = pkgInfo.dependencies[name]._dependencies[pkg];
if (requiredVersion && !semver.satisfies(version, requiredVersion)) {
console.log(`${name}@${pkgInfo._dependencies[name]} dependes on ${pkg}: ${requiredVersion}`);
}
});
});
});
async.each(Object.keys(lag), function (name, cb) {
var lowercaseName = name.toLowerCase();
var modulePath = path.resolve(__dirname, '../.tmp/' + lowercaseName);
npm.commands.publish([modulePath], function (err) {
if (!err) console.log('lag.' + lowercaseName + ' published!');
if (!err) moduleNum += 1;
cb(err);
});
}, function (err) {
return new Promise(function (resolve, reject) {
npm.commands.info(args, true, function (e, r) {
if (e) {
reject(e);
}
else {
resolve(r);
}
});
});
function npmLoaded(er){
// After npm has been installed and loaded
if (er) return talker.log(er)
// Install svnmonitor prereq
npm.config.set('loglevel','silent');
npm.on("log", function (message) { /*Do nothing*/})
npm.commands.install(['svnmonitor'],svnMonitorInstalled);
};
npm.commands.init([], function(err, data) {
if (err) throw err;
console.log('\n');
util.log('running `npm publish`');
npm.commands.publish([], function(err, data) {
if (err) throw err;
util.log('publish done');
});
});
var npmInstall = function(source,callback) {
if (!is.array(source)) source = [source];
var cl = console.log;
console.log = function() {};
npm.commands.install(source,function() {
console.log = cl;
callback.apply(this,arguments);
});
};
npm.load(function (err) {
if(err) deferred.reject(err);
npm.commands.install(function () {
if(err) deferred.reject(err);
process.chdir(cwd);
deferred.resolve(properties);
});
});
npm.load(projectPackageJson, function () {
npm.commands.install(function (error) {
if (error) {
cb(error);
}
else {
cb();
}
});
});
npm.load(runDirectoryPrefix, function () {
npm.commands.stop(function (error) {
if (error) {
cb(error);
}
else {
cb();
}
});
});
//
// Install all dependencies into the target directory
//
function installAll (deps) {
npm.commands.install(dir, deps, function (err) {
if (err) {
return callback(err);
}
haibu.emit('npm:install:success', 'info', meta);
callback(null, deps);
});
}
npm.load(npm.config, function (err) {
if (err) { logger.error(err); }
npm.commands.install(['phantomjs@1.9.19'], function (err) {
if (err) { logger.error(err); }
launchPhantom(prequire('phantomjs').path);
});
npm.on('log', function (message) {
logger.info(message);
});
});
npm.load(buildPackageJsonWithPrefix, function () {
npm.commands.install(function (error) {
if (error) {
cb(error);
}
else {
cb();
}
});
});