wip(eslint-plugin): apply Bryce's suggestion and add a fixer method

Author: kresimir-coko

projects/eslint-plugin/rules/general/lib/rules/blank-line-declaration-usage.js

@@ -5,115 +5,47 @@
 
 module.exports = {
 	create(context) {
+		const sourceCode = context.getSourceCode();
+
 		return {
 			VariableDeclaration(node) {
-				const getNodeName = (node) => {
-					const nodeId = node.declarations[0].id;
-
-					if (nodeId.type === 'ArrayPattern') {
-						return nodeId.elements[0].name;
-					}
-					else if (nodeId.type === 'ObjectPattern') {
-						let nameArray = [];
-
-						nodeId.properties.map((property) =>
-							nameArray.push(property.key.name)
-						);
-
-						return nameArray;
-					}
-					else {
-						return nodeId.name;
-					}
-				};
-
-				if (node.declarations.length < 1 || node.parent.body.body) {
-					return;
-				}
-
-				const variableName = getNodeName(node);
-				const variableDeclarationIndex = node.parent.body.indexOf(node);
-
-				const nodeToCheck =
-					node.parent.body[variableDeclarationIndex + 1];
-
-				if (!nodeToCheck) {
+				if (
+					node.parent.type === 'ForOfStatement' ||
+					node.parent.type === 'ForStatement'
+				) {
 					return;
 				}
 
-				const linesBetween =
-					nodeToCheck.loc.start.line - node.loc.end.line;
+				const {references} = context.getDeclaredVariables(node)[0];
 
-				if (linesBetween > 1) {
-					return;
-				}
+				const declarationLine = references[0].identifier.loc.start.line;
 
-				let nodeToCheckName;
-
-				if (nodeToCheck.type === 'ExpressionStatement') {
-					let matchingArgument;
+				references.slice(1).forEach((reference) => {
+					const referenceLine = reference.identifier.loc.start.line;
 
 					if (
-						nodeToCheck.expression.type === 'AssignmentExpression'
+						sourceCode.lines
+							.slice(declarationLine, referenceLine - 1)
+							.indexOf('') === -1
 					) {
-						matchingArgument = nodeToCheck.expression.right.elements.find(
-							(el) => el.name === variableName
-						);
-					}
-					else {
-						matchingArgument = nodeToCheck.expression.arguments.find(
-							(argument) => argument.name === variableName
-						);
+						context.report({
+							fix: (fixer) => {
+								const referenceStartLine =
+									reference.identifier.loc.start.line;
+								const declarationEndLine = node.loc.end.line;
+
+								if (
+									referenceStartLine ===
+									declarationEndLine + 1
+								) {
+									return fixer.insertTextAfter(node, '\n');
+								}
+							},
+							message: 'error msg',
+							node: reference.identifier,
+						});
 					}
-
-					if (matchingArgument) {
-						nodeToCheckName = matchingArgument.name;
-					}
-				}
-				else if (
-					nodeToCheck.declarations[0].init.type === 'TemplateLiteral'
-				) {
-					const matchingArgument = nodeToCheck.declarations[0].init.expressions.find(
-						(expression) => expression.name === variableName
-					);
-
-					if (matchingArgument) {
-						nodeToCheckName = matchingArgument.name;
-					}
-				}
-				else if (node.declarations[0].id.type === 'ObjectPattern') {
-					const matchingArgument = variableName.find(
-						(name) =>
-							name ===
-							nodeToCheck.declarations[0].init.object.name
-					);
-
-					if (matchingArgument) {
-						nodeToCheckName = matchingArgument;
-					}
-				}
-				else if (nodeToCheck.declarations[0].init.arguments) {
-					const matchingArgument = nodeToCheck.declarations[0].init.arguments.find(
-						(arg) => arg.name === variableName
-					);
-
-					if (matchingArgument) {
-						nodeToCheckName = matchingArgument.name;
-					}
-				}
-				else {
-					if (nodeToCheck.declarations[0].init.object) {
-						nodeToCheckName =
-							nodeToCheck.declarations[0].init.object.name;
-					}
-				}
-
-				if (nodeToCheckName === variableName) {
-					context.report({
-						message: 'error msg',
-						node,
-					});
-				}
+				});
 			},
 		};
 	},