Adds hypermod codemod

Author: Daniel Del Core

community/hypermod/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@hypermod/mod-hypermod",
+  "version": "0.0.0",
+  "license": "MIT",
+  "source": "src/hypermod.config.js",
+  "main": "dist/hypermod.config.js",
+  "scripts": {
+    "dev": "hypermod",
+    "build": "parcel build",
+    "test": "jest --watch",
+    "validate": "hypermod validate ."
+  },
+  "dependencies": {
+    "@hypermod/utils": "^0.4.2",
+    "jscodeshift": "^0.13.1"
+  },
+  "devDependencies": {
+    "@hypermod/cli": "^0.19.3",
+    "@types/jest": "^29.0.0",
+    "@types/node": "^16.11.0",
+    "jest": "^29.0.0",
+    "parcel": "^2.8.3",
+    "prettier": "^2.0.0",
+    "ts-jest": "^29.0.0",
+    "typescript": "^5.2.2"
+  },
+  "repository": "https://github.com/hypermod-io/hypermod-community/tree/main/community/hypermod"
+}

community/hypermod/src/defineInlineTest-to-applyTransform/README.md

@@ -0,0 +1,46 @@
+# hypermod#defineInlineTest-to-applyTransform
+
+Codemods for hypermod#defineInlineTest-to-applyTransform
+
+This codemod transforms test cases written with `defineInlineTest` from ` jscodeshift`` to use the  `applyTransform`function from`@hypermod/utils`. Below is an example of the transformation:
+
+```js
+/* INPUT */
+const defineInlineTest = require('jscodeshift/dist/testUtils').defineInlineTest;
+
+defineInlineTest(
+  { default: transformer, parser: 'tsx' },
+  {},
+  `
+      import React from "react";
+      import Tag from "@atlaskit/tag";
+      export default () => <Tag text="Removable button"/>;
+    `,
+  `
+      import React from "react";
+      import Tag from "@atlaskit/tag";
+      export default () => <Tag text="Removable button"/>;
+    `,
+  'should not add isRemovable flag when no removeButtonText defined',
+);
+
+/* OUTPUT */
+import { applyTransform } from '@hypermod/utils';
+
+it('should not add isRemovable flag when no removeButtonText defined', async () => {
+  const result = await applyTransform(
+    transformer,
+    `
+      import React from "react";
+      import Tag from "@atlaskit/tag";
+      export default () => <Tag text="Removable button"/>;
+    `,
+    { parser: 'tsx' },
+  );
+  expect(result).toMatchInlineSnapshot(`
+    "import React from "react";
+    import Tag from "@atlaskit/tag";
+    export default () => <Tag text="Removable button"/>;"
+  `);
+});
+```

community/hypermod/src/defineInlineTest-to-applyTransform/transform.spec.ts

@@ -0,0 +1,72 @@
+import { applyTransform } from '@hypermod/utils';
+import * as transformer from './transform';
+
+describe('hypermod#defineInlineTest-to-applyTransform transform', () => {
+  it('should transform defineInlineTest to applyTransform wrapped in it function', async () => {
+    const inputCode = `
+const defineInlineTest = require('jscodeshift/dist/testUtils').defineInlineTest;
+defineInlineTest(
+  { default: transformer, parser: 'tsx' },
+  {},
+  'input code',
+  'output code',
+  'test description'
+);`;
+
+    const expectedOutput = `import { applyTransform } from "@hypermod/utils";
+it('test description', async () => {
+  const result = await applyTransform(transformer, 'input code', {
+    parser: 'tsx'
+  });
+
+  expect(result).toMatchInlineSnapshot('output code');
+});`;
+
+    const result = await applyTransform(transformer, inputCode, {
+      parser: 'tsx',
+    });
+
+    expect(result).toBe(expectedOutput.trim());
+  });
+
+  it('should not transform unrelated code', async () => {
+    const inputCode = `console.log('hello world');`;
+    const result = await applyTransform(transformer, inputCode, {
+      parser: 'tsx',
+    });
+
+    expect(result).toBe(inputCode);
+  });
+
+  it('should be idempotent', async () => {
+    const inputCode = `
+const defineInlineTest = require('jscodeshift/dist/testUtils').defineInlineTest;
+defineInlineTest(
+  { default: transformer, parser: 'tsx' },
+  {},
+  'input code',
+  'output code',
+  'test description'
+);`;
+
+    const expectedOutput = `import { applyTransform } from "@hypermod/utils";
+it('test description', async () => {
+  const result = await applyTransform(transformer, 'input code', {
+    parser: 'tsx'
+  });
+
+  expect(result).toMatchInlineSnapshot('output code');
+});`;
+
+    const firstPass = await applyTransform(transformer, inputCode, {
+      parser: 'tsx',
+    });
+
+    expect(firstPass).toBe(expectedOutput);
+
+    const secondPass = await applyTransform(transformer, firstPass, {
+      parser: 'tsx',
+    });
+    expect(secondPass).toBe(firstPass);
+  });
+});

community/hypermod/src/defineInlineTest-to-applyTransform/transform.ts

@@ -0,0 +1,160 @@
+import core, { API, FileInfo, Options, Collection } from 'jscodeshift';
+
+import { hasImportDeclaration, hasImportSpecifier } from '@hypermod/utils';
+
+export default function transformer(
+  file: FileInfo,
+  { jscodeshift: j }: API,
+  options: Options,
+) {
+  const source = j(file.source);
+
+  if (!hasTestUtilsImport(j, source)) {
+    return file.source;
+  }
+
+  // Replace the import of defineInlineTest with applyTransform from '@hypermod/utils'
+  replaceImport(j, source);
+
+  // Transform defineInlineTest calls to it function with applyTransform
+  transformDefineInlineTestCalls(j, source);
+
+  return source.toSource(options);
+}
+
+function replaceImport(j: core.JSCodeshift, source: Collection<any>) {
+  // Remove defineInlineTest import or require
+  source
+    .find(j.ImportDeclaration)
+    .filter(path => path.node.source.value === 'jscodeshift/dist/testUtils')
+    .remove();
+
+  source
+    .find(j.VariableDeclarator)
+    .filter(path => {
+      return (
+        path.node.init &&
+        // @ts-expect-error
+        path.node.init.object &&
+        // @ts-expect-error
+        path.node.init.object.callee &&
+        // @ts-expect-error
+        path.node.init.object.callee.name === 'require' &&
+        // @ts-expect-error
+        path.node.init.object.arguments.length &&
+        // @ts-expect-error
+        path.node.init.object.arguments[0].value ===
+          'jscodeshift/dist/testUtils'
+      );
+    })
+    .remove();
+
+  if (hasImportSpecifier(j, source, 'applyTransform', '@hypermod/utils')) {
+    return;
+  }
+
+  // Insert the applyTransform import
+  const applyTransformImport = j.importDeclaration(
+    [j.importSpecifier(j.identifier('applyTransform'))],
+    j.stringLiteral('@hypermod/utils'),
+  );
+
+  // Insert the new import at the top of the file
+  source.get().node.program.body.unshift(applyTransformImport);
+}
+
+function hasTestUtilsImport(j: core.JSCodeshift, source: Collection<any>) {
+  const hasRequireStatement = source.find(j.VariableDeclarator).filter(path => {
+    return (
+      path.node.init &&
+      // @ts-expect-error
+      path.node.init.object &&
+      // @ts-expect-error
+      path.node.init.object.callee &&
+      // @ts-expect-error
+      path.node.init.object.callee.name === 'require' &&
+      // @ts-expect-error
+      path.node.init.object.arguments.length &&
+      // @ts-expect-error
+      path.node.init.object.arguments[0].value === 'jscodeshift/dist/testUtils'
+    );
+  }).length;
+
+  return (
+    hasImportSpecifier(j, source, 'applyTransform', '@hypermod/utils') ||
+    hasRequireStatement
+  );
+}
+
+function transformDefineInlineTestCalls(
+  j: core.JSCodeshift,
+  source: Collection<any>,
+) {
+  source
+    .find(j.CallExpression)
+    .filter(
+      path =>
+        // @ts-expect-error
+        path.node.callee.name === 'defineInlineTest' ||
+        // @ts-expect-error
+        (path.node.callee.property &&
+          // @ts-expect-error
+          path.node.callee.property.name === 'defineInlineTest'),
+    )
+    .forEach(path => {
+      const [transformerOpts, _configOpts, input, output, description] =
+        path.node.arguments;
+
+      const transformer = j(transformerOpts).find(j.ObjectProperty, {
+        key: { name: 'default' },
+      });
+
+      const parser = j(transformerOpts).find(j.ObjectProperty, {
+        key: { name: 'parser' },
+      });
+
+      if (!parser.length || !transformer.length) {
+        throw new Error('Parser or transformer not found');
+      }
+
+      // Create the async arrow function for the test body
+      const testBody = j.blockStatement([
+        j.variableDeclaration('const', [
+          j.variableDeclarator(
+            j.identifier('result'),
+            j.awaitExpression(
+              j.callExpression(j.identifier('applyTransform'), [
+                transformer.get().value.value,
+                input,
+                j.objectExpression([parser.get().value]),
+              ]),
+            ),
+          ),
+        ]),
+        j.expressionStatement(
+          j.callExpression(
+            j.memberExpression(
+              j.callExpression(j.identifier('expect'), [
+                j.identifier('result'),
+              ]),
+              j.identifier('toMatchInlineSnapshot'),
+            ),
+            [output],
+          ),
+        ),
+      ]);
+
+      const asyncArrowFunction = j.arrowFunctionExpression([], testBody, true);
+      // https://github.com/benjamn/ast-types/issues/264#issuecomment-384392685
+      asyncArrowFunction.async = true;
+
+      // Create the it function call
+      const itFunctionCall = j.callExpression(j.identifier('it'), [
+        description,
+        asyncArrowFunction,
+      ]);
+
+      // Replace the original call with the new it function call
+      j(path).replaceWith(itFunctionCall);
+    });
+}

community/hypermod/src/hypermod.config.js

@@ -0,0 +1,10 @@
+module.exports = {
+  maintainers: [],
+  targets: [],
+  description: 'Codemods for hypermod',
+  transforms: {},
+
+  presets: {
+    'defineInlineTest-to-applyTransform': require('./defineInlineTest-to-applyTransform/transform'),
+  },
+};