Implement instance cloning methods in WeakDom

rbx_dom_weak/src/dom.rs

@@ -235,6 +235,48 @@ impl WeakDom {
         dest_parent.children.push(referent);
     }
 
+    /// Clone the instance with the given `referent` and all its descendants
+    /// (i.e. the entire subtree) into the same WeakDom.
+    ///
+    /// After the operation, the root of the cloned subtree has no parent.
+    ///
+    /// Any Ref properties that point to instances contained in the subtree are
+    /// rewritten to point to the cloned instances.
+    pub fn clone_within(&mut self, referent: Ref) -> Ref {
+        let mut ctx = CloneContext::default();
+        let root_builder = ctx.clone_ref_as_builder(self, referent);
+        let root_ref = self.insert(Ref::none(), root_builder);
+
+        while let Some((cloned_parent, uncloned_child)) = ctx.queue.pop_front() {
+            let builder = ctx.clone_ref_as_builder(self, uncloned_child);
+            self.insert(cloned_parent, builder);
+        }
+
+        ctx.rewrite_refs(self);
+        root_ref
+    }
+
+    /// Clone the instance with the given `referent` and all its descendants (i.e. the
+    /// entire subtree) into the given WeakDom.
+    ///
+    /// After the operation, the root of the cloned subtree has no parent.
+    ///
+    /// Any Ref properties that point to instances contained in the subtree are
+    /// rewritten to point to the cloned instances.
+    pub fn clone_into_external(&self, referent: Ref, dest: &mut WeakDom) -> Ref {
+        let mut ctx = CloneContext::default();
+        let root_builder = ctx.clone_ref_as_builder(self, referent);
+        let root_ref = dest.insert(Ref::none(), root_builder);
+
+        while let Some((cloned_parent, uncloned_child)) = ctx.queue.pop_front() {
+            let builder = ctx.clone_ref_as_builder(self, uncloned_child);
+            dest.insert(cloned_parent, builder);
+        }
+
+        ctx.rewrite_refs(dest);
+        root_ref
+    }
+
     fn inner_insert(&mut self, referent: Ref, instance: Instance) {
         self.instances.insert(referent, instance);
 
@@ -279,6 +321,59 @@ impl WeakDom {
     }
 }
 
