@dittowords/cli 3.0.0 → 3.2.2-alpha

package/lib/replace.test.ts

@@ -0,0 +1,101 @@
+import fs from "fs/promises";
+import { parseOptions, replaceJSXTextInFile } from "./replace"; // Assuming the function is exported in a separate file
+
+// Helper function to create a temporary file
+async function createTempJSXFile(content: string): Promise<string> {
+  const tempFile = "tempFile.jsx";
+  await fs.writeFile(tempFile, content);
+  return tempFile;
+}
+
+// Helper function to delete the temporary file
+async function deleteTempFile(filePath: string): Promise<void> {
+  await fs.unlink(filePath);
+}
+
+describe("parseOptions", () => {
+  test("should pass with valid input", async () => {
+    const tempFile = await createTempJSXFile("<div>Hello, world!</div>");
+    expect(() =>
+      parseOptions([tempFile, "secondString", "thirdString"])
+    ).not.toThrow();
+
+    const result = parseOptions([tempFile, "secondString", "thirdString"]);
+    expect(result).toEqual({
+      filePath: tempFile,
+      searchString: "secondString",
+      replaceWith: "thirdString",
+    });
+
+    deleteTempFile(tempFile);
+  });
+
+  test("should throw error when options array does not have exactly three strings", () => {
+    expect(() => parseOptions(["oneString"])).toThrow(
+      "The options array must contain <file path> <search string> <replace with>."
+    );
+    expect(() => parseOptions(["one", "two"])).toThrow(
+      "The options array must contain <file path> <search string> <replace with>."
+    );
+    expect(() => parseOptions(["one", "two", "three", "four"])).toThrow(
+      "The options array must contain <file path> <search string> <replace with>."
+    );
+  });
+
+  test("should throw error when the first string is not a valid file path", () => {
+    const invalidFilePath = "/path/to/invalid/file.txt";
+    expect(() =>
+      parseOptions([invalidFilePath, "secondString", "thirdString"])
+    ).toThrow(`${invalidFilePath} is not a valid file path.`);
+  });
+
+  test("should throw error when the first string is a directory", () => {
+    const directoryPath = ".";
+    expect(() =>
+      parseOptions([directoryPath, "secondString", "thirdString"])
+    ).toThrow(`${directoryPath} is not a valid file path.`);
+  });
+});
+
+describe("replaceJSXTextInFile", () => {
+  afterEach(async () => {
+    await deleteTempFile("tempFile.jsx");
+  });
+
+  test("should replace JSX text with a DittoComponent", async () => {
+    const tempFile = await createTempJSXFile("<div>Hello, world</div>");
+    const searchString = "world";
+    const replaceWith = "some-id";
+
+    await replaceJSXTextInFile(tempFile, { searchString, replaceWith });
+
+    const transformedCode = await fs.readFile(tempFile, "utf-8");
+    expect(transformedCode).toContain(
+      `<div>Hello, <DittoComponent componentId="${replaceWith}" /></div>`
+    );
+  });
+
+  test("should handle case-insensitive search", async () => {
+    const tempFile = await createTempJSXFile("<div>HeLLo, WoRlD</div>");
+    const searchString = "world";
+    const replaceWith = "some-id";
+
+    await replaceJSXTextInFile(tempFile, { searchString, replaceWith });
+
+    const transformedCode = await fs.readFile(tempFile, "utf-8");
+    expect(transformedCode).toContain(
+      `<div>HeLLo, <DittoComponent componentId="${replaceWith}" /></div>`
+    );
+  });
+
+  test("should not replace JSX text if searchString is not found", async () => {
+    const tempFile = await createTempJSXFile("<div>Hello, world!</div>");
+    const searchString = "foobar";
+    const replaceWith = "some-id";
+
+    await replaceJSXTextInFile(tempFile, { searchString, replaceWith });
+
+    const transformedCode = await fs.readFile(tempFile, "utf-8");
+    expect(transformedCode).toContain("<div>Hello, world!</div>");
+  });
+});

package/lib/replace.ts

