Fixes and improvements on the History API

Clava-JS/src-api/clava/events/EventListener.ts

@@ -0,0 +1,133 @@
+import { EventEmitter } from "events";
+import { Event, EventTime } from "./Events.js";
+import ophistory from  "../history/History.js"
+import { DetachOperation, DetachReference, InlineCommentOperation, InsertOperation, RemoveChildrenOperation, ReplaceOperation, SetChildOperation, TypeChangeOperation, ValueOperation } from "../history/Operations.js";
+import { Joinpoint } from "../../Joinpoints.js";
+
+const eventListener = new EventEmitter();
+
+
+eventListener.on("ACTION", (e: Event) => {
+
+  switch (e.timing) {
+    case EventTime.BEFORE:
+      switch (e.description) {
+        case "detach":
+          detachOperationFromEvent(e);
+          break;
+        case "removeChildren":
+          removeChildrenOperationFromEvent(e);
+          break;
+        case "setType":
+          changeTypeFromEvent(e);
+          break;
+        case "setInlineComments":
+          inlineCommentOperationFromEvent(e);
+          break;
+        case "setValue":
+          setValueOperationFromEvent(e);
+          break;
+        default:
+          break;
+      }
+      break;
+    case EventTime.AFTER:
+      switch (e.description){
+        case "insertAfter":
+        case "insertBefore":
+          insertOperationFromEvent(e);
+          break;
+        case "replaceWith":
+          if (e.inputs.length > 0){
+            if (typeof e.inputs[0] === 'string' || e.inputs[0] instanceof Joinpoint){
+              replaceSingleOperationFromEvent(e);
+            }
+            else {
+              replaceMultipleOperationFromEvent(e);
+            }
+          }
+          break;
+        case "replaceWithStrings":
+          if (e.inputs.length > 0){
+            replaceMultipleOperationFromEvent(e);
+          }
+          break;
+        case "toComment":
+          replaceSingleOperationFromEvent(e);
+          break;
+        case "setFirstChild":
+          setFirstChildFromEvent(e);
+          break;
+        case "setLastChild":
+          setLastChildFromEvent(e);
+          break;
+        default:
+          break;
+      }
+      break;
+  }
+});
+
+function insertOperationFromEvent(e: Event) {
+  if (e.returnValue !== undefined){
+    ophistory.newOperation(new InsertOperation(e.returnValue))
+  }
+}
+
+function replaceSingleOperationFromEvent(e: Event) {
+  if (e.returnValue !== undefined){
+    ophistory.newOperation(new ReplaceOperation(e.mainJP, e.returnValue, 1));
+  }
+}
+
+function replaceMultipleOperationFromEvent(e: Event) {
+  if (e.returnValue !== undefined){
+    ophistory.newOperation(new ReplaceOperation(e.mainJP, e.returnValue, (e.inputs[0] as (Joinpoint[] | string[])).length));
+  }
+}
+
+function detachOperationFromEvent(e: Event) {
+  let refJP: Joinpoint, ref: DetachReference;
+  if (e.mainJP.siblingsLeft.length >= 1){
+    refJP = e.mainJP.leftJp;
+    ref = DetachReference.LEFT;
+  } else if  (e.mainJP.siblingsRight.length >= 1) {
+    refJP = e.mainJP.rightJp;
+    ref = DetachReference.RIGHT;
+  } else {
+    refJP = e.mainJP.parent;
+    ref = DetachReference.TOP;
+  }
+  ophistory.newOperation(new DetachOperation(e.mainJP, refJP, ref));
+}
+
+function setFirstChildFromEvent(e: Event) {
+  ophistory.newOperation(new SetChildOperation(e.mainJP.firstChild, e.returnValue));
+}
+
+function setLastChildFromEvent(e: Event) {
+  ophistory.newOperation(new SetChildOperation(e.mainJP.lastChild, e.returnValue));
+}
+
+function removeChildrenOperationFromEvent(e: Event) {
+  ophistory.newOperation(new RemoveChildrenOperation(e.mainJP, e.mainJP.children));
+}
+
+function changeTypeFromEvent(e: Event) {
+  ophistory.newOperation(new TypeChangeOperation(e.mainJP, e.mainJP.type));
+}
+
+function inlineCommentOperationFromEvent(e: Event) {
+  const comments = e.mainJP.inlineComments
+    .map((comment) => comment.text)
+    .filter((comment): comment is string => comment !== null);
+  ophistory.newOperation(new InlineCommentOperation(e.mainJP, comments));
+}
+
+function setValueOperationFromEvent(e: Event) {
+  if (e.inputs && e.inputs.at(0)) {
+    ophistory.newOperation(new ValueOperation(e.mainJP, e.inputs.at(0) as string, e.mainJP.getValue(e.inputs.at(0) as string)));
+  }
+}
+
+export default eventListener;