+#[derive(Debug, Default)]
+struct CloneContext {
+    queue: VecDeque<(Ref, Ref)>,
+    ref_rewrites: HashMap<Ref, Ref>,
+}
+
+impl CloneContext {
+    /// On any instances cloned during the operation, rewrite any Ref properties that
+    /// point to instances that were also cloned.
+    fn rewrite_refs(self, dom: &mut WeakDom) {
+        for (_, new_ref) in self.ref_rewrites.iter() {
+            let instance = dom
+                .get_by_ref_mut(*new_ref)
+                .expect("Cannot rewrite refs on an instance that does not exist");
+
+            for prop_value in instance.properties.values_mut() {
+                if let Variant::Ref(original_ref) = prop_value {
+                    // We only want to rewrite Refs if they point to instances within the
+                    // cloned subtree
+                    if let Some(new_ref) = self.ref_rewrites.get(original_ref) {
+                        *prop_value = Variant::Ref(*new_ref);
+                    }
+                }
+            }
+        }
+    }
+
+    /// Clone the instance with the given `referent` and `source` WeakDom into a new
+    /// InstanceBuilder, and record the mapping of the original referent to the new
+    /// referent.
+    ///
+    /// This method only clones the instance's class name, name, and properties; it
+    /// does not clone any children.
+    fn clone_ref_as_builder(&mut self, source: &WeakDom, original_ref: Ref) -> InstanceBuilder {
+        let instance = source
+            .get_by_ref(original_ref)
+            .expect("Cannot clone an instance that does not exist");
+
+        let builder = InstanceBuilder::new(instance.class.to_string())
+            .with_name(instance.name.to_string())
+            .with_properties(instance.properties.clone());
+
+        let new_ref = builder.referent;
+
+        for uncloned_child in instance.children.iter() {
+            self.queue.push_back((new_ref, *uncloned_child))
+        }
+
+        self.ref_rewrites.insert(original_ref, new_ref);
+        builder
+    }
+}
+
 #[cfg(test)]
 mod test {
     use super::*;
@@ -343,6 +438,75 @@ mod test {
         insta::assert_yaml_snapshot!(viewer.view_children(&dom));
     }
 
+    #[test]
+    fn clone_within() {
+        let mut dom = {
+            let mut child1 = InstanceBuilder::new("Part");
+            let mut child2 = InstanceBuilder::new("Part");
+
+            child1 = child1.with_property("RefProp", child2.referent);
+            child2 = child2.with_property("RefProp", child1.referent);
+
+            WeakDom::new(
+                InstanceBuilder::new("Folder")
+                    .with_name("Root")
+                    .with_children([child1, child2]),
+            )
+        };
+
+        let cloned_root = dom.clone_within(dom.root_ref);
+
+        assert!(
+            dom.get_by_ref(cloned_root).unwrap().parent.is_none(),
+            "parent of cloned subtree root should be none directly after a clone"
+        );
+
+        dom.transfer_within(cloned_root, dom.root_ref);
+
+        // This snapshot should have a clone of the root Folder under itself, with the ref
+        // properties in the cloned subtree pointing to the cloned instances.
+        let mut viewer = DomViewer::new();
+        insta::assert_yaml_snapshot!(viewer.view(&dom));
+    }
+
+    #[test]
+    fn clone_into_external() {
+        let dom = {
+            let mut child1 = InstanceBuilder::new("Part");
+            let mut child2 = InstanceBuilder::new("Part");
+
+            child1 = child1.with_property("RefProp", child2.referent);
+            child2 = child2.with_property("RefProp", child1.referent);
+
+            WeakDom::new(
+                InstanceBuilder::new("Folder")
+                    .with_name("Root")
+                    .with_children([child1, child2]),
+            )
+        };
+
+        let mut other_dom = WeakDom::new(InstanceBuilder::new("DataModel"));
+        let cloned_root = dom.clone_into_external(dom.root_ref, &mut other_dom);
+
+        assert!(
+            other_dom.get_by_ref(cloned_root).unwrap().parent.is_none(),
+            "parent of cloned subtree root should be none directly after a clone"
+        );
+
+        other_dom.transfer_within(cloned_root, other_dom.root_ref);
+
+        let mut viewer = DomViewer::new();
+
+        // This snapshot is here just to show that the ref props are rewritten after being
+        // cloned into the other dom. It should contain a Folder at the root with two
+        // Parts as children
+        insta::assert_yaml_snapshot!(viewer.view(&dom));
+
+        // This snapshot should have a clone of the root Folder under the other dom's
+        // DataModel, with the ref properties pointing to the newly cloned parts.
+        insta::assert_yaml_snapshot!(viewer.view(&other_dom));
+    }
+
     #[test]
     fn large_depth_tree() {
         // We've had issues with stack overflows when creating WeakDoms with

rbx_dom_weak/src/snapshots/rbx_dom_weak__dom__test__clone_into_external-2.snap

@@ -0,0 +1,27 @@
+---
+source: rbx_dom_weak/src/dom.rs
+expression: viewer.view(&other_dom)
+---
+referent: referent-3
+name: DataModel
+class: DataModel
+properties: {}
+children:
+  - referent: referent-4
+    name: Root
+    class: Folder
+    properties: {}
+    children:
+      - referent: referent-5
+        name: Part
+        class: Part
+        properties:
+          RefProp: referent-6
+        children: []
+      - referent: referent-6
+        name: Part
+        class: Part
+        properties:
+          RefProp: referent-5
+        children: []
+

rbx_dom_weak/src/snapshots/rbx_dom_weak__dom__test__clone_into_external.snap

@@ -0,0 +1,22 @@
+---
+source: rbx_dom_weak/src/dom.rs
+expression: viewer.view(&dom)
+---
+referent: referent-0
+name: Root
+class: Folder
+properties: {}
+children:
+  - referent: referent-1
+    name: Part
+    class: Part
+    properties:
+      RefProp: referent-2
+    children: []
+  - referent: referent-2
+    name: Part
+    class: Part
+    properties:
+      RefProp: referent-1
+    children: []
+

rbx_dom_weak/src/snapshots/rbx_dom_weak__dom__test__clone_within.snap

@@ -0,0 +1,39 @@
+---
+source: rbx_dom_weak/src/dom.rs
+expression: viewer.view(&dom)
+---
+referent: referent-0
+name: Root
+class: Folder
+properties: {}
+children:
+  - referent: referent-1
+    name: Part
+    class: Part
+    properties:
+      RefProp: referent-2
+    children: []
+  - referent: referent-2
+    name: Part
+    class: Part
+    properties:
+      RefProp: referent-1
+    children: []
+  - referent: referent-3
+    name: Root
+    class: Folder
+    properties: {}
+    children:
+      - referent: referent-4
+        name: Part
+        class: Part
+        properties:
+          RefProp: referent-5
+        children: []
+      - referent: referent-5
+        name: Part
+        class: Part
+        properties:
+          RefProp: referent-4
+        children: []
+