fix(Quantum): global process and process.env are handled gracefully

nchanged · nchanged · commit 341d5ff76190 · 2018-09-18T10:50:41.000+02:00
diff --git a/src/quantum/core/AstUtils.ts b/src/quantum/core/AstUtils.ts
@@ -297,6 +297,35 @@ export function isTrueRequireFunction(node) {
 export function matchesSingleFunction(node: any, name: string) {
 	return node.callee && node.callee.type === "Identifier" && node.callee.name === name;
 }
+export function matchesGlobalVariable(node: any, name: string) {
+	const parent = node.$parent;
+	const isMemberExpression = parent && parent.type === "MemberExpression";
+	const isProperty = parent && parent.type === "Property";
+	const isDeclarator = parent && parent.type === "VariableDeclarator";
+	return node.type === "Identifier" && node.name === name && !isMemberExpression && !isProperty && !isDeclarator;
+}
+
+export function matchesGlobalVariableReference(node: any, name: string) {
+	const [first, second] = name.split(".");
+	const parent = node.$parent;
+	const isMemberExpression = parent && parent.type === "MemberExpression";
+	const isProperty = parent && parent.type === "Property";
+	const isDeclarator = parent && parent.type === "VariableDeclarator";
+
+	const initial =
+		node.type === "Identifier" && node.name === first && !isProperty && !isDeclarator && isMemberExpression;
+	let secondCondition = true;
+	if (second && initial) {
+		secondCondition = parent.property && parent.property.type === "Identifier" && parent.property.name === second;
+	}
+	return initial && secondCondition;
+}
+
+export function matchesVariableDeclarator(node: any, name: string) {
+	const parent = node.$parent;
+	const isDeclarator = parent && parent.type === "VariableDeclarator";
+	return node.type === "Identifier" && node.name === name && isDeclarator;
+}
 
 export function trackRequireMember(node: any, name: string): string {
 	if (node && node.type === "MemberExpression") {
diff --git a/src/quantum/core/FileAbstraction.ts b/src/quantum/core/FileAbstraction.ts
@@ -1,42 +1,44 @@
-import { acornParse } from "../../analysis/FileAnalysis";
-import { PackageAbstraction } from "./PackageAbstraction";
-import { ASTTraverse } from "../../ASTTraverse";
-import { RequireStatement } from "./nodes/RequireStatement";
 import * as escodegen from "escodegen";
 import * as path from "path";
+import { acornParse } from "../../analysis/FileAnalysis";
+import { ASTTraverse } from "../../ASTTraverse";
 import { ensureFuseBoxPath, transpileToEs5 } from "../../Utils";
-
+import { QuantumBit } from "../plugin/QuantumBit";
+import { QuantumCore } from "../plugin/QuantumCore";
 import {
+	compareStatement,
+	isExportComputed,
+	isExportMisused,
+	isTrueRequireFunction,
+	matcheObjectDefineProperty,
 	matchesAssignmentExpression,
-	matchesLiteralStringExpression,
-	matchesSingleFunction,
+	matchesDefinedExpression,
 	matchesDoubleMemberExpression,
-	matcheObjectDefineProperty,
 	matchesEcmaScript6,
+	matchesExportReference,
+	matchesGlobalVariable,
+	matchesIfStatementFuseBoxIsEnvironment,
+	matchesIfStatementProcessEnv,
+	matchesLiteralStringExpression,
+	matchesNodeEnv,
+	matchesSingleFunction,
 	matchesTypeOf,
+	matchNamedExport,
 	matchRequireIdentifier,
 	trackRequireMember,
-	matchNamedExport,
-	isExportMisused,
-	matchesNodeEnv,
-	matchesExportReference,
-	matchesIfStatementProcessEnv,
-	compareStatement,
-	matchesIfStatementFuseBoxIsEnvironment,
-	isExportComputed,
-	isTrueRequireFunction,
-	matchesDefinedExpression,
+	matchesVariableDeclarator,
+	matchesGlobalVariableReference,
 } from "./AstUtils";
 import { ExportsInterop } from "./nodes/ExportsInterop";
-import { UseStrict } from "./nodes/UseStrict";
+import { GenericAst } from "./nodes/GenericAst";
+import { NamedExport } from "./nodes/NamedExport";
+import { ReplaceableBlock } from "./nodes/ReplaceableBlock";
+import { RequireStatement } from "./nodes/RequireStatement";
 import { TypeOfExportsKeyword } from "./nodes/TypeOfExportsKeyword";
 import { TypeOfModuleKeyword } from "./nodes/TypeOfModuleKeyword";
 import { TypeOfWindowKeyword } from "./nodes/TypeOfWindowKeyword";
-import { NamedExport } from "./nodes/NamedExport";
-import { GenericAst } from "./nodes/GenericAst";
-import { QuantumCore } from "../plugin/QuantumCore";
-import { ReplaceableBlock } from "./nodes/ReplaceableBlock";
-import { QuantumBit } from "../plugin/QuantumBit";
+import { UseStrict } from "./nodes/UseStrict";
+import { PackageAbstraction } from "./PackageAbstraction";
 
 const globalNames = new Set<string>(["__filename", "__dirname", "exports", "module"]);
 
@@ -75,6 +77,9 @@ export class FileAbstraction {
 	public typeofGlobalKeywords = new Set<GenericAst>();
 	public typeofDefineKeywords = new Set<GenericAst>();
 	public typeofRequireKeywords = new Set<GenericAst>();
+	public globalProcess: Set<GenericAst>;
+	public globalProcessVersion: Set<GenericAst>;
+	public processVariableDefined: boolean;
 
 	public namedExports = new Map<string, NamedExport>();
 	public processNodeEnv = new Set<ReplaceableBlock>();
@@ -90,9 +95,15 @@ export class FileAbstraction {
 	private removalRestricted = false;
 	private dependencies = new Map<FileAbstraction, Set<RequireStatement>>();
 
+	public renderedHeaders: string[];
+
 	constructor(public fuseBoxPath: string, public packageAbstraction: PackageAbstraction) {
 		this.fuseBoxDir = ensureFuseBoxPath(path.dirname(fuseBoxPath));
 		this.setID(fuseBoxPath);
+		this.globalProcess = new Set();
+		this.renderedHeaders = [];
+		this.globalProcessVersion = new Set();
+		this.processVariableDefined = false;
 		packageAbstraction.registerFileAbstraction(this);
 		this.core = this.packageAbstraction.bundleAbstraction.producerAbstraction.quantumCore;
 
@@ -269,6 +280,9 @@ export class FileAbstraction {
 		if (this.isDirnameUsed()) {
 			fn.push(`var __dirname = ${JSON.stringify(this.fuseBoxDir)};` + "\n");
 		}
+		if (this.renderedHeaders.length) {
+			fn.push(this.renderedHeaders.join("\n") + "\n");
+		}
 		if (this.isFilenameUsed()) {
 			fn.push(`var __filename = ${JSON.stringify(this.fuseBoxPath)};` + "\n");
 		}
@@ -286,6 +300,7 @@ export class FileAbstraction {
 	 */
 	private onNode(node, parent, prop, idx) {
 		// process.env
+
 		if (this.core) {
 			if (this.core.opts.definedExpressions) {
 				const matchedExpression = matchesDefinedExpression(node, this.core.opts.definedExpressions);
@@ -364,6 +379,15 @@ export class FileAbstraction {
 			}
 		}
 
+		if (matchesGlobalVariable(node, "process")) {
+			this.globalProcess.add(new GenericAst(parent, prop, node));
+		}
+		if (matchesGlobalVariableReference(node, "process.version")) {
+			this.globalProcessVersion.add(new GenericAst(parent, prop, node));
+		}
+		if (matchesVariableDeclarator(node, "process")) {
+			this.processVariableDefined = true;
+		}
 		// detecting es6
 		if (matchesEcmaScript6(node)) {
 			this.isEcmaScript6 = true;
diff --git a/src/quantum/plugin/QuantumCore.ts b/src/quantum/plugin/QuantumCore.ts
@@ -30,6 +30,8 @@ import { QuantumBit } from "./QuantumBit";
 import { CSSModifications } from "./modifications/CSSModifications";
 import { CSSCollection } from "../core/CSSCollection";
 import { QuantumTask } from "../core/QuantumTask";
+import { GlobalProcessReplacement } from "./modifications/GlobalProcessReplacement";
+import { GlobalProcessVersionReplacement } from "./modifications/GlobalProcessVersionReplacement";
 
 export interface QuantumStatementMapping {
 	statement: RequireStatement;
@@ -211,7 +213,7 @@ export class QuantumCore {
 
 	public prepareFiles(bundleAbstraction: BundleAbstraction) {
 		bundleAbstraction.packageAbstractions.forEach(packageAbstraction => {
-			let entryId = `${this.producer.entryPackageName}/${packageAbstraction.entryFile}`
+			let entryId = `${this.producer.entryPackageName}/${packageAbstraction.entryFile}`;
 			packageAbstraction.fileAbstractions.forEach((fileAbstraction, key: string) => {
 				let fileId = fileAbstraction.getFuseBoxFullPath();
 				const id = this.index;
@@ -318,6 +320,10 @@ export class QuantumCore {
 			TypeOfModifications,
 			// process.env removal
 			ProcessEnvModification,
+			// process global replacement with "undefined"
+			GlobalProcessReplacement,
+			// process.version global replacement with ""
+			GlobalProcessVersionReplacement,
 		];
 		return each(modifications, (modification: IPerformable) => modification.perform(this, file));
 	}
diff --git a/src/quantum/plugin/modifications/GlobalProcessReplacement.ts b/src/quantum/plugin/modifications/GlobalProcessReplacement.ts
@@ -0,0 +1,12 @@
+import { FileAbstraction } from "../../core/FileAbstraction";
+import { QuantumCore } from "../QuantumCore";
+
+export class GlobalProcessReplacement {
+	public static perform(core: QuantumCore, file: FileAbstraction) {
+		if (!file.processVariableDefined) {
+			file.globalProcess.forEach(item => {
+				item.replaceWithString(undefined);
+			});
+		}
+	}
+}
diff --git a/src/quantum/plugin/modifications/GlobalProcessVersionReplacement.ts b/src/quantum/plugin/modifications/GlobalProcessVersionReplacement.ts
@@ -0,0 +1,12 @@
+import { FileAbstraction } from "../../core/FileAbstraction";
+import { QuantumCore } from "../QuantumCore";
+
+export class GlobalProcessVersionReplacement {
+	public static perform(core: QuantumCore, file: FileAbstraction) {
+		if (!file.processVariableDefined) {
+			if (file.globalProcessVersion.size) {
+				file.renderedHeaders.push(`var process = { version : "" };`);
+			}
+		}
+	}
+}
diff --git a/src/quantum/tests/RemoveProcess.test.ts b/src/quantum/tests/RemoveProcess.test.ts
@@ -0,0 +1,82 @@
+import { should } from "fuse-test-runner";
+import { createOptimisedBundleEnv } from "../../tests/stubs/TestEnvironment";
+
+export class RemoveProcess {
+	"Should replace process with undefined"() {
+		return createOptimisedBundleEnv({
+			stubs: true,
+			options: {
+				removeExportsInterop: false,
+			},
+			project: {
+				natives: {
+					process: false,
+				},
+				files: {
+					"index.ts": `
+	                 if ( process ) {
+	                     console.log("hello")
+					 }
+					`,
+					"dev.ts": ``,
+				},
+				instructions: "> index.ts",
+			},
+		}).then(result => {
+			const contents = result.contents["index.js"];
+			should(contents).notFindString("process");
+			should(contents).findString("undefined");
+		});
+	}
+
+	"Should not process with undefined"() {
+		return createOptimisedBundleEnv({
+			stubs: true,
+			options: {
+				removeExportsInterop: false,
+			},
+			project: {
+				natives: {
+					process: false,
+				},
+				files: {
+					"index.ts": `
+					 var process = {};
+	                 if ( process ) {
+	                     console.log("hello")
+					 }
+					`,
+					"dev.ts": ``,
+				},
+				instructions: "> index.ts",
+			},
+		}).then(result => {
+			const contents = result.contents["index.js"];
+			should(contents).findString("if (process) {");
+		});
+	}
+
+	"Should replace process.version with a string"() {
+		return createOptimisedBundleEnv({
+			stubs: true,
+			options: {
+				removeExportsInterop: false,
+			},
+			project: {
+				natives: {
+					process: false,
+				},
+				files: {
+					"index.ts": `
+					 	var version = process.version;
+					`,
+					"dev.ts": ``,
+				},
+				instructions: "> index.ts",
+			},
+		}).then(result => {
+			const contents = result.contents["index.js"];
+			should(contents).findString(`var process = { version : "" };`);
+		});
+	}
+}
