Add move and more tests

Sources/Nodal/Document/Document+PendingNameRecords.swift

@@ -42,7 +42,7 @@ internal extension Document {
         for key in keys { pendingNamespaceRecords[key] = nil }
     }
 
-    func pendingNameRecords(forDescendantsOf parent: Element) -> [(Element, PendingNameRecord)] {
+    func pendingNameRecords(forDescendantsOf parent: Node) -> [(Element, PendingNameRecord)] {
         pendingNamespaceRecords.compactMap {
             $1.belongsToTree(parent) ? (element(for: .init($0)), $1) : nil
         }

Sources/Nodal/Element/Element.swift

@@ -6,7 +6,7 @@ import pugixml
 /// - Note: This class provides functionality for working with XML elements, including accessing their attributes,
 ///         child nodes, and text content. It extends the `Node` class, inheriting its methods and properties.
 public class Element: Node {
-    override func declaredNamespacesDidChange() {
+    internal override func declaredNamespacesDidChange() {
         let namespaces = declaredNamespaces
         for (element, record) in document.pendingNameRecords(forDescendantsOf: self) {
             if record.attemptResolution(for: element, with: namespaces) {
@@ -15,7 +15,7 @@ public class Element: Node {
         }
     }
 
-    override var hasNamespaceDeclarations: Bool {
+    internal override var hasNamespaceDeclarations: Bool {
         node.attributes.contains(where: { String(cString: $0.name()).hasPrefix("xmlns") })
     }
 }

Sources/Nodal/Element/PendingNameRecord.swift

@@ -16,6 +16,15 @@ internal class PendingNameRecord {
         }
     }
 
+    func updateAncestors(with element: Element) {
+        ancestors = []
+        var node = element.node
+        while !node.empty() {
+            ancestors.insert(node)
+            node = node.parent()
+        }
+    }
+
     func belongsToTree(_ node: Node) -> Bool {
         ancestors.contains(node.node)
     }

Sources/Nodal/Node/Node+Hierarchy.swift

@@ -99,6 +99,32 @@ public extension Node {
     }
 }
 
+public extension Node {
+    /// Moves this node to a new parent node at the specified position within the parent's children.
+    ///
+    /// - Parameters:
+    ///   - parent: The new parent node to which this node should be moved.
+    ///   - position: The position within the parent's children where this node should be inserted. Defaults to `.last`, adding the node as the last child of the parent.
+    /// - Returns: A Boolean value indicating whether the move was successful.
+    ///            Returns `false` if the node cannot be moved. Examples of such cases include:
+    ///            - The new parent node belongs to a different document.
+    ///            - The node is being moved to within itself, which would create an invalid structure.
+    @discardableResult
+    func move(to parent: Node, at position: Position = .last) -> Bool {
+        let records = document.pendingNameRecords(forDescendantsOf: self)
+        var destination = parent.node
+
+        if destination.insertChild(self.node, at: position).empty() {
+            return false
+        }
+
+        for (element, record) in records {
+            record.updateAncestors(with: element)
+        }
+        return true
+    }
+}
+
 public extension Node {
     /// Adds a new comment with the specified content to this node at the given position.
     ///

Sources/Nodal/Node/Node.swift

@@ -57,8 +57,8 @@ public class Node {
         }
     }
 
-    func declaredNamespacesDidChange() {}
-    var hasNamespaceDeclarations: Bool { false }
+    internal func declaredNamespacesDidChange() {}
+    internal var hasNamespaceDeclarations: Bool { false }
 
     /// The document that owns this node.
     ///
@@ -151,7 +151,7 @@ extension Node: CustomDebugStringConvertible {
         case .text: "Text \"\(value)\""
         case .cdata: "CDATA \"\(value)\""
         case .comment: "Comment <!--\(value)-->"
-        case .doctype: "<!DOCTYPE \(value)>"
+        case .doctype: "DOCTYPE <!DOCTYPE \(value)>"
         case .processingInstruction: "PI <?\(name) \(value)?>"
         case .declaration: "Declaration <?\(name)...?>"
         case .document: "Document"

Sources/Nodal/Pugi.swift

@@ -35,4 +35,17 @@ internal extension pugi.xml_node {
         case .last: append_child(kind)
         }
     }
+
+    mutating func insertChild(_ child: pugi.xml_node, at childPosition: Node.Position) -> pugi.xml_node {
+        guard childPosition.validate(for: self) else {
+            fatalError("Peer node for Node.Position must be a valid child of the parent")
+        }
+
+        return switch childPosition {
+        case .first: prepend_move(child)
+        case .before (let other): insert_move_before(child, other.node)
+        case .after (let other): insert_move_after(child, other.node)
+        case .last: append_move(child)
+        }
+    }
 }

Sources/Tests/Tests.swift

@@ -87,7 +87,7 @@ struct Tests {
     }
 
     @Test
-    func testInvalidation() throws {
+    func invalidation() throws {
         let doc = Document()
         let root = doc.makeDocumentElement(name: "root")
         let a = root.addElement("a")
@@ -135,20 +135,34 @@ struct Tests {
     }
 
     @Test
-    func lab() throws {
-        let doc = try Document(string: """
-        <root>
-            foo
-            <a>
-                bar
-                <b>baz<!--comment--><![CDATA[zoing]]>biz</b>
-                doz
-            </a>
-        </root>
-""", options: [.default, .trimTextWhitespace])
+    func move() throws {
+        let doc = Document()
+        let root = doc.makeDocumentElement(name: "root")
+        let a = root.addElement("a")
+        let b = root.addElement("b")
+        let c = a.addComment("hello")
+
+        #expect(c.move(to: a) == true, "Successful move")
+        #expect(Array(a.children) == [c], "Destination has target")
+        #expect(a.move(to: b) == true, "Successful move with children")
+        #expect(c.parent?.parent == b, "Grandparent is correct")
+
+        let doc2 = Document()
+        let root2 = doc2.makeDocumentElement(name: "root2")
+        #expect(c.move(to: root2) == false, "Move between documents")
+        #expect(c.move(to: c) == false, "Move to itself")
+    }
+
+    @Test
+    func addAt() throws {
+        let doc = Document()
+        let root = doc.makeDocumentElement(name: "root")
+        let a = root.addElement("a")
+        let b = root.addElement("b", at: .first)
+
+        #expect(Array(root.children) == [b, a], "Order of children")
+        let c = root.addCDATA("c", at: .after(b))
+        #expect(Array(root.children) == [b, c, a], "Order of children")
 
-        for node in doc.descendants {
-            print("Found \(node)!")
-        }
     }
 }