separate logic for determining production dependencies in a class

fix broken tests

Author: petekanev

lib/definitions/platform.d.ts

@@ -56,3 +56,7 @@ interface INodeModulesBuilder {
 	prepareNodeModules(absoluteOutputPath: string, platform: string, lastModifiedTime: Date): IFuture<void>;
 	cleanNodeModules(absoluteOutputPath: string, platform: string): void;
 }
+
+interface INodeModulesDependenciesBuilder {
+	getProductionDependencies(projectPath: string): void;
+}

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

@@ -4,6 +4,7 @@ import * as path from "path";
 import * as shelljs from "shelljs";
 import Future = require("fibers/future");
 import { TnsModulesCopy, NpmPluginPrepare } from "./node-modules-dest-copy";
+import { NodeModulesDependenciesBuilder } from "./node-modules-dependencies-builder";
 import * as fiberBootstrap from "../../common/fiber-bootstrap";
 import { sleep } from "../../../lib/common/helpers";
 
@@ -134,12 +135,8 @@ export class NodeModulesBuilder implements INodeModulesBuilder {
 				lastModifiedTime = null;
 			}
 
-			let productionDependencies = this.getProductionDependencies(this.$projectData.projectDir);
-
-			// console.log(productionDependencies);
-
-			// TODO: Pip3r4o - result is not used currently
-			// let nodeModules = this.getChangedNodeModules(absoluteOutputPath, platform, lastModifiedTime).wait();
+			let dependenciesBuilder = this.$injector.resolve(NodeModulesDependenciesBuilder, {});
+			let productionDependencies = dependenciesBuilder.getProductionDependencies(this.$projectData.projectDir);
 
 			if (!this.$options.bundle) {
 				const tnsModulesCopy = this.$injector.resolve(TnsModulesCopy, {
@@ -155,140 +152,6 @@ export class NodeModulesBuilder implements INodeModulesBuilder {
 		}).future<void>()();
 	}
 
-	public getProductionDependencies(projectPath: string) {
-		var deps: any = [];
-		var seen: any = {};
-
-		var pJson = path.join(projectPath, "package.json");
-		var nodeModulesDir = path.join(projectPath, "node_modules");
-
-		var content = require(pJson);
-
-		Object.keys(content.dependencies).forEach((key) => {
-			var depth = 0;
-			var directory = path.join(nodeModulesDir, key);
-
-			// find and traverse child with name `key`, parent's directory -> dep.directory
-			traverseChild(key, directory, depth);
-		});
-
-		return filterUniqueDirectories(deps);
-
-		function traverseChild(name: string, currentModulePath: string, depth: number) {
-			// check if key appears in a scoped module dependency
-			var isScoped = name.indexOf('@') === 0;
-
-			if (!isScoped) {
-				// Check if child has been extracted in the parent's node modules, AND THEN in `node_modules`
-				// Slower, but prevents copying wrong versions if multiple of the same module are installed
-				// Will also prevent copying project's devDependency's version if current module depends on another version
-				var modulePath = path.join(currentModulePath, "node_modules", name); // /node_modules/parent/node_modules/<package>
-				var exists = ensureModuleExists(modulePath);
-
-				if (exists) {
-					var dep = addDependency(deps, name, modulePath, depth + 1);
-
-					traverseModule(modulePath, depth + 1, dep);
-				} else {
-					modulePath = path.join(nodeModulesDir, name); // /node_modules/<package>
-					exists = ensureModuleExists(modulePath);
-
-					if(!exists) {
-						return;
-					}
-
-					var dep = addDependency(deps, name, modulePath, 0);
-
-					traverseModule(modulePath, 0, dep);
-				}
-
-			}
-			// module is scoped 
-			else {
-				var scopeSeparatorIndex = name.indexOf('/');
-				var scope = name.substring(0, scopeSeparatorIndex);
-				var moduleName = name.substring(scopeSeparatorIndex + 1, name.length);
-				var scopedModulePath = path.join(nodeModulesDir, scope, moduleName);
-
-				var exists = ensureModuleExists(scopedModulePath);
-
-				if (exists) {
-					var dep = addDependency(deps, name, scopedModulePath, 0);
-					traverseModule(scopedModulePath, depth, dep);
-				}
-				else {
-					scopedModulePath = path.join(currentModulePath, "node_modules", scope, moduleName);
-
-					exists = ensureModuleExists(scopedModulePath);
-
-					if (!exists) {
-						return;
-					}
-
-					var dep = addDependency(deps, name, scopedModulePath, depth + 1);
-					traverseModule(scopedModulePath, depth + 1, dep);
-				}
-			}
-
-			function traverseModule(modulePath: string, depth: number, currentDependency: any) {
-				var packageJsonPath = path.join(modulePath, 'package.json');
-				var packageJsonExists = fs.lstatSync(packageJsonPath).isFile();
-
-				if (packageJsonExists) {
-					var packageJsonContents = require(packageJsonPath);
-
-					if (!!packageJsonContents.nativescript) {
-						// add `nativescript` property, necessary for resolving plugins
-						currentDependency.nativescript = packageJsonContents.nativescript;
-					}
-
-					if (packageJsonContents.dependencies) {
-						Object.keys(packageJsonContents.dependencies).forEach((key) => {
-
-							traverseChild(key, modulePath, depth);
-						});
-					}
-				}
-			}
-
-			function addDependency(deps: any[], name: string, directory: string, depth: number) {
-				var dep: any = {};
-				dep.name = name;
-				dep.directory = directory;
-				dep.depth = depth;
-
-				deps.push(dep);
-
-				return dep;
-			}
-
-			function ensureModuleExists(modulePath: string): boolean {
-				try {
-					var exists = fs.lstatSync(modulePath);
-					return exists.isDirectory();
-				} catch (e) {
-					return false;
-				}
-			}
-		}
-
-		function filterUniqueDirectories(dependencies: any) {
-			var unique: any = [];
-			var distinct: any = [];
-			for (var i in dependencies) {
-				var dep = dependencies[i];
-				if (distinct.indexOf(dep.directory) > -1) {
-					continue;
-				}
-
-				distinct.push(dep.directory);
-				unique.push(dep);
-			}
-
-			return unique;
-		}
-	}
-
 	public cleanNodeModules(absoluteOutputPath: string, platform: string): void {
 		shelljs.rm("-rf", absoluteOutputPath);
 	}

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

@@ -0,0 +1,112 @@
+import * as path from "path";
+import * as fs from "fs";
+
+export class NodeModulesDependenciesBuilder implements INodeModulesDependenciesBuilder {
+    private projectPath: string;
+    private rootNodeModulesPath: string;
+    private resolvedDependencies: any[];
+    private seen: any;
+
+    public constructor(private $fs: IFileSystem) {
+        this.seen = {};
+        this.resolvedDependencies = [];
+    }
+
+    public getProductionDependencies(projectPath: string): any {
+        this.projectPath = projectPath;
+        this.rootNodeModulesPath = path.join(this.projectPath, "node_modules");
+
+        let projectPackageJsonpath = path.join(this.projectPath, "package.json");
+        let packageJsonContent = this.$fs.readJson(projectPackageJsonpath).wait();
+
+        _.keys(packageJsonContent.dependencies).forEach(dependencyName => {
+            let depth = 0;
+            let directory = path.join(this.rootNodeModulesPath, dependencyName);
+
+            // find and traverse child with name `key`, parent's directory -> dep.directory
+            this.traverseDependency(dependencyName, directory, depth);
+        });
+
+        return this.resolvedDependencies;
+    }
+
+    private traverseDependency(name: string, currentModulePath: string, depth: number): void {
+        // Check if child has been extracted in the parent's node modules, AND THEN in `node_modules`
+        // Slower, but prevents copying wrong versions if multiple of the same module are installed
+        // Will also prevent copying project's devDependency's version if current module depends on another version
+        let modulePath = path.join(currentModulePath, "node_modules", name); // node_modules/parent/node_modules/<package>
+        let alternativeModulePath = path.join(this.rootNodeModulesPath, name);
+
+        this.findModule(modulePath, alternativeModulePath, name, depth);
+    }
+
+    private findModule(modulePath: string, alternativeModulePath: string, name: string, depth: number) {
+        let exists = this.moduleExists(modulePath);
+
+        if (exists) {
+            if (this.seen[modulePath]) {
+                return;
+            }
+
+            let dependency = this.addDependency(name, modulePath, depth + 1);
+            this.readModuleDependencies(modulePath, depth + 1, dependency);
+        } else {
+            modulePath = alternativeModulePath; // /node_modules/<package>
+            exists = this.moduleExists(modulePath);
+
+            if (!exists) {
+                return;
+            }
+
+            if (this.seen[modulePath]) {
+                return;
+            }
+
+            let dependency = this.addDependency(name, modulePath, 0);
+            this.readModuleDependencies(modulePath, 0, dependency);
+        }
+
+        this.seen[modulePath] = true;
+    }
+
+    private readModuleDependencies(modulePath: string, depth: number, currentModule: any): void {
+        let packageJsonPath = path.join(modulePath, 'package.json');
+        let packageJsonExists = fs.lstatSync(packageJsonPath).isFile();
+
+        if (packageJsonExists) {
+            let packageJsonContents = this.$fs.readJson(packageJsonPath).wait();
+
+            if (!!packageJsonContents.nativescript) {
+                // add `nativescript` property, necessary for resolving plugins
+                currentModule.nativescript = packageJsonContents.nativescript;
+            }
+
+            _.keys(packageJsonContents.dependencies).forEach((dependencyName) => {
+                this.traverseDependency(dependencyName, modulePath, depth);
+            });
+        }
+    }
+
+    private addDependency(name: string, directory: string, depth: number): any {
+        let dependency: any = {
+            name,
+            directory,
+            depth
+        };
+
+        this.resolvedDependencies.push(dependency);
+
+        return dependency;
+    }
+
+    private moduleExists(modulePath: string): boolean {
+        try {
+            let exists = fs.lstatSync(modulePath);
+            return exists.isDirectory();
+        } catch (e) {
+            return false;
+        }
+    }
+}
+
+$injector.register("nodeModulesDependenciesBuilder", NodeModulesDependenciesBuilder);

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

@@ -1,6 +1,4 @@
-import * as fs from "fs";
 import * as path from "path";
-import * as semver from "semver";
 import * as shelljs from "shelljs";
 import * as constants from "../../constants";
 import * as minimatch from "minimatch";
@@ -18,8 +16,8 @@ export class TnsModulesCopy {
 	}
 
 	public copyModules(dependencies: any[], platform: string): void {
-		for (var entry in dependencies) {
-			var dependency = dependencies[entry];
+		for (let entry in dependencies) {
+			let dependency = dependencies[entry];
 
 			this.copyDependencyDir(dependency);
 
@@ -30,13 +28,11 @@ export class TnsModulesCopy {
 				let allFiles = this.$fs.enumerateFilesInDirectorySync(tnsCoreModulesResourcePath);
 				let deleteFilesFutures = allFiles.filter(file => minimatch(file, "**/*.ts", { nocase: true })).map(file => this.$fs.deleteFile(file));
 				Future.wait(deleteFilesFutures);
-
-				shelljs.rm("-rf", path.join(this.outputRoot, dependency.name, "node_modules"));
 			}
 		}
 	}
 
-	private copyDependencyDir(dependency: any) {
+	private copyDependencyDir(dependency: any): void {
 		if (dependency.depth === 0) {
 			let isScoped = dependency.name.indexOf("@") === 0;
 			let targetDir = this.outputRoot;
@@ -47,7 +43,6 @@ export class TnsModulesCopy {
 
 			shelljs.mkdir("-p", targetDir);
 			shelljs.cp("-Rf", dependency.directory, targetDir);
-			// console.log("Copied dependency: " + dependency.name);
 		}
 	}
 }