Merge pull request #2118 from NativeScript/hdeshev/webpack-plugins

Prepare plugins independently of node_modules

Author: hdeshev

.travis.yml

@@ -14,6 +14,9 @@ before_script:
 - npm install grunt
 - node_modules/.bin/grunt enableScripts:false
 - npm install
+- grunt rebuild
+- ./bin/nativescript error-reporting disable # force ~/.local dir creation -- some tests rely on it
+- ./bin/nativescript usage-reporting disable
 - npm test
 - node_modules/.bin/grunt enableScripts:true
 script:

lib/definitions/plugins.d.ts

@@ -5,8 +5,6 @@ interface IPluginsService {
 	prepare(pluginData: IDependencyData, platform: string): IFuture<void>;
 	getAllInstalledPlugins(): IFuture<IPluginData[]>;
 	ensureAllDependenciesAreInstalled(): IFuture<void>;
-	afterPrepareAllPlugins(): IFuture<void>;
-	beforePrepareAllPlugins(): IFuture<void>;
 	getDependenciesFromPackageJson(): IFuture<IPackageJsonDepedenciesResult>
 }
 

lib/services/platform-service.ts

@@ -290,13 +290,8 @@ export class PlatformService implements IPlatformService {
 			let appDir = path.join(platformData.appDestinationDirectoryPath, constants.APP_FOLDER_NAME);
 			try {
 				let tnsModulesDestinationPath = path.join(appDir, constants.TNS_MODULES_FOLDER_NAME);
-				if (!this.$options.bundle) {
-					// Process node_modules folder
-					this.$nodeModulesBuilder.prepareNodeModules(tnsModulesDestinationPath, platform, lastModifiedTime).wait();
-				} else {
-					// Clean target node_modules folder. Not needed when bundling.
-					this.$nodeModulesBuilder.cleanNodeModules(tnsModulesDestinationPath, platform);
-				}
+				// Process node_modules folder
+				this.$nodeModulesBuilder.prepareNodeModules(tnsModulesDestinationPath, platform, lastModifiedTime).wait();
 			} catch (error) {
 				this.$logger.debug(error);
 				shell.rm("-rf", appDir);

lib/services/plugins-service.ts

@@ -109,32 +109,48 @@ export class PluginsService implements IPluginsService {
 		return (() => {
 			platform = platform.toLowerCase();
 			let platformData = this.$platformsData.getPlatformData(platform);
-			let pluginDestinationPath = path.join(platformData.appDestinationDirectoryPath, constants.APP_FOLDER_NAME, "tns_modules");
 			let pluginData = this.convertToPluginData(dependencyData);
 
-			let exists = this.$fs.exists(path.join(platformData.appDestinationDirectoryPath, constants.APP_FOLDER_NAME)).wait();
-
-			if (!this.isPluginDataValidForPlatform(pluginData, platform).wait()) {
-				// Still clean up platform in case other platforms were supported.
-				shelljs.rm("-rf", path.join(pluginDestinationPath, pluginData.name, "platforms"));
-				return;
-			}
-
-			if (exists) {
-				//prepare platform speciffic files, .map and .ts files
-				this.$projectFilesManager.processPlatformSpecificFiles(pluginDestinationPath, platform).wait();
-
-				//deal with platforms/android folder in ns plugin
-				pluginData.pluginPlatformsFolderPath = (_platform: string) => path.join(pluginData.fullPath, "platforms", _platform);
-				platformData.platformProjectService.preparePluginNativeCode(pluginData).wait();
-				shelljs.rm("-rf", path.join(pluginDestinationPath, pluginData.name, "platforms"));
+			let appFolderExists = this.$fs.exists(path.join(platformData.appDestinationDirectoryPath, constants.APP_FOLDER_NAME)).wait();
+			if (appFolderExists) {
+				this.preparePluginScripts(pluginData, platform);
+				this.preparePluginNativeCode(pluginData, platform);
 
 				// Show message
 				this.$logger.out(`Successfully prepared plugin ${pluginData.name} for ${platform}.`);
 			}
 		}).future<void>()();
 	}
 
+	private preparePluginScripts(pluginData: IPluginData, platform: string): void {
+		let platformData = this.$platformsData.getPlatformData(platform);
+		let pluginScriptsDestinationPath = path.join(platformData.appDestinationDirectoryPath, constants.APP_FOLDER_NAME, "tns_modules");
+		let scriptsDestinationExists = this.$fs.exists(pluginScriptsDestinationPath).wait();
+		if (!scriptsDestinationExists) {
+			//tns_modules/<plugin> doesn't exist. Assuming we're running a bundled prepare.
+			return;
+		}
+
+		if (!this.isPluginDataValidForPlatform(pluginData, platform).wait()) {
+			// Still clean up platform in case other platforms were supported.
+			shelljs.rm("-rf", path.join(pluginScriptsDestinationPath , pluginData.name, "platforms"));
+			return;
+		}
+
+		//prepare platform speciffic files, .map and .ts files
+		this.$projectFilesManager.processPlatformSpecificFiles(pluginScriptsDestinationPath , platform).wait();
+	}
+
+	private preparePluginNativeCode(pluginData: IPluginData, platform: string): void {
+		let platformData = this.$platformsData.getPlatformData(platform);
+		let pluginScriptsDestinationPath = path.join(platformData.appDestinationDirectoryPath, constants.APP_FOLDER_NAME, "tns_modules");
+
+		pluginData.pluginPlatformsFolderPath = (_platform: string) => path.join(pluginData.fullPath, "platforms", _platform);
+		platformData.platformProjectService.preparePluginNativeCode(pluginData).wait();
+		shelljs.rm("-rf", path.join(pluginScriptsDestinationPath , pluginData.name, "platforms"));
+
+	}
+
 	public ensureAllDependenciesAreInstalled(): IFuture<void> {
 		return (() => {
 			let installedDependencies = this.$fs.exists(this.nodeModulesPath).wait() ? this.$fs.readDirectory(this.nodeModulesPath).wait() : [];
@@ -165,22 +181,6 @@ export class PluginsService implements IPluginsService {
 		}).future<IPluginData[]>()();
 	}
 
-	public afterPrepareAllPlugins(): IFuture<void> {
-		let action = (pluginDestinationPath: string, platform: string, platformData: IPlatformData) => {
-			return platformData.platformProjectService.afterPrepareAllPlugins();
-		};
-
-		return this.executeForAllInstalledPlatforms(action);
-	}
-
-	public beforePrepareAllPlugins(): IFuture<void> {
-		let action = (pluginDestinationPath: string, platform: string, platformData: IPlatformData) => {
-			return platformData.platformProjectService.beforePrepareAllPlugins();
-		};
-
-		return this.executeForAllInstalledPlatforms(action);
-	}
-
 	public getDependenciesFromPackageJson(): IFuture<IPackageJsonDepedenciesResult> {
 		return (() => {
 			let packageJson = this.$fs.readJson(this.getPackageJsonFilePath()).wait();

lib/tools/node-modules/node-modules-builder.ts

@@ -3,7 +3,7 @@ import * as fs from "fs";
 import * as path from "path";
 import * as shelljs from "shelljs";
 import Future = require("fibers/future");
-import * as destCopyLib from "./node-modules-dest-copy";
+import {NpmDependencyResolver, TnsModulesCopy, NpmPluginPrepare} from "./node-modules-dest-copy";
 import * as fiberBootstrap from "../../common/fiber-bootstrap";
 import {sleep} from "../../../lib/common/helpers";
 
@@ -16,7 +16,9 @@ export class NodeModulesBuilder implements INodeModulesBuilder {
 		private $projectDataService: IProjectDataService,
 		private $injector: IInjector,
 		private $logger: ILogger,
-		private $lockfile: ILockFile) { }
+		private $lockfile: ILockFile,
+		private $options: IOptions
+	) { }
 
 	public getChangedNodeModules(absoluteOutputPath: string, platform: string, lastModifiedTime?: Date): IFuture<any> {
 		return (() => {
@@ -108,20 +110,20 @@ export class NodeModulesBuilder implements INodeModulesBuilder {
 			}
 
 			if (!lastModifiedTime || isNodeModulesModified) {
-				this.listModules(nodeModulesPath, nodeModules);
+				this.expandScopedModules(nodeModulesPath, nodeModules);
 			}
 
 			return nodeModules;
 		}).future<any>()();
 	}
 
-	private listModules(nodeModulesPath: string, nodeModules: any): void {
+	private expandScopedModules(nodeModulesPath: string, nodeModules: IStringDictionary): void {
 		let nodeModulesDirectories = this.$fs.exists(nodeModulesPath).wait() ? this.$fs.readDirectory(nodeModulesPath).wait() : [];
 		_.each(nodeModulesDirectories, nodeModuleDirectoryName => {
 			let isNpmScope = /^@/.test(nodeModuleDirectoryName);
 			let nodeModuleFullPath = path.join(nodeModulesPath, nodeModuleDirectoryName);
 			if (isNpmScope) {
-				this.listModules(nodeModuleFullPath, nodeModules);
+				this.expandScopedModules(nodeModuleFullPath, nodeModules);
 			} else {
 				nodeModules[nodeModuleFullPath] = nodeModuleFullPath;
 			}
@@ -135,16 +137,21 @@ export class NodeModulesBuilder implements INodeModulesBuilder {
 				lastModifiedTime = null;
 			}
 			let nodeModules = this.getChangedNodeModules(absoluteOutputPath, platform, lastModifiedTime).wait();
-			let destCopy = this.$injector.resolve(destCopyLib.DestCopy, {
-				inputPath: this.$projectData.projectDir,
-				cachePath: "",
-				outputRoot: absoluteOutputPath,
-				projectDir: this.$projectData.projectDir,
-				platform: platform
-			});
 
-			destCopy.rebuildChangedDirectories(_.keys(nodeModules), platform);
+			const resolver = new NpmDependencyResolver(this.$projectData.projectDir);
+			const resolvedDependencies = resolver.resolveDependencies(_.keys(nodeModules), platform);
 
+			if (!this.$options.bundle) {
+				const tnsModulesCopy = this.$injector.resolve(TnsModulesCopy, {
+					outputRoot: absoluteOutputPath
+				});
+				tnsModulesCopy.copyModules(resolvedDependencies, platform);
+			} else {
+				this.cleanNodeModules(absoluteOutputPath, platform);
+			}
+
+			const npmPluginPrepare = this.$injector.resolve(NpmPluginPrepare, {});
+			npmPluginPrepare.preparePlugins(resolvedDependencies, platform);
 		}).future<void>()();
 	}
 

lib/tools/node-modules/node-modules-dest-copy.ts

@@ -6,33 +6,28 @@ import * as constants from "../../constants";
 import * as minimatch from "minimatch";
 import Future = require("fibers/future");
 
-/**
- * Intercepts each directory as it is copied to the destination tempdir,
- * and tees a copy to the given path outside the tmp dir.
- */
-export class DestCopy {
-	private dependencies: IDictionary<any> = null;
-	private devDependencies: IDictionary<any> = null;
+export interface ILocalDependencyData extends IDependencyData {
+	directory: string;
+}
 
+export class NpmDependencyResolver {
 	constructor(
-		private inputPath: string,
-		private cachePath: string,
-		private outputRoot: string,
-		private projectDir: string,
-		private platform: string,
-		private $fs: IFileSystem,
-		private $projectFilesManager: IProjectFilesManager,
-		private $pluginsService: IPluginsService,
-		private $platformsData: IPlatformsData
+		private projectDir: string
 	) {
-		this.dependencies = Object.create(null);
-		this.devDependencies = this.getDevDependencies(projectDir);
 	}
 
-	public rebuildChangedDirectories(changedDirectories: string[], platform: string): void {
+	private getDevDependencies(projectDir: string): IDictionary<any> {
+		let projectFilePath = path.join(projectDir, constants.PACKAGE_JSON_FILE_NAME);
+		let projectFileContent = require(projectFilePath);
+		return projectFileContent.devDependencies || {};
+	}
+
+    public resolveDependencies(changedDirectories: string[], platform: string): IDictionary<ILocalDependencyData> {
+		const devDependencies = this.getDevDependencies(this.projectDir);
+		const dependencies: IDictionary<ILocalDependencyData> = Object.create(null);
 
 		_.each(changedDirectories, changedDirectoryAbsolutePath => {
-			if (!this.devDependencies[path.basename(changedDirectoryAbsolutePath)]) {
+			if (!devDependencies[path.basename(changedDirectoryAbsolutePath)]) {
 				let pathToPackageJson = path.join(changedDirectoryAbsolutePath, constants.PACKAGE_JSON_FILE_NAME);
 				let packageJsonFiles = fs.existsSync(pathToPackageJson) ? [pathToPackageJson] : [];
 				let nodeModulesFolderPath = path.join(changedDirectoryAbsolutePath, constants.NODE_MODULES_FOLDER_NAME);
@@ -41,15 +36,15 @@ export class DestCopy {
 				_.each(packageJsonFiles, packageJsonFilePath => {
 					let fileContent = require(packageJsonFilePath);
 
-					if (!this.devDependencies[fileContent.name] && fileContent.name && fileContent.version) { // Don't flatten dev dependencies and flatten only dependencies with valid package.json
-						let currentDependency = {
+					if (!devDependencies[fileContent.name] && fileContent.name && fileContent.version) { // Don't flatten dev dependencies and flatten only dependencies with valid package.json
+						let currentDependency: ILocalDependencyData = {
 							name: fileContent.name,
 							version: fileContent.version,
 							directory: path.dirname(packageJsonFilePath),
 							nativescript: fileContent.nativescript
 						};
 
-						let addedDependency = this.dependencies[currentDependency.name];
+						let addedDependency = dependencies[currentDependency.name];
 						if (addedDependency) {
 							if (semver.gt(currentDependency.version, addedDependency.version)) {
 								let currentDependencyMajorVersion = semver.major(currentDependency.version);
@@ -59,26 +54,53 @@ export class DestCopy {
 								let logger = $injector.resolve("$logger");
 								currentDependencyMajorVersion === addedDependencyMajorVersion ? logger.out(message) : logger.warn(message);
 
-								this.dependencies[currentDependency.name] = currentDependency;
+								dependencies[currentDependency.name] = currentDependency;
 							}
 						} else {
-							this.dependencies[currentDependency.name] = currentDependency;
+							dependencies[currentDependency.name] = currentDependency;
 						}
 					}
 				});
 			}
 		});
-		if (!_.isEmpty(this.dependencies)) {
-			this.$platformsData.getPlatformData(platform).platformProjectService.beforePrepareAllPlugins().wait();
-		}
+		return dependencies;
+    }
 
-		_.each(this.dependencies, dependency => {
-			this.copyDependencyDir(dependency);
+	private enumeratePackageJsonFilesSync(nodeModulesDirectoryPath: string, foundFiles?: string[]): string[] {
+		foundFiles = foundFiles || [];
+		if (fs.existsSync(nodeModulesDirectoryPath)) {
+			let contents = fs.readdirSync(nodeModulesDirectoryPath);
+			for (let i = 0; i < contents.length; ++i) {
+				let moduleName = contents[i];
+				let moduleDirectoryInNodeModules = path.join(nodeModulesDirectoryPath, moduleName);
+				let packageJsonFilePath = path.join(moduleDirectoryInNodeModules, constants.PACKAGE_JSON_FILE_NAME);
+				if (fs.existsSync(packageJsonFilePath)) {
+					foundFiles.push(packageJsonFilePath);
+				}
 
-			let isPlugin = !!dependency.nativescript;
-			if (isPlugin) {
-				this.$pluginsService.prepare(dependency, platform).wait();
+				let directoryPath = path.join(moduleDirectoryInNodeModules, constants.NODE_MODULES_FOLDER_NAME);
+				if (fs.existsSync(directoryPath)) {
+					this.enumeratePackageJsonFilesSync(directoryPath, foundFiles);
+				} else if (fs.statSync(moduleDirectoryInNodeModules).isDirectory()) {
+					// Scoped modules (e.g. @angular) are grouped in a subfolder and we need to enumerate them too.
+					this.enumeratePackageJsonFilesSync(moduleDirectoryInNodeModules, foundFiles);
+				}
 			}
+		}
+		return foundFiles;
+	}
+}
+
+export class TnsModulesCopy {
+	constructor(
+		private outputRoot: string,
+		private $fs: IFileSystem
+	) {
+	}
+
+	public copyModules(dependencies: IDictionary<ILocalDependencyData>, platform: string): void {
+		_.each(dependencies, dependency => {
+			this.copyDependencyDir(dependency);
 
 			if (dependency.name === constants.TNS_CORE_MODULES_NAME) {
 				let tnsCoreModulesResourcePath = path.join(this.outputRoot, constants.TNS_CORE_MODULES_NAME);
@@ -92,10 +114,6 @@ export class DestCopy {
 				this.$fs.deleteDirectory(tnsCoreModulesResourcePath).wait();
 			}
 		});
-
-		if (!_.isEmpty(this.dependencies)) {
-			this.$platformsData.getPlatformData(platform).platformProjectService.afterPrepareAllPlugins().wait();
-		}
 	}
 
 	private copyDependencyDir(dependency: any): void {
@@ -109,36 +127,29 @@ export class DestCopy {
 		shelljs.cp("-Rf", dependency.directory, targetDir);
 		shelljs.rm("-rf", path.join(targetDir, dependency.name, "node_modules"));
 	}
+}
 
-	private getDevDependencies(projectDir: string): IDictionary<any> {
-		let projectFilePath = path.join(projectDir, constants.PACKAGE_JSON_FILE_NAME);
-		let projectFileContent = require(projectFilePath);
-		return projectFileContent.devDependencies || {};
+export class NpmPluginPrepare {
+	constructor(
+		private $fs: IFileSystem,
+		private $pluginsService: IPluginsService,
+		private $platformsData: IPlatformsData
+	) {
 	}
 
-	private enumeratePackageJsonFilesSync(nodeModulesDirectoryPath: string, foundFiles?: string[]): string[] {
-		foundFiles = foundFiles || [];
-		if (fs.existsSync(nodeModulesDirectoryPath)) {
-			let contents = fs.readdirSync(nodeModulesDirectoryPath);
-			for (let i = 0; i < contents.length; ++i) {
-				let moduleName = contents[i];
-				let moduleDirectoryInNodeModules = path.join(nodeModulesDirectoryPath, moduleName);
-				let packageJsonFilePath = path.join(moduleDirectoryInNodeModules, constants.PACKAGE_JSON_FILE_NAME);
-				if (fs.existsSync(packageJsonFilePath)) {
-					foundFiles.push(packageJsonFilePath);
-				}
+	public preparePlugins(dependencies: IDictionary<IDependencyData>, platform: string): void {
+		if (_.isEmpty(dependencies)) {
+			return;
+		}
 
-				let directoryPath = path.join(moduleDirectoryInNodeModules, constants.NODE_MODULES_FOLDER_NAME);
-				if (fs.existsSync(directoryPath)) {
-					this.enumeratePackageJsonFilesSync(directoryPath, foundFiles);
-				} else if (fs.statSync(moduleDirectoryInNodeModules).isDirectory()) {
-					// Some modules can be grouped in one folder and we need to enumerate them too (e.g. @angular).
-					this.enumeratePackageJsonFilesSync(moduleDirectoryInNodeModules, foundFiles);
-				}
+		this.$platformsData.getPlatformData(platform).platformProjectService.beforePrepareAllPlugins().wait();
+		_.each(dependencies, dependency => {
+			let isPlugin = !!dependency.nativescript;
+			if (isPlugin) {
+				console.log("preparing: " + dependency.name);
+				this.$pluginsService.prepare(dependency, platform).wait();
 			}
-		}
-		return foundFiles;
+		});
+		this.$platformsData.getPlatformData(platform).platformProjectService.afterPrepareAllPlugins().wait();
 	}
 }
-
-export default DestCopy;