wip: mess up tests

Author: ca-d

XMLEditor.spec.ts

@@ -19,9 +19,9 @@ import {
 import { EditV2, isSetAttributes, isSetTextContent } from "./editv2.js";
 
 import { XMLEditor } from "./XMLEditor.js";
-import { Transactor } from "./Transactor.js";
+import { Commit, Transactor } from "./Transactor.js";
 
-describe("Utility function to handle EditV2 edits", () => {
+describe("XMLEditor", () => {
   let editor: Transactor<EditV2>;
   let sclDoc: XMLDocument;
 
@@ -192,43 +192,100 @@ describe("Utility function to handle EditV2 edits", () => {
   it("undoes a committed edit on undo() call", () => {
     const node = sclDoc.querySelector("Substation")!;
 
-    editor.commit({ node });
-    editor.undo();
+    const commit = editor.commit({ node });
+    const undone = editor.undo();
 
+    expect(undone).to.exist.and.to.equal(commit);
     expect(sclDoc.querySelector("Substation")).to.exist;
   });
 
   it("redoes an undone edit on redo() call", () => {
     const node = sclDoc.querySelector("Substation")!;
 
+    const commit = editor.commit({ node });
+    editor.undo();
+    const redone = editor.redo();
+
+    expect(redone).to.exist.and.to.equal(commit);
+    expect(sclDoc.querySelector("Substation")).to.be.null;
+  });
+
+  it("undoes nothing at the beginning of the history", () => {
+    const node = sclDoc.querySelector("Substation")!;
+
     editor.commit({ node });
     editor.undo();
+    const secondUndo = editor.undo();
+
+    expect(secondUndo).to.not.exist;
+  });
+
+  it("redoes nothing at the end of the history", () => {
+    const node = sclDoc.querySelector("Substation")!;
+
+    editor.commit({ node });
+    const redo = editor.redo();
+
+    expect(redo).to.not.exist;
+  });
+
+  it("allows the user to subscribe to commits and to unsubscribe", () => {
+    const node = sclDoc.querySelector("Substation")!;
+    const edit = { node };
+    let committed: Commit<EditV2> | undefined;
+    let called = 0;
+    const callback = (commit: Commit<EditV2>) => {
+      committed = commit;
+      called++;
+    };
+    const unsubscribe = editor.subscribe(callback);
+    editor.commit(edit, { title: "test" });
+    expect(committed).to.exist.and.to.have.property("redo").to.include(edit);
+    expect(committed).to.have.property("title", "test");
+    expect(called).to.equal(1);
+    expect(editor.past).to.have.lengthOf(1);
+
+    editor.undo();
+    expect(called).to.equal(1);
+    expect(editor.past).to.have.lengthOf(0);
+    expect(editor.future).to.have.lengthOf(1);
+
     editor.redo();
+    expect(called).to.equal(1);
+    expect(editor.past).to.have.lengthOf(1);
+    expect(editor.future).to.have.lengthOf(0);
 
-    expect(sclDoc.querySelector("Substation")).to.be.null;
+    const unsubscribed = unsubscribe();
+    expect(unsubscribed).to.equal(callback);
+
+    editor.commit(edit, { title: "some other title, not test" });
+    expect(committed).to.have.property("title", "test");
+    expect(called).to.equal(1);
+    expect(editor.past).to.have.lengthOf(2);
   });
 
   describe("generally", () => {
-    it("inserts elements on Insert edit events", () =>
+    it("inserts elements on Insert edits", () =>
       assert(
         property(
           testDocs.chain(([doc1, doc2]) => {
             const nodes = doc1.nodes.concat(doc2.nodes);
             return insert(nodes);
           }),
           (edit) => {
-            editor.commit(edit);
-            if (isValidInsert(edit))
+            if (isValidInsert(edit)) {
+              editor.commit(edit);
               return (
                 edit.node.parentElement === edit.parent &&
                 edit.node.nextSibling === edit.reference
               );
+            }
             return true;
           },
         ),
       ));
 
-    it("set's an element's textContent on SetTextContent edit events", () =>
+    it("sets an element's textContent on SetTextContent edits", () =>
       assert(
         property(
           testDocs.chain(([doc1, doc2]) => {
@@ -243,7 +300,7 @@ describe("Utility function to handle EditV2 edits", () => {
         ),
       ));
 
-    it("updates default- and foreign-namespace attributes on UpdateNS events", () =>
+    it("updates default- and foreign-namespace attributes on SetAttribute edits", () =>
       assert(
         property(
           testDocs.chain(([{ nodes }]) => setAttributes(nodes)),
@@ -279,7 +336,7 @@ describe("Utility function to handle EditV2 edits", () => {
         ),
       )).timeout(20000);
 
-    it("removes elements on Remove edit events", () =>
+    it("removes elements on Remove edits", () =>
       assert(
         property(
           testDocs.chain(([{ nodes }]) => remove(nodes)),
@@ -299,7 +356,11 @@ describe("Utility function to handle EditV2 edits", () => {
               doc.cloneNode(true),
             );
             edits.forEach((a: EditV2) => {
-              editor.commit(a, { squash });
+              try {
+                editor.commit(a, { squash });
+              } catch (e) {
+                console.log("error", e);
+              }
             });
             while (editor.past.length) editor.undo();
             expect(doc1).to.satisfy((doc: XMLDocument) =>

handleEdit.ts

@@ -30,19 +30,6 @@ function handleSetTextContent({
   return [undoTextContent, ...restoreChildNodes];
 }
 
-function uniqueNSPrefix(element: Element, ns: string): string {
-  let i = 1;
-  const attributes = Array.from(element.attributes);
-  const hasSamePrefix = (attribute: Attr) =>
-    attribute.prefix === `ens${i}` && attribute.namespaceURI !== ns;
-  const nsOrNull = new Set([null, ns]);
-  const differentNamespace = (prefix: string) =>
-    !nsOrNull.has(element.lookupNamespaceURI(prefix));
-  while (differentNamespace(`ens${i}`) || attributes.find(hasSamePrefix))
-    i += 1;
-  return `ens${i}`;
-}
-
 const xmlAttributeName =
   /^(?!xml|Xml|xMl|xmL|XMl|xML|XmL|XML)[A-Za-z_][A-Za-z0-9-_.]*(:[A-Za-z_][A-Za-z0-9-_.]*)?$/;
 
@@ -58,6 +45,8 @@ function handleSetAttributes({
   const oldAttributes = { ...attributes };
   const oldAttributesNS = { ...attributesNS };
 
+  const errors: unknown[] = [];
+
   // save element's non-prefixed attributes for undo
   Object.keys(attributes)
     .reverse()
@@ -71,9 +60,10 @@ function handleSetAttributes({
       const [name, value] = entry as [string, string | null];
       if (value === null) element.removeAttribute(name);
       else element.setAttribute(name, value);
-    } catch (_e) {
+    } catch (e) {
       // undo nothing if update didn't work on this attribute
       delete oldAttributes[entry[0]];
+      errors.push(e);
     }
   }
 
@@ -109,20 +99,21 @@ function handleSetAttributes({
         if (value === null) {
           element.removeAttributeNS(ns, name.split(":").pop()!);
         } else {
-          let qualifiedName = name;
-          if (!qualifiedName.includes(":")) {
-            let prefix = element.lookupPrefix(ns);
-            if (!prefix) prefix = uniqueNSPrefix(element, ns);
-            qualifiedName = `${prefix}:${name}`;
-          }
-          element.setAttributeNS(ns, qualifiedName, value);
+          element.setAttributeNS(ns, name, value);
         }
-      } catch (_e) {
+      } catch (e) {
         delete oldAttributesNS[ns]![entry[0]];
+        errors.push(e);
       }
     }
   }
 
+  if (errors.length > 0)
+    throw new Error(
+      `Failed to set attributes on element ${element.tagName}`,
+      { cause: errors },
+    );
+
   return {
     element,
     attributes: oldAttributes,
@@ -148,22 +139,17 @@ function handleInsert({
   node,
   reference,
 }: Insert): Insert | Remove | [] {
-  try {
-    const { parentNode, nextSibling } = node;
-    parent.insertBefore(node, reference);
-    if (parentNode)
-      // undo: move child node back to original place
-      return {
-        node,
-        parent: parentNode,
-        reference: nextSibling,
-      };
-    // undo: remove orphaned node
-    return { node };
-  } catch (_e) {
-    // undo nothing if insert doesn't work on these nodes
-    return [];
-  }
+  const { parentNode, nextSibling } = node;
+  parent.insertBefore(node, reference);
+  if (parentNode)
+    // undo: move child node back to original place
+    return {
+      node,
+      parent: parentNode,
+      reference: nextSibling,
+    };
+  // undo: remove orphaned node
+  return { node };
 }
 
 /** Applies an EditV2, returning the corresponding "undo" EditV2. */

tsconfig.json

@@ -4,7 +4,7 @@
     "module": "esnext",
     "moduleResolution": "node",
     "noEmitOnError": true,
-    "lib": ["es2018", "dom"],
+    "lib": ["es2022", "dom"],
     "strict": true,
     "esModuleInterop": false,
     "allowSyntheticDefaultImports": true,