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

Batch rename: imfs -> vfs

Browse Source
This commit is contained in:
Lucien Greathouse
2019-10-12 13:58:00 -07:00
parent 24c697bea7
commit 1031600c63
40 changed files with 539 additions and 545 deletions
Download Patch File Download Diff File Expand all files Collapse all files

36
src/change_processor.rs
View File

@@ -1,4 +1,4 @@
//! Defines the process by which changes are pulled from the Imfs, filtered, and
//! Defines the process by which changes are pulled from the Vfs, filtered, and
//! used to mutate Rojo's tree during a live session.
//!
//! This object is owned by a ServeSession.
@@ -9,10 +9,10 @@ use crossbeam_channel::{select, Receiver, Sender};
use jod_thread::JoinHandle;
use crate::{
imfs::{Imfs, ImfsEvent, ImfsFetcher},
message_queue::MessageQueue,
snapshot::{apply_patch_set, compute_patch_set, AppliedPatchSet, InstigatingSource, RojoTree},
snapshot_middleware::{snapshot_from_imfs, InstanceSnapshotContext},
snapshot_middleware::{snapshot_from_vfs, InstanceSnapshotContext},
vfs::{Vfs, VfsEvent, VfsFetcher},
};
pub struct ChangeProcessor {
@@ -21,10 +21,10 @@ pub struct ChangeProcessor {
}
impl ChangeProcessor {
pub fn start<F: ImfsFetcher + Send + 'static>(
pub fn start<F: VfsFetcher + Send + 'static>(
tree: Arc<Mutex<RojoTree>>,
message_queue: Arc<MessageQueue<AppliedPatchSet>>,
imfs: Arc<Mutex<Imfs<F>>>,
vfs: Arc<Mutex<Vfs<F>>>,
) -> Self {
let (shutdown_sender, shutdown_receiver) = crossbeam_channel::bounded(1);
@@ -32,7 +32,7 @@ impl ChangeProcessor {
.name("ChangeProcessor thread".to_owned())
.spawn(move || {
log::trace!("ChangeProcessor thread started");
Self::main_task(shutdown_receiver, tree, message_queue, imfs);
Self::main_task(shutdown_receiver, tree, message_queue, vfs);
log::trace!("ChangeProcessor thread stopped");
})
.expect("Could not start ChangeProcessor thread");
@@ -43,15 +43,15 @@ impl ChangeProcessor {
}
}
fn main_task<F: ImfsFetcher>(
fn main_task<F: VfsFetcher>(
shutdown_receiver: Receiver<()>,
tree: Arc<Mutex<RojoTree>>,
message_queue: Arc<MessageQueue<AppliedPatchSet>>,
imfs: Arc<Mutex<Imfs<F>>>,
vfs: Arc<Mutex<Vfs<F>>>,
) {
let imfs_receiver = {
let imfs = imfs.lock().unwrap();
imfs.change_receiver()
let vfs_receiver = {
let vfs = vfs.lock().unwrap();
vfs.change_receiver()
};
// Crossbeam's select macro generates code that Clippy doesn't like, and
@@ -59,20 +59,20 @@ impl ChangeProcessor {
#[allow(clippy::drop_copy)]
loop {
select! {
recv(imfs_receiver) -> event => {
recv(vfs_receiver) -> event => {
let event = event.unwrap();
log::trace!("Imfs event: {:?}", event);
log::trace!("Vfs event: {:?}", event);
let applied_patches = {
let mut imfs = imfs.lock().unwrap();
imfs.commit_change(&event).expect("Error applying IMFS change");
let mut vfs = vfs.lock().unwrap();
vfs.commit_change(&event).expect("Error applying VFS change");
let mut tree = tree.lock().unwrap();
let mut applied_patches = Vec::new();
match event {
ImfsEvent::Created(path) | ImfsEvent::Modified(path) | ImfsEvent::Removed(path) => {
VfsEvent::Created(path) | VfsEvent::Modified(path) | VfsEvent::Removed(path) => {
let affected_ids = tree.get_ids_at_path(&path).to_vec();
if affected_ids.len() == 0 {
@@ -95,14 +95,14 @@ impl ChangeProcessor {
let snapshot = match instigating_source {
InstigatingSource::Path(path) => {
let entry = imfs
let entry = vfs
.get(path)
.expect("could not get instigating path from filesystem");
// TODO: Use persisted snapshot
// context struct instead of
// recreating it every time.
let snapshot = snapshot_from_imfs(&mut InstanceSnapshotContext::default(), &mut imfs, &entry)
let snapshot = snapshot_from_vfs(&mut InstanceSnapshotContext::default(), &mut vfs, &entry)
.expect("snapshot failed")
.expect("snapshot did not return an instance");

6
src/commands/build.rs
View File

@@ -8,8 +8,8 @@ use failure::Fail;
use crate::{
common_setup,
imfs::{FsError, Imfs, RealFetcher, WatchMode},
project::ProjectLoadError,
vfs::{FsError, RealFetcher, Vfs, WatchMode},
};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -81,9 +81,9 @@ pub fn build(options: &BuildOptions) -> Result<(), BuildError> {
log::debug!("Hoping to generate file of type {:?}", output_kind);
log::trace!("Constructing in-memory filesystem");
let mut imfs = Imfs::new(RealFetcher::new(WatchMode::Disabled));
let mut vfs = Vfs::new(RealFetcher::new(WatchMode::Disabled));
let (_maybe_project, tree) = common_setup::start(&options.fuzzy_project_path, &mut imfs);
let (_maybe_project, tree) = common_setup::start(&options.fuzzy_project_path, &mut vfs);
let root_id = tree.get_root_id();
log::trace!("Opening output file for write");

6
src/commands/serve.rs
View File

@@ -8,9 +8,9 @@ use failure::Fail;
use termcolor::{BufferWriter, Color, ColorChoice, ColorSpec, WriteColor};
use crate::{
imfs::{Imfs, RealFetcher, WatchMode},
project::ProjectLoadError,
serve_session::ServeSession,
vfs::{RealFetcher, Vfs, WatchMode},
web::LiveServer,
};
@@ -33,9 +33,9 @@ impl_from!(ServeError {
});
pub fn serve(options: &ServeOptions) -> Result<(), ServeError> {
let imfs = Imfs::new(RealFetcher::new(WatchMode::Enabled));
let vfs = Vfs::new(RealFetcher::new(WatchMode::Enabled));
let session = Arc::new(ServeSession::new(imfs, &options.fuzzy_project_path));
let session = Arc::new(ServeSession::new(vfs, &options.fuzzy_project_path));
let port = options
.port

6
src/commands/upload.rs
View File

@@ -6,7 +6,7 @@ use reqwest::header::{ACCEPT, CONTENT_TYPE, COOKIE, USER_AGENT};
use crate::{
auth_cookie::get_auth_cookie,
common_setup,
imfs::{Imfs, RealFetcher, WatchMode},
vfs::{RealFetcher, Vfs, WatchMode},
};
#[derive(Debug, Fail)]
@@ -44,9 +44,9 @@ pub fn upload(options: UploadOptions) -> Result<(), UploadError> {
.ok_or(UploadError::NeedAuthCookie)?;
log::trace!("Constructing in-memory filesystem");
let mut imfs = Imfs::new(RealFetcher::new(WatchMode::Disabled));
let mut vfs = Vfs::new(RealFetcher::new(WatchMode::Disabled));
let (_maybe_project, tree) = common_setup::start(&options.fuzzy_project_path, &mut imfs);
let (_maybe_project, tree) = common_setup::start(&options.fuzzy_project_path, &mut vfs);
let root_id = tree.get_root_id();
let mut buffer = Vec::new();

14
src/common_setup.rs
View File

@@ -6,15 +6,15 @@ use std::path::Path;
use rbx_dom_weak::RbxInstanceProperties;
use crate::{
imfs::{Imfs, ImfsFetcher},
project::{Project, ProjectLoadError},
snapshot::{apply_patch_set, compute_patch_set, InstancePropertiesWithMeta, RojoTree},
snapshot_middleware::{snapshot_from_imfs, InstanceSnapshotContext, SnapshotPluginContext},
snapshot_middleware::{snapshot_from_vfs, InstanceSnapshotContext, SnapshotPluginContext},
vfs::{Vfs, VfsFetcher},
};
pub fn start<F: ImfsFetcher>(
pub fn start<F: VfsFetcher>(
fuzzy_project_path: &Path,
imfs: &mut Imfs<F>,
vfs: &mut Vfs<F>,
) -> (Option<Project>, RojoTree) {
log::trace!("Loading project file from {}", fuzzy_project_path.display());
let maybe_project = match Project::load_fuzzy(fuzzy_project_path) {
@@ -47,12 +47,12 @@ pub fn start<F: ImfsFetcher>(
}
log::trace!("Reading project root");
let entry = imfs
let entry = vfs
.get(fuzzy_project_path)
.expect("could not get project path");
log::trace!("Generating snapshot of instances from IMFS");
let snapshot = snapshot_from_imfs(&mut snapshot_context, imfs, &entry)
log::trace!("Generating snapshot of instances from VFS");
let snapshot = snapshot_from_vfs(&mut snapshot_context, vfs, &entry)
.expect("snapshot failed")
.expect("snapshot did not return an instance");

42
src/imfs/snapshot.rs
View File

@@ -1,42 +0,0 @@
// This file is non-critical and used for testing, so it's okay if it's unused.
#![allow(unused)]
use std::collections::HashMap;
#[derive(Debug, Clone)]
pub enum ImfsSnapshot {
File(FileSnapshot),
Directory(DirectorySnapshot),
}
impl ImfsSnapshot {
/// Create a new file ImfsSnapshot with the given contents.
pub fn file(contents: impl Into<Vec<u8>>) -> ImfsSnapshot {
ImfsSnapshot::File(FileSnapshot {
contents: contents.into(),
})
}
/// Create a new directory ImfsSnapshot with the given children.
pub fn dir<S: Into<String>>(children: HashMap<S, ImfsSnapshot>) -> ImfsSnapshot {
let children = children.into_iter().map(|(k, v)| (k.into(), v)).collect();
ImfsSnapshot::Directory(DirectorySnapshot { children })
}
pub fn empty_dir() -> ImfsSnapshot {
ImfsSnapshot::Directory(DirectorySnapshot {
children: Default::default(),
})
}
}
#[derive(Debug, Clone)]
pub struct FileSnapshot {
pub contents: Vec<u8>,
}
#[derive(Debug, Clone)]
pub struct DirectorySnapshot {
pub children: HashMap<String, ImfsSnapshot>,
}

2
src/lib.rs
View File

@@ -18,7 +18,6 @@ mod tree_view;
mod auth_cookie;
mod change_processor;
mod common_setup;
mod imfs;
mod message_queue;
mod multimap;
mod path_map;
@@ -27,6 +26,7 @@ mod serve_session;
mod session_id;
mod snapshot;
mod snapshot_middleware;
mod vfs;
mod web;
pub use crate::session_id::SessionId;

84
src/serve_session.rs
View File

@@ -8,11 +8,11 @@ use std::{
use crate::{
change_processor::ChangeProcessor,
common_setup,
imfs::{Imfs, ImfsFetcher},
message_queue::MessageQueue,
project::Project,
session_id::SessionId,
snapshot::{AppliedPatchSet, RojoTree},
vfs::{Vfs, VfsFetcher},
};
/// Contains all of the state for a Rojo serve session.
@@ -43,7 +43,7 @@ pub struct ServeSession<F> {
session_id: SessionId,
/// The tree of Roblox instances associated with this session that will be
/// updated in real-time. This is derived from the session's IMFS and will
/// updated in real-time. This is derived from the session's VFS and will
/// eventually be mutable to connected clients.
tree: Arc<Mutex<RojoTree>>,
@@ -52,7 +52,7 @@ pub struct ServeSession<F> {
///
/// The main use for accessing it from the session is for debugging issues
/// with Rojo's live-sync protocol.
imfs: Arc<Mutex<Imfs<F>>>,
vfs: Arc<Mutex<Vfs<F>>>,
/// A queue of changes that have been applied to `tree` that affect clients.
///
@@ -68,37 +68,37 @@ pub struct ServeSession<F> {
_change_processor: ChangeProcessor,
}
/// Methods that need thread-safety bounds on ImfsFetcher are limited to this
/// Methods that need thread-safety bounds on VfsFetcher are limited to this
/// block to prevent needing to spread Send + Sync + 'static into everything
/// that handles ServeSession.
impl<F: ImfsFetcher + Send + 'static> ServeSession<F> {
impl<F: VfsFetcher + Send + 'static> ServeSession<F> {
/// Start a new serve session from the given in-memory filesystem and start
/// path.
///
/// The project file is expected to be loaded out-of-band since it's
/// currently loaded from the filesystem directly instead of through the
/// in-memory filesystem layer.
pub fn new<P: AsRef<Path>>(mut imfs: Imfs<F>, start_path: P) -> Self {
pub fn new<P: AsRef<Path>>(mut vfs: Vfs<F>, start_path: P) -> Self {
let start_path = start_path.as_ref();
log::trace!("Starting new ServeSession at path {}", start_path.display(),);
let start_time = Instant::now();
let (root_project, tree) = common_setup::start(start_path, &mut imfs);
let (root_project, tree) = common_setup::start(start_path, &mut vfs);
let session_id = SessionId::new();
let message_queue = MessageQueue::new();
let tree = Arc::new(Mutex::new(tree));
let message_queue = Arc::new(message_queue);
let imfs = Arc::new(Mutex::new(imfs));
let vfs = Arc::new(Mutex::new(vfs));
log::trace!("Starting ChangeProcessor");
let change_processor = ChangeProcessor::start(
Arc::clone(&tree),
Arc::clone(&message_queue),
Arc::clone(&imfs),
Arc::clone(&vfs),
);
Self {
@@ -107,13 +107,13 @@ impl<F: ImfsFetcher + Send + 'static> ServeSession<F> {
root_project,
tree,
message_queue,
imfs,
vfs,
_change_processor: change_processor,
}
}
}
impl<F: ImfsFetcher> ServeSession<F> {
impl<F: VfsFetcher> ServeSession<F> {
pub fn tree_handle(&self) -> Arc<Mutex<RojoTree>> {
Arc::clone(&self.tree)
}
@@ -122,8 +122,8 @@ impl<F: ImfsFetcher> ServeSession<F> {
self.tree.lock().unwrap()
}
pub fn imfs(&self) -> MutexGuard<'_, Imfs<F>> {
self.imfs.lock().unwrap()
pub fn vfs(&self) -> MutexGuard<'_, Vfs<F>> {
self.vfs.lock().unwrap()
}
pub fn message_queue(&self) -> &MessageQueue<AppliedPatchSet> {
@@ -173,17 +173,17 @@ mod serve_session {
use tokio::{runtime::Runtime, timer::Timeout};
use crate::{
imfs::{ImfsDebug, ImfsEvent, ImfsSnapshot, NoopFetcher, TestFetcher},
tree_view::view_tree,
vfs::{NoopFetcher, TestFetcher, VfsDebug, VfsEvent, VfsSnapshot},
};
#[test]
fn just_folder() {
let mut imfs = Imfs::new(NoopFetcher);
let mut vfs = Vfs::new(NoopFetcher);
imfs.debug_load_snapshot("/foo", ImfsSnapshot::empty_dir());
vfs.debug_load_snapshot("/foo", VfsSnapshot::empty_dir());
let session = ServeSession::new(imfs, "/foo");
let session = ServeSession::new(vfs, "/foo");
let mut rm = RedactionMap::new();
assert_yaml_snapshot!(view_tree(&session.tree(), &mut rm));
@@ -191,12 +191,12 @@ mod serve_session {
#[test]
fn project_with_folder() {
let mut imfs = Imfs::new(NoopFetcher);
let mut vfs = Vfs::new(NoopFetcher);
imfs.debug_load_snapshot(
vfs.debug_load_snapshot(
"/foo",
ImfsSnapshot::dir(hashmap! {
"default.project.json" => ImfsSnapshot::file(r#"
VfsSnapshot::dir(hashmap! {
"default.project.json" => VfsSnapshot::file(r#"
{
"name": "HelloWorld",
"tree": {
@@ -204,13 +204,13 @@ mod serve_session {
}
}
"#),
"src" => ImfsSnapshot::dir(hashmap! {
"hello.txt" => ImfsSnapshot::file("Hello, world!"),
"src" => VfsSnapshot::dir(hashmap! {
"hello.txt" => VfsSnapshot::file("Hello, world!"),
}),
}),
);
let session = ServeSession::new(imfs, "/foo");
let session = ServeSession::new(vfs, "/foo");
let mut rm = RedactionMap::new();
assert_yaml_snapshot!(view_tree(&session.tree(), &mut rm));
@@ -218,17 +218,17 @@ mod serve_session {
#[test]
fn script_with_meta() {
let mut imfs = Imfs::new(NoopFetcher);
let mut vfs = Vfs::new(NoopFetcher);
imfs.debug_load_snapshot(
vfs.debug_load_snapshot(
"/root",
ImfsSnapshot::dir(hashmap! {
"test.lua" => ImfsSnapshot::file("This is a test."),
"test.meta.json" => ImfsSnapshot::file(r#"{ "ignoreUnknownInstances": true }"#),
VfsSnapshot::dir(hashmap! {
"test.lua" => VfsSnapshot::file("This is a test."),
"test.meta.json" => VfsSnapshot::file(r#"{ "ignoreUnknownInstances": true }"#),
}),
);
let session = ServeSession::new(imfs, "/root");
let session = ServeSession::new(vfs, "/root");
let mut rm = RedactionMap::new();
assert_yaml_snapshot!(view_tree(&session.tree(), &mut rm));
@@ -240,14 +240,14 @@ mod serve_session {
state.load_snapshot(
"/root",
ImfsSnapshot::dir(hashmap! {
"test.lua" => ImfsSnapshot::file("This is a test."),
"test.meta.json" => ImfsSnapshot::file(r#"{ "ignoreUnknownInstances": true }"#),
VfsSnapshot::dir(hashmap! {
"test.lua" => VfsSnapshot::file("This is a test."),
"test.meta.json" => VfsSnapshot::file(r#"{ "ignoreUnknownInstances": true }"#),
}),
);
let imfs = Imfs::new(fetcher);
let session = ServeSession::new(imfs, "/root");
let vfs = Vfs::new(fetcher);
let session = ServeSession::new(vfs, "/root");
let mut redactions = RedactionMap::new();
assert_yaml_snapshot!(
@@ -257,14 +257,14 @@ mod serve_session {
state.load_snapshot(
"/root/test.meta.json",
ImfsSnapshot::file(r#"{ "ignoreUnknownInstances": false }"#),
VfsSnapshot::file(r#"{ "ignoreUnknownInstances": false }"#),
);
let receiver = Timeout::new(
session.message_queue().subscribe_any(),
Duration::from_millis(200),
);
state.raise_event(ImfsEvent::Modified(PathBuf::from("/root/test.meta.json")));
state.raise_event(VfsEvent::Modified(PathBuf::from("/root/test.meta.json")));
let mut rt = Runtime::new().unwrap();
let changes = rt.block_on(receiver).unwrap();
@@ -283,10 +283,10 @@ mod serve_session {
fn change_txt_file() {
let (state, fetcher) = TestFetcher::new();
state.load_snapshot("/foo.txt", ImfsSnapshot::file("Hello!"));
state.load_snapshot("/foo.txt", VfsSnapshot::file("Hello!"));
let imfs = Imfs::new(fetcher);
let session = ServeSession::new(imfs, "/foo.txt");
let vfs = Vfs::new(fetcher);
let session = ServeSession::new(vfs, "/foo.txt");
let mut redactions = RedactionMap::new();
assert_yaml_snapshot!(
@@ -294,11 +294,11 @@ mod serve_session {
view_tree(&session.tree(), &mut redactions)
);
state.load_snapshot("/foo.txt", ImfsSnapshot::file("World!"));
state.load_snapshot("/foo.txt", VfsSnapshot::file("World!"));
let receiver = session.message_queue().subscribe_any();
state.raise_event(ImfsEvent::Modified(PathBuf::from("/foo.txt")));
state.raise_event(VfsEvent::Modified(PathBuf::from("/foo.txt")));
let receiver = Timeout::new(receiver, Duration::from_millis(200));

2
src/snapshot_middleware/context.rs
View File

@@ -62,4 +62,4 @@ impl<T> Deref for IgnoreDebug<T> {
}
}
pub struct ImfsSnapshotContext;
pub struct VfsSnapshotContext;

42
src/snapshot_middleware/csv.rs
View File

@@ -5,8 +5,8 @@ use rbx_dom_weak::RbxValue;
use serde::Serialize;
use crate::{
imfs::{FsResultExt, Imfs, ImfsEntry, ImfsFetcher},
snapshot::{InstanceMetadata, InstanceSnapshot},
vfs::{FsResultExt, Vfs, VfsEntry, VfsFetcher},
};
use super::{
@@ -19,10 +19,10 @@ use super::{
pub struct SnapshotCsv;
impl SnapshotMiddleware for SnapshotCsv {
fn from_imfs<F: ImfsFetcher>(
fn from_vfs<F: VfsFetcher>(
_context: &mut InstanceSnapshotContext,
imfs: &mut Imfs<F>,
entry: &ImfsEntry,
vfs: &mut Vfs<F>,
entry: &VfsEntry,
) -> SnapshotInstanceResult<'static> {
if entry.is_directory() {
return Ok(None);
@@ -37,7 +37,7 @@ impl SnapshotMiddleware for SnapshotCsv {
.path()
.with_file_name(format!("{}.meta.json", instance_name));
let table_contents = convert_localization_csv(entry.contents(imfs)?);
let table_contents = convert_localization_csv(entry.contents(vfs)?);
let mut snapshot = InstanceSnapshot {
snapshot_id: None,
@@ -56,8 +56,8 @@ impl SnapshotMiddleware for SnapshotCsv {
children: Vec::new(),
};
if let Some(meta_entry) = imfs.get(meta_path).with_not_found()? {
let meta_contents = meta_entry.contents(imfs)?;
if let Some(meta_entry) = vfs.get(meta_path).with_not_found()? {
let meta_contents = meta_entry.contents(vfs)?;
let mut metadata = AdjacentMetadata::from_slice(meta_contents);
metadata.apply_all(&mut snapshot);
}
@@ -146,23 +146,23 @@ fn convert_localization_csv(contents: &[u8]) -> String {
mod test {
use super::*;
use crate::imfs::{ImfsDebug, ImfsSnapshot, NoopFetcher};
use crate::vfs::{NoopFetcher, VfsDebug, VfsSnapshot};
use insta::assert_yaml_snapshot;
#[test]
fn csv_from_imfs() {
let mut imfs = Imfs::new(NoopFetcher);
let file = ImfsSnapshot::file(
fn csv_from_vfs() {
let mut vfs = Vfs::new(NoopFetcher);
let file = VfsSnapshot::file(
r#"
Key,Source,Context,Example,es
Ack,Ack!,,An exclamation of despair,¡Ay!"#,
);
imfs.debug_load_snapshot("/foo.csv", file);
vfs.debug_load_snapshot("/foo.csv", file);
let entry = imfs.get("/foo.csv").unwrap();
let entry = vfs.get("/foo.csv").unwrap();
let instance_snapshot =
SnapshotCsv::from_imfs(&mut InstanceSnapshotContext::default(), &mut imfs, &entry)
SnapshotCsv::from_vfs(&mut InstanceSnapshotContext::default(), &mut vfs, &entry)
.unwrap()
.unwrap();
@@ -171,20 +171,20 @@ Ack,Ack!,,An exclamation of despair,¡Ay!"#,
#[test]
fn csv_with_meta() {
let mut imfs = Imfs::new(NoopFetcher);
let file = ImfsSnapshot::file(
let mut vfs = Vfs::new(NoopFetcher);
let file = VfsSnapshot::file(
r#"
Key,Source,Context,Example,es
Ack,Ack!,,An exclamation of despair,¡Ay!"#,
);
let meta = ImfsSnapshot::file(r#"{ "ignoreUnknownInstances": true }"#);
let meta = VfsSnapshot::file(r#"{ "ignoreUnknownInstances": true }"#);
imfs.debug_load_snapshot("/foo.csv", file);
imfs.debug_load_snapshot("/foo.meta.json", meta);
vfs.debug_load_snapshot("/foo.csv", file);
vfs.debug_load_snapshot("/foo.meta.json", meta);
let entry = imfs.get("/foo.csv").unwrap();
let entry = vfs.get("/foo.csv").unwrap();
let instance_snapshot =
SnapshotCsv::from_imfs(&mut InstanceSnapshotContext::default(), &mut imfs, &entry)
SnapshotCsv::from_vfs(&mut InstanceSnapshotContext::default(), &mut vfs, &entry)
.unwrap()
.unwrap();

40
src/snapshot_middleware/dir.rs
View File

@@ -3,35 +3,35 @@ use std::{borrow::Cow, collections::HashMap};
use rbx_dom_weak::{RbxId, RbxTree};
use crate::{
imfs::{DirectorySnapshot, Imfs, ImfsEntry, ImfsFetcher, ImfsSnapshot},
snapshot::{InstanceMetadata, InstanceSnapshot},
vfs::{DirectorySnapshot, Vfs, VfsEntry, VfsFetcher, VfsSnapshot},
};
use super::{
context::InstanceSnapshotContext,
error::SnapshotError,
middleware::{SnapshotFileResult, SnapshotInstanceResult, SnapshotMiddleware},
snapshot_from_imfs, snapshot_from_instance,
snapshot_from_instance, snapshot_from_vfs,
};
pub struct SnapshotDir;
impl SnapshotMiddleware for SnapshotDir {
fn from_imfs<F: ImfsFetcher>(
fn from_vfs<F: VfsFetcher>(
context: &mut InstanceSnapshotContext,
imfs: &mut Imfs<F>,
entry: &ImfsEntry,
vfs: &mut Vfs<F>,
entry: &VfsEntry,
) -> SnapshotInstanceResult<'static> {
if entry.is_file() {
return Ok(None);
}
let children: Vec<ImfsEntry> = entry.children(imfs)?;
let children: Vec<VfsEntry> = entry.children(vfs)?;
let mut snapshot_children = Vec::new();
for child in children.into_iter() {
if let Some(child_snapshot) = snapshot_from_imfs(context, imfs, &child)? {
if let Some(child_snapshot) = snapshot_from_vfs(context, vfs, &child)? {
snapshot_children.push(child_snapshot);
}
}
@@ -73,7 +73,7 @@ impl SnapshotMiddleware for SnapshotDir {
}
}
let snapshot = ImfsSnapshot::Directory(DirectorySnapshot { children });
let snapshot = VfsSnapshot::Directory(DirectorySnapshot { children });
Some((instance.name.clone(), snapshot))
}
@@ -86,18 +86,18 @@ mod test {
use insta::assert_yaml_snapshot;
use maplit::hashmap;
use crate::imfs::{ImfsDebug, NoopFetcher};
use crate::vfs::{NoopFetcher, VfsDebug};
#[test]
fn empty_folder() {
let mut imfs = Imfs::new(NoopFetcher);
let dir = ImfsSnapshot::dir::<String>(HashMap::new());
let mut vfs = Vfs::new(NoopFetcher);
let dir = VfsSnapshot::dir::<String>(HashMap::new());
imfs.debug_load_snapshot("/foo", dir);
vfs.debug_load_snapshot("/foo", dir);
let entry = imfs.get("/foo").unwrap();
let entry = vfs.get("/foo").unwrap();
let instance_snapshot =
SnapshotDir::from_imfs(&mut InstanceSnapshotContext::default(), &mut imfs, &entry)
SnapshotDir::from_vfs(&mut InstanceSnapshotContext::default(), &mut vfs, &entry)
.unwrap()
.unwrap();
@@ -106,16 +106,16 @@ mod test {
#[test]
fn folder_in_folder() {
let mut imfs = Imfs::new(NoopFetcher);
let dir = ImfsSnapshot::dir(hashmap! {
"Child" => ImfsSnapshot::dir::<String>(HashMap::new()),
let mut vfs = Vfs::new(NoopFetcher);
let dir = VfsSnapshot::dir(hashmap! {
"Child" => VfsSnapshot::dir::<String>(HashMap::new()),
});
imfs.debug_load_snapshot("/foo", dir);
vfs.debug_load_snapshot("/foo", dir);
let entry = imfs.get("/foo").unwrap();
let entry = vfs.get("/foo").unwrap();
let instance_snapshot =
SnapshotDir::from_imfs(&mut InstanceSnapshotContext::default(), &mut imfs, &entry)
SnapshotDir::from_vfs(&mut InstanceSnapshotContext::default(), &mut vfs, &entry)
.unwrap()
.unwrap();

2
src/snapshot_middleware/error.rs
View File

@@ -1,6 +1,6 @@
use std::{error::Error, fmt, io, path::PathBuf};
use crate::imfs::FsError;
use crate::vfs::FsError;
#[derive(Debug)]
pub struct SnapshotError {

33
src/snapshot_middleware/json_model.rs
View File

@@ -5,8 +5,8 @@ use rbx_reflection::try_resolve_value;
use serde::Deserialize;
use crate::{
imfs::{Imfs, ImfsEntry, ImfsFetcher},
snapshot::InstanceSnapshot,
vfs::{Vfs, VfsEntry, VfsFetcher},
};
use super::{
@@ -18,10 +18,10 @@ use super::{
pub struct SnapshotJsonModel;
impl SnapshotMiddleware for SnapshotJsonModel {
fn from_imfs<F: ImfsFetcher>(
fn from_vfs<F: VfsFetcher>(
_context: &mut InstanceSnapshotContext,
imfs: &mut Imfs<F>,
entry: &ImfsEntry,
vfs: &mut Vfs<F>,
entry: &VfsEntry,
) -> SnapshotInstanceResult<'static> {
if entry.is_directory() {
return Ok(None);
@@ -33,7 +33,7 @@ impl SnapshotMiddleware for SnapshotJsonModel {
};
let instance: JsonModel =
serde_json::from_slice(entry.contents(imfs)?).expect("TODO: Handle serde_json errors");
serde_json::from_slice(entry.contents(vfs)?).expect("TODO: Handle serde_json errors");
if let Some(json_name) = &instance.name {
if json_name != &instance_name {
@@ -137,12 +137,12 @@ mod test {
use insta::assert_yaml_snapshot;
use crate::imfs::{ImfsDebug, ImfsSnapshot, NoopFetcher};
use crate::vfs::{NoopFetcher, VfsDebug, VfsSnapshot};
#[test]
fn model_from_imfs() {
let mut imfs = Imfs::new(NoopFetcher);
let file = ImfsSnapshot::file(
fn model_from_vfs() {
let mut vfs = Vfs::new(NoopFetcher);
let file = VfsSnapshot::file(
r#"
{
"Name": "children",
@@ -160,16 +160,13 @@ mod test {
"#,
);
imfs.debug_load_snapshot("/foo.model.json", file);
vfs.debug_load_snapshot("/foo.model.json", file);
let entry = imfs.get("/foo.model.json").unwrap();
let instance_snapshot = SnapshotJsonModel::from_imfs(
&mut InstanceSnapshotContext::default(),
&mut imfs,
&entry,
)
.unwrap()
.unwrap();
let entry = vfs.get("/foo.model.json").unwrap();
let instance_snapshot =
SnapshotJsonModel::from_vfs(&mut InstanceSnapshotContext::default(), &mut vfs, &entry)
.unwrap()
.unwrap();
assert_yaml_snapshot!(instance_snapshot);
}

120
src/snapshot_middleware/lua.rs
View File

@@ -4,8 +4,8 @@ use maplit::hashmap;
use rbx_dom_weak::RbxValue;
use crate::{
imfs::{FsResultExt, Imfs, ImfsEntry, ImfsFetcher},
snapshot::{InstanceMetadata, InstanceSnapshot},
vfs::{FsResultExt, Vfs, VfsEntry, VfsFetcher},
};
use super::{
@@ -19,10 +19,10 @@ use super::{
pub struct SnapshotLua;
impl SnapshotMiddleware for SnapshotLua {
fn from_imfs<F: ImfsFetcher>(
fn from_vfs<F: VfsFetcher>(
context: &mut InstanceSnapshotContext,
imfs: &mut Imfs<F>,
entry: &ImfsEntry,
vfs: &mut Vfs<F>,
entry: &VfsEntry,
) -> SnapshotInstanceResult<'static> {
let file_name = entry.path().file_name().unwrap().to_string_lossy();
@@ -34,15 +34,15 @@ impl SnapshotMiddleware for SnapshotLua {
}
if entry.is_file() {
snapshot_lua_file(imfs, entry)
snapshot_lua_file(vfs, entry)
} else {
if let Some(snapshot) = snapshot_init(context, imfs, entry, "init.lua")? {
if let Some(snapshot) = snapshot_init(context, vfs, entry, "init.lua")? {
// An `init.lua` file turns its parent into a ModuleScript
Ok(Some(snapshot))
} else if let Some(snapshot) = snapshot_init(context, imfs, entry, "init.server.lua")? {
} else if let Some(snapshot) = snapshot_init(context, vfs, entry, "init.server.lua")? {
// An `init.server.lua` file turns its parent into a Script
Ok(Some(snapshot))
} else if let Some(snapshot) = snapshot_init(context, imfs, entry, "init.client.lua")? {
} else if let Some(snapshot) = snapshot_init(context, vfs, entry, "init.client.lua")? {
// An `init.client.lua` file turns its parent into a LocalScript
Ok(Some(snapshot))
} else {
@@ -53,9 +53,9 @@ impl SnapshotMiddleware for SnapshotLua {
}
/// Core routine for turning Lua files into snapshots.
fn snapshot_lua_file<F: ImfsFetcher>(
imfs: &mut Imfs<F>,
entry: &ImfsEntry,
fn snapshot_lua_file<F: VfsFetcher>(
vfs: &mut Vfs<F>,
entry: &VfsEntry,
) -> SnapshotInstanceResult<'static> {
let file_name = entry.path().file_name().unwrap().to_string_lossy();
@@ -70,7 +70,7 @@ fn snapshot_lua_file<F: ImfsFetcher>(
return Ok(None);
};
let contents = entry.contents(imfs)?;
let contents = entry.contents(vfs)?;
let contents_str = str::from_utf8(contents)
// TODO: Turn into error type
.expect("File content was not valid UTF-8")
@@ -101,8 +101,8 @@ fn snapshot_lua_file<F: ImfsFetcher>(
children: Vec::new(),
};
if let Some(meta_entry) = imfs.get(meta_path).with_not_found()? {
let meta_contents = meta_entry.contents(imfs)?;
if let Some(meta_entry) = vfs.get(meta_path).with_not_found()? {
let meta_contents = meta_entry.contents(vfs)?;
let mut metadata = AdjacentMetadata::from_slice(meta_contents);
metadata.apply_all(&mut snapshot);
}
@@ -115,17 +115,17 @@ fn snapshot_lua_file<F: ImfsFetcher>(
///
/// Scripts named `init.lua`, `init.server.lua`, or `init.client.lua` usurp
/// their parents, which acts similarly to `__init__.py` from the Python world.
fn snapshot_init<F: ImfsFetcher>(
fn snapshot_init<F: VfsFetcher>(
context: &mut InstanceSnapshotContext,
imfs: &mut Imfs<F>,
folder_entry: &ImfsEntry,
vfs: &mut Vfs<F>,
folder_entry: &VfsEntry,
init_name: &str,
) -> SnapshotInstanceResult<'static> {
let init_path = folder_entry.path().join(init_name);
if let Some(init_entry) = imfs.get(init_path).with_not_found()? {
if let Some(dir_snapshot) = SnapshotDir::from_imfs(context, imfs, folder_entry)? {
if let Some(mut init_snapshot) = snapshot_lua_file(imfs, &init_entry)? {
if let Some(init_entry) = vfs.get(init_path).with_not_found()? {
if let Some(dir_snapshot) = SnapshotDir::from_vfs(context, vfs, folder_entry)? {
if let Some(mut init_snapshot) = snapshot_lua_file(vfs, &init_entry)? {
init_snapshot.name = dir_snapshot.name;
init_snapshot.children = dir_snapshot.children;
// TODO: Metadata
@@ -145,18 +145,18 @@ mod test {
use insta::{assert_yaml_snapshot, with_settings};
use crate::imfs::{ImfsDebug, ImfsSnapshot, NoopFetcher};
use crate::vfs::{NoopFetcher, VfsDebug, VfsSnapshot};
#[test]
fn module_from_imfs() {
let mut imfs = Imfs::new(NoopFetcher);
let file = ImfsSnapshot::file("Hello there!");
fn module_from_vfs() {
let mut vfs = Vfs::new(NoopFetcher);
let file = VfsSnapshot::file("Hello there!");
imfs.debug_load_snapshot("/foo.lua", file);
vfs.debug_load_snapshot("/foo.lua", file);
let entry = imfs.get("/foo.lua").unwrap();
let entry = vfs.get("/foo.lua").unwrap();
let instance_snapshot =
SnapshotLua::from_imfs(&mut InstanceSnapshotContext::default(), &mut imfs, &entry)
SnapshotLua::from_vfs(&mut InstanceSnapshotContext::default(), &mut vfs, &entry)
.unwrap()
.unwrap();
@@ -164,15 +164,15 @@ mod test {
}
#[test]
fn server_from_imfs() {
let mut imfs = Imfs::new(NoopFetcher);
let file = ImfsSnapshot::file("Hello there!");
fn server_from_vfs() {
let mut vfs = Vfs::new(NoopFetcher);
let file = VfsSnapshot::file("Hello there!");
imfs.debug_load_snapshot("/foo.server.lua", file);
vfs.debug_load_snapshot("/foo.server.lua", file);
let entry = imfs.get("/foo.server.lua").unwrap();
let entry = vfs.get("/foo.server.lua").unwrap();
let instance_snapshot =
SnapshotLua::from_imfs(&mut InstanceSnapshotContext::default(), &mut imfs, &entry)
SnapshotLua::from_vfs(&mut InstanceSnapshotContext::default(), &mut vfs, &entry)
.unwrap()
.unwrap();
@@ -180,15 +180,15 @@ mod test {
}
#[test]
fn client_from_imfs() {
let mut imfs = Imfs::new(NoopFetcher);
let file = ImfsSnapshot::file("Hello there!");
fn client_from_vfs() {
let mut vfs = Vfs::new(NoopFetcher);
let file = VfsSnapshot::file("Hello there!");
imfs.debug_load_snapshot("/foo.client.lua", file);
vfs.debug_load_snapshot("/foo.client.lua", file);
let entry = imfs.get("/foo.client.lua").unwrap();
let entry = vfs.get("/foo.client.lua").unwrap();
let instance_snapshot =
SnapshotLua::from_imfs(&mut InstanceSnapshotContext::default(), &mut imfs, &entry)
SnapshotLua::from_vfs(&mut InstanceSnapshotContext::default(), &mut vfs, &entry)
.unwrap()
.unwrap();
@@ -197,9 +197,9 @@ mod test {
#[test]
fn module_with_meta() {
let mut imfs = Imfs::new(NoopFetcher);
let file = ImfsSnapshot::file("Hello there!");
let meta = ImfsSnapshot::file(
let mut vfs = Vfs::new(NoopFetcher);
let file = VfsSnapshot::file("Hello there!");
let meta = VfsSnapshot::file(
r#"
{
"ignoreUnknownInstances": true
@@ -207,12 +207,12 @@ mod test {
"#,
);
imfs.debug_load_snapshot("/foo.lua", file);
imfs.debug_load_snapshot("/foo.meta.json", meta);
vfs.debug_load_snapshot("/foo.lua", file);
vfs.debug_load_snapshot("/foo.meta.json", meta);
let entry = imfs.get("/foo.lua").unwrap();
let entry = vfs.get("/foo.lua").unwrap();
let instance_snapshot =
SnapshotLua::from_imfs(&mut InstanceSnapshotContext::default(), &mut imfs, &entry)
SnapshotLua::from_vfs(&mut InstanceSnapshotContext::default(), &mut vfs, &entry)
.unwrap()
.unwrap();
@@ -221,9 +221,9 @@ mod test {
#[test]
fn script_with_meta() {
let mut imfs = Imfs::new(NoopFetcher);
let file = ImfsSnapshot::file("Hello there!");
let meta = ImfsSnapshot::file(
let mut vfs = Vfs::new(NoopFetcher);
let file = VfsSnapshot::file("Hello there!");
let meta = VfsSnapshot::file(
r#"
{
"ignoreUnknownInstances": true
@@ -231,12 +231,12 @@ mod test {
"#,
);
imfs.debug_load_snapshot("/foo.server.lua", file);
imfs.debug_load_snapshot("/foo.meta.json", meta);
vfs.debug_load_snapshot("/foo.server.lua", file);
vfs.debug_load_snapshot("/foo.meta.json", meta);
let entry = imfs.get("/foo.server.lua").unwrap();
let entry = vfs.get("/foo.server.lua").unwrap();
let instance_snapshot =
SnapshotLua::from_imfs(&mut InstanceSnapshotContext::default(), &mut imfs, &entry)
SnapshotLua::from_vfs(&mut InstanceSnapshotContext::default(), &mut vfs, &entry)
.unwrap()
.unwrap();
@@ -245,9 +245,9 @@ mod test {
#[test]
fn script_disabled() {
let mut imfs = Imfs::new(NoopFetcher);
let file = ImfsSnapshot::file("Hello there!");
let meta = ImfsSnapshot::file(
let mut vfs = Vfs::new(NoopFetcher);
let file = VfsSnapshot::file("Hello there!");
let meta = VfsSnapshot::file(
r#"
{
"properties": {
@@ -257,12 +257,12 @@ mod test {
"#,
);
imfs.debug_load_snapshot("/bar.server.lua", file);
imfs.debug_load_snapshot("/bar.meta.json", meta);
vfs.debug_load_snapshot("/bar.server.lua", file);
vfs.debug_load_snapshot("/bar.meta.json", meta);
let entry = imfs.get("/bar.server.lua").unwrap();
let entry = vfs.get("/bar.server.lua").unwrap();
let instance_snapshot =
SnapshotLua::from_imfs(&mut InstanceSnapshotContext::default(), &mut imfs, &entry)
SnapshotLua::from_vfs(&mut InstanceSnapshotContext::default(), &mut vfs, &entry)
.unwrap()
.unwrap();

10
src/snapshot_middleware/middleware.rs
View File

@@ -3,20 +3,20 @@ use std::path::{Path, PathBuf};
use rbx_dom_weak::{RbxId, RbxTree};
use crate::{
imfs::{Imfs, ImfsEntry, ImfsFetcher, ImfsSnapshot},
snapshot::InstanceSnapshot,
vfs::{Vfs, VfsEntry, VfsFetcher, VfsSnapshot},
};
use super::{context::InstanceSnapshotContext, error::SnapshotError};
pub type SnapshotInstanceResult<'a> = Result<Option<InstanceSnapshot<'a>>, SnapshotError>;
pub type SnapshotFileResult = Option<(String, ImfsSnapshot)>;
pub type SnapshotFileResult = Option<(String, VfsSnapshot)>;
pub trait SnapshotMiddleware {
fn from_imfs<F: ImfsFetcher>(
fn from_vfs<F: VfsFetcher>(
context: &mut InstanceSnapshotContext,
imfs: &mut Imfs<F>,
entry: &ImfsEntry,
vfs: &mut Vfs<F>,
entry: &VfsEntry,
) -> SnapshotInstanceResult<'static>;
fn from_instance(_tree: &RbxTree, _id: RbxId) -> SnapshotFileResult {

12
src/snapshot_middleware/mod.rs
View File

@@ -37,20 +37,20 @@ use self::{
txt::SnapshotTxt,
user_plugins::SnapshotUserPlugins,
};
use crate::imfs::{Imfs, ImfsEntry, ImfsFetcher};
use crate::vfs::{Vfs, VfsEntry, VfsFetcher};
macro_rules! middlewares {
( $($middleware: ident,)* ) => {
/// Generates a snapshot of instances from the given ImfsEntry.
pub fn snapshot_from_imfs<F: ImfsFetcher>(
/// Generates a snapshot of instances from the given VfsEntry.
pub fn snapshot_from_vfs<F: VfsFetcher>(
context: &mut InstanceSnapshotContext,
imfs: &mut Imfs<F>,
entry: &ImfsEntry,
vfs: &mut Vfs<F>,
entry: &VfsEntry,
) -> SnapshotInstanceResult<'static> {
$(
log::trace!("trying middleware {} on {}", stringify!($middleware), entry.path().display());
if let Some(snapshot) = $middleware::from_imfs(context, imfs, entry)? {
if let Some(snapshot) = $middleware::from_vfs(context, vfs, entry)? {
log::trace!("middleware {} success on {}", stringify!($middleware), entry.path().display());
return Ok(Some(snapshot));
}

146
src/snapshot_middleware/project.rs
View File

@@ -3,16 +3,16 @@ use std::{borrow::Cow, collections::HashMap};
use rbx_reflection::try_resolve_value;
use crate::{
imfs::{FsResultExt, Imfs, ImfsEntry, ImfsFetcher},
project::{Project, ProjectNode},
snapshot::{InstanceMetadata, InstanceSnapshot, InstigatingSource},
vfs::{FsResultExt, Vfs, VfsEntry, VfsFetcher},
};
use super::{
context::InstanceSnapshotContext,
error::SnapshotError,
middleware::{SnapshotInstanceResult, SnapshotMiddleware},
snapshot_from_imfs,
snapshot_from_vfs,
};
/// Handles snapshots for:
@@ -21,19 +21,19 @@ use super::{
pub struct SnapshotProject;
impl SnapshotMiddleware for SnapshotProject {
fn from_imfs<F: ImfsFetcher>(
fn from_vfs<F: VfsFetcher>(
context: &mut InstanceSnapshotContext,
imfs: &mut Imfs<F>,
entry: &ImfsEntry,
vfs: &mut Vfs<F>,
entry: &VfsEntry,
) -> SnapshotInstanceResult<'static> {
if entry.is_directory() {
let project_path = entry.path().join("default.project.json");
match imfs.get(project_path).with_not_found()? {
match vfs.get(project_path).with_not_found()? {
// TODO: Do we need to muck with the relevant paths if we're a
// project file within a folder? Should the folder path be the
// relevant path instead of the project file path?
Some(entry) => return SnapshotProject::from_imfs(context, imfs, &entry),
Some(entry) => return SnapshotProject::from_vfs(context, vfs, &entry),
None => return Ok(None),
}
}
@@ -43,13 +43,13 @@ impl SnapshotMiddleware for SnapshotProject {
return Ok(None);
}
let project = Project::load_from_slice(entry.contents(imfs)?, entry.path())
let project = Project::load_from_slice(entry.contents(vfs)?, entry.path())
.map_err(|err| SnapshotError::malformed_project(err, entry.path()))?;
// Snapshotting a project should always return an instance, so this
// unwrap is safe.
let mut snapshot =
snapshot_project_node(context, &project.name, &project.tree, imfs)?.unwrap();
snapshot_project_node(context, &project.name, &project.tree, vfs)?.unwrap();
// Setting the instigating source to the project file path is a little
// coarse.
@@ -76,11 +76,11 @@ impl SnapshotMiddleware for SnapshotProject {
}
}
fn snapshot_project_node<F: ImfsFetcher>(
fn snapshot_project_node<F: VfsFetcher>(
context: &mut InstanceSnapshotContext,
instance_name: &str,
node: &ProjectNode,
imfs: &mut Imfs<F>,
vfs: &mut Vfs<F>,
) -> SnapshotInstanceResult<'static> {
let name = Cow::Owned(instance_name.to_owned());
let mut class_name = node
@@ -92,9 +92,9 @@ fn snapshot_project_node<F: ImfsFetcher>(
let mut metadata = InstanceMetadata::default();
if let Some(path) = &node.path {
let entry = imfs.get(path)?;
let entry = vfs.get(path)?;
if let Some(snapshot) = snapshot_from_imfs(context, imfs, &entry)? {
if let Some(snapshot) = snapshot_from_vfs(context, vfs, &entry)? {
// If a class name was already specified, then it'll override the
// class name of this snapshot ONLY if it's a Folder.
//
@@ -144,7 +144,7 @@ fn snapshot_project_node<F: ImfsFetcher>(
.expect("$className or $path must be specified");
for (child_name, child_project_node) in &node.children {
if let Some(child) = snapshot_project_node(context, child_name, child_project_node, imfs)? {
if let Some(child) = snapshot_project_node(context, child_name, child_project_node, vfs)? {
children.push(child);
}
}
@@ -192,15 +192,15 @@ mod test {
use insta::assert_yaml_snapshot;
use maplit::hashmap;
use crate::imfs::{ImfsDebug, ImfsSnapshot, NoopFetcher};
use crate::vfs::{NoopFetcher, VfsDebug, VfsSnapshot};
#[test]
fn project_from_folder() {
let _ = env_logger::try_init();
let mut imfs = Imfs::new(NoopFetcher);
let dir = ImfsSnapshot::dir(hashmap! {
"default.project.json" => ImfsSnapshot::file(r#"
let mut vfs = Vfs::new(NoopFetcher);
let dir = VfsSnapshot::dir(hashmap! {
"default.project.json" => VfsSnapshot::file(r#"
{
"name": "indirect-project",
"tree": {
@@ -210,11 +210,11 @@ mod test {
"#),
});
imfs.debug_load_snapshot("/foo", dir);
vfs.debug_load_snapshot("/foo", dir);
let entry = imfs.get("/foo").unwrap();
let entry = vfs.get("/foo").unwrap();
let instance_snapshot =
SnapshotProject::from_imfs(&mut InstanceSnapshotContext::default(), &mut imfs, &entry)
SnapshotProject::from_vfs(&mut InstanceSnapshotContext::default(), &mut vfs, &entry)
.expect("snapshot error")
.expect("snapshot returned no instances");
@@ -225,9 +225,9 @@ mod test {
fn project_from_direct_file() {
let _ = env_logger::try_init();
let mut imfs = Imfs::new(NoopFetcher);
let dir = ImfsSnapshot::dir(hashmap! {
"hello.project.json" => ImfsSnapshot::file(r#"
let mut vfs = Vfs::new(NoopFetcher);
let dir = VfsSnapshot::dir(hashmap! {
"hello.project.json" => VfsSnapshot::file(r#"
{
"name": "direct-project",
"tree": {
@@ -237,11 +237,11 @@ mod test {
"#),
});
imfs.debug_load_snapshot("/foo", dir);
vfs.debug_load_snapshot("/foo", dir);
let entry = imfs.get("/foo/hello.project.json").unwrap();
let entry = vfs.get("/foo/hello.project.json").unwrap();
let instance_snapshot =
SnapshotProject::from_imfs(&mut InstanceSnapshotContext::default(), &mut imfs, &entry)
SnapshotProject::from_vfs(&mut InstanceSnapshotContext::default(), &mut vfs, &entry)
.expect("snapshot error")
.expect("snapshot returned no instances");
@@ -252,9 +252,9 @@ mod test {
fn project_with_resolved_properties() {
let _ = env_logger::try_init();
let mut imfs = Imfs::new(NoopFetcher);
let dir = ImfsSnapshot::dir(hashmap! {
"default.project.json" => ImfsSnapshot::file(r#"
let mut vfs = Vfs::new(NoopFetcher);
let dir = VfsSnapshot::dir(hashmap! {
"default.project.json" => VfsSnapshot::file(r#"
{
"name": "resolved-properties",
"tree": {
@@ -270,11 +270,11 @@ mod test {
"#),
});
imfs.debug_load_snapshot("/foo", dir);
vfs.debug_load_snapshot("/foo", dir);
let entry = imfs.get("/foo").unwrap();
let entry = vfs.get("/foo").unwrap();
let instance_snapshot =
SnapshotProject::from_imfs(&mut InstanceSnapshotContext::default(), &mut imfs, &entry)
SnapshotProject::from_vfs(&mut InstanceSnapshotContext::default(), &mut vfs, &entry)
.expect("snapshot error")
.expect("snapshot returned no instances");
@@ -285,9 +285,9 @@ mod test {
fn project_with_unresolved_properties() {
let _ = env_logger::try_init();
let mut imfs = Imfs::new(NoopFetcher);
let dir = ImfsSnapshot::dir(hashmap! {
"default.project.json" => ImfsSnapshot::file(r#"
let mut vfs = Vfs::new(NoopFetcher);
let dir = VfsSnapshot::dir(hashmap! {
"default.project.json" => VfsSnapshot::file(r#"
{
"name": "unresolved-properties",
"tree": {
@@ -300,11 +300,11 @@ mod test {
"#),
});
imfs.debug_load_snapshot("/foo", dir);
vfs.debug_load_snapshot("/foo", dir);
let entry = imfs.get("/foo").unwrap();
let entry = vfs.get("/foo").unwrap();
let instance_snapshot =
SnapshotProject::from_imfs(&mut InstanceSnapshotContext::default(), &mut imfs, &entry)
SnapshotProject::from_vfs(&mut InstanceSnapshotContext::default(), &mut vfs, &entry)
.expect("snapshot error")
.expect("snapshot returned no instances");
@@ -315,9 +315,9 @@ mod test {
fn project_with_children() {
let _ = env_logger::try_init();
let mut imfs = Imfs::new(NoopFetcher);
let dir = ImfsSnapshot::dir(hashmap! {
"default.project.json" => ImfsSnapshot::file(r#"
let mut vfs = Vfs::new(NoopFetcher);
let dir = VfsSnapshot::dir(hashmap! {
"default.project.json" => VfsSnapshot::file(r#"
{
"name": "children",
"tree": {
@@ -331,11 +331,11 @@ mod test {
"#),
});
imfs.debug_load_snapshot("/foo", dir);
vfs.debug_load_snapshot("/foo", dir);
let entry = imfs.get("/foo").unwrap();
let entry = vfs.get("/foo").unwrap();
let instance_snapshot =
SnapshotProject::from_imfs(&mut InstanceSnapshotContext::default(), &mut imfs, &entry)
SnapshotProject::from_vfs(&mut InstanceSnapshotContext::default(), &mut vfs, &entry)
.expect("snapshot error")
.expect("snapshot returned no instances");
@@ -346,9 +346,9 @@ mod test {
fn project_with_path_to_txt() {
let _ = env_logger::try_init();
let mut imfs = Imfs::new(NoopFetcher);
let dir = ImfsSnapshot::dir(hashmap! {
"default.project.json" => ImfsSnapshot::file(r#"
let mut vfs = Vfs::new(NoopFetcher);
let dir = VfsSnapshot::dir(hashmap! {
"default.project.json" => VfsSnapshot::file(r#"
{
"name": "path-project",
"tree": {
@@ -356,14 +356,14 @@ mod test {
}
}
"#),
"other.txt" => ImfsSnapshot::file("Hello, world!"),
"other.txt" => VfsSnapshot::file("Hello, world!"),
});
imfs.debug_load_snapshot("/foo", dir);
vfs.debug_load_snapshot("/foo", dir);
let entry = imfs.get("/foo").unwrap();
let entry = vfs.get("/foo").unwrap();
let instance_snapshot =
SnapshotProject::from_imfs(&mut InstanceSnapshotContext::default(), &mut imfs, &entry)
SnapshotProject::from_vfs(&mut InstanceSnapshotContext::default(), &mut vfs, &entry)
.expect("snapshot error")
.expect("snapshot returned no instances");
@@ -374,9 +374,9 @@ mod test {
fn project_with_path_to_project() {
let _ = env_logger::try_init();
let mut imfs = Imfs::new(NoopFetcher);
let dir = ImfsSnapshot::dir(hashmap! {
"default.project.json" => ImfsSnapshot::file(r#"
let mut vfs = Vfs::new(NoopFetcher);
let dir = VfsSnapshot::dir(hashmap! {
"default.project.json" => VfsSnapshot::file(r#"
{
"name": "path-project",
"tree": {
@@ -384,7 +384,7 @@ mod test {
}
}
"#),
"other.project.json" => ImfsSnapshot::file(r#"
"other.project.json" => VfsSnapshot::file(r#"
{
"name": "other-project",
"tree": {
@@ -394,11 +394,11 @@ mod test {
"#),
});
imfs.debug_load_snapshot("/foo", dir);
vfs.debug_load_snapshot("/foo", dir);
let entry = imfs.get("/foo").unwrap();
let entry = vfs.get("/foo").unwrap();
let instance_snapshot =
SnapshotProject::from_imfs(&mut InstanceSnapshotContext::default(), &mut imfs, &entry)
SnapshotProject::from_vfs(&mut InstanceSnapshotContext::default(), &mut vfs, &entry)
.expect("snapshot error")
.expect("snapshot returned no instances");
@@ -409,9 +409,9 @@ mod test {
fn project_with_path_to_project_with_children() {
let _ = env_logger::try_init();
let mut imfs = Imfs::new(NoopFetcher);
let dir = ImfsSnapshot::dir(hashmap! {
"default.project.json" => ImfsSnapshot::file(r#"
let mut vfs = Vfs::new(NoopFetcher);
let dir = VfsSnapshot::dir(hashmap! {
"default.project.json" => VfsSnapshot::file(r#"
{
"name": "path-child-project",
"tree": {
@@ -419,7 +419,7 @@ mod test {
}
}
"#),
"other.project.json" => ImfsSnapshot::file(r#"
"other.project.json" => VfsSnapshot::file(r#"
{
"name": "other-project",
"tree": {
@@ -433,11 +433,11 @@ mod test {
"#),
});
imfs.debug_load_snapshot("/foo", dir);
vfs.debug_load_snapshot("/foo", dir);
let entry = imfs.get("/foo").unwrap();
let entry = vfs.get("/foo").unwrap();
let instance_snapshot =
SnapshotProject::from_imfs(&mut InstanceSnapshotContext::default(), &mut imfs, &entry)
SnapshotProject::from_vfs(&mut InstanceSnapshotContext::default(), &mut vfs, &entry)
.expect("snapshot error")
.expect("snapshot returned no instances");
@@ -451,9 +451,9 @@ mod test {
fn project_path_property_overrides() {
let _ = env_logger::try_init();
let mut imfs = Imfs::new(NoopFetcher);
let dir = ImfsSnapshot::dir(hashmap! {
"default.project.json" => ImfsSnapshot::file(r#"
let mut vfs = Vfs::new(NoopFetcher);
let dir = VfsSnapshot::dir(hashmap! {
"default.project.json" => VfsSnapshot::file(r#"
{
"name": "path-property-override",
"tree": {
@@ -464,7 +464,7 @@ mod test {
}
}
"#),
"other.project.json" => ImfsSnapshot::file(r#"
"other.project.json" => VfsSnapshot::file(r#"
{
"name": "other-project",
"tree": {
@@ -477,11 +477,11 @@ mod test {
"#),
});
imfs.debug_load_snapshot("/foo", dir);
vfs.debug_load_snapshot("/foo", dir);
let entry = imfs.get("/foo").unwrap();
let entry = vfs.get("/foo").unwrap();
let instance_snapshot =
SnapshotProject::from_imfs(&mut InstanceSnapshotContext::default(), &mut imfs, &entry)
SnapshotProject::from_vfs(&mut InstanceSnapshotContext::default(), &mut vfs, &entry)
.expect("snapshot error")
.expect("snapshot returned no instances");

10
src/snapshot_middleware/rbxlx.rs
View File

@@ -1,8 +1,8 @@
use std::borrow::Cow;
use crate::{
imfs::{Imfs, ImfsEntry, ImfsFetcher},
snapshot::InstanceSnapshot,
vfs::{Vfs, VfsEntry, VfsFetcher},
};
use super::{
@@ -14,10 +14,10 @@ use super::{
pub struct SnapshotRbxlx;
impl SnapshotMiddleware for SnapshotRbxlx {
fn from_imfs<F: ImfsFetcher>(
fn from_vfs<F: VfsFetcher>(
_context: &mut InstanceSnapshotContext,
imfs: &mut Imfs<F>,
entry: &ImfsEntry,
vfs: &mut Vfs<F>,
entry: &VfsEntry,
) -> SnapshotInstanceResult<'static> {
if entry.is_directory() {
return Ok(None);
@@ -31,7 +31,7 @@ impl SnapshotMiddleware for SnapshotRbxlx {
let options = rbx_xml::DecodeOptions::new()
.property_behavior(rbx_xml::DecodePropertyBehavior::ReadUnknown);
let temp_tree = rbx_xml::from_reader(entry.contents(imfs)?, options)
let temp_tree = rbx_xml::from_reader(entry.contents(vfs)?, options)
.expect("TODO: Handle rbx_xml errors");
let root_id = temp_tree.get_root_id();

24
src/snapshot_middleware/rbxm.rs
View File

@@ -3,8 +3,8 @@ use std::{borrow::Cow, collections::HashMap};
use rbx_dom_weak::{RbxInstanceProperties, RbxTree};
use crate::{
imfs::{Imfs, ImfsEntry, ImfsFetcher},
snapshot::InstanceSnapshot,
vfs::{Vfs, VfsEntry, VfsFetcher},
};
use super::{
@@ -16,10 +16,10 @@ use super::{
pub struct SnapshotRbxm;
impl SnapshotMiddleware for SnapshotRbxm {
fn from_imfs<F: ImfsFetcher>(
fn from_vfs<F: VfsFetcher>(
_context: &mut InstanceSnapshotContext,
imfs: &mut Imfs<F>,
entry: &ImfsEntry,
vfs: &mut Vfs<F>,
entry: &VfsEntry,
) -> SnapshotInstanceResult<'static> {
if entry.is_directory() {
return Ok(None);
@@ -37,7 +37,7 @@ impl SnapshotMiddleware for SnapshotRbxm {
});
let root_id = temp_tree.get_root_id();
rbx_binary::decode(&mut temp_tree, root_id, entry.contents(imfs)?)
rbx_binary::decode(&mut temp_tree, root_id, entry.contents(vfs)?)
.expect("TODO: Handle rbx_binary errors");
let root_instance = temp_tree.get_instance(root_id).unwrap();
@@ -60,18 +60,18 @@ impl SnapshotMiddleware for SnapshotRbxm {
mod test {
use super::*;
use crate::imfs::{ImfsDebug, ImfsSnapshot, NoopFetcher};
use crate::vfs::{NoopFetcher, VfsDebug, VfsSnapshot};
#[test]
fn model_from_imfs() {
let mut imfs = Imfs::new(NoopFetcher);
let file = ImfsSnapshot::file(include_bytes!("../../assets/test-folder.rbxm").to_vec());
fn model_from_vfs() {
let mut vfs = Vfs::new(NoopFetcher);
let file = VfsSnapshot::file(include_bytes!("../../assets/test-folder.rbxm").to_vec());
imfs.debug_load_snapshot("/foo.rbxm", file);
vfs.debug_load_snapshot("/foo.rbxm", file);
let entry = imfs.get("/foo.rbxm").unwrap();
let entry = vfs.get("/foo.rbxm").unwrap();
let instance_snapshot =
SnapshotRbxm::from_imfs(&mut InstanceSnapshotContext::default(), &mut imfs, &entry)
SnapshotRbxm::from_vfs(&mut InstanceSnapshotContext::default(), &mut vfs, &entry)
.unwrap()
.unwrap();

24
src/snapshot_middleware/rbxmx.rs
View File

@@ -1,8 +1,8 @@
use std::borrow::Cow;
use crate::{
imfs::{Imfs, ImfsEntry, ImfsFetcher},
snapshot::InstanceSnapshot,
vfs::{Vfs, VfsEntry, VfsFetcher},
};
use super::{
@@ -14,10 +14,10 @@ use super::{
pub struct SnapshotRbxmx;
impl SnapshotMiddleware for SnapshotRbxmx {
fn from_imfs<F: ImfsFetcher>(
fn from_vfs<F: VfsFetcher>(
_context: &mut InstanceSnapshotContext,
imfs: &mut Imfs<F>,
entry: &ImfsEntry,
vfs: &mut Vfs<F>,
entry: &VfsEntry,
) -> SnapshotInstanceResult<'static> {
if entry.is_directory() {
return Ok(None);
@@ -31,7 +31,7 @@ impl SnapshotMiddleware for SnapshotRbxmx {
let options = rbx_xml::DecodeOptions::new()
.property_behavior(rbx_xml::DecodePropertyBehavior::ReadUnknown);
let temp_tree = rbx_xml::from_reader(entry.contents(imfs)?, options)
let temp_tree = rbx_xml::from_reader(entry.contents(vfs)?, options)
.expect("TODO: Handle rbx_xml errors");
let root_instance = temp_tree.get_instance(temp_tree.get_root_id()).unwrap();
@@ -56,12 +56,12 @@ mod test {
use std::collections::HashMap;
use crate::imfs::{ImfsDebug, ImfsSnapshot, NoopFetcher};
use crate::vfs::{NoopFetcher, VfsDebug, VfsSnapshot};
#[test]
fn model_from_imfs() {
let mut imfs = Imfs::new(NoopFetcher);
let file = ImfsSnapshot::file(
fn model_from_vfs() {
let mut vfs = Vfs::new(NoopFetcher);
let file = VfsSnapshot::file(
r#"
<roblox version="4">
<Item class="Folder" referent="0">
@@ -73,11 +73,11 @@ mod test {
"#,
);
imfs.debug_load_snapshot("/foo.rbxmx", file);
vfs.debug_load_snapshot("/foo.rbxmx", file);
let entry = imfs.get("/foo.rbxmx").unwrap();
let entry = vfs.get("/foo.rbxmx").unwrap();
let instance_snapshot =
SnapshotRbxmx::from_imfs(&mut InstanceSnapshotContext::default(), &mut imfs, &entry)
SnapshotRbxmx::from_vfs(&mut InstanceSnapshotContext::default(), &mut vfs, &entry)
.unwrap()
.unwrap();

0
src/snapshot_middleware/snapshots/test__client_from_imfs.snap → src/snapshot_middleware/snapshots/test__client_from_vfs.snap
View File

0
src/snapshot_middleware/snapshots/test__csv_from_imfs.snap → src/snapshot_middleware/snapshots/test__csv_from_vfs.snap
View File

0
src/snapshot_middleware/snapshots/test__instance_from_imfs.snap → src/snapshot_middleware/snapshots/test__instance_from_vfs.snap
View File

0
src/snapshot_middleware/snapshots/test__model_from_imfs.snap → src/snapshot_middleware/snapshots/test__model_from_vfs.snap
View File

0
src/snapshot_middleware/snapshots/test__module_from_imfs.snap → src/snapshot_middleware/snapshots/test__module_from_vfs.snap
View File

0
src/snapshot_middleware/snapshots/test__server_from_imfs.snap → src/snapshot_middleware/snapshots/test__server_from_vfs.snap
View File

32
src/snapshot_middleware/txt.rs
View File

@@ -4,8 +4,8 @@ use maplit::hashmap;
use rbx_dom_weak::{RbxId, RbxTree, RbxValue};
use crate::{
imfs::{FileSnapshot, FsResultExt, Imfs, ImfsEntry, ImfsFetcher, ImfsSnapshot},
snapshot::{InstanceMetadata, InstanceSnapshot},
vfs::{FileSnapshot, FsResultExt, Vfs, VfsEntry, VfsFetcher, VfsSnapshot},
};
use super::{
@@ -19,10 +19,10 @@ use super::{
pub struct SnapshotTxt;
impl SnapshotMiddleware for SnapshotTxt {
fn from_imfs<F: ImfsFetcher>(
fn from_vfs<F: VfsFetcher>(
_context: &mut InstanceSnapshotContext,
imfs: &mut Imfs<F>,
entry: &ImfsEntry,
vfs: &mut Vfs<F>,
entry: &VfsEntry,
) -> SnapshotInstanceResult<'static> {
if entry.is_directory() {
return Ok(None);
@@ -33,7 +33,7 @@ impl SnapshotMiddleware for SnapshotTxt {
None => return Ok(None),
};
let contents = entry.contents(imfs)?;
let contents = entry.contents(vfs)?;
let contents_str = str::from_utf8(contents)
.map_err(|err| SnapshotError::file_contents_bad_unicode(err, entry.path()))?
.to_string();
@@ -61,8 +61,8 @@ impl SnapshotMiddleware for SnapshotTxt {
children: Vec::new(),
};
if let Some(meta_entry) = imfs.get(meta_path).with_not_found()? {
let meta_contents = meta_entry.contents(imfs)?;
if let Some(meta_entry) = vfs.get(meta_path).with_not_found()? {
let meta_contents = meta_entry.contents(vfs)?;
let mut metadata = AdjacentMetadata::from_slice(meta_contents);
metadata.apply_all(&mut snapshot);
}
@@ -87,7 +87,7 @@ impl SnapshotMiddleware for SnapshotTxt {
None => String::new(),
};
let snapshot = ImfsSnapshot::File(FileSnapshot {
let snapshot = VfsSnapshot::File(FileSnapshot {
contents: value.into_bytes(),
});
@@ -106,18 +106,18 @@ mod test {
use maplit::hashmap;
use rbx_dom_weak::RbxInstanceProperties;
use crate::imfs::{ImfsDebug, NoopFetcher};
use crate::vfs::{NoopFetcher, VfsDebug};
#[test]
fn instance_from_imfs() {
let mut imfs = Imfs::new(NoopFetcher);
let file = ImfsSnapshot::file("Hello there!");
fn instance_from_vfs() {
let mut vfs = Vfs::new(NoopFetcher);
let file = VfsSnapshot::file("Hello there!");
imfs.debug_load_snapshot("/foo.txt", file);
vfs.debug_load_snapshot("/foo.txt", file);
let entry = imfs.get("/foo.txt").unwrap();
let entry = vfs.get("/foo.txt").unwrap();
let instance_snapshot =
SnapshotTxt::from_imfs(&mut InstanceSnapshotContext::default(), &mut imfs, &entry)
SnapshotTxt::from_vfs(&mut InstanceSnapshotContext::default(), &mut vfs, &entry)
.unwrap()
.unwrap();
@@ -125,7 +125,7 @@ mod test {
}
#[test]
fn imfs_from_instance() {
fn vfs_from_instance() {
let tree = RbxTree::new(string_value("Root", "Hello, world!"));
let root_id = tree.get_root_id();

12
src/snapshot_middleware/user_plugins.rs
View File

@@ -2,7 +2,7 @@ use std::{fs, path::Path};
use rlua::{Lua, RegistryKey};
use crate::imfs::{Imfs, ImfsEntry, ImfsFetcher};
use crate::vfs::{Vfs, VfsEntry, VfsFetcher};
use super::{
context::InstanceSnapshotContext,
@@ -19,10 +19,10 @@ use super::{
pub struct SnapshotUserPlugins;
impl SnapshotMiddleware for SnapshotUserPlugins {
fn from_imfs<F: ImfsFetcher>(
fn from_vfs<F: VfsFetcher>(
context: &mut InstanceSnapshotContext,
_imfs: &mut Imfs<F>,
_entry: &ImfsEntry,
_vfs: &mut Vfs<F>,
_entry: &VfsEntry,
) -> SnapshotInstanceResult<'static> {
// User plugins are only enabled if present on the snapshot context.
let plugin_context = match &mut context.plugin_context {
@@ -52,7 +52,7 @@ impl SnapshotMiddleware for SnapshotUserPlugins {
// The current plan for plugins here is to make them work
// like Redux/Rodux middleware. A plugin will be a function
// that accepts the next middleware in the chain as a
// function and the snapshot subject (the IMFS entry).
// function and the snapshot subject (the VFS entry).
//
// Plugins can (but don't have to) invoke the next snapshot
// function and may or may not mutate the result. The hope
@@ -69,7 +69,7 @@ impl SnapshotMiddleware for SnapshotUserPlugins {
// * Will plugins hurt Rojo's ability to parallelize
// snapshotting in the future?
//
// * Do the mutable handles to the Imfs and the snapshot
// * Do the mutable handles to the Vfs and the snapshot
// context prevent plugins from invoking other plugins
// indirectly?
//

0
src/imfs/error.rs → src/vfs/error.rs
View File

2
src/imfs/event.rs → src/vfs/event.rs
View File

@@ -1,7 +1,7 @@
use std::path::PathBuf;
#[derive(Debug)]
pub enum ImfsEvent {
pub enum VfsEvent {
Modified(PathBuf),
Created(PathBuf),
Removed(PathBuf),

8
src/imfs/fetcher.rs → src/vfs/fetcher.rs
View File

@@ -5,7 +5,7 @@ use std::{
use crossbeam_channel::Receiver;
use super::event::ImfsEvent;
use super::event::VfsEvent;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum FileType {
@@ -13,10 +13,10 @@ pub enum FileType {
Directory,
}
/// The generic interface that `Imfs` uses to lazily read files from the disk.
/// The generic interface that `Vfs` uses to lazily read files from the disk.
/// In tests, it's stubbed out to do different versions of absolutely nothing
/// depending on the test.
pub trait ImfsFetcher {
pub trait VfsFetcher {
fn file_type(&mut self, path: &Path) -> io::Result<FileType>;
fn read_children(&mut self, path: &Path) -> io::Result<Vec<PathBuf>>;
fn read_contents(&mut self, path: &Path) -> io::Result<Vec<u8>>;
@@ -27,7 +27,7 @@ pub trait ImfsFetcher {
fn watch(&mut self, path: &Path);
fn unwatch(&mut self, path: &Path);
fn receiver(&self) -> Receiver<ImfsEvent>;
fn receiver(&self) -> Receiver<VfsEvent>;
/// A method intended for debugging what paths the fetcher is watching.
fn watched_paths(&self) -> Vec<&Path> {

4
src/imfs/mod.rs → src/vfs/mod.rs
View File

@@ -1,18 +1,18 @@
mod error;
mod event;
mod fetcher;
mod imfs;
mod noop_fetcher;
mod real_fetcher;
mod snapshot;
mod vfs;
pub use error::*;
pub use event::*;
pub use fetcher::*;
pub use imfs::*;
pub use noop_fetcher::*;
pub use real_fetcher::*;
pub use snapshot::*;
pub use vfs::*;
#[cfg(test)]
mod test_fetcher;

10
src/imfs/noop_fetcher.rs → src/vfs/noop_fetcher.rs
View File

@@ -1,4 +1,4 @@
//! Implements the IMFS fetcher interface for a fake filesystem using Rust's
//! Implements the VFS fetcher interface for a fake filesystem using Rust's
//! std::fs interface.
// This interface is only used for testing, so it's okay if it isn't used.
@@ -12,13 +12,13 @@ use std::{
use crossbeam_channel::Receiver;
use super::{
event::ImfsEvent,
fetcher::{FileType, ImfsFetcher},
event::VfsEvent,
fetcher::{FileType, VfsFetcher},
};
pub struct NoopFetcher;
impl ImfsFetcher for NoopFetcher {
impl VfsFetcher for NoopFetcher {
fn file_type(&mut self, _path: &Path) -> io::Result<FileType> {
Err(io::Error::new(
io::ErrorKind::NotFound,
@@ -56,7 +56,7 @@ impl ImfsFetcher for NoopFetcher {
fn unwatch(&mut self, _path: &Path) {}
fn receiver(&self) -> Receiver<ImfsEvent> {
fn receiver(&self) -> Receiver<VfsEvent> {
crossbeam_channel::never()
}
}

24
src/imfs/real_fetcher.rs → src/vfs/real_fetcher.rs
View File

@@ -1,4 +1,4 @@
//! Implements the IMFS fetcher interface for the real filesystem using Rust's
//! Implements the VFS fetcher interface for the real filesystem using Rust's
//! std::fs interface and notify as the file watcher.
use std::{
@@ -14,8 +14,8 @@ use jod_thread::JoinHandle;
use notify::{DebouncedEvent, RecommendedWatcher, RecursiveMode, Watcher};
use super::{
event::ImfsEvent,
fetcher::{FileType, ImfsFetcher},
event::VfsEvent,
fetcher::{FileType, VfsFetcher},
};
/// Workaround to disable the file watcher for processes that don't need it,
@@ -41,7 +41,7 @@ pub struct RealFetcher {
_converter_thread: JoinHandle<()>,
/// The crossbeam receiver filled with events from the converter thread.
receiver: Receiver<ImfsEvent>,
receiver: Receiver<VfsEvent>,
/// All of the paths that the fetcher is watching, tracked here because
/// notify does not expose this information.
@@ -84,19 +84,19 @@ impl RealFetcher {
}
}
fn converter_thread(notify_receiver: mpsc::Receiver<DebouncedEvent>, sender: Sender<ImfsEvent>) {
fn converter_thread(notify_receiver: mpsc::Receiver<DebouncedEvent>, sender: Sender<VfsEvent>) {
use DebouncedEvent::*;
for event in notify_receiver {
log::trace!("Notify event: {:?}", event);
match event {
Create(path) => sender.send(ImfsEvent::Created(path)).unwrap(),
Write(path) => sender.send(ImfsEvent::Modified(path)).unwrap(),
Remove(path) => sender.send(ImfsEvent::Removed(path)).unwrap(),
Create(path) => sender.send(VfsEvent::Created(path)).unwrap(),
Write(path) => sender.send(VfsEvent::Modified(path)).unwrap(),
Remove(path) => sender.send(VfsEvent::Removed(path)).unwrap(),
Rename(from_path, to_path) => {
sender.send(ImfsEvent::Created(from_path)).unwrap();
sender.send(ImfsEvent::Removed(to_path)).unwrap();
sender.send(VfsEvent::Created(from_path)).unwrap();
sender.send(VfsEvent::Removed(to_path)).unwrap();
}
Rescan => {
log::warn!("Unhandled filesystem rescan event.");
@@ -121,7 +121,7 @@ fn converter_thread(notify_receiver: mpsc::Receiver<DebouncedEvent>, sender: Sen
}
}
impl ImfsFetcher for RealFetcher {
impl VfsFetcher for RealFetcher {
fn file_type(&mut self, path: &Path) -> io::Result<FileType> {
let metadata = fs::metadata(path)?;
@@ -206,7 +206,7 @@ impl ImfsFetcher for RealFetcher {
}
}
fn receiver(&self) -> Receiver<ImfsEvent> {
fn receiver(&self) -> Receiver<VfsEvent> {
self.receiver.clone()
}

42
src/vfs/snapshot.rs Normal file
View File

@@ -0,0 +1,42 @@
// This file is non-critical and used for testing, so it's okay if it's unused.
#![allow(unused)]
use std::collections::HashMap;
#[derive(Debug, Clone)]
pub enum VfsSnapshot {
File(FileSnapshot),
Directory(DirectorySnapshot),
}
impl VfsSnapshot {
/// Create a new file VfsSnapshot with the given contents.
pub fn file(contents: impl Into<Vec<u8>>) -> VfsSnapshot {
VfsSnapshot::File(FileSnapshot {
contents: contents.into(),
})
}
/// Create a new directory VfsSnapshot with the given children.
pub fn dir<S: Into<String>>(children: HashMap<S, VfsSnapshot>) -> VfsSnapshot {
let children = children.into_iter().map(|(k, v)| (k.into(), v)).collect();
VfsSnapshot::Directory(DirectorySnapshot { children })
}
pub fn empty_dir() -> VfsSnapshot {
VfsSnapshot::Directory(DirectorySnapshot {
children: Default::default(),
})
}
}
#[derive(Debug, Clone)]
pub struct FileSnapshot {
pub contents: Vec<u8>,
}
#[derive(Debug, Clone)]
pub struct DirectorySnapshot {
pub children: HashMap<String, VfsSnapshot>,
}

32
src/imfs/test_fetcher.rs → src/vfs/test_fetcher.rs
View File

@@ -1,7 +1,7 @@
//! Implements the IMFS fetcher interface for a fake filesystem that can be
//! Implements the VFS fetcher interface for a fake filesystem that can be
//! mutated and have changes signaled through it.
//!
//! This is useful for testing how things using Imfs react to changed events
//! This is useful for testing how things using Vfs react to changed events
//! without relying on the real filesystem implementation, which is very
//! platform-specific.
@@ -19,9 +19,9 @@ use crossbeam_channel::{unbounded, Receiver, Sender};
use crate::path_map::PathMap;
use super::{
event::ImfsEvent,
fetcher::{FileType, ImfsFetcher},
snapshot::ImfsSnapshot,
event::VfsEvent,
fetcher::{FileType, VfsFetcher},
snapshot::VfsSnapshot,
};
#[derive(Clone)]
@@ -30,7 +30,7 @@ pub struct TestFetcherState {
}
impl TestFetcherState {
pub fn load_snapshot<P: AsRef<Path>>(&self, path: P, snapshot: ImfsSnapshot) {
pub fn load_snapshot<P: AsRef<Path>>(&self, path: P, snapshot: VfsSnapshot) {
let mut inner = self.inner.lock().unwrap();
inner.load_snapshot(path.as_ref().to_path_buf(), snapshot);
}
@@ -40,7 +40,7 @@ impl TestFetcherState {
inner.remove(path.as_ref());
}
pub fn raise_event(&self, event: ImfsEvent) {
pub fn raise_event(&self, event: VfsEvent) {
let mut inner = self.inner.lock().unwrap();
inner.raise_event(event);
}
@@ -53,24 +53,24 @@ pub enum TestFetcherEntry {
struct TestFetcherStateInner {
entries: PathMap<TestFetcherEntry>,
sender: Sender<ImfsEvent>,
sender: Sender<VfsEvent>,
}
impl TestFetcherStateInner {
fn new(sender: Sender<ImfsEvent>) -> Self {
fn new(sender: Sender<VfsEvent>) -> Self {
let mut entries = PathMap::new();
entries.insert(Path::new("/"), TestFetcherEntry::Dir);
Self { sender, entries }
}
fn load_snapshot(&mut self, path: PathBuf, snapshot: ImfsSnapshot) {
fn load_snapshot(&mut self, path: PathBuf, snapshot: VfsSnapshot) {
match snapshot {
ImfsSnapshot::File(file) => {
VfsSnapshot::File(file) => {
self.entries
.insert(path, TestFetcherEntry::File(file.contents));
}
ImfsSnapshot::Directory(directory) => {
VfsSnapshot::Directory(directory) => {
self.entries.insert(path.clone(), TestFetcherEntry::Dir);
for (child_name, child) in directory.children.into_iter() {
@@ -84,14 +84,14 @@ impl TestFetcherStateInner {
self.entries.remove(path);
}
fn raise_event(&mut self, event: ImfsEvent) {
fn raise_event(&mut self, event: VfsEvent) {
self.sender.send(event).unwrap();
}
}
pub struct TestFetcher {
state: TestFetcherState,
receiver: Receiver<ImfsEvent>,
receiver: Receiver<VfsEvent>,
}
impl TestFetcher {
@@ -106,7 +106,7 @@ impl TestFetcher {
}
}
impl ImfsFetcher for TestFetcher {
impl VfsFetcher for TestFetcher {
fn file_type(&mut self, path: &Path) -> io::Result<FileType> {
let inner = self.state.inner.lock().unwrap();
@@ -169,7 +169,7 @@ impl ImfsFetcher for TestFetcher {
fn unwatch(&mut self, _path: &Path) {}
fn receiver(&self) -> Receiver<ImfsEvent> {
fn receiver(&self) -> Receiver<VfsEvent> {
self.receiver.clone()
}
}

203
src/imfs/imfs.rs → src/vfs/vfs.rs
View File

@@ -9,48 +9,48 @@ use crate::path_map::PathMap;
use super::{
error::{FsError, FsResult},
event::ImfsEvent,
fetcher::{FileType, ImfsFetcher},
snapshot::ImfsSnapshot,
event::VfsEvent,
fetcher::{FileType, VfsFetcher},
snapshot::VfsSnapshot,
};
/// An in-memory filesystem that can be incrementally populated and updated as
/// filesystem modification events occur.
///
/// All operations on the `Imfs` are lazy and do I/O as late as they can to
/// All operations on the `Vfs` are lazy and do I/O as late as they can to
/// avoid reading extraneous files or directories from the disk. This means that
/// they all take `self` mutably, and means that it isn't possible to hold
/// references to the internal state of the Imfs while traversing it!
/// references to the internal state of the Vfs while traversing it!
///
/// Most operations return `ImfsEntry` objects to work around this, which is
/// effectively a index into the `Imfs`.
pub struct Imfs<F> {
/// Most operations return `VfsEntry` objects to work around this, which is
/// effectively a index into the `Vfs`.
pub struct Vfs<F> {
/// A hierarchical map from paths to items that have been read or partially
/// read into memory by the Imfs.
inner: PathMap<ImfsItem>,
/// read into memory by the Vfs.
inner: PathMap<VfsItem>,
/// This Imfs's fetcher, which is used for all actual interactions with the
/// This Vfs's fetcher, which is used for all actual interactions with the
/// filesystem. It's referred to by the type parameter `F` all over, and is
/// generic in order to make it feasible to mock.
fetcher: F,
}
impl<F: ImfsFetcher> Imfs<F> {
pub fn new(fetcher: F) -> Imfs<F> {
Imfs {
impl<F: VfsFetcher> Vfs<F> {
pub fn new(fetcher: F) -> Vfs<F> {
Vfs {
inner: PathMap::new(),
fetcher,
}
}
pub fn change_receiver(&self) -> Receiver<ImfsEvent> {
pub fn change_receiver(&self) -> Receiver<VfsEvent> {
self.fetcher.receiver()
}
pub fn commit_change(&mut self, event: &ImfsEvent) -> FsResult<()> {
use ImfsEvent::*;
pub fn commit_change(&mut self, event: &VfsEvent) -> FsResult<()> {
use VfsEvent::*;
log::trace!("Committing Imfs change {:?}", event);
log::trace!("Committing Vfs change {:?}", event);
match event {
Created(path) | Modified(path) => {
@@ -79,28 +79,28 @@ impl<F: ImfsFetcher> Imfs<F> {
match self.inner.get_mut(path) {
Some(existing_item) => {
match (existing_item, &new_type) {
(ImfsItem::File(existing_file), FileType::File) => {
(VfsItem::File(existing_file), FileType::File) => {
// Invalidate the existing file contents.
// We can probably be smarter about this by reading the changed file.
existing_file.contents = None;
}
(ImfsItem::Directory(_), FileType::Directory) => {
(VfsItem::Directory(_), FileType::Directory) => {
// No changes required, a directory updating doesn't mean anything to us.
self.fetcher.watch(path);
}
(ImfsItem::File(_), FileType::Directory) => {
(VfsItem::File(_), FileType::Directory) => {
self.inner.remove(path);
self.inner.insert(
path.to_path_buf(),
ImfsItem::new_from_type(FileType::Directory, path),
VfsItem::new_from_type(FileType::Directory, path),
);
self.fetcher.watch(path);
}
(ImfsItem::Directory(_), FileType::File) => {
(VfsItem::Directory(_), FileType::File) => {
self.inner.remove(path);
self.inner.insert(
path.to_path_buf(),
ImfsItem::new_from_type(FileType::File, path),
VfsItem::new_from_type(FileType::File, path),
);
self.fetcher.unwatch(path);
}
@@ -108,7 +108,7 @@ impl<F: ImfsFetcher> Imfs<F> {
}
None => {
self.inner
.insert(path.to_path_buf(), ImfsItem::new_from_type(new_type, path));
.insert(path.to_path_buf(), VfsItem::new_from_type(new_type, path));
}
}
@@ -127,17 +127,17 @@ impl<F: ImfsFetcher> Imfs<F> {
Ok(())
}
pub fn get(&mut self, path: impl AsRef<Path>) -> FsResult<ImfsEntry> {
pub fn get(&mut self, path: impl AsRef<Path>) -> FsResult<VfsEntry> {
self.read_if_not_exists(path.as_ref())?;
let item = self.inner.get(path.as_ref()).unwrap();
let is_file = match item {
ImfsItem::File(_) => true,
ImfsItem::Directory(_) => false,
VfsItem::File(_) => true,
VfsItem::Directory(_) => false,
};
Ok(ImfsEntry {
Ok(VfsEntry {
path: item.path().to_path_buf(),
is_file,
})
@@ -149,7 +149,7 @@ impl<F: ImfsFetcher> Imfs<F> {
self.read_if_not_exists(path)?;
match self.inner.get_mut(path).unwrap() {
ImfsItem::File(file) => {
VfsItem::File(file) => {
if file.contents.is_none() {
file.contents = Some(
self.fetcher
@@ -160,20 +160,20 @@ impl<F: ImfsFetcher> Imfs<F> {
Ok(file.contents.as_ref().unwrap())
}
ImfsItem::Directory(_) => Err(FsError::new(
VfsItem::Directory(_) => Err(FsError::new(
io::Error::new(io::ErrorKind::Other, "Can't read a directory"),
path.to_path_buf(),
)),
}
}
pub fn get_children(&mut self, path: impl AsRef<Path>) -> FsResult<Vec<ImfsEntry>> {
pub fn get_children(&mut self, path: impl AsRef<Path>) -> FsResult<Vec<VfsEntry>> {
let path = path.as_ref();
self.read_if_not_exists(path)?;
match self.inner.get_mut(path).unwrap() {
ImfsItem::Directory(dir) => {
VfsItem::Directory(dir) => {
self.fetcher.watch(path);
let enumerated = dir.children_enumerated;
@@ -187,7 +187,7 @@ impl<F: ImfsFetcher> Imfs<F> {
.collect::<Vec<PathBuf>>() // Collect all PathBufs, since self.get needs to borrow self mutably.
.into_iter()
.map(|path| self.get(path))
.collect::<FsResult<Vec<ImfsEntry>>>()
.collect::<FsResult<Vec<VfsEntry>>>()
} else {
dir.children_enumerated = true;
@@ -196,10 +196,10 @@ impl<F: ImfsFetcher> Imfs<F> {
.map_err(|err| FsError::new(err, path.to_path_buf()))?
.into_iter()
.map(|path| self.get(path))
.collect::<FsResult<Vec<ImfsEntry>>>()
.collect::<FsResult<Vec<VfsEntry>>>()
}
}
ImfsItem::File(_) => Err(FsError::new(
VfsItem::File(_) => Err(FsError::new(
io::Error::new(io::ErrorKind::Other, "Can't read a directory"),
path.to_path_buf(),
)),
@@ -222,7 +222,7 @@ impl<F: ImfsFetcher> Imfs<F> {
}
if let Some(parent) = path.parent() {
if let Some(ImfsItem::Directory(dir)) = self.inner.get(parent) {
if let Some(VfsItem::Directory(dir)) = self.inner.get(parent) {
return !dir.children_enumerated;
}
}
@@ -230,10 +230,10 @@ impl<F: ImfsFetcher> Imfs<F> {
false
}
/// Attempts to read the path into the `Imfs` if it doesn't exist.
/// Attempts to read the path into the `Vfs` if it doesn't exist.
///
/// This does not necessitate that file contents or directory children will
/// be read. Depending on the `ImfsFetcher` implementation that the `Imfs`
/// be read. Depending on the `VfsFetcher` implementation that the `Vfs`
/// is using, this call may read exactly only the given path and no more.
fn read_if_not_exists(&mut self, path: &Path) -> FsResult<()> {
if !self.inner.contains_key(path) {
@@ -247,7 +247,7 @@ impl<F: ImfsFetcher> Imfs<F> {
}
self.inner
.insert(path.to_path_buf(), ImfsItem::new_from_type(kind, path));
.insert(path.to_path_buf(), VfsItem::new_from_type(kind, path));
}
Ok(())
@@ -256,8 +256,8 @@ impl<F: ImfsFetcher> Imfs<F> {
/// Contains extra methods that should only be used for debugging. They're
/// broken out into a separate trait to make it more explicit to depend on them.
pub trait ImfsDebug {
fn debug_load_snapshot<P: AsRef<Path>>(&mut self, path: P, snapshot: ImfsSnapshot);
pub trait VfsDebug {
fn debug_load_snapshot<P: AsRef<Path>>(&mut self, path: P, snapshot: VfsSnapshot);
fn debug_is_file(&self, path: &Path) -> bool;
fn debug_contents<'a>(&'a self, path: &Path) -> Option<&'a [u8]>;
fn debug_children<'a>(&'a self, path: &Path) -> Option<(bool, Vec<&'a Path>)>;
@@ -265,24 +265,24 @@ pub trait ImfsDebug {
fn debug_watched_paths(&self) -> Vec<&Path>;
}
impl<F: ImfsFetcher> ImfsDebug for Imfs<F> {
fn debug_load_snapshot<P: AsRef<Path>>(&mut self, path: P, snapshot: ImfsSnapshot) {
impl<F: VfsFetcher> VfsDebug for Vfs<F> {
fn debug_load_snapshot<P: AsRef<Path>>(&mut self, path: P, snapshot: VfsSnapshot) {
let path = path.as_ref();
match snapshot {
ImfsSnapshot::File(file) => {
VfsSnapshot::File(file) => {
self.inner.insert(
path.to_path_buf(),
ImfsItem::File(ImfsFile {
VfsItem::File(VfsFile {
path: path.to_path_buf(),
contents: Some(file.contents),
}),
);
}
ImfsSnapshot::Directory(directory) => {
VfsSnapshot::Directory(directory) => {
self.inner.insert(
path.to_path_buf(),
ImfsItem::Directory(ImfsDirectory {
VfsItem::Directory(VfsDirectory {
path: path.to_path_buf(),
children_enumerated: true,
}),
@@ -297,21 +297,21 @@ impl<F: ImfsFetcher> ImfsDebug for Imfs<F> {
fn debug_is_file(&self, path: &Path) -> bool {
match self.inner.get(path) {
Some(ImfsItem::File(_)) => true,
Some(VfsItem::File(_)) => true,
_ => false,
}
}
fn debug_contents<'a>(&'a self, path: &Path) -> Option<&'a [u8]> {
match self.inner.get(path) {
Some(ImfsItem::File(file)) => file.contents.as_ref().map(|vec| vec.as_slice()),
Some(VfsItem::File(file)) => file.contents.as_ref().map(|vec| vec.as_slice()),
_ => None,
}
}
fn debug_children<'a>(&'a self, path: &Path) -> Option<(bool, Vec<&'a Path>)> {
match self.inner.get(path) {
Some(ImfsItem::Directory(dir)) => {
Some(VfsItem::Directory(dir)) => {
Some((dir.children_enumerated, self.inner.children(path).unwrap()))
}
_ => None,
@@ -327,31 +327,28 @@ impl<F: ImfsFetcher> ImfsDebug for Imfs<F> {
}
}
/// A reference to file or folder in an `Imfs`. Can only be produced by the
/// entry existing in the Imfs, but can later point to nothing if something
/// A reference to file or folder in an `Vfs`. Can only be produced by the
/// entry existing in the Vfs, but can later point to nothing if something
/// would invalidate that path.
///
/// This struct does not borrow from the Imfs since every operation has the
/// This struct does not borrow from the Vfs since every operation has the
/// possibility to mutate the underlying data structure and move memory around.
pub struct ImfsEntry {
pub struct VfsEntry {
path: PathBuf,
is_file: bool,
}
impl ImfsEntry {
impl VfsEntry {
pub fn path(&self) -> &Path {
&self.path
}
pub fn contents<'imfs>(
&self,
imfs: &'imfs mut Imfs<impl ImfsFetcher>,
) -> FsResult<&'imfs [u8]> {
imfs.get_contents(&self.path)
pub fn contents<'vfs>(&self, vfs: &'vfs mut Vfs<impl VfsFetcher>) -> FsResult<&'vfs [u8]> {
vfs.get_contents(&self.path)
}
pub fn children(&self, imfs: &mut Imfs<impl ImfsFetcher>) -> FsResult<Vec<ImfsEntry>> {
imfs.get_children(&self.path)
pub fn children(&self, vfs: &mut Vfs<impl VfsFetcher>) -> FsResult<Vec<VfsEntry>> {
vfs.get_children(&self.path)
}
pub fn is_file(&self) -> bool {
@@ -364,27 +361,27 @@ impl ImfsEntry {
}
/// Internal structure describing potentially partially-resident files and
/// folders in the `Imfs`.
pub enum ImfsItem {
File(ImfsFile),
Directory(ImfsDirectory),
/// folders in the `Vfs`.
pub enum VfsItem {
File(VfsFile),
Directory(VfsDirectory),
}
impl ImfsItem {
impl VfsItem {
fn path(&self) -> &Path {
match self {
ImfsItem::File(file) => &file.path,
ImfsItem::Directory(dir) => &dir.path,
VfsItem::File(file) => &file.path,
VfsItem::Directory(dir) => &dir.path,
}
}
fn new_from_type(kind: FileType, path: impl Into<PathBuf>) -> ImfsItem {
fn new_from_type(kind: FileType, path: impl Into<PathBuf>) -> VfsItem {
match kind {
FileType::Directory => ImfsItem::Directory(ImfsDirectory {
FileType::Directory => VfsItem::Directory(VfsDirectory {
path: path.into(),
children_enumerated: false,
}),
FileType::File => ImfsItem::File(ImfsFile {
FileType::File => VfsItem::File(VfsFile {
path: path.into(),
contents: None,
}),
@@ -392,12 +389,12 @@ impl ImfsItem {
}
}
pub struct ImfsFile {
pub struct VfsFile {
pub(super) path: PathBuf,
pub(super) contents: Option<Vec<u8>>,
}
pub struct ImfsDirectory {
pub struct VfsDirectory {
pub(super) path: PathBuf,
pub(super) children_enumerated: bool,
}
@@ -411,30 +408,30 @@ mod test {
use crossbeam_channel::Receiver;
use maplit::hashmap;
use super::super::{error::FsErrorKind, event::ImfsEvent, noop_fetcher::NoopFetcher};
use super::super::{error::FsErrorKind, event::VfsEvent, noop_fetcher::NoopFetcher};
#[test]
fn from_snapshot_file() {
let mut imfs = Imfs::new(NoopFetcher);
let file = ImfsSnapshot::file("hello, world!");
let mut vfs = Vfs::new(NoopFetcher);
let file = VfsSnapshot::file("hello, world!");
imfs.debug_load_snapshot("/hello.txt", file);
vfs.debug_load_snapshot("/hello.txt", file);
let entry = imfs.get_contents("/hello.txt").unwrap();
let entry = vfs.get_contents("/hello.txt").unwrap();
assert_eq!(entry, b"hello, world!");
}
#[test]
fn from_snapshot_dir() {
let mut imfs = Imfs::new(NoopFetcher);
let dir = ImfsSnapshot::dir(hashmap! {
"a.txt" => ImfsSnapshot::file("contents of a.txt"),
"b.lua" => ImfsSnapshot::file("contents of b.lua"),
let mut vfs = Vfs::new(NoopFetcher);
let dir = VfsSnapshot::dir(hashmap! {
"a.txt" => VfsSnapshot::file("contents of a.txt"),
"b.lua" => VfsSnapshot::file("contents of b.lua"),
});
imfs.debug_load_snapshot("/dir", dir);
vfs.debug_load_snapshot("/dir", dir);
let children = imfs.get_children("/dir").unwrap();
let children = vfs.get_children("/dir").unwrap();
let mut has_a = false;
let mut has_b = false;
@@ -452,10 +449,10 @@ mod test {
assert!(has_a, "/dir/a.txt was missing");
assert!(has_b, "/dir/b.lua was missing");
let a = imfs.get_contents("/dir/a.txt").unwrap();
let a = vfs.get_contents("/dir/a.txt").unwrap();
assert_eq!(a, b"contents of a.txt");
let b = imfs.get_contents("/dir/b.lua").unwrap();
let b = vfs.get_contents("/dir/b.lua").unwrap();
assert_eq!(b, b"contents of b.lua");
}
@@ -470,7 +467,7 @@ mod test {
inner: Rc<RefCell<MockState>>,
}
impl ImfsFetcher for MockFetcher {
impl VfsFetcher for MockFetcher {
fn file_type(&mut self, path: &Path) -> io::Result<FileType> {
if path == Path::new("/dir/a.txt") {
return Ok(FileType::File);
@@ -509,7 +506,7 @@ mod test {
fn unwatch(&mut self, _path: &Path) {}
fn receiver(&self) -> Receiver<ImfsEvent> {
fn receiver(&self) -> Receiver<VfsEvent> {
crossbeam_channel::never()
}
}
@@ -518,13 +515,13 @@ mod test {
a_contents: "Initial contents",
}));
let mut imfs = Imfs::new(MockFetcher {
let mut vfs = Vfs::new(MockFetcher {
inner: mock_state.clone(),
});
let a = imfs.get("/dir/a.txt").expect("mock file did not exist");
let a = vfs.get("/dir/a.txt").expect("mock file did not exist");
let contents = a.contents(&mut imfs).expect("mock file contents error");
let contents = a.contents(&mut vfs).expect("mock file contents error");
assert_eq!(contents, b"Initial contents");
@@ -533,36 +530,36 @@ mod test {
mock_state.a_contents = "Changed contents";
}
imfs.raise_file_changed("/dir/a.txt")
vfs.raise_file_changed("/dir/a.txt")
.expect("error processing file change");
let contents = a.contents(&mut imfs).expect("mock file contents error");
let contents = a.contents(&mut vfs).expect("mock file contents error");
assert_eq!(contents, b"Changed contents");
}
#[test]
fn removed_event_existing() {
let mut imfs = Imfs::new(NoopFetcher);
let mut vfs = Vfs::new(NoopFetcher);
let file = ImfsSnapshot::file("hello, world!");
imfs.debug_load_snapshot("/hello.txt", file);
let file = VfsSnapshot::file("hello, world!");
vfs.debug_load_snapshot("/hello.txt", file);
let hello = imfs.get("/hello.txt").expect("couldn't get hello.txt");
let hello = vfs.get("/hello.txt").expect("couldn't get hello.txt");
let contents = hello
.contents(&mut imfs)
.contents(&mut vfs)
.expect("couldn't get hello.txt contents");
assert_eq!(contents, b"hello, world!");
imfs.raise_file_removed("/hello.txt")
vfs.raise_file_removed("/hello.txt")
.expect("error processing file removal");
match imfs.get("hello.txt") {
match vfs.get("hello.txt") {
Err(ref err) if err.kind() == FsErrorKind::NotFound => {}
Ok(_) => {
panic!("hello.txt was not removed from Imfs");
panic!("hello.txt was not removed from Vfs");
}
Err(err) => {
panic!("Unexpected error: {:?}", err);

6
src/web/api.rs
View File

@@ -9,8 +9,8 @@ use hyper::{service::Service, Body, Method, Request, StatusCode};
use rbx_dom_weak::RbxId;
use crate::{
imfs::ImfsFetcher,
serve_session::ServeSession,
vfs::VfsFetcher,
web::{
interface::{
ErrorResponse, Instance, InstanceMetadata as WebInstanceMetadata, InstanceUpdate,
@@ -25,7 +25,7 @@ pub struct ApiService<F> {
serve_session: Arc<ServeSession<F>>,
}
impl<F: ImfsFetcher> Service for ApiService<F> {
impl<F: VfsFetcher> Service for ApiService<F> {
type ReqBody = Body;
type ResBody = Body;
type Error = hyper::Error;
@@ -49,7 +49,7 @@ impl<F: ImfsFetcher> Service for ApiService<F> {
}
}
impl<F: ImfsFetcher> ApiService<F> {
impl<F: VfsFetcher> ApiService<F> {
pub fn new(serve_session: Arc<ServeSession<F>>) -> Self {
ApiService { serve_session }
}

8
src/web/mod.rs
View File

@@ -13,7 +13,7 @@ use futures::{
use hyper::{service::Service, Body, Request, Response, Server};
use log::trace;
use crate::{imfs::ImfsFetcher, serve_session::ServeSession};
use crate::{serve_session::ServeSession, vfs::VfsFetcher};
use self::{api::ApiService, ui::UiService};
@@ -22,7 +22,7 @@ pub struct RootService<F> {
ui: UiService<F>,
}
impl<F: ImfsFetcher> Service for RootService<F> {
impl<F: VfsFetcher> Service for RootService<F> {
type ReqBody = Body;
type ResBody = Body;
type Error = hyper::Error;
@@ -39,7 +39,7 @@ impl<F: ImfsFetcher> Service for RootService<F> {
}
}
impl<F: ImfsFetcher> RootService<F> {
impl<F: VfsFetcher> RootService<F> {
pub fn new(serve_session: Arc<ServeSession<F>>) -> Self {
RootService {
api: ApiService::new(Arc::clone(&serve_session)),
@@ -52,7 +52,7 @@ pub struct LiveServer<F> {
serve_session: Arc<ServeSession<F>>,
}
impl<F: ImfsFetcher + Send + Sync + 'static> LiveServer<F> {
impl<F: VfsFetcher + Send + Sync + 'static> LiveServer<F> {
pub fn new(serve_session: Arc<ServeSession<F>>) -> Self {
LiveServer { serve_session }
}

40
src/web/ui.rs
View File

@@ -9,9 +9,9 @@ use rbx_dom_weak::{RbxId, RbxValue};
use ritz::{html, Fragment, HtmlContent, HtmlSelfClosingTag};
use crate::{
imfs::{Imfs, ImfsDebug, ImfsFetcher},
serve_session::ServeSession,
snapshot::RojoTree,
vfs::{Vfs, VfsDebug, VfsFetcher},
web::{
assets,
interface::{ErrorResponse, SERVER_VERSION},
@@ -23,7 +23,7 @@ pub struct UiService<F> {
serve_session: Arc<ServeSession<F>>,
}
impl<F: ImfsFetcher> Service for UiService<F> {
impl<F: VfsFetcher> Service for UiService<F> {
type ReqBody = Body;
type ResBody = Body;
type Error = hyper::Error;
@@ -35,7 +35,7 @@ impl<F: ImfsFetcher> Service for UiService<F> {
(&Method::GET, "/logo.png") => self.handle_logo(),
(&Method::GET, "/icon.png") => self.handle_icon(),
(&Method::GET, "/show-instances") => self.handle_show_instances(),
(&Method::GET, "/show-imfs") => self.handle_show_imfs(),
(&Method::GET, "/show-vfs") => self.handle_show_vfs(),
(_method, path) => {
return json(
ErrorResponse::not_found(format!("Route not found: {}", path)),
@@ -48,7 +48,7 @@ impl<F: ImfsFetcher> Service for UiService<F> {
}
}
impl<F: ImfsFetcher> UiService<F> {
impl<F: VfsFetcher> UiService<F> {
pub fn new(serve_session: Arc<ServeSession<F>>) -> Self {
UiService { serve_session }
}
@@ -71,7 +71,7 @@ impl<F: ImfsFetcher> UiService<F> {
let page = self.normal_page(html! {
<div class="button-list">
{ Self::button("Rojo Documentation", "https://rojo.space/docs") }
{ Self::button("View in-memory filesystem state", "/show-imfs") }
{ Self::button("View in-memory filesystem state", "/show-vfs") }
{ Self::button("View instance tree state", "/show-instances") }
</div>
});
@@ -96,16 +96,16 @@ impl<F: ImfsFetcher> UiService<F> {
.unwrap()
}
fn handle_show_imfs(&self) -> Response<Body> {
let imfs = self.serve_session.imfs();
fn handle_show_vfs(&self) -> Response<Body> {
let vfs = self.serve_session.vfs();
let orphans: Vec<_> = imfs
let orphans: Vec<_> = vfs
.debug_orphans()
.into_iter()
.map(|path| Self::render_imfs_path(&imfs, path, true))
.map(|path| Self::render_vfs_path(&vfs, path, true))
.collect();
let watched_list: Vec<_> = imfs
let watched_list: Vec<_> = vfs
.debug_watched_paths()
.into_iter()
.map(|path| {
@@ -135,25 +135,25 @@ impl<F: ImfsFetcher> UiService<F> {
.unwrap()
}
fn render_imfs_path(imfs: &Imfs<F>, path: &Path, is_root: bool) -> HtmlContent<'static> {
let is_file = imfs.debug_is_file(path);
fn render_vfs_path(vfs: &Vfs<F>, path: &Path, is_root: bool) -> HtmlContent<'static> {
let is_file = vfs.debug_is_file(path);
let (note, children) = if is_file {
(HtmlContent::None, Vec::new())
} else {
let (is_exhaustive, mut children) = imfs.debug_children(path).unwrap();
let (is_exhaustive, mut children) = vfs.debug_children(path).unwrap();
// Sort files above directories, then sort how Path does after that.
children.sort_unstable_by(|a, b| {
let a_is_file = imfs.debug_is_file(a);
let b_is_file = imfs.debug_is_file(b);
let a_is_file = vfs.debug_is_file(a);
let b_is_file = vfs.debug_is_file(b);
b_is_file.cmp(&a_is_file).then_with(|| a.cmp(b))
});
let children: Vec<_> = children
.into_iter()
.map(|child| Self::render_imfs_path(imfs, child, false))
.map(|child| Self::render_vfs_path(vfs, child, false))
.collect();
let note = if is_exhaustive {
@@ -178,12 +178,12 @@ impl<F: ImfsFetcher> UiService<F> {
}
html! {
<div class="imfs-entry">
<div class="vfs-entry">
<div>
<span class="imfs-entry-name">{ name }</span>
<span class="imfs-entry-note">{ note }</span>
<span class="vfs-entry-name">{ name }</span>
<span class="vfs-entry-note">{ note }</span>
</div>
<div class="imfs-entry-children">
<div class="vfs-entry-children">
{ Fragment::new(children) }
</div>
</div>