Fix symlinks that are added to output package and points to not existing location

Fatme Havaluova · Fatme Havaluova · commit 39863a4b9564 · 2015-06-26T10:14:52.000+03:00
diff --git a/lib/services/platform-service.ts b/lib/services/platform-service.ts
@@ -148,13 +148,17 @@ export class PlatformService implements IPlatformService {
 			platform = platform.toLowerCase();
 
 			var platformData = this.$platformsData.getPlatformData(platform);
+			let appDestinationDirectoryPath = path.join(platformData.appDestinationDirectoryPath, constants.APP_FOLDER_NAME);
+			let lastModifiedTime = this.$fs.exists(appDestinationDirectoryPath).wait() ? 
+				this.$fs.getFsStats(appDestinationDirectoryPath).wait().mtime : null;
 
 			// Copy app folder to native project
+			this.$fs.ensureDirectoryExists(appDestinationDirectoryPath).wait();
 			var appSourceDirectoryPath = path.join(this.$projectData.projectDir, constants.APP_FOLDER_NAME);
-
+			
 			// Delete the destination app in order to prevent EEXIST errors when symlinks are used.
 			this.$fs.deleteDirectory(path.join(platformData.appDestinationDirectoryPath, constants.APP_FOLDER_NAME)).wait();
-			shell.cp("-R", appSourceDirectoryPath, platformData.appDestinationDirectoryPath);
+			shell.cp("-R", appSourceDirectoryPath, platformData.appDestinationDirectoryPath);			
 
 			// Copy App_Resources to project root folder
 			this.$fs.ensureDirectoryExists(platformData.appResourcesDestinationDirectoryPath).wait(); // Should be deleted
@@ -182,7 +186,7 @@ export class PlatformService implements IPlatformService {
 			// Process node_modules folder
 			this.$pluginsService.ensureAllDependenciesAreInstalled().wait();
 			var tnsModulesDestinationPath = path.join(platformData.appDestinationDirectoryPath, constants.APP_FOLDER_NAME, PlatformService.TNS_MODULES_FOLDER_NAME);
-			this.$broccoliBuilder.prepareNodeModules(tnsModulesDestinationPath, this.$projectData.projectDir).wait();
+			this.$broccoliBuilder.prepareNodeModules(tnsModulesDestinationPath, this.$projectData.projectDir, lastModifiedTime).wait();
 
 			this.$logger.out("Project successfully prepared");
 		}).future<void>()();