@@ -0,0 +1,106 @@
+import fs from "fs-extra";
+import { parse } from "@babel/parser";
+import traverse from "@babel/traverse";
+import * as t from "@babel/types";
+import { transformFromAst } from "@babel/core";
+
+async function replaceJSXTextInFile(
+  filePath: string,
+  replacement: { searchString: string; replaceWith: string }
+) {
+  const code = await fs.readFile(filePath, "utf-8");
+  const ast = parse(code, {
+    sourceType: "module",
+    plugins: ["jsx", "typescript"],
+  });
+
+  traverse(ast, {
+    JSXText(path) {
+      const { searchString, replaceWith } = replacement;
+
+      const regex = new RegExp(searchString, "gi");
+      if (regex.test(path.node.value)) {
+        const splitValues = splitByCaseInsensitive(
+          path.node.value,
+          searchString
+        );
+        const nodes: (t.JSXElement | t.JSXText)[] = [];
+
+        splitValues.forEach((splitValue) => {
+          if (splitValue.toLowerCase() === searchString.toLowerCase()) {
+            const identifier = t.jsxIdentifier("DittoComponent");
+            const componentId = t.jsxAttribute(
+              t.jsxIdentifier("componentId"),
+              t.stringLiteral(replaceWith)
+            );
+            const o = t.jsxOpeningElement(identifier, [componentId], true);
+            const jsxElement = t.jsxElement(o, undefined, [], true);
+            nodes.push(jsxElement);
+          } else {
+            nodes.push(t.jsxText(splitValue));
+          }
+        });
+
+        path.replaceWithMultiple(nodes);
+      }
+    },
+  });
+
+  // transfromFromAst types are wrong?
+  /* @ts-ignore */
+  const { code: transformedCode } = transformFromAst(ast, code, {
+    // Don't let this codebase's Babel config affect the code we're transforming.
+    configFile: false,
+  });
+  fs.writeFile(filePath, transformedCode);
+}
+
+function splitByCaseInsensitive(str: string, delimiter: string) {
+  return str.split(new RegExp(`(${delimiter})`, "gi")).filter((s) => s !== "");
+}
+
+function replace(options: string[]) {
+  let filePath: string;
+  let searchString: string;
+  let replaceWith: string;
+
+  try {
+    const parsedOptions = parseOptions(options);
+    filePath = parsedOptions.filePath;
+    searchString = parsedOptions.searchString;
+    replaceWith = parsedOptions.replaceWith;
+  } catch (e) {
+    console.error(e);
+    console.error(
+      "Usage for replace: ditto-cli replace <file path> <search string> <replace with>"
+    );
+    return;
+  }
+
+  replaceJSXTextInFile(filePath, { searchString, replaceWith });
+}
+
+function parseOptions(options: string[]): {
+  filePath: string;
+  searchString: string;
+  replaceWith: string;
+} {
+  if (options.length !== 3) {
+    throw new Error(
+      "The options array must contain <file path> <search string> <replace with>."
+    );
+  }
+
+  const filePath = options[0];
+  // Check if the file path exists and points to a regular file (not a directory or other file system object).
+  const isFilePathValid =
+    fs.existsSync(filePath) && fs.lstatSync(filePath).isFile();
+
+  if (!isFilePathValid) {
+    throw new Error(`${filePath} is not a valid file path.`);
+  }
+
+  return { filePath, searchString: options[1], replaceWith: options[2] };
+}
+
+export { replace, parseOptions, replaceJSXTextInFile };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dittowords/cli",
-  "version": "3.0.0",
+  "version": "3.2.2-alpha",
   "description": "Command Line Interface for Ditto (dittowords.com).",
   "main": "bin/index.js",
   "scripts": {
@@ -33,7 +33,6 @@
     "ditto-cli": "bin/ditto.js"
   },
   "devDependencies": {
-    "@babel/core": "^7.11.4",
     "@babel/preset-env": "^7.20.2",
     "@babel/preset-typescript": "^7.18.6",
     "@tsconfig/node16": "^1.0.3",
@@ -53,12 +52,20 @@
     "typescript": "^4.7.4"
   },
   "dependencies": {
+    "@babel/core": "^7.11.4",
+    "@babel/parser": "^7.21.4",
+    "@babel/traverse": "^7.21.4",
+    "@babel/types": "^7.21.4",
+    "@types/babel-traverse": "^6.25.7",
+    "@types/fs-extra": "^11.0.1",
     "axios": "^0.27.2",
     "boxen": "^5.1.2",
     "chalk": "^4.1.0",
     "commander": "^6.1.0",
     "enquirer": "^2.3.6",
     "faker": "^5.1.0",
+    "fs-extra": "^11.1.1",
+    "glob": "^9.3.4",
     "js-yaml": "^4.1.0",
     "ora": "^5.0.0",
     "v8-compile-cache": "^2.1.1"