Merge branch '29-using-vitest-for-unit-testing' of https://github.com…

…/RAIRLab/Peirce-My-Heart into 29-using-vitest-for-unit-testing

.vscode/launch.json

@@ -4,6 +4,13 @@
     // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
     "version": "0.2.0",
     "configurations": [
+        {
+            "type": "msedge",
+            "name": "Edge Vite Debug",
+            "request": "launch",
+            "url": "http://localhost:5173/",
+            "webRoot": "${workspaceFolder}/src"
+        },
         {
             "type": "chrome",
             "request": "launch",

.vscode/settings.json

@@ -5,6 +5,8 @@
         "jamesoswald",
         "peaceiris",
         "peircemyheart",
+        "radx",
+        "rady",
         "styleguidelines",
         "Subrina",
         "Tiwari",

package.json

@@ -37,5 +37,8 @@
     "typescript": "~5.2.2",
     "vite": "^4.4.9",
     "vitest": "^0.34.6"
+  },
+  "dependencies": {
+    "nomial": "^1.0.11"
   }
 }

src/AEG/AEGTree.ts

@@ -55,12 +55,13 @@ export class AEGTree {
     }
 
     /**
-     * Checks whether the given node can be inserted into this tree
-     * without overlapping any bounding boxes.
+     * Method that checks whether the given node can be inserted into this tree
+     * at a given point without overlapping any bounding boxes.
      * @param incomingNode The node to be inserted.
      * @returns True, if the node can be inserted. Else, false
      */
     public canInsert(incomingNode: AtomNode | CutNode): boolean {
+        console.log("checking can insert");
         const currentCut: CutNode = this.sheet.getCurrentCut(incomingNode);
         for (let i = 0; i < currentCut.children.length; i++) {
             if (this.overlaps(incomingNode, currentCut.children[i])) {
@@ -81,7 +82,9 @@ export class AEGTree {
         }
 
         const currentCut: CutNode = this.sheet.getCurrentCut(incomingNode);
-        const originalChildren: (AtomNode | CutNode)[] = currentCut.children;
+        //const originalChildren: (AtomNode | CutNode)[] = currentCut.children;
+        //==============CHANGEDDDD=========
+        const originalChildren: (AtomNode | CutNode)[] = [...currentCut.children];
         currentCut.children.push(incomingNode);
 
         if (incomingNode instanceof CutNode) {
@@ -134,4 +137,8 @@ export class AEGTree {
             }
         }
     }
+
+    public toString(): string {
+        return this.sheet.toFormulaString();
+    }
 }

src/AEG/CutNode.ts

@@ -6,12 +6,13 @@ import {Point} from "./Point";
  * Class that defines a Cut in AEGTree.
  * @author Anusha Tiwari
  * @author Ryan Reilly
+ * @author James Oswald
  */
 export class CutNode {
     /**
      * The boundary of this node.
      */
-    ellipse: Ellipse | null; //Null for sheet
+    ellipse: Ellipse | null; //Null for sheet of assertion
 
     /**
      * Contains the list of child nodes nested within this node.
@@ -35,9 +36,12 @@ export class CutNode {
      */
     public getCurrentCut(newNode: CutNode | AtomNode): CutNode {
         for (let i = 0; i < this.children.length; i++) {
-            if (this.children[i] instanceof CutNode && this.children[i].containsNode(newNode)) {
+            const child: CutNode | AtomNode = this.children[i];
+            if (child instanceof CutNode && this.children[i].containsNode(newNode)) {
+                //======DEBUGGG=======
+                console.log("current cut: " + this.children[i]);
                 //newNode can be placed at least one layer deeper
-                return this.getCurrentCut(this.children[i]);
+                return child.getCurrentCut(newNode);
             }
         }
         return this; //we are at the deepest valid level that newNode can be placed
@@ -71,10 +75,12 @@ export class CutNode {
         }
 
         if (otherNode instanceof AtomNode) {
-            return this.ellipse.containsShape((otherNode as AtomNode).rect);
-        } else {
+            return this.ellipse.containsShape(otherNode.rect);
+        } else if (otherNode instanceof CutNode) {
             //ELLIPSE TO BE IMPLEMENTED ACCURATELY
-            return this.ellipse.containsShape((otherNode as CutNode).ellipse as Ellipse);
+            return this.ellipse.containsShape(otherNode.ellipse as Ellipse);
+        } else {
+            throw Error("containsNode expected AtomNode or CutNode");
         }
     }
 
@@ -130,4 +136,23 @@ export class CutNode {
         }
         return str;
     }
+
+    public toFormulaString(): string {
+        let formulaString = "";
+        for (const child of this.children) {
+            if (child instanceof AtomNode) {
+                formulaString += child.identifier;
+            } else if (child instanceof CutNode) {
+                formulaString += child.toFormulaString();
+            }
+            formulaString += " ";
+        }
+        formulaString = formulaString.slice(0, -1);
+        if (this.ellipse === null) {
+            formulaString = "[" + formulaString + "]";
+        } else {
+            formulaString = "(" + formulaString + ")";
+        }
+        return formulaString;
+    }
 }