diff --git a/lib/tools/broccoli/broccoli.d.ts b/lib/tools/broccoli/broccoli.d.ts
@@ -152,7 +152,7 @@ interface BroccoliNode {
 }
 
 interface IBroccoliBuilder {
-   prepareNodeModules(outputPath: string,  projectDir: string): IFuture<void>;
+   prepareNodeModules(outputPath: string,  projectDir: string, lastModifiedTime?: any): IFuture<void>;
 }
 
 interface IDiffResult {
@@ -162,6 +162,7 @@ interface IDiffResult {
 
 interface IBroccoliPlugin {
   rebuild(diff: IDiffResult): any;
+  rebuildChangedDirectories?(changedDirectories: string[]): void;
   cleanup? () : void;
 }
 
diff --git a/lib/tools/broccoli/builder.ts b/lib/tools/broccoli/builder.ts
@@ -5,29 +5,65 @@ let broccoli = require('broccoli');
 let path = require('path');
 import Future = require("fibers/future");
 import {TreeDiffer} from './tree-differ';
-import destCopy = require('./node-modules-dest-copy');
+import destCopyLib = require('./node-modules-dest-copy');
+
+var gulp = require("gulp");
+var vinylFilterSince = require('vinyl-filter-since')
+var through = require("through2"); 
 
 export class Builder implements IBroccoliBuilder {
+   private nodeModules: any = {};
+  
   constructor(private $fs: IFileSystem,
     private $nodeModulesTree: INodeModulesTree,
     private $projectDataService: IProjectDataService,
     private $logger: ILogger) { }
   
-  public prepareNodeModules(absoluteOutputPath: string, projectDir: string): IFuture<void> {
+  public prepareNodeModules(absoluteOutputPath: string, projectDir: string, lastModifiedTime?: any): IFuture<void> {
     return (() => {
-      // TODO: figure out a better way for doing this
-      this.$projectDataService.initialize(projectDir);
-      let cachedNodeModulesPath = this.$projectDataService.getValue("node-modules-cache-path").wait();
-      if (cachedNodeModulesPath && this.$fs.exists(cachedNodeModulesPath).wait()) {
-        let diffTree = new TreeDiffer(cachedNodeModulesPath);
-        let diffTreeResult = diffTree.diffTree(path.join(projectDir, absoluteOutputPath, "node_modules"));
-        
-        if(diffTreeResult.changedDirectories.length > 0 || diffTreeResult.removedDirectories.length > 0) {
-          this.rebuildNodeModulesTree(absoluteOutputPath, projectDir).wait();
-        }
-      } else { 
-         this.rebuildNodeModulesTree(absoluteOutputPath, projectDir).wait();
+      let nodeModulesPath = path.join(projectDir, "node_modules");
+      let future = new Future<any>();
+            
+      if(lastModifiedTime) {      
+        let pipeline = gulp.src(path.join(projectDir, "node_modules/**"))
+          .pipe(vinylFilterSince(lastModifiedTime))
+          .pipe(through.obj( (chunk: any, enc: any, cb: any) => {
+              let rootModuleName = chunk.path.split(nodeModulesPath)[1].split(path.sep)[1];
+              if(rootModuleName) {
+                let rootModuleFullPath = path.join(nodeModulesPath, rootModuleName);
+                this.nodeModules[rootModuleFullPath] = rootModuleFullPath;
+              }
+              
+              cb(null); 
+          }))
+          .pipe(gulp.dest(absoluteOutputPath));
+          
+         pipeline.on('end', (err: any, data: any) => {
+           if(err) {
+             future.throw(err);
+           } else {
+            future.return(data);
+           }
+         });
+         
+         future.wait();
+      } else {
+         let nodeModulesDirectories = this.$fs.readDirectory(nodeModulesPath).wait();
+         _.each(nodeModulesDirectories, nodeModuleDirectoryName => {
+           let nodeModuleFullPath = path.join(nodeModulesPath, nodeModuleDirectoryName);
+           this.nodeModules[nodeModuleFullPath] = nodeModuleFullPath;
+         })
       }
+      
+     let destCopy = $injector.resolve(destCopyLib.DestCopy, {
+           inputPath: projectDir,  
+           cachePath: "", 
+           outputRoot: absoluteOutputPath,
+           projectDir: projectDir
+      });
+      
+      destCopy.rebuildChangedDirectories(_.keys(this.nodeModules));
+      
     }).future<void>()();
   }
 
diff --git a/lib/tools/broccoli/node-modules-dest-copy.ts b/lib/tools/broccoli/node-modules-dest-copy.ts
@@ -14,23 +14,26 @@ import constants = require("./../../constants");
  * and tees a copy to the given path outside the tmp dir.
  */
 export class DestCopy implements IBroccoliPlugin {
-  constructor(private inputPath: string, private cachePath: string, private outputRoot: string, private projectDir: string) {}
-
-  public rebuild(treeDiff: IDiffResult): void {	  
-	let dependencies = this.getDependencies();	  
-	let devDependencies = this.getDevDependencies(this.projectDir);
+	private dependencies:  IDictionary<any>  = null;
+	private devDependencies:  IDictionary<any>  = null;
 	
-	treeDiff.changedDirectories.forEach(changedDirectory => {
-		let changedDirectoryAbsolutePath = path.join(this.inputPath, constants.NODE_MODULES_FOLDER_NAME, changedDirectory);
+  constructor(private inputPath: string, private cachePath: string, private outputRoot: string, private projectDir: string) {
+	this.dependencies = Object.create(null);
+	this.devDependencies = this.getDevDependencies(projectDir);
+  }
+  
+  public rebuildChangedDirectories(changedDirectories: string[]): void {
+	_.each(changedDirectories, changedDirectoryAbsolutePath => {
+		//let changedDirectoryAbsolutePath = path.join(this.inputPath, constants.NODE_MODULES_FOLDER_NAME, changedDirectory);
 		let packageJsonFiles = [path.join(changedDirectoryAbsolutePath, "package.json")];
 		let nodeModulesFolderPath = path.join(changedDirectoryAbsolutePath, "node_modules");
 		packageJsonFiles = packageJsonFiles.concat(this.enumeratePackageJsonFilesSync(nodeModulesFolderPath));
-		
+			
 		_.each(packageJsonFiles, packageJsonFilePath => {
 			let fileContent = require(packageJsonFilePath);
 			let isPlugin = fileContent.nativescript;
 	
-			if(!devDependencies[fileContent.name]) { // Don't flatten dev dependencies
+			if(!this.devDependencies[fileContent.name]) { // Don't flatten dev dependencies
 		
 				let currentDependency = {
 					name: fileContent.name,
@@ -39,7 +42,7 @@ export class DestCopy implements IBroccoliPlugin {
 					isPlugin: isPlugin
 				};
 				
-				let addedDependency = dependencies[currentDependency.name];
+				let addedDependency = this.dependencies[currentDependency.name];
 				if (addedDependency) {
 					if (semver.gt(currentDependency.version, addedDependency.version)) {
 						let currentDependencyMajorVersion = semver.major(currentDependency.version);
@@ -49,22 +52,26 @@ export class DestCopy implements IBroccoliPlugin {
 						let logger = $injector.resolve("$logger");
 						currentDependencyMajorVersion === addedDependencyMajorVersion ? logger.out(message) : logger.warn(message);
 		
-						dependencies[currentDependency.name] = currentDependency;
+						this.dependencies[currentDependency.name] = currentDependency;
 					}
 				} else {
-					dependencies[currentDependency.name] = currentDependency;
+					this.dependencies[currentDependency.name] = currentDependency;
 				}
 			}
 		});
 	});
 	
-	_.each(dependencies, dependency => {
+	_.each(this.dependencies, dependency => {
 		shelljs.cp("-R", dependency.directory, this.outputRoot);
 		shelljs.rm("-rf", path.join(this.outputRoot, dependency.name, "node_modules"));
 		if(dependency.isPlugin) {
 			shelljs.rm("-rf", path.join(this.outputRoot, dependency.name, "platforms"));
 		}
 	});
+  }
+
+  public rebuild(treeDiff: IDiffResult): void {	
+	this.rebuildChangedDirectories(treeDiff.changedDirectories);
 	
 	// Cache input tree
 	let projectFilePath = path.join(this.projectDir, constants.PACKAGE_JSON_FILE_NAME);	
@@ -73,22 +80,6 @@ export class DestCopy implements IBroccoliPlugin {
 	fs.writeFileSync(projectFilePath, JSON.stringify(projectFileContent, null, "\t"), { encoding: "utf8" });	
   }
   
-  private getDependencies(): IDictionary<any> {
-	let result = Object.create(null);
-	if(fs.existsSync(this.outputRoot)) {
-		let dirs = fs.readdirSync(this.outputRoot);
-		_.each(dirs, dir => {
-			let filePath = path.join(dir, constants.PACKAGE_JSON_FILE_NAME);
-			if(fs.existsSync(filePath)) {
-				let fileContent = require(filePath);
-				result[fileContent.name] = fileContent;		
-			}
-		});
-	}
-	
-	return result;
-  }
-  
   private getDevDependencies(projectDir: string): IDictionary<any> {
 	let projectFilePath = path.join(projectDir, constants.PACKAGE_JSON_FILE_NAME);	
 	let projectFileContent = require(projectFilePath);
diff --git a/package.json b/package.json
@@ -65,7 +65,9 @@
     "shelljs": "0.3.0",
     "tabtab": "https://github.com/Icenium/node-tabtab/tarball/master",
     "temp": "0.8.1",
+    "through": "2.3.7",
     "utf-8-validate": "https://github.com/telerik/utf-8-validate/tarball/master",
+    "vinyl-filter-since": "2.0.0",
     "winreg": "0.0.12",
     "ws": "0.7.1",
     "xcode": "https://github.com/NativeScript/node-xcode/archive/NativeScript-0.9.tar.gz",

Original file line number	Diff line number	Diff line change
`@@ -152,7 +152,7 @@ interface BroccoliNode {`
`152`	`152`	`}`
`153`	`153`
`154`	`154`	`interface IBroccoliBuilder {`
`155`		`- prepareNodeModules(outputPath: string, projectDir: string): IFuture<void>;`
	`155`	`+ prepareNodeModules(outputPath: string, projectDir: string, lastModifiedTime?: any): IFuture<void>;`
`156`	`156`	`}`
`157`	`157`
`158`	`158`	`interface IDiffResult {`
`@@ -162,6 +162,7 @@ interface IDiffResult {`
`162`	`162`
`163`	`163`	`interface IBroccoliPlugin {`
`164`	`164`	`rebuild(diff: IDiffResult): any;`
	`165`	`+ rebuildChangedDirectories?(changedDirectories: string[]): void;`
`165`	`166`	`cleanup? () : void;`
`166`	`167`	`}`
`167`	`168`