Merge pull request #524 from NativeScript/fatme/npm-as-package-manager

Npm as package manager

Author: Fatme

.idea/nativescript-cli.iml

@@ -44,9 +44,18 @@ $injector.requireCommand("emulate|android", "./commands/emulate");
 $injector.requireCommand("emulate|ios", "./commands/emulate");
 
 $injector.require("npm", "./node-package-manager");
+$injector.require("npmInstallationManager", "./npm-installation-manager");
 $injector.require("lockfile", "./lockfile");
 $injector.require("dynamicHelpProvider", "./dynamic-help-provider");
 $injector.require("mobilePlatformsCapabilities", "./mobile-platforms-capabilities");
 $injector.require("commandsServiceProvider", "./providers/commands-service-provider");
 
 $injector.require("logcatPrinter", "./providers/logcat-printer");
+
+$injector.require("broccoliBuilder", "./tools/broccoli/builder");
+$injector.require("nodeModulesTree", "./tools/broccoli/trees/node-modules-tree");
+$injector.require("broccoliPluginWrapper", "./tools/broccoli/broccoli-plugin-wrapper");
+
+$injector.require("pluginsService", "./services/plugins-service");
+$injector.requireCommand("plugin|add", "./commands/plugin/add-plugin");
+$injector.requireCommand("plugin|remove", "./commands/plugin/remove-plugin");

lib/bootstrap.ts

@@ -0,0 +1,30 @@
+///<reference path="../../.d.ts"/>
+"use strict";
+
+export class AddPluginCommand implements ICommand {
+	constructor(private $pluginsService: IPluginsService,
+		private $errors: IErrors) { }
+	
+	execute(args: string[]): IFuture<void> {
+		return this.$pluginsService.add(args[0]);
+	}
+	
+	canExecute(args: string[]): IFuture<boolean> {
+		return (() => {
+			if(!args[0]) {
+				this.$errors.fail("You must specify plugin name.");
+			}
+			
+			let installedPlugins = this.$pluginsService.getAllInstalledPlugins().wait();
+			let pluginName = args[0].toLowerCase();
+			if(_.any(installedPlugins, (plugin: IPluginData) => plugin.name.toLowerCase() === pluginName)) {
+				this.$errors.failWithoutHelp(`Plugin "${pluginName}" is already installed.`);
+			}
+			
+			return true; 
+		}).future<boolean>()();
+	}
+	
+	public allowedParameters: ICommandParameter[] = [];
+}
+$injector.registerCommand("plugin|add", AddPluginCommand);

lib/commands/plugin/add-plugin.ts

@@ -0,0 +1,30 @@
+///<reference path="../../.d.ts"/>
+"use strict";
+
+export class RemovePluginCommand implements ICommand {
+	constructor(private $pluginsService: IPluginsService,
+		private $errors: IErrors) { }
+	
+	execute(args: string[]): IFuture<void> {
+		return this.$pluginsService.remove(args[0]);
+	}
+	
+	canExecute(args: string[]): IFuture<boolean> {
+		return (() => {
+			if(!args[0]) {
+				this.$errors.fail("You must specify plugin name.");
+			}
+			
+			let installedPlugins = this.$pluginsService.getAllInstalledPlugins().wait();
+			let pluginName = args[0].toLowerCase();
+			if(!_.any(installedPlugins, (plugin: IPluginData) => plugin.name.toLowerCase() === pluginName)) {
+				this.$errors.failWithoutHelp(`Plugin "${pluginName}" is not installed.`);
+			}
+			
+			return true;
+		}).future<boolean>()();
+	}
+	
+	public allowedParameters: ICommandParameter[] = [];
+}
+$injector.registerCommand("plugin|remove", RemovePluginCommand);

lib/commands/plugin/remove-plugin.ts

@@ -3,6 +3,10 @@
 export var APP_FOLDER_NAME = "app";
 export var APP_RESOURCES_FOLDER_NAME = "App_Resources";
 export var PROJECT_FRAMEWORK_FOLDER_NAME = "framework";
