Merge pull request #113 from ivogabe/common-source-dir

Calculate common source directory for files outside the common base path. Fixes #112

Author: ivogabe

lib/compiler.ts

@@ -1,17 +1,25 @@
 import ts = require('typescript');
 import path = require('path');
 import gutil = require('gulp-util');
+import sourceMap = require('source-map');
 import tsApi = require('./tsapi');
 import input = require('./input');
 import output = require('./output');
 import host = require('./host');
 import project = require('./project');
 import filter = require('./filter');
+import utils = require('./utils');
 
 export interface ICompiler {
 	prepare(_project: project.Project): void;
 	inputFile(file: input.File);
 	inputDone();
+	/**
+	 * Corrects the paths in the sourcemap.
+	 * Returns true when the file is located
+	 * under the base path.
+	 */
+	correctSourceMap(map: sourceMap.RawSourceMap): boolean;
 }
 
 /**
@@ -90,6 +98,51 @@ export class ProjectCompiler implements ICompiler {
 
 		this.project.output.finish();
 	}
+	
+	private _commonBaseDiff: [number, string];
+	/**
+	 * Calculates the difference between the common base directory calculated based on the base paths of the input files
+	 * and the common source directory calculated by TypeScript.
+	 */
+	private get commonBaseDiff(): [number, string] {
+		if (this._commonBaseDiff) return this._commonBaseDiff;
+		
+		const expected = this.project.input.commonBasePath;
+		const real = this.project.input.commonSourceDirectory;
+		
+		const length = real.length - expected.length;
+		
+		if (length > 0) {
+			return this._commonBaseDiff = [length, real.substring(real.length - length)];
+		} else {
+			return this._commonBaseDiff = [length, expected.substring(expected.length + length)];
+		}
+	}
+	
+	correctSourceMap(map: sourceMap.RawSourceMap) {
+		const [diffLength, diff] = this.commonBaseDiff;
+		
+		if (diffLength < 0) {
+			// There were files added outside of the common base.
+			map.sources = map.sources.map<string>(fileName => {
+				const full = utils.normalizePath(path.join(this.project.input.commonSourceDirectory, fileName));
+				let relative = path.relative(utils.normalizePath(this.project.input.commonBasePath), full);
+				if (relative.substring(0, 3) === '../') {
+					
+					return undefined;
+				}
+				
+				if (relative.substring(0, 2) === './') {
+					relative = relative.substring(2);
+				}
+				return full.substring(full.length - relative.length);
+			}).filter(fileName => fileName !== undefined);
+			
+			if (map.sources.length === 0) return false;
+		}
+		
+		return true;
+	}
 }
 
 // TODO: file-based compiler

lib/input.ts

@@ -139,6 +139,16 @@ export class FileDictionary {
 			})
 			.reduce(getCommonBasePath)
 	}
