ast(parser): add

packages/utils/__snapshots__/ast-utils.test.js.snap

@@ -1,5 +1,68 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP
 
+exports[`utils addProperty add entry property while add 1`] = `
+"module.exports = {
+				entry: {
+                  objects: are,
+
+                  super: [yeah, {
+                    test: /\\\\\\\\.(js|vue)$/,
+                    loader: 'eslint-loader',
+                    enforce: 'pre',
+                    include: [customObj, 'Stringy'],
+
+                    options: {
+                      formatter: 'someOption'
+                    }
+                  }],
+
+                  nice: ':)',
+                  foo: Promise.resolve(),
+                  man: () => duper,
+                  objects: are not,
+
+                  super: [op, {
+                    test: /\\\\.(wasm|c)$/,
+                    loader: 'pia-loader',
+                    enforce: 'pre',
+                    include: [asd, 'Stringy'],
+
+                    options: {
+                      formatter: 'nao'
+                    }
+                  }],
+
+                  nice: '=)',
+                  foo: Promise.resolve(),
+                  man: () => nice!!,
+                  mode: super-man
+                }
+			}"
+`;
+
+exports[`utils addProperty add entry property while init 1`] = `
+"module.exports = {
+  entry: {
+    objects: are,
+
+    super: [yeah, {
+      test: /\\\\.(js|vue)$/,
+      loader: 'eslint-loader',
+      enforce: 'pre',
+      include: [customObj, 'Stringy'],
+
+      options: {
+        formatter: 'someOption'
+      }
+    }],
+
+    nice: ':)',
+    foo: Promise.resolve(),
+    man: () => duper
+  }
+}"
+`;
+
 exports[`utils createIdentifierOrLiteral should create basic literal 1`] = `"'stringLiteral'"`;
 
 exports[`utils createIdentifierOrLiteral should create boolean 1`] = `"true"`;

packages/utils/__snapshots__/recursive-parser.test.js.snap

@@ -1,5 +1,52 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP
 
+exports[`add transforms correctly using "fixture-2" data 1`] = `
+"const webpack = require(\\"webpack\\");
+
+module.exports = {
+	entry: {
+        objects: \\"are\\",
+
+        super: [
+            \\"yeah\\",
+            {
+                test: new RegExp(/\\\\.(js|vue)$/),
+                loader: \\"'eslint-loader'\\",
+                enforce: \\"'pre'\\",
+                include: [\\"customObj\\", \\"'Stringy'\\"],
+                options: {
+                    formatter: \\"'oki'\\",
+                    updateMe: \\"sure\\"
+                }
+            }
+        ],
+
+        nice: \\"':)'\\",
+        foo: \\"Promise.resolve()\\",
+        man: \\"() => duper\\",
+        mode: \\"yaaa\\",
+        objects: are not,
+
+        super: [op, {
+            test: /\\\\.(wasm|c)$/,
+            loader: 'pia-loader',
+            enforce: 'pre',
+            include: [asd, 'Stringy'],
+
+            options: {
+                formatter: 'nao'
+            }
+        }],
+
+        nice: '=)',
+        foo: Promise.resolve(),
+        man: () => nice!!,
+        mode: super-man
+    }
+}
+"
+`;
+
 exports[`init transforms correctly using "fixture-1" data 1`] = `
 "module.exports = {
   entry: {
@@ -17,6 +64,7 @@ exports[`init transforms correctly using "fixture-1" data 1`] = `
     }],
 
     nice: ':)',
+    foo: Promise.resolve(),
     man: () => duper
   }
 };"

packages/utils/__testfixtures__/fixture-2.input.js

@@ -0,0 +1,25 @@
+const webpack = require("webpack");
+
+module.exports = {
+	entry: {
+            objects: "are",
+            super: [
+                "yeah",
+                {
+                    test: new RegExp(/\.(js|vue)$/),
+                    loader: "'eslint-loader'",
+                    enforce: "'pre'",
+                    include: ["customObj", "'Stringy'"],
+                    options: {
+                        formatter: "'oki'",
+                        updateMe: "sure"
+                    }
+                }
+            ],
+            nice: "':)'",
+            foo: "Promise.resolve()",
+            man: "() => duper",
+            mode: "yaaa"
+
+    }
+}

packages/utils/ast-utils.js

@@ -1,5 +1,12 @@
 const validateIdentifier = require("./validate-identifier");
 