+export var NATIVESCRIPT_KEY_NAME = "nativescript";
+export var NODE_MODULES_FOLDER_NAME = "node_modules";
+export var PACKAGE_JSON_FILE_NAME = "package.json";
+export var NODE_MODULE_CACHE_PATH_KEY_NAME = "node-modules-cache-path";
 
 export class ReleaseType {
 	static MAJOR = "major";

lib/constants.ts

@@ -1,8 +1,17 @@
 interface INodePackageManager {
+	getCache(): string;
+	load(config?: any): IFuture<void>;
+	install(packageName: string, pathToSave: string, config?: any): IFuture<any>;
+	uninstall(packageName: string, config?: any): IFuture<any>;
+	cache(packageName: string, version: string, cache?: any): IFuture<ICacheData>;
+	cacheUnpack(packageName: string, version: string, unpackTarget?: string): IFuture<void>;
+	view(packageName: string, propertyName: string): IFuture<any>;
+}
+
+interface INpmInstallationManager {
 	getCacheRootPath(): string;
 	addToCache(packageName: string, version: string): IFuture<void>;
 	cacheUnpack(packageName: string, version: string, unpackTarget?: string): IFuture<void>;
-	load(config?: any): IFuture<void>;
 	install(packageName: string, options?: INpmInstallOptions): IFuture<string>;
 	getLatestVersion(packageName: string): IFuture<string>;
 	getCachedPackagePath(packageName: string, version: string): string;
@@ -13,6 +22,14 @@ interface INpmInstallOptions {
 	version?: string;
 }
 
+interface ICacheData {
+	name: string;
+	version: string;
+	dependencies: IStringDictionary;
+	devDependencies: IStringDictionary;
+	nativescript?: any;
+}
+
 interface IStaticConfig extends Config.IStaticConfig { }
 
 interface IConfiguration extends Config.IConfig { }
@@ -40,6 +57,7 @@ interface IOptions extends ICommonOptions {
 	symlink: boolean;
 	forDevice: boolean;
 	client: boolean;
+	production: boolean;
 	keyStorePath: string;
 	keyStorePassword: string;
 	keyStoreAlias: string;

lib/declarations.ts

@@ -34,6 +34,8 @@ interface IPlatformData {
 	frameworkDirectoriesExtensions?: string[];
 	frameworkDirectoriesNames?: string[];
 	targetedOS?: string[];
+	configurationFileName?: string;
+	configurationFilePath?: string;
 }
 
 interface IPlatformsData {

lib/definitions/platform.d.ts

@@ -0,0 +1,24 @@
+interface IPluginsService {
+	add(plugin: string): IFuture<void>; // adds plugin by name, github url, local path and et.
+	remove(pluginName: string): IFuture<void>; // removes plugin only by name
+	prepare(pluginData: IPluginData): IFuture<void>;
+	getAllInstalledPlugins(): IFuture<IPluginData[]>;
+	ensureAllDependenciesAreInstalled(): IFuture<void>;
+}
+
+interface IPluginData extends INodeModuleData {
+	platformsData: IPluginPlatformsData; 
+}
+
+interface INodeModuleData {
+	name: string;
+	version: string;
+	fullPath: string;
+	isPlugin: boolean;
+	moduleInfo: any;
+}
+
+interface IPluginPlatformsData {
+	ios: string;
+	android: string;
+}

lib/definitions/plugins.d.ts

@@ -3,5 +3,6 @@ declare module "shelljs" {
 	function cp(arg: string, sourcePath: string[], destinationPath: string): void;
 	function sed(arg: string, oldValue: any, newValue: string, filePath: string): void;
 	function mv(source: string[], destination: string): void;
+	function rm(option: string, filePath: string): void;
 	function grep(what: any, where: string): any;
 }

lib/definitions/shelljs.d.ts

@@ -3,42 +3,18 @@
 
 import Future = require("fibers/future");
 import npm = require("npm");
-import path = require("path");
-import semver = require("semver");
-import shell = require("shelljs");
-import helpers = require("./common/helpers");
-import constants = require("./constants");
 
 export class NodePackageManager implements INodePackageManager {
-	private static NPM_LOAD_FAILED = "Failed to retrieve data from npm. Please try again a little bit later.";
-	private static NPM_REGISTRY_URL = "http://registry.npmjs.org/";
-
-	private versionsCache: IDictionary<string[]>;
-
 	constructor(private $logger: ILogger,
 		private $errors: IErrors,
 		private $fs: IFileSystem,
 		private $lockfile: ILockFile,
-		private $options: IOptions) {
-		this.versionsCache = {};
-		this.load().wait();
-	}
+		private $options: IOptions) { }
 
-	public getCacheRootPath(): string {
+	public getCache(): string {
 		return npm.cache;
 	}
-
-	public addToCache(packageName: string, version: string): IFuture<void> {
-		return (() => {
-			this.addToCacheCore(packageName, version).wait();
-
-			var packagePath = path.join(npm.cache, packageName, version, "package");
-			if(!this.isPackageUnpacked(packagePath).wait()) {
-				this.cacheUnpack(packageName, version).wait();
-			}
-		}).future<void>()();
-	}
-
+	
 	public load(config?: any): IFuture<void> {
 		var future = new Future<void>();
 		npm.load(config, (err) => {
@@ -50,128 +26,51 @@ export class NodePackageManager implements INodePackageManager {
 		});
 		return future;
 	}
-
-	public install(packageName: string, opts?: INpmInstallOptions): IFuture<string> {
-		return (() => {
-			this.$lockfile.lock().wait();
-
-			try {
-				var packageToInstall = packageName;
-				var pathToSave = (opts && opts.pathToSave) || npm.cache;
-				var version = (opts && opts.version) || null;
-
-				return this.installCore(packageToInstall, pathToSave, version).wait();
-			} catch(error) {
-				this.$logger.debug(error);
-				this.$errors.fail("%s. Error: %s", NodePackageManager.NPM_LOAD_FAILED, error);
-			} finally {
-				this.$lockfile.unlock().wait();
-			}
-
-		}).future<string>()();
+	
+	public install(packageName: string, pathToSave: string, config?: any): IFuture<any> {
+		return this.loadAndExecute("install", [pathToSave, packageName], { config: config });
 	}
-
-	public getLatestVersion(packageName: string): IFuture<string> {
-		var future = new Future<string>();
-
-		npm.commands["view"]([packageName, "dist-tags"], [false], (err: any, data: any) => { // [false] - silent
-			if(err) {
-				future.throw(err);
-			} else {
-				var latestVersion = _.first(_.keys(data));
-				this.$logger.trace("Using version %s. ", latestVersion);
-
-				future.return(latestVersion);
-			}
-		});
-
-		return future;
+	
+	public uninstall(packageName: string, config?: any): IFuture<any> {
+		return this.loadAndExecute("uninstall", [[packageName]], { config: config });
 	}
 
-	public getCachedPackagePath(packageName: string, version: string): string {
-		return path.join(npm.cache, packageName, version, "package");
+	public cache(packageName: string, version: string, config?: any): IFuture<ICacheData> {
+		// function cache (pkg, ver, where, scrub, cb)
+		return this.loadAndExecute("cache", [packageName, version, undefined, false], { subCommandName: "add", config: config });
 	}
-
-	private installCore(packageName: string, pathToSave: string, version: string): IFuture<string> {
-		return (() => {
-			if (this.$options.frameworkPath) {
-				if (this.$fs.getFsStats(this.$options.frameworkPath).wait().isFile()) {
-					this.npmInstall(packageName, pathToSave, version).wait();
-					var pathToNodeModules = path.join(pathToSave, "node_modules");
-					var folders = this.$fs.readDirectory(pathToNodeModules).wait();
-					return path.join(pathToNodeModules, folders[0]);
-				}
-				return this.$options.frameworkPath;
-			} else {
-				version = version || this.getLatestVersion(packageName).wait();
-				var packagePath = this.getCachedPackagePath(packageName, version);
-				if (!this.isPackageCached(packagePath).wait()) {
-					this.addToCacheCore(packageName, version).wait();
-				}
-
-				if(!this.isPackageUnpacked(packagePath).wait()) {
-					this.cacheUnpack(packageName, version).wait();
-				}
-				return packagePath;
-			}
-		}).future<string>()();
-	}
-
-	private npmInstall(packageName: string, pathToSave: string, version: string): IFuture<void> {
-		this.$logger.out("Installing ", packageName);
-
-		var incrementedVersion = semver.inc(version, constants.ReleaseType.MINOR);
-		if (!this.$options.frameworkPath && packageName.indexOf("@") < 0) {
-			packageName = packageName + "@<" + incrementedVersion;
-		}
-
-		var future = new Future<void>();
-		npm.commands["install"](pathToSave, packageName, (err: Error, data: any) => {
-			if(err) {
-				future.throw(err);
-			} else {
-				this.$logger.out("Installed ", packageName);
-				future.return(data);
-			}
-		});
-		return future;
+	
+	public cacheUnpack(packageName: string, version: string, unpackTarget?: string): IFuture<void> {
+		// function unpack (pkg, ver, unpackTarget, dMode, fMode, uid, gid, cb)
+		return this.loadAndExecute("cache", [packageName, version, unpackTarget, null, null, null, null], { subCommandName: "unpack" });
 	}
-
-	private isPackageCached(packagePath: string): IFuture<boolean> {
-		return this.$fs.exists(packagePath);
+	
+	public view(packageName: string, propertyName: string): IFuture<any> {
+		return this.loadAndExecute("view", [[packageName, propertyName], [false]]);
 	}
-
-	private isPackageUnpacked(packagePath: string): IFuture<boolean> {
+	
+	private loadAndExecute(commandName: string, args: any[], opts?: { config?: any, subCommandName?: string }): IFuture<any> {
 		return (() => {
-			return this.$fs.getFsStats(packagePath).wait().isDirectory() &&
-				this.$fs.enumerateFilesInDirectorySync(packagePath).length > 1;
-		}).future<boolean>()();
-	}
-
-	private addToCacheCore(packageName: string, version: string): IFuture<void> {
-		var future = new Future<void>();
-		// cache.add = function (pkg, ver, where, scrub, cb)
-		npm.commands["cache"].add(packageName, version, undefined, false, (err: Error, data: any) => {
-			if(err) {
-				future.throw(err);
-			} else {
-				future.return();
-			}
-		});
-		return future;
+			opts = opts || {};
+			this.load(opts.config).wait();
+			return this.executeCore(commandName, args, opts.subCommandName).wait();
+		}).future<any>()();
 	}
-
-	public cacheUnpack(packageName: string, version: string, unpackTarget?: string): IFuture<void> {
-		var future = new Future<void>();
-		unpackTarget = unpackTarget || path.join(npm.cache, packageName, version, "package");
-		// function unpack (pkg, ver, unpackTarget, dMode, fMode, uid, gid, cb)
-		npm.commands["cache"].unpack(packageName, version, unpackTarget, null, null, null, null, (err: Error, data: any) => {
+	
+	private executeCore(commandName: string, args: any[], subCommandName?: string): IFuture<any> {
+		let future = new Future<any>();
+		let callback = (err: Error, data: any) => {
 			if(err) {
 				future.throw(err);
 			} else {
-				future.return();
+				future.return(data);
 			}
-		});
+		}
+		args.push(callback);
+		
+		let command = subCommandName ? npm.commands[commandName][subCommandName] : npm.commands[commandName];
+		command.apply(this, args);
+		
 		return future;
 	}
 }