Clava-JS/src-api/clava/events/Events.ts

@@ -0,0 +1,28 @@
+import { Joinpoint } from "../../Joinpoints.js";
+
+export enum EventTime {
+  BEFORE = "Before",
+  AFTER = "After",
+}
+
+export class Event {
+  public timing: EventTime;
+  public description: string;
+  public mainJP: Joinpoint;
+  public returnValue?: any;
+  public inputs: unknown[];
+
+  constructor(
+    timing: EventTime,
+    description: string,
+    mainJP: Joinpoint,
+    returnJP?: Joinpoint,
+    ...inputs: unknown[]
+  ) {
+    this.timing = timing;
+    this.description = description;
+    this.mainJP = mainJP;
+    this.returnValue = returnJP;
+    this.inputs = inputs;
+  }
+}

Clava-JS/src-api/clava/history/History.test.ts

@@ -0,0 +1,179 @@
+import { registerSourceCode } from "lara-js/jest/jestHelpers";
+import Clava from "../Clava";
+import { FunctionJp, Joinpoint, Loop, ReturnStmt } from "../../Joinpoints";
+import Query from "lara-js/api/weaver/Query";
+import ophistory from "./History";
+import {jest} from '@jest/globals'
+
+
+const code: string = `void func() {
+    for (int i = 0; i < 1; i++){
+        i++;
+    }
+    for (int i = 0; i < 2; i++){
+        i++;
+    }
+}
+
+void test() {}
+
+int main(int argc, char *argv[]) {
+    func();
+    return 0;
+}
+`;
+
+describe("Transformation History: Multiple operations", () => {
+    registerSourceCode(code);
+    ophistory.checkpoint();
+
+    it("Inserts and detaches code comparison", () => {
+        const a: string = Clava.getProgram().code;
+
+        const loopStmt1 = Query.search(Loop).get().at(0) as Joinpoint;
+        const loopStmt2 = Query.search(Loop).get().at(1) as Joinpoint;
+        loopStmt1.insertBefore(loopStmt2.deepCopy());
+        loopStmt2.insertAfter(loopStmt1.deepCopy());
+
+        loopStmt1.detach();
+        loopStmt2.detach();
+
+        const b: string = Clava.getProgram().code;
+
+        ophistory.rollback(4);
+        const c: string = Clava.getProgram().code;
+
+        expect(a).toEqual(c);
+        expect(b).not.toEqual(c);
+    });
+
+    it("Replaces and detach code comparison", () => {
+        const a: string = Clava.getProgram().code;
+
+        const loopStmt1 = Query.search(Loop).get().at(0) as Joinpoint;
+        const returnStmt = Query.search(ReturnStmt).get().at(0) as Joinpoint;
+
+        let cur = loopStmt1.replaceWith(returnStmt.deepCopy());
+        cur = cur.replaceWith("aaaaa");
+        cur = cur.replaceWithStrings(["aaaaa", "bbbbb", "ccccc"]);
+        cur = cur.toComment();
+        cur.detach();
+
+        const b: string = Clava.getProgram().code;
+
+        ophistory.rollback(5);
+        const c: string = Clava.getProgram().code;
+
+        expect(a).toEqual(c);
+        expect(b).not.toEqual(c);
+    });
+
+    it("Children set and removes code comparison", () => {
+        const a: string = Clava.getProgram().code;
+
+        const loopStmt1 = Query.search(Loop).get().at(0) as Joinpoint;
+        const testFunc = Query.search(FunctionJp).get().at(1) as FunctionJp;
+        const returnStmt = Query.search(ReturnStmt).get().at(0) as Joinpoint;
+
+        testFunc.body.setFirstChild(loopStmt1.deepCopy());
+        testFunc.body.setLastChild(returnStmt.deepCopy());
+        testFunc.body.setFirstChild(loopStmt1.deepCopy());
+        testFunc.body.setLastChild(returnStmt.deepCopy());
+
+        const b: string = Clava.getProgram().code;
+
+        ophistory.rollback(4);
+        const c: string = Clava.getProgram().code;
+
+        expect(a).toEqual(c);
+        expect(b).not.toEqual(c);
+    });
+
+    it("Log an error message on undo operation (single rollback)", () => {
+        const errorSpy = jest.spyOn(global.console, "error")
+            .mockImplementation(() => {});
+
+        const loopStmt1 = Query.search(Loop).get().at(0) as Joinpoint;
+
+        loopStmt1.replaceWith("aaaa");
+        loopStmt1.detach();
+
+        ophistory.rollback(2);
+
+        expect(errorSpy).toHaveBeenCalledTimes(1);
+
+        errorSpy.mockRestore();
+    });
+
+    it("Checkpoints code comparison", () => {
+
+        const loopStmt1 = Query.search(Loop).get().at(0) as Joinpoint;
+        const loopStmt2 = Query.search(Loop).get().at(1) as Joinpoint;
+        loopStmt1.insertBefore(loopStmt2.deepCopy());
+        loopStmt2.insertAfter(loopStmt1.deepCopy());
+
+        ophistory.checkpoint();
+        const a: string = Clava.getProgram().code;
+
+        loopStmt1.detach();
+        loopStmt2.detach();
+
+        const b: string = Clava.getProgram().code;
+
+        ophistory.returnToLastCheckpoint();
+        const c: string = Clava.getProgram().code;
+
+        expect(a).toEqual(c);
+        expect(b).not.toEqual(c);
+    });
+
+    it("Log an error message on undo operation (checkpoint rollback)", () => {
+        const errorSpy = jest.spyOn(global.console, "error")
+            .mockImplementation(() => {});
+
+        const loopStmt1 = Query.search(Loop).get().at(0) as Joinpoint;
+
+        ophistory.checkpoint();
+        loopStmt1.replaceWith("aaaa");
+        loopStmt1.detach();
+
+        ophistory.returnToLastCheckpoint();
+
+        expect(errorSpy).toHaveBeenCalledTimes(1);
+
+        errorSpy.mockRestore();
+    });
+
+    it("Start and stop history recording", () => {
+        ophistory.stop();
+
+        const a: string = Clava.getProgram().code;
+
+        const loopStmt1 = Query.search(Loop).get().at(0) as Joinpoint;
+        loopStmt1.replaceWith("aaaa");
+
+        const b: string = Clava.getProgram().code;
+
+        ophistory.start();
+
+        const returnStmt = Query.search(Loop).get().at(0) as Joinpoint;
+        const comment = returnStmt.toComment();
+        ophistory.checkpoint();
+        const c: string = Clava.getProgram().code;
+
+        comment.detach();
+        const d: string = Clava.getProgram().code;
+
+        ophistory.returnToLastCheckpoint();
+        const e: string = Clava.getProgram().code;
+
+        expect(c).toEqual(e);
+        expect(a).not.toEqual(b);
+        expect(a).not.toEqual(c);
+        expect(a).not.toEqual(d);
+        expect(b).not.toEqual(c);
+        expect(b).not.toEqual(d);
+        expect(c).not.toEqual(d);
+    });
+
+});