+/**
+ *
+ * Traverse safely over a path object for array for paths
+ * @param {Object} obj - Object on which we traverse
+ * @param {Array} paths - Array of strings containing the traversal path
+ * @returns {Any} Value at given traversal path
+ */
 function safeTraverse(obj, paths) {
 	let val = obj;
 	let idx = 0;
@@ -14,6 +21,17 @@ function safeTraverse(obj, paths) {
 	return val;
 }
 
+/**
+ *
+ * Traverse safely and return `type` for path object with value.value property
+ * @param {Node} path - pathNode
+ * @returns {String|Boolean} type at given path.
+ */
+function safeTraverseAndGetType(path) {
+	const pathValue = safeTraverse(path, ["value", "value"]);
+	return pathValue ? pathValue.type : false;
+}
+
 // Convert nested MemberExpressions to strings like webpack.optimize.DedupePlugin
 function memberExpressionToPathString(path) {
 	if (path && path.object) {
@@ -382,26 +400,37 @@ function getRequire(j, constName, packagePath) {
  * @param {Node} p - AST node
  * @param {String} key - key of a key/val object
  * @param {Any} value - Any type of object
+ * @param {String} action - Action to be done on the given ast
  * @returns {Node} - the created ast
  */
 
-function addProperty(j, p, key, value) {
-	let valForNode;
+function addProperty(j, p, key, value, action) {
 	if (!p) {
 		return;
 	}
+	let valForNode;
 	if (Array.isArray(value)) {
-		const arr = j.arrayExpression([]);
-		value.filter(val => val).forEach(val => {
-			addProperty(j, arr, null, val);
+		let arrExp = j.arrayExpression([]);
+		if (
+			safeTraverseAndGetType(p) === "ArrayExpression"
+		) {
+			arrExp = p.value.value;
+		}
+		value.forEach(val => {
+			addProperty(j, arrExp, null, val);
 		});
-		valForNode = arr;
+		valForNode = arrExp;
 	} else if (
 		typeof value === "object" &&
 		!(value.__paths || value instanceof RegExp)
 	) {
-		// object -> loop through it
 		let objectExp = j.objectExpression([]);
+		if (
+			safeTraverseAndGetType(p) === "ObjectExpression"
+		) {
+			objectExp = p.value.value;
+		}
+		// object -> loop through it
 		Object.keys(value).forEach(prop => {
 			addProperty(j, objectExp, prop, value[prop]);
 		});
@@ -415,6 +444,11 @@ function addProperty(j, p, key, value) {
 	} else {
 		pushVal = valForNode;
 	}
+
+	// incase of _add_ or while updating a property,
+	// we only return the generated pushVal which will be replace the node path
+	if (action === "add") return pushVal;
+
 	if (p.properties) {
 		p.properties.push(pushVal);
 		return p;
@@ -507,8 +541,10 @@ function parseMerge(j, ast, value, action) {
 		return ast;
 	}
 }
+
 module.exports = {
 	safeTraverse,
+	safeTraverseAndGetType,
 	createProperty,
 	findPluginsByName,
 	findRootNodesByName,

packages/utils/ast-utils.test.js

@@ -210,4 +210,144 @@ const a = { plugs: [] }
 			expect(j(require).toSource()).toMatchSnapshot();
 		});
 	});
+
+	describe("safeTraverse", () => {
+		it("should safe traverse", () => {
+			const VALUE = "a value";
+			const p = {
+				value: {
+					value: VALUE
+				}
+			};
+			const require = utils.safeTraverse(p, ["value", "value"]);
+			expect(require).toEqual(VALUE);
+		});
+
+		it("should safe traverse thrice", () => {
+			const type = {
+				type: "NodeType"
+			};
+			const p = {
+				parent: {
+					value: {
+						value: type
+					}
+				}
+			};
+			const require = utils.safeTraverse(p, ["parent", "value", "value"]);
+			expect(require).toEqual(type);
+		});
+	});
+
+	describe("safeTraverseAndGetType", () => {
+		it("should safe traverse and get type", () => {
+			const NODE_TYPE = "NodeType";
+			const p = {
+				value: {
+					value: {
+						type: NODE_TYPE
+					}
+				}
+			};
+			const require = utils.safeTraverseAndGetType(p);
+			expect(require).toEqual(NODE_TYPE);
+		});
+
+		it("should safe traverse and return false if not found", () => {
+			const NODE_TYPE = "NodeType";
+			const p = {
+				ed: {
+					sheeran: {
+						type: NODE_TYPE
+					}
+				}
+			};
+			const require = utils.safeTraverseAndGetType(p);
+			expect(require).toEqual(false);
+		});
+	});
+
+	describe("addProperty", () => {
+		it("add entry property while init", () => {
+			const ast = j("module.exports = {}");
+			const propertyValue = {
+				objects: "are",
+				super: [
+					"yeah",
+					{
+						test: new RegExp(/\.(js|vue)$/),
+						loader: "'eslint-loader'",
+						enforce: "'pre'",
+						include: ["customObj", "'Stringy'"],
+						options: {
+							formatter: "'someOption'"
+						}
+					}
+				],
+				nice: "':)'",
+				foo: "Promise.resolve()",
+				man: "() => duper"
+			};
+
+			const root = ast
+				.find(j.ObjectExpression);
+
+			root.forEach(p => {
+				utils.addProperty(j, p, "entry", propertyValue);
+			});
+
+			expect(ast.toSource()).toMatchSnapshot();
+		});
+
+		it("add entry property while add", () => {
+			const ast = j(`module.exports = {
+				entry: {
+					objects: are,
+
+					super: [yeah, {
+					  test: /\\\\.(js|vue)$/,
+					  loader: 'eslint-loader',
+					  enforce: 'pre',
+					  include: [customObj, 'Stringy'],
+
+					  options: {
+						formatter: 'someOption'
+					  }
+					}],
+
+					nice: ':)',
+					foo: Promise.resolve(),
+					man: () => duper
+				}
+			}`);
+			const propertyValue = {
+				objects: "are not",
+				super: [
+					"op",
+					{
+						test: new RegExp(/\.(wasm|c)$/),
+						loader: "'pia-loader'",
+						enforce: "'pre'",
+						include: ["asd", "'Stringy'"],
+						options: {
+							formatter: "'nao'"
+						}
+					}
+				],
+				nice: "'=)'",
+				foo: "Promise.resolve()",
+				man: "() => nice!!",
+				mode: "super-man"
+			};
+
+			const root = ast
+				.find(j.ObjectExpression);
+
+			utils.findRootNodesByName(j, root, "entry").forEach(p => {
+				j(p).replaceWith(utils.addProperty(j, p, "entry", propertyValue, "add"));
+			});
+
+			expect(ast.toSource()).toMatchSnapshot();
+		});
+	});
 });