ari-party/rojo
1
0
Fork 0
forked from rojo-rbx/rojo
Code Pull Requests Activity

Upgrade to rbx_dom_weak 2.0 (#377)

Browse Source 
* Mostly mechanical port bits

* Almost there

* It builds again!

* Turn on all the code again

* Tests compiling but not passing

* Stub work for value resolution

* Implement resolution minus enums and derived properties

* Implement property descriptor resolution

* Update referent snapshots

* Update unions test project

Using a place file instead of a model yields better
error messages in Roblox Studio.

* Add easy shortcut to testing with local rbx-dom

* Update rbx-dom

* Add enum resolution

* Update init.meta.json to use UnresolvedValue

* Expand value resolution support, add test

* Filter SharedString values from web API

* Add 'property' builder method to InstanceSnapshot

* Change InstanceSnapshot/InstanceBuilder boundary

* Fix remove_file crash

* rustfmt

* Update to latest rbx_dom_lua

* Update dependencies, including rbx_dom_weak

* Update to latest rbx-dom

* Update dependencies

* Update rbx-dom, fixing more bugs

* Remove experimental warning on binary place builds

* Remove unused imports
This commit is contained in:
Lucien Greathouse
2021-02-18 20:56:09 -05:00
committed by GitHub
parent b84aab0960
commit 59ef5f05ea
63 changed files with 45602 additions and 21004 deletions
Download Patch File Download Diff File Expand all files Collapse all files

42
src/snapshot/instance_snapshot.rs
View File

@@ -2,7 +2,10 @@
use std::{borrow::Cow, collections::HashMap};
use rbx_dom_weak::{RbxId, RbxTree, RbxValue};
use rbx_dom_weak::{
types::{Ref, Variant},
WeakDom,
};
use serde::{Deserialize, Serialize};
use super::InstanceMetadata;
@@ -11,11 +14,12 @@ use super::InstanceMetadata;
///
// Possible future improvements:
// - Use refcounted/interned strings
// - Replace use of RbxValue with a sum of RbxValue + borrowed value
// - Replace use of Variant with a sum of Variant + borrowed value
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct InstanceSnapshot {
// FIXME: Don't use Option<Ref> anymore!
/// A temporary ID applied to the snapshot that's used for Ref properties.
pub snapshot_id: Option<RbxId>,
pub snapshot_id: Option<Ref>,
/// Rojo-specific metadata associated with the instance.
pub metadata: InstanceMetadata,
@@ -27,7 +31,7 @@ pub struct InstanceSnapshot {
pub class_name: Cow<'static, str>,
/// All other properties of the instance, weakly-typed.
pub properties: HashMap<String, RbxValue>,
pub properties: HashMap<String, Variant>,
/// The children of the instance represented as more snapshots.
///
@@ -61,7 +65,16 @@ impl InstanceSnapshot {
}
}
pub fn properties(self, properties: impl Into<HashMap<String, RbxValue>>) -> Self {
pub fn property<K, V>(mut self, key: K, value: V) -> Self
where
K: Into<String>,
V: Into<Variant>,
{
self.properties.insert(key.into(), value.into());
self
}
pub fn properties(self, properties: impl Into<HashMap<String, Variant>>) -> Self {
Self {
properties: properties.into(),
..self
@@ -75,6 +88,13 @@ impl InstanceSnapshot {
}
}
pub fn snapshot_id(self, snapshot_id: Option<Ref>) -> Self {
Self {
snapshot_id,
..self
}
}
pub fn metadata(self, metadata: impl Into<InstanceMetadata>) -> Self {
Self {
metadata: metadata.into(),
@@ -82,15 +102,13 @@ impl InstanceSnapshot {
}
}
pub fn from_tree(tree: &RbxTree, id: RbxId) -> Self {
let instance = tree
.get_instance(id)
.expect("instance did not exist in tree");
pub fn from_tree(tree: &WeakDom, id: Ref) -> Self {
let instance = tree.get_by_ref(id).expect("instance did not exist in tree");
let children = instance
.get_children_ids()
.children()
.iter()
.cloned()
.copied()
.map(|id| Self::from_tree(tree, id))
.collect();
@@ -98,7 +116,7 @@ impl InstanceSnapshot {
snapshot_id: Some(id),
metadata: InstanceMetadata::default(),
name: Cow::Owned(instance.name.clone()),
class_name: Cow::Owned(instance.class_name.clone()),
class_name: Cow::Owned(instance.class.clone()),
properties: instance.properties.clone(),
children,
}

22
src/snapshot/patch.rs
View File

@@ -2,19 +2,19 @@
use std::collections::HashMap;
use rbx_dom_weak::{RbxId, RbxValue};
use rbx_dom_weak::types::{Ref, Variant};
use serde::{Deserialize, Serialize};
use super::{InstanceMetadata, InstanceSnapshot};
/// A set of different kinds of patches that can be applied to an RbxTree.
/// A set of different kinds of patches that can be applied to an WeakDom.
///
/// These patches shouldn't be persisted: there's no mechanism in place to make
/// sure that another patch wasn't applied before this one that could cause a
/// conflict!
#[derive(Debug, Default, Clone, PartialEq, Serialize, Deserialize)]
pub struct PatchSet {
pub removed_instances: Vec<RbxId>,
pub removed_instances: Vec<Ref>,
pub added_instances: Vec<PatchAdd>,
pub updated_instances: Vec<PatchUpdate>,
}
@@ -32,20 +32,20 @@ impl<'a> PatchSet {
/// A patch containing an instance that was added to the tree.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PatchAdd {
pub parent_id: RbxId,
pub parent_id: Ref,
pub instance: InstanceSnapshot,
}
/// A patch indicating that properties of an instance changed.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PatchUpdate {
pub id: RbxId,
pub id: Ref,
pub changed_name: Option<String>,
pub changed_class_name: Option<String>,
/// Contains all changed properties. If a property is assigned to `None`,
/// then that property has been removed.
pub changed_properties: HashMap<String, Option<RbxValue>>,
pub changed_properties: HashMap<String, Option<Variant>>,
/// Changed Rojo-specific metadata, if any of it changed.
pub changed_metadata: Option<InstanceMetadata>,
@@ -63,8 +63,8 @@ pub struct PatchUpdate {
// current values in all fields.
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct AppliedPatchSet {
pub removed: Vec<RbxId>,
pub added: Vec<RbxId>,
pub removed: Vec<Ref>,
pub added: Vec<Ref>,
pub updated: Vec<AppliedPatchUpdate>,
}
@@ -80,17 +80,17 @@ impl AppliedPatchSet {
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AppliedPatchUpdate {
pub id: RbxId,
pub id: Ref,
// TODO: Store previous values in order to detect application conflicts
pub changed_name: Option<String>,
pub changed_class_name: Option<String>,
pub changed_properties: HashMap<String, Option<RbxValue>>,
pub changed_properties: HashMap<String, Option<Variant>>,
pub changed_metadata: Option<InstanceMetadata>,
}
impl AppliedPatchUpdate {
pub fn new(id: RbxId) -> Self {
pub fn new(id: Ref) -> Self {
Self {
id,
changed_name: None,

135
src/snapshot/patch_apply.rs
View File

@@ -2,11 +2,11 @@
use std::collections::HashMap;
use rbx_dom_weak::{RbxId, RbxInstanceProperties, RbxValue};
use rbx_dom_weak::types::{Ref, Variant};
use super::{
patch::{AppliedPatchSet, AppliedPatchUpdate, PatchSet, PatchUpdate},
InstancePropertiesWithMeta, InstanceSnapshot, RojoTree,
InstanceSnapshot, RojoTree,
};
/// Consumes the input `PatchSet`, applying all of its prescribed changes to the
@@ -37,7 +37,7 @@ pub fn apply_patch_set(tree: &mut RojoTree, patch_set: PatchSet) -> AppliedPatch
struct PatchApplyContext {
/// A map from transient snapshot IDs (generated by snapshot middleware) to
/// instance IDs in the actual tree. These are both the same data type so
/// that they fit into the same `RbxValue::Ref` type.
/// that they fit into the same `Variant::Ref` type.
///
/// At this point in the patch process, IDs in instance properties have been
/// partially translated from 'snapshot space' into 'tree space' by the
@@ -53,7 +53,7 @@ struct PatchApplyContext {
/// #2 should not occur in well-formed projects, but is indistinguishable
/// from #1 right now. It could happen if two model files try to reference
/// eachother.
snapshot_id_to_instance_id: HashMap<RbxId, RbxId>,
snapshot_id_to_instance_id: HashMap<Ref, Ref>,
/// The properties of instances added by the current `PatchSet`.
///
@@ -68,7 +68,7 @@ struct PatchApplyContext {
///
/// This doesn't affect updated instances, since they're always applied
/// after we've added all the instances from the patch.
added_instance_properties: HashMap<RbxId, HashMap<String, RbxValue>>,
added_instance_properties: HashMap<Ref, HashMap<String, Variant>>,
/// The current applied patch result, describing changes made to the tree.
applied_patch_set: AppliedPatchSet,
@@ -93,11 +93,10 @@ fn finalize_patch_application(context: PatchApplyContext, tree: &mut RojoTree) -
.expect("Invalid instance ID in deferred property map");
for (key, mut property_value) in properties {
if let RbxValue::Ref { value: Some(id) } = property_value {
if let Some(&instance_id) = context.snapshot_id_to_instance_id.get(&id) {
property_value = RbxValue::Ref {
value: Some(instance_id),
};
if let Variant::Ref(referent) = property_value {
if let Some(&instance_referent) = context.snapshot_id_to_instance_id.get(&referent)
{
property_value = Variant::Ref(instance_referent);
}
}
@@ -108,50 +107,40 @@ fn finalize_patch_application(context: PatchApplyContext, tree: &mut RojoTree) -
context.applied_patch_set
}
fn apply_remove_instance(context: &mut PatchApplyContext, tree: &mut RojoTree, removed_id: RbxId) {
match tree.remove_instance(removed_id) {
Some(_) => context.applied_patch_set.removed.push(removed_id),
None => {
log::warn!(
"Patch misapplication: Tried to remove instance {} but it did not exist.",
removed_id
);
}
}
fn apply_remove_instance(context: &mut PatchApplyContext, tree: &mut RojoTree, removed_id: Ref) {
tree.remove(removed_id);
context.applied_patch_set.removed.push(removed_id);
}
fn apply_add_child(
context: &mut PatchApplyContext,
tree: &mut RojoTree,
parent_id: RbxId,
parent_id: Ref,
snapshot: InstanceSnapshot,
) {
let properties = InstancePropertiesWithMeta {
properties: RbxInstanceProperties {
name: snapshot.name.into_owned(),
class_name: snapshot.class_name.into_owned(),
let snapshot_id = snapshot.snapshot_id;
let properties = snapshot.properties;
let children = snapshot.children;
// Property assignment is deferred until after we know about all
// instances in this patch. See `PatchApplyContext` for details.
properties: HashMap::new(),
},
metadata: snapshot.metadata,
};
let id = tree.insert_instance(properties, parent_id);
// Property application is deferred until after all children
// are constructed. This helps apply referents correctly.
let remaining_snapshot = InstanceSnapshot::new()
.name(snapshot.name)
.class_name(snapshot.class_name)
.metadata(snapshot.metadata)
.snapshot_id(snapshot.snapshot_id);
let id = tree.insert_instance(parent_id, remaining_snapshot);
context.applied_patch_set.added.push(id);
context
.added_instance_properties
.insert(id, snapshot.properties);
context.added_instance_properties.insert(id, properties);
if let Some(snapshot_id) = snapshot.snapshot_id {
if let Some(snapshot_id) = snapshot_id {
context.snapshot_id_to_instance_id.insert(snapshot_id, id);
}
for child_snapshot in snapshot.children {
apply_add_child(context, tree, id, child_snapshot);
for child in children {
apply_add_child(context, tree, id, child);
}
}
@@ -167,7 +156,7 @@ fn apply_update_child(context: &mut PatchApplyContext, tree: &mut RojoTree, patc
Some(instance) => instance,
None => {
log::warn!(
"Patch misapplication: Instance {}, referred to by update patch, did not exist.",
"Patch misapplication: Instance {:?}, referred to by update patch, did not exist.",
patch.id
);
return;
@@ -189,23 +178,24 @@ fn apply_update_child(context: &mut PatchApplyContext, tree: &mut RojoTree, patc
// Ref values need to be potentially rewritten from snapshot IDs to
// instance IDs if they referred to an instance that was created as
// part of this patch.
Some(RbxValue::Ref { value: Some(id) }) => {
Some(Variant::Ref(referent)) => {
if referent.is_none() {
continue;
}
// If our ID is not found in this map, then it either refers to
// an existing instance NOT added by this patch, or there was an
// error. See `PatchApplyContext::snapshot_id_to_instance_id`
// for more info.
let new_id = context
let new_referent = context
.snapshot_id_to_instance_id
.get(&id)
.get(&referent)
.copied()
.unwrap_or(id);
.unwrap_or(referent);
instance.properties_mut().insert(
key.clone(),
RbxValue::Ref {
value: Some(new_id),
},
);
instance
.properties_mut()
.insert(key.clone(), Variant::Ref(new_referent));
}
Some(ref value) => {
instance.properties_mut().insert(key.clone(), value.clone());
@@ -225,10 +215,10 @@ fn apply_update_child(context: &mut PatchApplyContext, tree: &mut RojoTree, patc
mod test {
use super::*;
use std::{borrow::Cow, collections::HashMap};
use std::borrow::Cow;
use maplit::hashmap;
use rbx_dom_weak::RbxValue;
use rbx_dom_weak::types::Variant;
use super::super::PatchAdd;
@@ -236,14 +226,7 @@ mod test {
fn add_from_empty() {
let _ = env_logger::try_init();
let mut tree = RojoTree::new(InstancePropertiesWithMeta {
properties: RbxInstanceProperties {
name: "Folder".to_owned(),
class_name: "Folder".to_owned(),
properties: HashMap::new(),
},
metadata: Default::default(),
});
let mut tree = RojoTree::new(InstanceSnapshot::new());
let root_id = tree.get_root_id();
@@ -253,7 +236,7 @@ mod test {
name: Cow::Borrowed("Foo"),
class_name: Cow::Borrowed("Bar"),
properties: hashmap! {
"Baz".to_owned() => RbxValue::Int32 { value: 5 },
"Baz".to_owned() => Variant::Int32(5),
},
children: Vec::new(),
};
@@ -282,18 +265,14 @@ mod test {
fn update_existing() {
let _ = env_logger::try_init();
let mut tree = RojoTree::new(InstancePropertiesWithMeta {
properties: RbxInstanceProperties {
name: "OldName".to_owned(),
class_name: "OldClassName".to_owned(),
properties: hashmap! {
"Foo".to_owned() => RbxValue::Int32 { value: 7 },
"Bar".to_owned() => RbxValue::Int32 { value: 3 },
"Unchanged".to_owned() => RbxValue::Int32 { value: -5 },
},
},
metadata: Default::default(),
});
let mut tree = RojoTree::new(
InstanceSnapshot::new()
.class_name("OldClassName")
.name("OldName")
.property("Foo", 7i32)
.property("Bar", 3i32)
.property("Unchanged", -5i32),
);
let root_id = tree.get_root_id();
@@ -303,13 +282,13 @@ mod test {
changed_class_name: Some("NewClassName".to_owned()),
changed_properties: hashmap! {
// The value of Foo has changed
"Foo".to_owned() => Some(RbxValue::Int32 { value: 8 }),
"Foo".to_owned() => Some(Variant::Int32(8)),
// Bar has been deleted
"Bar".to_owned() => None,
// Baz has been added
"Baz".to_owned() => Some(RbxValue::Int32 { value: 10 }),
"Baz".to_owned() => Some(Variant::Int32(10)),
},
changed_metadata: None,
};
@@ -322,9 +301,9 @@ mod test {
apply_patch_set(&mut tree, patch_set);
let expected_properties = hashmap! {
"Foo".to_owned() => RbxValue::Int32 { value: 8 },
"Baz".to_owned() => RbxValue::Int32 { value: 10 },
"Unchanged".to_owned() => RbxValue::Int32 { value: -5 },
"Foo".to_owned() => Variant::Int32(8),
"Baz".to_owned() => Variant::Int32(10),
"Unchanged".to_owned() => Variant::Int32(-5),
};
let root_instance = tree.get_instance(root_id).unwrap();

67
src/snapshot/patch_compute.rs
View File

@@ -3,14 +3,14 @@
use std::collections::{HashMap, HashSet};
use rbx_dom_weak::{RbxId, RbxValue};
use rbx_dom_weak::types::{Ref, Variant};
use super::{
patch::{PatchAdd, PatchSet, PatchUpdate},
InstanceSnapshot, InstanceWithMeta, RojoTree,
};
pub fn compute_patch_set(snapshot: &InstanceSnapshot, tree: &RojoTree, id: RbxId) -> PatchSet {
pub fn compute_patch_set(snapshot: &InstanceSnapshot, tree: &RojoTree, id: Ref) -> PatchSet {
let mut patch_set = PatchSet::new();
let mut context = ComputePatchContext::default();
@@ -26,17 +26,15 @@ pub fn compute_patch_set(snapshot: &InstanceSnapshot, tree: &RojoTree, id: RbxId
#[derive(Default)]
struct ComputePatchContext {
snapshot_id_to_instance_id: HashMap<RbxId, RbxId>,
snapshot_id_to_instance_id: HashMap<Ref, Ref>,
}
fn rewrite_refs_in_updates(context: &ComputePatchContext, updates: &mut [PatchUpdate]) {
for update in updates {
for property_value in update.changed_properties.values_mut() {
if let Some(RbxValue::Ref { value: Some(id) }) = property_value {
if let Some(&instance_id) = context.snapshot_id_to_instance_id.get(id) {
*property_value = Some(RbxValue::Ref {
value: Some(instance_id),
});
if let Some(Variant::Ref(referent)) = property_value {
if let Some(&instance_ref) = context.snapshot_id_to_instance_id.get(referent) {
*property_value = Some(Variant::Ref(instance_ref));
}
}
}
@@ -51,11 +49,9 @@ fn rewrite_refs_in_additions(context: &ComputePatchContext, additions: &mut [Pat
fn rewrite_refs_in_snapshot(context: &ComputePatchContext, snapshot: &mut InstanceSnapshot) {
for property_value in snapshot.properties.values_mut() {
if let RbxValue::Ref { value: Some(id) } = property_value {
if let Some(&instance_id) = context.snapshot_id_to_instance_id.get(id) {
*property_value = RbxValue::Ref {
value: Some(instance_id),
};
if let Variant::Ref(referent) = property_value {
if let Some(&instance_referent) = context.snapshot_id_to_instance_id.get(referent) {
*property_value = Variant::Ref(instance_referent);
}
}
}
@@ -69,7 +65,7 @@ fn compute_patch_set_internal(
context: &mut ComputePatchContext,
snapshot: &InstanceSnapshot,
tree: &RojoTree,
id: RbxId,
id: Ref,
patch_set: &mut PatchSet,
) {
if let Some(snapshot_id) = snapshot.snapshot_id {
@@ -154,7 +150,7 @@ fn compute_children_patches(
context: &mut ComputePatchContext,
snapshot: &InstanceSnapshot,
tree: &RojoTree,
id: RbxId,
id: Ref,
patch_set: &mut PatchSet,
) {
let instance = tree
@@ -224,9 +220,6 @@ mod test {
use std::borrow::Cow;
use maplit::hashmap;
use rbx_dom_weak::RbxInstanceProperties;
use super::super::InstancePropertiesWithMeta;
/// This test makes sure that rewriting refs in instance update patches to
/// instances that already exists works. We should be able to correlate the
@@ -234,26 +227,17 @@ mod test {
/// value before returning from compute_patch_set.
#[test]
fn rewrite_ref_existing_instance_update() {
let tree = RojoTree::new(InstancePropertiesWithMeta {
properties: RbxInstanceProperties {
name: "foo".to_owned(),
class_name: "foo".to_owned(),
properties: HashMap::new(),
},
metadata: Default::default(),
});
let tree = RojoTree::new(InstanceSnapshot::new().name("foo").class_name("foo"));
let root_id = tree.get_root_id();
// This snapshot should be identical to the existing tree except for the
// addition of a prop named Self, which is a self-referential Ref.
let snapshot_id = RbxId::new();
let snapshot_id = Ref::new();
let snapshot = InstanceSnapshot {
snapshot_id: Some(snapshot_id),
properties: hashmap! {
"Self".to_owned() => RbxValue::Ref {
value: Some(snapshot_id),
}
"Self".to_owned() => Variant::Ref(snapshot_id),
},
metadata: Default::default(),
@@ -270,9 +254,7 @@ mod test {
changed_name: None,
changed_class_name: None,
changed_properties: hashmap! {
"Self".to_owned() => Some(RbxValue::Ref {
value: Some(root_id),
}),
"Self".to_owned() => Some(Variant::Ref(root_id)),
},
changed_metadata: None,
}],
@@ -288,26 +270,17 @@ mod test {
/// one.
#[test]
fn rewrite_ref_existing_instance_addition() {
let tree = RojoTree::new(InstancePropertiesWithMeta {
properties: RbxInstanceProperties {
name: "foo".to_owned(),
class_name: "foo".to_owned(),
properties: HashMap::new(),
},
metadata: Default::default(),
});
let tree = RojoTree::new(InstanceSnapshot::new().name("foo").class_name("foo"));
let root_id = tree.get_root_id();
// This patch describes the existing instance with a new child added.
let snapshot_id = RbxId::new();
let snapshot_id = Ref::new();
let snapshot = InstanceSnapshot {
snapshot_id: Some(snapshot_id),
children: vec![InstanceSnapshot {
properties: hashmap! {
"Self".to_owned() => RbxValue::Ref {
value: Some(snapshot_id),
},
"Self".to_owned() => Variant::Ref(snapshot_id),
},
snapshot_id: None,
@@ -332,9 +305,7 @@ mod test {
snapshot_id: None,
metadata: Default::default(),
properties: hashmap! {
"Self".to_owned() => RbxValue::Ref {
value: Some(root_id),
},
"Self".to_owned() => Variant::Ref(root_id),
},
name: Cow::Borrowed("child"),
class_name: Cow::Borrowed("child"),

25
src/snapshot/tests/apply.rs
View File

@@ -1,11 +1,10 @@
use insta::assert_yaml_snapshot;
use maplit::hashmap;
use rbx_dom_weak::{RbxInstanceProperties, RbxValue};
use rojo_insta_ext::RedactionMap;
use crate::{
snapshot::{apply_patch_set, InstancePropertiesWithMeta, PatchSet, PatchUpdate, RojoTree},
snapshot::{apply_patch_set, InstanceSnapshot, PatchSet, PatchUpdate, RojoTree},
tree_view::{intern_tree, view_tree},
};
@@ -49,9 +48,7 @@ fn add_property() {
changed_name: None,
changed_class_name: None,
changed_properties: hashmap! {
"Foo".to_owned() => Some(RbxValue::String {
value: "Value of Foo".to_owned(),
}),
"Foo".to_owned() => Some("Value of Foo".into()),
},
changed_metadata: None,
}],
@@ -78,12 +75,9 @@ fn remove_property() {
let root_id = tree.get_root_id();
let mut root_instance = tree.get_instance_mut(root_id).unwrap();
root_instance.properties_mut().insert(
"Foo".to_owned(),
RbxValue::String {
value: "Should be removed".to_owned(),
},
);
root_instance
.properties_mut()
.insert("Foo".to_owned(), "Should be removed".into());
}
let tree_view = view_tree(&tree, &mut redactions);
@@ -112,12 +106,5 @@ fn remove_property() {
}
fn empty_tree() -> RojoTree {
RojoTree::new(InstancePropertiesWithMeta {
properties: RbxInstanceProperties {
name: "ROOT".to_owned(),
class_name: "ROOT".to_owned(),
properties: Default::default(),
},
metadata: Default::default(),
})
RojoTree::new(InstanceSnapshot::new().name("ROOT").class_name("ROOT"))
}

29
src/snapshot/tests/compute.rs
View File

@@ -2,11 +2,10 @@ use std::borrow::Cow;
use insta::assert_yaml_snapshot;
use maplit::hashmap;
use rbx_dom_weak::{RbxInstanceProperties, RbxValue};
use rojo_insta_ext::RedactionMap;
use crate::snapshot::{compute_patch_set, InstancePropertiesWithMeta, InstanceSnapshot, RojoTree};
use crate::snapshot::{compute_patch_set, InstanceSnapshot, RojoTree};
#[test]
fn set_name_and_class_name() {
@@ -43,9 +42,7 @@ fn set_property() {
name: Cow::Borrowed("ROOT"),
class_name: Cow::Borrowed("ROOT"),
properties: hashmap! {
"PropertyName".to_owned() => RbxValue::String {
value: "Hello, world!".to_owned(),
},
"PropertyName".to_owned() => "Hello, world!".into(),
},
children: Vec::new(),
};
@@ -68,9 +65,7 @@ fn remove_property() {
let mut root_instance = tree.get_instance_mut(root_id).unwrap();
root_instance.properties_mut().insert(
"Foo".to_owned(),
RbxValue::String {
value: "This should be removed by the patch.".to_owned(),
},
"This should be removed by the patch.".into(),
);
}
@@ -128,15 +123,8 @@ fn remove_child() {
{
let root_id = tree.get_root_id();
let new_id = tree.insert_instance(
InstancePropertiesWithMeta {
properties: RbxInstanceProperties {
name: "Should not appear in snapshot".to_owned(),
class_name: "Folder".to_owned(),
properties: Default::default(),
},
metadata: Default::default(),
},
root_id,
InstanceSnapshot::new().name("Should not appear in snapshot"),
);
redactions.intern(new_id);
@@ -158,12 +146,5 @@ fn remove_child() {
}
fn empty_tree() -> RojoTree {
RojoTree::new(InstancePropertiesWithMeta {
properties: RbxInstanceProperties {
name: "ROOT".to_owned(),
class_name: "ROOT".to_owned(),
properties: Default::default(),
},
metadata: Default::default(),
})
RojoTree::new(InstanceSnapshot::new().name("ROOT").class_name("ROOT"))
}

193
src/snapshot/tree.rs
View File

@@ -1,26 +1,29 @@
use std::{
collections::HashMap,
collections::{HashMap, VecDeque},
path::{Path, PathBuf},
};
use rbx_dom_weak::{Descendants, RbxId, RbxInstance, RbxInstanceProperties, RbxTree, RbxValue};
use rbx_dom_weak::{
types::{Ref, Variant},
Instance, InstanceBuilder, WeakDom,
};
use crate::multimap::MultiMap;
use super::InstanceMetadata;
use super::{InstanceMetadata, InstanceSnapshot};
/// An expanded variant of rbx_dom_weak's `RbxTree` that tracks additional
/// An expanded variant of rbx_dom_weak's `WeakDom` that tracks additional
/// metadata per instance that's Rojo-specific.
///
/// This tree is also optimized for doing fast incremental updates and patches.
#[derive(Debug)]
pub struct RojoTree {
/// Contains the instances without their Rojo-specific metadata.
inner: RbxTree,
inner: WeakDom,
/// Metadata associated with each instance that is kept up-to-date with the
/// set of actual instances.
metadata_map: HashMap<RbxId, InstanceMetadata>,
metadata_map: HashMap<Ref, InstanceMetadata>,
/// A multimap from source paths to all of the root instances that were
/// constructed from that path.
@@ -29,31 +32,42 @@ pub struct RojoTree {
/// value portion of the map is also a set in order to support the same path
/// appearing multiple times in the same Rojo project. This is sometimes
/// called "path aliasing" in various Rojo documentation.
path_to_ids: MultiMap<PathBuf, RbxId>,
path_to_ids: MultiMap<PathBuf, Ref>,
}
impl RojoTree {
pub fn new(root: InstancePropertiesWithMeta) -> RojoTree {
pub fn new(snapshot: InstanceSnapshot) -> RojoTree {
let root_builder = InstanceBuilder::new(snapshot.class_name.to_owned())
.with_name(snapshot.name.to_owned())
.with_properties(snapshot.properties);
let mut tree = RojoTree {
inner: RbxTree::new(root.properties),
inner: WeakDom::new(root_builder),
metadata_map: HashMap::new(),
path_to_ids: MultiMap::new(),
};
tree.insert_metadata(tree.inner.get_root_id(), root.metadata);
let root_ref = tree.inner.root_ref();
tree.insert_metadata(root_ref, snapshot.metadata);
for child in snapshot.children {
tree.insert_instance(root_ref, child);
}
tree
}
pub fn inner(&self) -> &RbxTree {
pub fn inner(&self) -> &WeakDom {
&self.inner
}
pub fn get_root_id(&self) -> RbxId {
self.inner.get_root_id()
pub fn get_root_id(&self) -> Ref {
self.inner.root_ref()
}
pub fn get_instance(&self, id: RbxId) -> Option<InstanceWithMeta> {
if let Some(instance) = self.inner.get_instance(id) {
pub fn get_instance(&self, id: Ref) -> Option<InstanceWithMeta> {
if let Some(instance) = self.inner.get_by_ref(id) {
let metadata = self.metadata_map.get(&id).unwrap();
Some(InstanceWithMeta { instance, metadata })
@@ -62,8 +76,8 @@ impl RojoTree {
}
}
pub fn get_instance_mut(&mut self, id: RbxId) -> Option<InstanceWithMetaMut> {
if let Some(instance) = self.inner.get_instance_mut(id) {
pub fn get_instance_mut(&mut self, id: Ref) -> Option<InstanceWithMetaMut> {
if let Some(instance) = self.inner.get_by_ref_mut(id) {
let metadata = self.metadata_map.get_mut(&id).unwrap();
Some(InstanceWithMetaMut { instance, metadata })
@@ -72,38 +86,38 @@ impl RojoTree {
}
}
pub fn insert_instance(
&mut self,
properties: InstancePropertiesWithMeta,
parent_id: RbxId,
) -> RbxId {
let id = self.inner.insert_instance(properties.properties, parent_id);
self.insert_metadata(id, properties.metadata);
id
pub fn insert_instance(&mut self, parent_ref: Ref, snapshot: InstanceSnapshot) -> Ref {
let builder = InstanceBuilder::new(snapshot.class_name.to_owned())
.with_name(snapshot.name.to_owned())
.with_properties(snapshot.properties);
let referent = self.inner.insert(parent_ref, builder);
self.insert_metadata(referent, snapshot.metadata);
for child in snapshot.children {
self.insert_instance(referent, child);
}
referent
}
pub fn remove_instance(&mut self, id: RbxId) -> Option<RojoTree> {
if let Some(inner) = self.inner.remove_instance(id) {
let mut metadata_map = HashMap::new();
let mut path_to_ids = MultiMap::new();
pub fn remove(&mut self, id: Ref) {
let mut to_move = VecDeque::new();
to_move.push_back(id);
self.move_metadata(id, &mut metadata_map, &mut path_to_ids);
for instance in inner.descendants(id) {
self.move_metadata(instance.get_id(), &mut metadata_map, &mut path_to_ids);
while let Some(id) = to_move.pop_front() {
self.remove_metadata(id);
if let Some(instance) = self.inner.get_by_ref(id) {
to_move.extend(instance.children().iter().copied());
}
Some(RojoTree {
inner,
metadata_map,
path_to_ids,
})
} else {
None
}
self.inner.destroy(id);
}
/// Replaces the metadata associated with the given instance ID.
pub fn update_metadata(&mut self, id: RbxId, metadata: InstanceMetadata) {
pub fn update_metadata(&mut self, id: Ref, metadata: InstanceMetadata) {
use std::collections::hash_map::Entry;
match self.metadata_map.entry(id) {
@@ -131,22 +145,22 @@ impl RojoTree {
}
}
pub fn descendants(&self, id: RbxId) -> RojoDescendants<'_> {
RojoDescendants {
inner: self.inner.descendants(id),
tree: self,
}
pub fn descendants(&self, id: Ref) -> RojoDescendants<'_> {
let mut queue = VecDeque::new();
queue.push_back(id);
RojoDescendants { queue, tree: self }
}
pub fn get_ids_at_path(&self, path: &Path) -> &[RbxId] {
pub fn get_ids_at_path(&self, path: &Path) -> &[Ref] {
self.path_to_ids.get(path)
}
pub fn get_metadata(&self, id: RbxId) -> Option<&InstanceMetadata> {
pub fn get_metadata(&self, id: Ref) -> Option<&InstanceMetadata> {
self.metadata_map.get(&id)
}
fn insert_metadata(&mut self, id: RbxId, metadata: InstanceMetadata) {
fn insert_metadata(&mut self, id: Ref, metadata: InstanceMetadata) {
for path in &metadata.relevant_paths {
self.path_to_ids.insert(path.clone(), id);
}
@@ -156,25 +170,17 @@ impl RojoTree {
/// Moves the Rojo metadata from the instance with the given ID from this
/// tree into some loose maps.
fn move_metadata(
&mut self,
id: RbxId,
metadata_map: &mut HashMap<RbxId, InstanceMetadata>,
path_to_ids: &mut MultiMap<PathBuf, RbxId>,
) {
fn remove_metadata(&mut self, id: Ref) {
let metadata = self.metadata_map.remove(&id).unwrap();
for path in &metadata.relevant_paths {
self.path_to_ids.remove(path, id);
path_to_ids.insert(path.clone(), id);
}
metadata_map.insert(id, metadata);
}
}
pub struct RojoDescendants<'a> {
inner: Descendants<'a>,
queue: VecDeque<Ref>,
tree: &'a RojoTree,
}
@@ -182,50 +188,43 @@ impl<'a> Iterator for RojoDescendants<'a> {
type Item = InstanceWithMeta<'a>;
fn next(&mut self) -> Option<Self::Item> {
let instance = self.inner.next()?;
let id = self.queue.pop_front()?;
let instance = self
.tree
.inner
.get_by_ref(id)
.expect("Instance did not exist");
let metadata = self
.tree
.get_metadata(instance.get_id())
.get_metadata(instance.referent())
.expect("Metadata did not exist for instance");
self.queue.extend(instance.children().iter().copied());
Some(InstanceWithMeta { instance, metadata })
}
}
/// RojoTree's equivalent of `RbxInstanceProperties`.
#[derive(Debug, Clone)]
pub struct InstancePropertiesWithMeta {
pub properties: RbxInstanceProperties,
pub metadata: InstanceMetadata,
}
impl InstancePropertiesWithMeta {
pub fn new(properties: RbxInstanceProperties, metadata: InstanceMetadata) -> Self {
InstancePropertiesWithMeta {
properties,
metadata,
}
}
}
/// RojoTree's equivalent of `&'a RbxInstance`.
/// RojoTree's equivalent of `&'a Instance`.
///
/// This has to be a value type for RojoTree because the instance and metadata
/// are stored in different places. The mutable equivalent is
/// `InstanceWithMetaMut`.
#[derive(Debug, Clone, Copy)]
pub struct InstanceWithMeta<'a> {
instance: &'a RbxInstance,
instance: &'a Instance,
metadata: &'a InstanceMetadata,
}
impl<'a> InstanceWithMeta<'a> {
pub fn id(&self) -> RbxId {
self.instance.get_id()
pub fn id(&self) -> Ref {
self.instance.referent()
}
pub fn parent(&self) -> Option<RbxId> {
self.instance.get_parent_id()
pub fn parent(&self) -> Ref {
self.instance.parent()
}
pub fn name(&self) -> &'a str {
@@ -233,15 +232,15 @@ impl<'a> InstanceWithMeta<'a> {
}
pub fn class_name(&self) -> &'a str {
&self.instance.class_name
&self.instance.class
}
pub fn properties(&self) -> &'a HashMap<String, RbxValue> {
pub fn properties(&self) -> &'a HashMap<String, Variant> {
&self.instance.properties
}
pub fn children(&self) -> &'a [RbxId] {
self.instance.get_children_ids()
pub fn children(&self) -> &'a [Ref] {
self.instance.children()
}
pub fn metadata(&self) -> &'a InstanceMetadata {
@@ -249,20 +248,20 @@ impl<'a> InstanceWithMeta<'a> {
}
}
/// RojoTree's equivalent of `&'a mut RbxInstance`.
/// RojoTree's equivalent of `&'a mut Instance`.
///
/// This has to be a value type for RojoTree because the instance and metadata
/// are stored in different places. The immutable equivalent is
/// `InstanceWithMeta`.
#[derive(Debug)]
pub struct InstanceWithMetaMut<'a> {
instance: &'a mut RbxInstance,
instance: &'a mut Instance,
metadata: &'a mut InstanceMetadata,
}
impl InstanceWithMetaMut<'_> {
pub fn id(&self) -> RbxId {
self.instance.get_id()
pub fn id(&self) -> Ref {
self.instance.referent()
}
pub fn name(&self) -> &str {
@@ -274,23 +273,23 @@ impl InstanceWithMetaMut<'_> {
}
pub fn class_name(&self) -> &str {
&self.instance.class_name
&self.instance.class
}
pub fn class_name_mut(&mut self) -> &mut String {
&mut self.instance.class_name
&mut self.instance.class
}
pub fn properties(&self) -> &HashMap<String, RbxValue> {
pub fn properties(&self) -> &HashMap<String, Variant> {
&self.instance.properties
}
pub fn properties_mut(&mut self) -> &mut HashMap<String, RbxValue> {
pub fn properties_mut(&mut self) -> &mut HashMap<String, Variant> {
&mut self.instance.properties
}
pub fn children(&self) -> &[RbxId] {
self.instance.get_children_ids()
pub fn children(&self) -> &[Ref] {
self.instance.children()
}
pub fn metadata(&self) -> &InstanceMetadata {