VFS in external crate (#297)

* vroom

* Port dir middleware

* Filter rules

* Directory metadata

* Project support

* Enable Lua support

* StringValue support

* CSV

* rbxm, rbxmx, and rbxlx

* JSON models

* Clean up some warnings

* Strip out PathMap

* Unwatch paths when they're reported as removed

* Fix 'rojo upload' behavior

* Upgrade to Insta 0.13.1

* Update dependencies

* Release 0.6.0-alpha.2

* Fix bad merge

* Replace MemoryBackend with InMemoryFs

* Sledgehammer tests into passing for now

* Txt middleware

* Update easy snapshot tests

* Lua tests

* Project middleware tests

* Try to fix test failures by sorting

* Port first set of serve session tests

* Add InMemoryFs::raise_event

* Finish porting serve session tests

* Remove UI code for introspecting VFS for now

* VFS docs

src/snapshot_middleware/txt.rs

@@ -1,40 +1,36 @@
-use std::str;
+use std::{path::Path, str};
 
 use maplit::hashmap;
-use rbx_dom_weak::{RbxId, RbxTree, RbxValue};
+use rbx_dom_weak::RbxValue;
+use vfs::{IoResultExt, Vfs};
 
-use crate::{
-    snapshot::{InstanceContext, InstanceMetadata, InstanceSnapshot},
-    vfs::{FileSnapshot, FsResultExt, Vfs, VfsEntry, VfsFetcher, VfsSnapshot},
-};
+use crate::snapshot::{InstanceContext, InstanceMetadata, InstanceSnapshot};
 
 use super::{
     error::SnapshotError,
     meta_file::AdjacentMetadata,
-    middleware::{SnapshotFileResult, SnapshotInstanceResult, SnapshotMiddleware},
+    middleware::{SnapshotInstanceResult, SnapshotMiddleware},
     util::match_file_name,
 };
 
 pub struct SnapshotTxt;
 
 impl SnapshotMiddleware for SnapshotTxt {
-    fn from_vfs<F: VfsFetcher>(
-        context: &InstanceContext,
-        vfs: &Vfs<F>,
-        entry: &VfsEntry,
-    ) -> SnapshotInstanceResult {
-        if entry.is_directory() {
+    fn from_vfs(context: &InstanceContext, vfs: &Vfs, path: &Path) -> SnapshotInstanceResult {
+        let meta = vfs.metadata(path)?;
+
+        if meta.is_dir() {
             return Ok(None);
         }
 
-        let instance_name = match match_file_name(entry.path(), ".txt") {
+        let instance_name = match match_file_name(path, ".txt") {
             Some(name) => name,
             None => return Ok(None),
         };
 
-        let contents = entry.contents(vfs)?;
+        let contents = vfs.read(path)?;
         let contents_str = str::from_utf8(&contents)
-            .map_err(|err| SnapshotError::file_contents_bad_unicode(err, entry.path()))?
+            .map_err(|err| SnapshotError::file_contents_bad_unicode(err, path))?
             .to_string();
 
         let properties = hashmap! {
@@ -43,9 +39,7 @@ impl SnapshotMiddleware for SnapshotTxt {
             },
         };
 
-        let meta_path = entry
-            .path()
-            .with_file_name(format!("{}.meta.json", instance_name));
+        let meta_path = path.with_file_name(format!("{}.meta.json", instance_name));
 
         let mut snapshot = InstanceSnapshot::new()
             .name(instance_name)
@@ -53,99 +47,39 @@ impl SnapshotMiddleware for SnapshotTxt {
             .properties(properties)
             .metadata(
                 InstanceMetadata::new()
-                    .instigating_source(entry.path())
-                    .relevant_paths(vec![entry.path().to_path_buf(), meta_path.clone()])
+                    .instigating_source(path)
+                    .relevant_paths(vec![path.to_path_buf(), meta_path.clone()])
                     .context(context),
             );
 
-        if let Some(meta_entry) = vfs.get(meta_path).with_not_found()? {
-            let meta_contents = meta_entry.contents(vfs)?;
+        if let Some(meta_contents) = vfs.read(meta_path).with_not_found()? {
             let mut metadata = AdjacentMetadata::from_slice(&meta_contents);
             metadata.apply_all(&mut snapshot);
         }
 
         Ok(Some(snapshot))
     }
-
-    fn from_instance(tree: &RbxTree, id: RbxId) -> SnapshotFileResult {
-        let instance = tree.get_instance(id).unwrap();
-
-        if instance.class_name != "StringValue" {
-            return None;
-        }
-
-        if !instance.get_children_ids().is_empty() {
-            return None;
-        }
-
-        let value = match instance.properties.get("Value") {
-            Some(RbxValue::String { value }) => value.clone(),
-            Some(_) => panic!("wrong type ahh"),
-            None => String::new(),
-        };
-
-        let snapshot = VfsSnapshot::File(FileSnapshot {
-            contents: value.into_bytes(),
-        });
-
-        let mut file_name = instance.name.clone();
-        file_name.push_str(".txt");
-
-        Some((file_name, snapshot))
-    }
 }
 
 #[cfg(test)]
 mod test {
     use super::*;
 
-    use insta::assert_yaml_snapshot;
-    use maplit::hashmap;
-    use rbx_dom_weak::RbxInstanceProperties;
-
-    use crate::vfs::{NoopFetcher, VfsDebug};
+    use vfs::{InMemoryFs, VfsSnapshot};
 
     #[test]
     fn instance_from_vfs() {
-        let mut vfs = Vfs::new(NoopFetcher);
-        let file = VfsSnapshot::file("Hello there!");
+        let mut imfs = InMemoryFs::new();
+        imfs.load_snapshot("/foo.txt", VfsSnapshot::file("Hello there!"))
+            .unwrap();
 
-        vfs.debug_load_snapshot("/foo.txt", file);
+        let mut vfs = Vfs::new(imfs.clone());
 
-        let entry = vfs.get("/foo.txt").unwrap();
         let instance_snapshot =
-            SnapshotTxt::from_vfs(&InstanceContext::default(), &mut vfs, &entry)
+            SnapshotTxt::from_vfs(&InstanceContext::default(), &mut vfs, Path::new("/foo.txt"))
                 .unwrap()
                 .unwrap();
 
-        assert_yaml_snapshot!(instance_snapshot);
-    }
-
-    #[test]
-    fn vfs_from_instance() {
-        let tree = RbxTree::new(string_value("Root", "Hello, world!"));
-        let root_id = tree.get_root_id();
-
-        let (_file_name, _file) = SnapshotTxt::from_instance(&tree, root_id).unwrap();
-    }
-
-    fn folder(name: impl Into<String>) -> RbxInstanceProperties {
-        RbxInstanceProperties {
-            name: name.into(),
-            class_name: "Folder".to_owned(),
-            properties: Default::default(),
-        }
-    }
-
-    fn string_value(name: impl Into<String>, value: impl Into<String>) -> RbxInstanceProperties {
-        RbxInstanceProperties {
-            name: name.into(),
-            class_name: "StringValue".to_owned(),
-            properties: hashmap! {
-                "Value".to_owned() => RbxValue::String {
-                    value: value.into(),
-                },
-            },
-        }
+        insta::assert_yaml_snapshot!(instance_snapshot);
     }
 }