feat: add codemod for iterate-iterator

Author: Brady Blair

codemods/iterate-iterator/index.js

@@ -0,0 +1,79 @@
+import jscodeshift from 'jscodeshift';
+import { removeImport } from '../shared.js';
+
+/**
+ * @typedef {import('../../types.js').Codemod} Codemod
+ * @typedef {import('../../types.js').CodemodOptions} CodemodOptions
+ */
+
+/**
+ * @param {CodemodOptions} [options]
+ * @returns {Codemod}
+ */
+export default function (options) {
+	return {
+		name: 'iterate-iterator',
+		transform: ({ file }) => {
+			const j = jscodeshift;
+			const root = j(file.source);
+			let isDirty = false;
+
+			const { identifier } = removeImport('iterate-iterator', root, j);
+
+			if (identifier) {
+				const callExpressions = root.find(j.CallExpression, {
+					callee: {
+						type: 'Identifier',
+						name: identifier,
+					},
+				});
+
+				for (const path of callExpressions.paths()) {
+					const args = path.node.arguments;
+
+					if (args.length === 1) {
+						// Case: Converting an iterator to an array
+						const [iterable] = args;
+						const arrayFromExpression = j.callExpression(
+							j.memberExpression(j.identifier('Array'), j.identifier('from')),
+							[iterable],
+						);
+
+						j(path).replaceWith(arrayFromExpression);
+						isDirty = true;
+					} else if (args.length === 2) {
+						// Case: Using a callback function
+						const [iterable, callback] = args;
+						const iterableArg =
+							iterable.type === 'SpreadElement' ? iterable.argument : iterable;
+
+						if (
+							callback.type !== 'Identifier' &&
+							callback.type !== 'FunctionExpression' &&
+							callback.type !== 'ArrowFunctionExpression'
+						) {
+							continue;
+						}
+
+						const forOfStatement = j.forOfStatement(
+							j.variableDeclaration('const', [
+								j.variableDeclarator(j.identifier('i')),
+							]),
+							iterableArg,
+							j.blockStatement([
+								j.expressionStatement(
+									j.callExpression(callback, [j.identifier('i')]),
+								),
+							]),
+						);
+
+						j(path).replaceWith(forOfStatement);
+						isDirty = true;
+					}
+				}
+			}
+
+			return isDirty ? root.toSource(options) : file.source;
+		},
+	};
+}

test/fixtures/iterate-iterator/case-1/after.js

@@ -0,0 +1,30 @@
+import assert from 'assert';
+
+assert.deepEqual(Array.from('a 💩'[Symbol.iterator]()), ['a', ' ', '💩']);
+assert.deepEqual(Array.from([1, 2][Symbol.iterator]()), [1, 2]);
+assert.deepEqual(Array.from(new Set([1, 2]).values()), [1, 2]);
+assert.deepEqual(Array.from(new Map([[1, 2], [3, 4]]).entries()), [[1, 2], [3, 4]]);
+
+function assertWithCallback(iterable, expected) {
+    const values = [];
+    const callback = function (x) { values.push(x); };
+
+    for (const i of iterable) {
+        callback(i);
+    };
+
+    assert.deepEqual(values, expected);
+}
+
+assertWithCallback('a 💩'[Symbol.iterator](), ['a', ' ', '💩']);
+assertWithCallback([1, 2][Symbol.iterator](), [1, 2]);
+assertWithCallback(new Set([1, 2]).values(), [1, 2]);
+assertWithCallback(new Map([[1, 2], [3, 4]]).entries(), [[1, 2], [3, 4]]);
+
+for (const i of [1, 2][Symbol.iterator]()) {
+    (function(x) { console.log(x); })(i);
+};
+
+for (const i of [1, 2][Symbol.iterator]()) {
+    (x => console.log(x))(i);
+};

test/fixtures/iterate-iterator/case-1/before.js

@@ -0,0 +1,25 @@
+import { iterate } from 'iterate-iterator';
+import assert from 'assert';
+
+assert.deepEqual(iterate('a 💩'[Symbol.iterator]()), ['a', ' ', '💩']);
+assert.deepEqual(iterate([1, 2][Symbol.iterator]()), [1, 2]);
+assert.deepEqual(iterate(new Set([1, 2]).values()), [1, 2]);
+assert.deepEqual(iterate(new Map([[1, 2], [3, 4]]).entries()), [[1, 2], [3, 4]]);
+
+function assertWithCallback(iterable, expected) {
+    const values = [];
+    const callback = function (x) { values.push(x); };
+
+    iterate(iterable, callback);
+
+    assert.deepEqual(values, expected);
+}
+
+assertWithCallback('a 💩'[Symbol.iterator](), ['a', ' ', '💩']);
+assertWithCallback([1, 2][Symbol.iterator](), [1, 2]);
+assertWithCallback(new Set([1, 2]).values(), [1, 2]);
+assertWithCallback(new Map([[1, 2], [3, 4]]).entries(), [[1, 2], [3, 4]]);
+
+iterate([1, 2][Symbol.iterator](), function (x) { console.log(x); });
+
+iterate([1, 2][Symbol.iterator](), x => console.log(x));

test/fixtures/iterate-iterator/case-1/result.js

