add wrap api

Author: flyerhzm

README.md

@@ -68,6 +68,8 @@ mutation.group(() => {
   mutation.delete(node: Node, selectors: string | string[], options: DeleteOptions)
   mutation.insert(node: Node, code: string, options: InsertOptions)
 })
+// wrap the ast node
+mutation.wrap(node: Node, options: WrapOptions)
 ```
 
 3. process actions and write the new source code to file:

src/action/indent.ts

@@ -8,17 +8,17 @@ import NodeMutation from "../node-mutation";
  * @extends BaseAction
  */
 export class IndentAction<T> extends BaseAction<T> {
-  private options: IndentOptions;
+  private tabSize: number;
 
   /**
    * Create an IndentAction
    * @param {T} node
    * @param {IndentOptions} options
    * @param options.adapter - adapter to parse the node
    */
-  constructor(node: T, options: IndentOptions & { adapter: Adapter<T> }) {
-    super(node, "", { adapter: options.adapter });
-    this.options = { tabSize: 1, ...options };
+  constructor(node: T, { tabSize, adapter }: IndentOptions & { adapter: Adapter<T> }) {
+    super(node, "", { adapter });
+    this.tabSize = tabSize || 1;
     this.type = "replace";
   }
 
@@ -37,6 +37,6 @@ export class IndentAction<T> extends BaseAction<T> {
    */
   get newCode(): string {
     const source = this.adapter.getSource(this.node!);
-    return source.split("\n").map(line => ' '.repeat(NodeMutation.tabWidth * this.options.tabSize!) + line).join("\n");
+    return source.split("\n").map(line => ' '.repeat(NodeMutation.tabWidth * this.tabSize) + line).join("\n");
   }
 }

src/node-mutation.ts

@@ -1,5 +1,5 @@
 import debug from "debug";
-import type { Action, IndentOptions, InsertOptions, ReplaceOptions, DeleteOptions, RemoveOptions } from "./types/action";
+import type { Action, IndentOptions, InsertOptions, ReplaceOptions, DeleteOptions, RemoveOptions, WrapOptions } from "./types/action";
 import type { ProcessResult, TestResult } from "./types/node-mutation";
 import Adapter from "./adapter";
 import TypescriptAdapter from "./adapter/typescript";
@@ -275,6 +275,44 @@ class NodeMutation<T> {
     this.actions.push(new ReplaceWithAction<T>(node, code, { adapter: this.adapter }).process());
   }
 
+  /**
+   * Wrap the ast node with prefix and suffix.
+   * @param node {T} - ast node
+   * @param prefix {string} - prefix
+   * @param suffix {string} - suffix
+   * @param newLine {boolean} - if true, the prefix and suffix will be wrapped in a new line
+   * @example
+   * source code of the ast node is
+   * ```
+   * console.log('foo)
+   * ```
+   * then we call
+   * ```
+   * mutation.wrap(node, { prefix: "function logFoo() {", suffix: "}", newLine: true });
+   * ```
+   * the source code will be rewritten to
+   * ```
+   * function logFoo() {
+   *   console.log('foo')
+   * }
+   * ```
+   */
+  wrap(node: T, { prefix, suffix, newLine }: WrapOptions) {
+    if (newLine) {
+      const indentation = this.adapter.getStartLoc(node).column;
+      this.group(() => {
+        this.insert(node, prefix + "\n" + (' '.repeat(indentation)), { at: "beginning" });
+        this.insert(node, "\n" + (' '.repeat(indentation)) + suffix, { at: "end" });
+        this.indent(node);
+      });
+    } else {
+      this.group(() => {
+        this.insert(node, prefix, { at: "beginning" });
+        this.insert(node, suffix, { at: "end" });
+      });
+    }
+  }
+
   /**
    * Process Result
    * @typedef {Object} ProcessResult

src/types/action.ts

@@ -33,3 +33,9 @@ export type DeleteOptions = {
 export type RemoveOptions = {
   andComma?: boolean;
 }
+
+export type WrapOptions = {
+  prefix: string;
+  suffix: string;
+  newLine: boolean;
+}

test/node-mutation.spec.ts

@@ -4,10 +4,13 @@ import Strategy from "../src/strategy";
 import { ConflictActionError } from "../src/error";
 import { parseCode } from "./helper";
 import { Node } from "typescript";
-import TypescriptAdapter from "../src/adapter/typescript";
 
 describe("NodeMutation", () => {
   describe("configure", () => {
+    afterEach(() => {
+      NodeMutation.configure({ tabWidth: 2 });
+    });
+
     it("sets tabWidth", () => {
       expect(NodeMutation.tabWidth).toEqual(2);
       NodeMutation.configure({ tabWidth: 4 });
@@ -128,6 +131,24 @@ describe("NodeMutation", () => {
         }
       `)
     });
+
+    it("wraps the ast node", () => {
+      const source1 = dedent`
+        console.log('foo');
+      `;
+      NodeMutation.configure({ strategy: Strategy.KEEP_RUNNING });
+      const mutation = new NodeMutation<Node>(source1, { adapter: "typescript" });
+      const node = parseCode(source1);
+      mutation.wrap(node, { prefix: "function logFoo() {", suffix: "}", newLine: true });
+      const result = mutation.process();
+      expect(result.affected).toBeTruthy();
+      expect(result.conflicted).toBeFalsy();
+      expect(result.newSource).toEqual(dedent`
+        function logFoo() {
+          console.log('foo');
+        }
+      `);
+    });
   });
 
   describe("test", () => {
@@ -260,5 +281,47 @@ describe("NodeMutation", () => {
         }],
       }])
     });
+
+    it("wraps the ast node", () => {
+      const source1 = dedent`
+        console.log('foo');
+      `;
+      NodeMutation.configure({ strategy: Strategy.KEEP_RUNNING });
+      const mutation = new NodeMutation<Node>(source1, { adapter: "typescript" });
+      const node = parseCode(source1);
+      mutation.wrap(node, { prefix: "function logFoo() {", suffix: "}", newLine: true });
+      const result = mutation.test();
+      expect(result.affected).toBeTruthy();
+      expect(result.conflicted).toBeFalsy();
+      expect(result.actions).toEqual([{
+        "actions": [
+          {
+            "actions": undefined,
+            "end": 0,
+            "newCode": `function logFoo() {\n`,
+            "start": 0,
+            "type": "insert",
+          },
+          {
+            "actions": undefined,
+            "end": 19,
+            "newCode": "  console.log('foo');",
+            "start": 0,
+            "type": "replace",
+          },
+          {
+            "actions": undefined,
+            "end": 19,
+            "newCode": `\n}`,
+            "start": 19,
+            "type": "insert",
+          },
+        ],
+        "end": 19,
+        "newCode": undefined,
+        "start": 0,
+        "type": "group",
+      }]);
+    });
   });
 });