+	get commonSourceDirectory() {
+		const fileNames = this.getFileNames();
+		return fileNames
+			.filter(fileName => fileName.substr(fileName.length - 5).toLowerCase() !== '.d.ts')
+			.map(fileName => {
+				const file = this.files[utils.normalizePath(fileName)];
+				return path.dirname(file.fileNameNormalized);
+			})
+			.reduce(getCommonBasePath)
+	}
 }
 
 export class FileCache {
@@ -213,6 +223,9 @@ export class FileCache {
 	get commonBasePath() {
 		return this.current.commonBasePath;
 	}
+	get commonSourceDirectory() {
+		return this.current.commonSourceDirectory;
+	}
 
 	isChanged(onlyGulp = false) {
 		if (!this.previous) return true;

lib/output.ts

@@ -79,6 +79,11 @@ export class Output {
 				&& (file.content[OutputFileKind.Definitions] !== undefined || !this.project.options.declaration)) {
 
 				file.sourceMap = JSON.parse(file.content[OutputFileKind.SourceMap]);
+				if (!this.project.compiler.correctSourceMap(file.sourceMap)) {
+					file.skipPush = true;
+					return;
+				}
+				
 				if (this.project.singleOutput) {
 					file.original = this.project.input.firstSourceFile;
 					file.sourceMapOrigins = this.project.input.getFileNames(true).map(fName => this.project.input.getFile(fName));
@@ -208,6 +213,12 @@ export class Output {
 	}
 
 	private getError(info: ts.Diagnostic): reporter.TypeScriptError {
+		if (info.code === 6059) {
+			// "File '...' is not under 'rootDir' '...'. 'rootDir' is expected to contain all source files."
+			// This is handled by ICompiler#correctSourceMap, so this error can be muted.
+			return undefined;
+		}
+		
 		const err = <reporter.TypeScriptError> new Error();
 		err.name = 'TypeScript error';
 		err.diagnostic = info;
@@ -259,6 +270,8 @@ export class Output {
 		this.error(this.getError(info));
 	}
 	error(error: reporter.TypeScriptError) {
+		if (!error) return;
+		
 		// Save errors for lazy compilation (if the next input is the same as the current),
 		this.errors.push(error);
 		// call reporter callback

release/compiler.js

@@ -1,8 +1,10 @@
 var ts = require('typescript');
+var path = require('path');
 var tsApi = require('./tsapi');
 var output = require('./output');
 var host = require('./host');
 var filter = require('./filter');
+var utils = require('./utils');
 /**
  * Compiles a whole project, with full type checking
  */
@@ -58,6 +60,48 @@ var ProjectCompiler = (function () {
         }
         this.project.output.finish();
     };
+    Object.defineProperty(ProjectCompiler.prototype, "commonBaseDiff", {
+        /**
+         * Calculates the difference between the common base directory calculated based on the base paths of the input files
+         * and the common source directory calculated by TypeScript.
+         */
+        get: function () {
+            if (this._commonBaseDiff)
+                return this._commonBaseDiff;
+            var expected = this.project.input.commonBasePath;
+            var real = this.project.input.commonSourceDirectory;
+            var length = real.length - expected.length;
+            if (length > 0) {
+                return this._commonBaseDiff = [length, real.substring(real.length - length)];
+            }
+            else {
+                return this._commonBaseDiff = [length, expected.substring(expected.length + length)];
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    ProjectCompiler.prototype.correctSourceMap = function (map) {
+        var _this = this;
+        var _a = this.commonBaseDiff, diffLength = _a[0], diff = _a[1];
+        if (diffLength < 0) {
+            // There were files added outside of the common base.
+            map.sources = map.sources.map(function (fileName) {
+                var full = utils.normalizePath(path.join(_this.project.input.commonSourceDirectory, fileName));
+                var relative = path.relative(utils.normalizePath(_this.project.input.commonBasePath), full);
+                if (relative.substring(0, 3) === '../') {
+                    return undefined;
+                }
+                if (relative.substring(0, 2) === './') {
+                    relative = relative.substring(2);
+                }
+                return full.substring(full.length - relative.length);
+            }).filter(function (fileName) { return fileName !== undefined; });
+            if (map.sources.length === 0)
+                return false;
+        }
+        return true;
+    };
     return ProjectCompiler;
 })();
 exports.ProjectCompiler = ProjectCompiler;

release/input.js

@@ -123,6 +123,21 @@ var FileDictionary = (function () {
         enumerable: true,
         configurable: true
     });
+    Object.defineProperty(FileDictionary.prototype, "commonSourceDirectory", {
+        get: function () {
+            var _this = this;
+            var fileNames = this.getFileNames();
+            return fileNames
+                .filter(function (fileName) { return fileName.substr(fileName.length - 5).toLowerCase() !== '.d.ts'; })
+                .map(function (fileName) {
+                var file = _this.files[utils.normalizePath(fileName)];
+                return path.dirname(file.fileNameNormalized);
+            })
+                .reduce(getCommonBasePath);
+        },
+        enumerable: true,
+        configurable: true
+    });
     return FileDictionary;
 })();
 exports.FileDictionary = FileDictionary;
@@ -193,6 +208,13 @@ var FileCache = (function () {
         enumerable: true,
         configurable: true
     });
+    Object.defineProperty(FileCache.prototype, "commonSourceDirectory", {
+        get: function () {
+            return this.current.commonSourceDirectory;
+        },
+        enumerable: true,
+        configurable: true
+    });
     FileCache.prototype.isChanged = function (onlyGulp) {
         if (onlyGulp === void 0) { onlyGulp = false; }
         if (!this.previous)

release/output.js

@@ -49,6 +49,10 @@ var Output = (function () {
                 && file.content[OutputFileKind.SourceMap] !== undefined
                 && (file.content[OutputFileKind.Definitions] !== undefined || !this.project.options.declaration)) {
                 file.sourceMap = JSON.parse(file.content[OutputFileKind.SourceMap]);
+                if (!this.project.compiler.correctSourceMap(file.sourceMap)) {
+                    file.skipPush = true;
+                    return;
+                }
                 if (this.project.singleOutput) {
                     file.original = this.project.input.firstSourceFile;
                     file.sourceMapOrigins = this.project.input.getFileNames(true).map(function (fName) { return _this.project.input.getFile(fName); });
@@ -169,6 +173,11 @@ var Output = (function () {
         this.streamDts.push(null);
     };
     Output.prototype.getError = function (info) {
+        if (info.code === 6059) {
+            // "File '...' is not under 'rootDir' '...'. 'rootDir' is expected to contain all source files."
+            // This is handled by ICompiler#correctSourceMap, so this error can be muted.
+            return undefined;
+        }
         var err = new Error();
         err.name = 'TypeScript error';
         err.diagnostic = info;
@@ -215,6 +224,8 @@ var Output = (function () {
         this.error(this.getError(info));
     };
     Output.prototype.error = function (error) {
+        if (!error)
+            return;
         // Save errors for lazy compilation (if the next input is the same as the current),
         this.errors.push(error);
         // call reporter callback