@@ -0,0 +1,30 @@
+import assert from 'assert';
+
+assert.deepEqual(Array.from('a 💩'[Symbol.iterator]()), ['a', ' ', '💩']);
+assert.deepEqual(Array.from([1, 2][Symbol.iterator]()), [1, 2]);
+assert.deepEqual(Array.from(new Set([1, 2]).values()), [1, 2]);
+assert.deepEqual(Array.from(new Map([[1, 2], [3, 4]]).entries()), [[1, 2], [3, 4]]);
+
+function assertWithCallback(iterable, expected) {
+    const values = [];
+    const callback = function (x) { values.push(x); };
+
+    for (const i of iterable) {
+        callback(i);
+    };
+
+    assert.deepEqual(values, expected);
+}
+
+assertWithCallback('a 💩'[Symbol.iterator](), ['a', ' ', '💩']);
+assertWithCallback([1, 2][Symbol.iterator](), [1, 2]);
+assertWithCallback(new Set([1, 2]).values(), [1, 2]);
+assertWithCallback(new Map([[1, 2], [3, 4]]).entries(), [[1, 2], [3, 4]]);
+
+for (const i of [1, 2][Symbol.iterator]()) {
+    (function(x) { console.log(x); })(i);
+};
+
+for (const i of [1, 2][Symbol.iterator]()) {
+    (x => console.log(x))(i);
+};

test/fixtures/iterate-iterator/case-2/after.js

@@ -0,0 +1,30 @@
+const assert = require('assert');
+
+assert.deepEqual(Array.from('a 💩'[Symbol.iterator]()), ['a', ' ', '💩']);
+assert.deepEqual(Array.from([1, 2][Symbol.iterator]()), [1, 2]);
+assert.deepEqual(Array.from(new Set([1, 2]).values()), [1, 2]);
+assert.deepEqual(Array.from(new Map([[1, 2], [3, 4]]).entries()), [[1, 2], [3, 4]]);
+
+function assertWithCallback(iterable, expected) {
+    const values = [];
+    const callback = function (x) { values.push(x); };
+
+    for (const i of iterable) {
+        callback(i);
+    };
+
+    assert.deepEqual(values, expected);
+}
+
+assertWithCallback('a 💩'[Symbol.iterator](), ['a', ' ', '💩']);
+assertWithCallback([1, 2][Symbol.iterator](), [1, 2]);
+assertWithCallback(new Set([1, 2]).values(), [1, 2]);
+assertWithCallback(new Map([[1, 2], [3, 4]]).entries(), [[1, 2], [3, 4]]);
+
+for (const i of [1, 2][Symbol.iterator]()) {
+    (function(x) { console.log(x); })(i);
+};
+
+for (const i of [1, 2][Symbol.iterator]()) {
+    (x => console.log(x))(i);
+};

test/fixtures/iterate-iterator/case-2/before.js

@@ -0,0 +1,25 @@
+const assert = require('assert');
+const iterate = require('iterate-iterator');
+
+assert.deepEqual(iterate('a 💩'[Symbol.iterator]()), ['a', ' ', '💩']);
+assert.deepEqual(iterate([1, 2][Symbol.iterator]()), [1, 2]);
+assert.deepEqual(iterate(new Set([1, 2]).values()), [1, 2]);
+assert.deepEqual(iterate(new Map([[1, 2], [3, 4]]).entries()), [[1, 2], [3, 4]]);
+
+function assertWithCallback(iterable, expected) {
+    const values = [];
+    const callback = function (x) { values.push(x); };
+
+    iterate(iterable, callback);
+
+    assert.deepEqual(values, expected);
+}
+
+assertWithCallback('a 💩'[Symbol.iterator](), ['a', ' ', '💩']);
+assertWithCallback([1, 2][Symbol.iterator](), [1, 2]);
+assertWithCallback(new Set([1, 2]).values(), [1, 2]);
+assertWithCallback(new Map([[1, 2], [3, 4]]).entries(), [[1, 2], [3, 4]]);
+
+iterate([1, 2][Symbol.iterator](), function (x) { console.log(x); });
+
+iterate([1, 2][Symbol.iterator](), x => console.log(x));

test/fixtures/iterate-iterator/case-2/result.js

@@ -0,0 +1,30 @@
+const assert = require('assert');
+
+assert.deepEqual(Array.from('a 💩'[Symbol.iterator]()), ['a', ' ', '💩']);
+assert.deepEqual(Array.from([1, 2][Symbol.iterator]()), [1, 2]);
+assert.deepEqual(Array.from(new Set([1, 2]).values()), [1, 2]);
+assert.deepEqual(Array.from(new Map([[1, 2], [3, 4]]).entries()), [[1, 2], [3, 4]]);
+
+function assertWithCallback(iterable, expected) {
+    const values = [];
+    const callback = function (x) { values.push(x); };
+
+    for (const i of iterable) {
+        callback(i);
+    };
+
+    assert.deepEqual(values, expected);
+}
+
+assertWithCallback('a 💩'[Symbol.iterator](), ['a', ' ', '💩']);
+assertWithCallback([1, 2][Symbol.iterator](), [1, 2]);
+assertWithCallback(new Set([1, 2]).values(), [1, 2]);
+assertWithCallback(new Map([[1, 2], [3, 4]]).entries(), [[1, 2], [3, 4]]);
+
+for (const i of [1, 2][Symbol.iterator]()) {
+    (function(x) { console.log(x); })(i);
+};
+
+for (const i of [1, 2][Symbol.iterator]()) {
+    (x => console.log(x))(i);
+};