Code coverage report for lib\DefinePlugin.js

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
 
 
 
 
1
1
 
1
 
1
487
 
1
1
487
499
499
 
487
488
496
496
496
1
1
1
 
495
495
 
 
1
495
495
495
495
495
494
 
 
494
91
91
91
91
91
91
 
494
20
20
20
20
 
 
495
495
6
6
6
6
6
6
 
495
11
11
11
11
11
11
 
 
1
1
3
3
1
3
 
1
 
 
1
2
 
1
1
 
1
2
2
2
2
 
1
 
 
 
 
 
 
 
/*
	MIT License http://www.opensource.org/licenses/mit-license.php
	Author Tobias Koppers @sokra
*/
var ConstDependency = require("./dependencies/ConstDependency");
var BasicEvaluatedExpression = require("./BasicEvaluatedExpression");
 
var NullFactory = require("./NullFactory");
 
function DefinePlugin(definitions) {
	this.definitions = definitions;
}
module.exports = DefinePlugin;
DefinePlugin.prototype.apply = function(compiler) {
	compiler.plugin("compilation", function(compilation, params) {
		compilation.dependencyFactories.set(ConstDependency, new NullFactory());
		compilation.dependencyTemplates.set(ConstDependency, new ConstDependency.Template());
	});
	(function walkDefinitions(definitions, prefix) {
		Object.keys(definitions).forEach(function(key) {
			var code = definitions[key];
			Iif(code === undefined || code === null) code = code + "";
			else if(typeof code === "object") {
				walkDefinitions(code, key + ".");
				applyObjectDefine(key, code);
				return;
			}
			else code = code.toString();
			applyDefine(prefix + key, code);
		});
	}(this.definitions, ""));
	function applyDefine(key, code) {
		var isTypeof = /^typeof\s+/.test(key);
		if(isTypeof) key = key.replace(/^typeof\s+/, "");
		var recurse = false;
		var recurseTypeof = false;
		if(!isTypeof) {
			compiler.parser.plugin("can-rename " + key, function(expr) {
				return true;
			});
			compiler.parser.plugin("evaluate Identifier " + key, function(expr) {
				Iif(recurse) return;
				recurse = true;
				var res = compiler.parser.evaluate(code);
				recurse = false;
				res.setRange(expr.range);
				return res;
			});
			compiler.parser.plugin("expression " + key, function(expr) {
				var dep = new ConstDependency("("+code+")", expr.range);
				dep.loc = expr.loc;
				this.state.current.addDependency(dep);
				return true;
			});
		}
		var typeofCode = isTypeof ? code : "typeof (" + code + ")"
		compiler.parser.plugin("evaluate typeof " + key, function(expr) {
			Iif(recurseTypeof) return;
			recurseTypeof = true;
			var res = compiler.parser.evaluate(typeofCode);
			recurseTypeof = false;
			res.setRange(expr.range);
			return res;
		});
		compiler.parser.plugin("typeof " + key, function(expr) {
			var res = compiler.parser.evaluate(typeofCode);
			Iif(!res.isString()) return;
			var dep = new ConstDependency(JSON.stringify(res.string), expr.range);
			dep.loc = expr.loc;
			this.state.current.addDependency(dep);
			return true;
		});
	}
	function applyObjectDefine(key, obj) {
		var code = "{" + Object.keys(obj).map(function(key) {
			var code = obj[key];
			if(typeof code !== "string" && code.toString) code = code.toString();
			else Iif(typeof code !== "string") code = code + "";
			return JSON.stringify(key) + ":" + code;
		}).join(",") + "}";
		compiler.parser.plugin("can-rename " + key, function(expr) {
			return true;
		});
		compiler.parser.plugin("evaluate Identifier " + key, function(expr) {
			return new BasicEvaluatedExpression().setRange(expr.range);
		});
		compiler.parser.plugin("evaluate typeof " + key, function(expr) {
			return new BasicEvaluatedExpression().setString("object").setRange(expr.range);
		});
		compiler.parser.plugin("expression " + key, function(expr) {
			var dep = new ConstDependency("("+code+")", expr.range);
			dep.loc = expr.loc;
			this.state.current.addDependency(dep);
			return true;
		});
		compiler.parser.plugin("typeof " + key, function(expr) {
			var dep = new ConstDependency("\"object\"", expr.range);
			dep.loc = expr.loc;
			this.state.current.addDependency(dep);
			return true;
		});
	}
};