New snapshot tests (#134)

* Changes project-related structures to use `BTreeMap` instead of `HashMap` for children to aid determiniusm
* Changes imfs-related structures to have total ordering and use `BTreeSet` instead of `HashSet`
* Upgrades dependencies to `bx_dom_weak`1.2.0 and rbx_xml 0.5.0 to aid in more determinism stuff
* Re-exposes the `RbxSession`'s root project via `root_project()`
* Implements `Default` for a couple things
* Tweaks visualization code to support visualizing trees not attached to an `RbxSession`
* Adds an ID-invariant comparison method for `rbx_tree` relying on previous determinism changes
* Adds a (disabled) test to start finding issues in the reconciler with regards to communicativity of snapshot application
* Adds a snapshot testing system that operates on `RbxTree` and associated metadata, which are committed in this change

server/src/imfs.rs

@@ -1,9 +1,10 @@
 use std::{
-    collections::{HashMap, HashSet},
-    path::{self, Path, PathBuf},
+    cmp::Ordering,
+    collections::{HashMap, HashSet, BTreeSet},
     fmt,
     fs,
     io,
+    path::{self, Path, PathBuf},
 };
 
 use failure::Fail;
@@ -237,7 +238,7 @@ impl Imfs {
         } else if metadata.is_dir() {
             let item = ImfsItem::Directory(ImfsDirectory {
                 path: path.to_path_buf(),
-                children: HashSet::new(),
+                children: BTreeSet::new(),
             });
 
             self.items.insert(path.to_path_buf(), item);
@@ -285,19 +286,43 @@ impl Imfs {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub struct ImfsFile {
     pub path: PathBuf,
     pub contents: Vec<u8>,
 }
 
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-pub struct ImfsDirectory {
-    pub path: PathBuf,
-    pub children: HashSet<PathBuf>,
+impl PartialOrd for ImfsFile {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
 }
 
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+impl Ord for ImfsFile {
+    fn cmp(&self, other: &Self) -> Ordering {
+        self.path.cmp(&other.path)
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct ImfsDirectory {
+    pub path: PathBuf,
+    pub children: BTreeSet<PathBuf>,
+}
+
+impl PartialOrd for ImfsDirectory {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for ImfsDirectory {
+    fn cmp(&self, other: &Self) -> Ordering {
+        self.path.cmp(&other.path)
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
 pub enum ImfsItem {
     File(ImfsFile),
     Directory(ImfsDirectory),

server/src/live_session.rs

@@ -85,6 +85,10 @@ impl LiveSession {
         Ok(())
     }
 
+    pub fn root_project(&self) -> &Project {
+        &self.project
+    }
+
     pub fn session_id(&self) -> SessionId {
         self.session_id
     }

server/src/path_map.rs

@@ -20,6 +20,12 @@ pub struct PathMap<T> {
     nodes: HashMap<PathBuf, PathMapNode<T>>,
 }
 
+impl<T> Default for PathMap<T> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl<T> PathMap<T> {
     pub fn new() -> PathMap<T> {
         PathMap {

server/src/project.rs

@@ -1,5 +1,5 @@
 use std::{
-    collections::{HashMap, HashSet},
+    collections::{HashMap, HashSet, BTreeMap},
     fmt,
     fs::{self, File},
     io,
@@ -128,7 +128,7 @@ fn serialize_unresolved_map<S>(value: &HashMap<String, UnresolvedRbxValue>, seri
 /// Similar to SourceProject, the structure of nodes in the project tree is
 /// slightly different on-disk than how we want to handle them in the rest of
 /// Rojo.
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 struct SourceProjectNode {
     #[serde(rename = "$className", skip_serializing_if = "Option::is_none")]
     class_name: Option<String>,
@@ -148,14 +148,14 @@ struct SourceProjectNode {
     path: Option<String>,
 
     #[serde(flatten)]
-    children: HashMap<String, SourceProjectNode>,
+    children: BTreeMap<String, SourceProjectNode>,
 }
 
 impl SourceProjectNode {
     /// Consumes the SourceProjectNode and turns it into a ProjectNode.
-    pub fn into_project_node(mut self, project_file_location: &Path) -> ProjectNode {
-        let children = self.children.drain()
-            .map(|(key, value)| (key, value.into_project_node(project_file_location)))
+    pub fn into_project_node(self, project_file_location: &Path) -> ProjectNode {
+        let children = self.children.iter()
+            .map(|(key, value)| (key.clone(), value.clone().into_project_node(project_file_location)))
             .collect();
 
         // Make sure that paths are absolute, transforming them by adding the
@@ -264,7 +264,7 @@ pub enum ProjectSaveError {
 #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
 pub struct ProjectNode {
     pub class_name: Option<String>,
-    pub children: HashMap<String, ProjectNode>,
+    pub children: BTreeMap<String, ProjectNode>,
     pub properties: HashMap<String, UnresolvedRbxValue>,
     pub ignore_unknown_instances: Option<bool>,
 
@@ -486,6 +486,10 @@ impl Project {
         }
     }
 
+    pub fn folder_location(&self) -> &Path {
+        self.file_location.parent().unwrap()
+    }
+
     fn to_source_project(&self) -> SourceProject {
         let plugins = self.plugins
             .iter()

server/src/rbx_session.rs

@@ -251,6 +251,10 @@ impl RbxSession {
         &self.tree
     }
 
+    pub fn get_all_instance_metadata(&self) -> &HashMap<RbxId, MetadataPerInstance> {
+        &self.metadata_per_instance
+    }
+
     pub fn get_instance_metadata(&self, id: RbxId) -> Option<&MetadataPerInstance> {
         self.metadata_per_instance.get(&id)
     }

server/src/snapshot_reconciler.rs

@@ -64,7 +64,7 @@ impl InstanceChanges {
 
 /// A lightweight, hierarchical representation of an instance that can be
 /// applied to the tree.
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
 pub struct RbxSnapshotInstance<'a> {
     pub name: Cow<'a, str>,
     pub class_name: Cow<'a, str>,

server/src/visualize.rs

@@ -1,4 +1,5 @@
 use std::{
+    collections::HashMap,
     fmt,
     io::Write,
     path::Path,
@@ -6,12 +7,13 @@ use std::{
 };
 
 use log::warn;
-use rbx_dom_weak::RbxId;
+use rbx_dom_weak::{RbxTree, RbxId};
 
 use crate::{
     imfs::{Imfs, ImfsItem},
     rbx_session::RbxSession,
     web::api::PublicInstanceMetadata,
+    rbx_session::MetadataPerInstance,
 };
 
 static GRAPHVIZ_HEADER: &str = r#"
@@ -53,42 +55,59 @@ pub fn graphviz_to_svg(source: &str) -> Option<String> {
     Some(String::from_utf8(output.stdout).expect("Failed to parse stdout as UTF-8"))
 }
 
+pub struct VisualizeRbxTree<'a, 'b> {
+    pub tree: &'a RbxTree,
+    pub metadata: &'b HashMap<RbxId, MetadataPerInstance>,
+}
+
+impl<'a, 'b> fmt::Display for VisualizeRbxTree<'a, 'b> {
+    fn fmt(&self, output: &mut fmt::Formatter) -> fmt::Result {
+        writeln!(output, "{}", GRAPHVIZ_HEADER)?;
+
+        visualize_instance(&self.tree, self.tree.get_root_id(), &self.metadata, output)?;
+
+        writeln!(output, "}}")
+    }
+}
+
 /// A Display wrapper struct to visualize an RbxSession as SVG.
 pub struct VisualizeRbxSession<'a>(pub &'a RbxSession);
 
 impl<'a> fmt::Display for VisualizeRbxSession<'a> {
     fn fmt(&self, output: &mut fmt::Formatter) -> fmt::Result {
-        writeln!(output, "{}", GRAPHVIZ_HEADER)?;
-
-        visualize_rbx_node(self.0, self.0.get_tree().get_root_id(), output)?;
-
-        writeln!(output, "}}")?;
-
-        Ok(())
+        writeln!(output, "{}", VisualizeRbxTree {
+            tree: self.0.get_tree(),
+            metadata: self.0.get_all_instance_metadata(),
+        })
     }
 }
 
-fn visualize_rbx_node(session: &RbxSession, id: RbxId, output: &mut fmt::Formatter) -> fmt::Result {
-    let node = session.get_tree().get_instance(id).unwrap();
+fn visualize_instance(
+    tree: &RbxTree,
+    id: RbxId,
+    metadata: &HashMap<RbxId, MetadataPerInstance>,
+    output: &mut fmt::Formatter,
+) -> fmt::Result {
+    let instance = tree.get_instance(id).unwrap();
 
-    let mut node_label = format!("{}|{}|{}", node.name, node.class_name, id);
+    let mut instance_label = format!("{}|{}|{}", instance.name, instance.class_name, id);
 
-    if let Some(session_metadata) = session.get_instance_metadata(id) {
+    if let Some(session_metadata) = metadata.get(&id) {
         let metadata = PublicInstanceMetadata::from_session_metadata(session_metadata);
-        node_label.push('|');
-        node_label.push_str(&serde_json::to_string(&metadata).unwrap());
+        instance_label.push('|');
+        instance_label.push_str(&serde_json::to_string(&metadata).unwrap());
     }
 
-    node_label = node_label
+    instance_label = instance_label
         .replace("\"", "&quot;")
         .replace("{", "\\{")
         .replace("}", "\\}");
 
-    writeln!(output, "    \"{}\" [label=\"{}\"]", id, node_label)?;
+    writeln!(output, "    \"{}\" [label=\"{}\"]", id, instance_label)?;
 
-    for &child_id in node.get_children_ids() {
+    for &child_id in instance.get_children_ids() {
         writeln!(output, "    \"{}\" -> \"{}\"", id, child_id)?;
-        visualize_rbx_node(session, child_id, output)?;
+        visualize_instance(tree, child_id, metadata, output)?;
     }
 
     Ok(())