Implement Syncback to support converting Roblox files to a Rojo project (#937)

This is a very large commit.
Consider checking the linked PR for more information.

tests/rojo_test/io_util.rs

@@ -10,6 +10,8 @@ use walkdir::WalkDir;
 pub static ROJO_PATH: &str = env!("CARGO_BIN_EXE_rojo");
 pub static BUILD_TESTS_PATH: &str = concat!(env!("CARGO_MANIFEST_DIR"), "/rojo-test/build-tests");
 pub static SERVE_TESTS_PATH: &str = concat!(env!("CARGO_MANIFEST_DIR"), "/rojo-test/serve-tests");
+pub static SYNCBACK_TESTS_PATH: &str =
+    concat!(env!("CARGO_MANIFEST_DIR"), "/rojo-test/syncback-tests");
 
 pub fn get_working_dir_path() -> PathBuf {
     let mut manifest_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR"));

tests/rojo_test/mod.rs

@@ -1,3 +1,4 @@
 pub mod internable;
 pub mod io_util;
 pub mod serve_util;
+pub mod syncback_util;

tests/rojo_test/syncback_util.rs

@@ -0,0 +1,116 @@
+use std::{io::Write as _, path::Path, process::Command};
+
+use insta::{assert_snapshot, assert_yaml_snapshot};
+use tempfile::tempdir;
+
+use crate::rojo_test::io_util::SYNCBACK_TESTS_PATH;
+
+use super::io_util::{copy_recursive, ROJO_PATH};
+
+const INPUT_FILE_PROJECT: &str = "input-project";
+const INPUT_FILE_PLACE: &str = "input.rbxl";
+const INPUT_FILE_MODEL: &str = "input.rbxm";
+
+/// Convenience method to run a `rojo syncback` test.
+///
+/// Test projects should be defined in the `syncback-tests` folder; their filename
+/// should be given as the first parameter.
+///
+/// The passed in callback is where the actual test body should go. Setup and
+/// cleanup happens automatically.
+pub fn run_syncback_test(name: &str, callback: impl FnOnce(&Path)) {
+    let _ = env_logger::try_init();
+
+    // let working_dir = get_working_dir_path();
+
+    let source_path = Path::new(SYNCBACK_TESTS_PATH)
+        .join(name)
+        .join(INPUT_FILE_PROJECT);
+    // We want to support both rbxls and rbxms as input
+    let input_file = {
+        let mut path = Path::new(SYNCBACK_TESTS_PATH)
+            .join(name)
+            .join(INPUT_FILE_PLACE);
+        if !path.exists() {
+            path.set_file_name(INPUT_FILE_MODEL);
+        }
+        path
+    };
+
+    let test_dir = tempdir().expect("Couldn't create temporary directory");
+    let project_path = test_dir
+        .path()
+        .canonicalize()
+        .expect("Couldn't canonicalize temporary directory path")
+        .join(name);
+
+    let source_is_file = fs_err::metadata(&source_path).unwrap().is_file();
+
+    if source_is_file {
+        fs_err::copy(&source_path, &project_path).expect("couldn't copy project file");
+    } else {
+        fs_err::create_dir(&project_path).expect("Couldn't create temporary project subdirectory");
+
+        copy_recursive(&source_path, &project_path)
+            .expect("Couldn't copy project to temporary directory");
+    };
+
+    let output = Command::new(ROJO_PATH)
+        // I don't really understand why setting the working directory breaks this, but it does.
+        // It's a bit concerning but I'm more interested in writing tests than debugging it right now.
+        // TODO: Figure out why and fix it.
+        // .current_dir(working_dir)
+        .args([
+            "--color",
+            "never",
+            "syncback",
+            project_path.to_str().unwrap(),
+            "--input",
+            input_file.to_str().unwrap(),
+            "--non-interactive",
+            "--list",
+        ])
+        .output()
+        .expect("Couldn't spawn syncback process");
+
+    if !output.status.success() {
+        let mut lock = std::io::stderr().lock();
+        writeln!(
+            lock,
+            "Rojo exited with status code {:?}",
+            output.status.code()
+        )
+        .unwrap();
+        writeln!(lock, "Stdout from process:").unwrap();
+        lock.write_all(&output.stdout).unwrap();
+        writeln!(lock, "Stderr from process:").unwrap();
+        lock.write_all(&output.stderr).unwrap();
+
+        std::process::exit(1)
+    }
+
+    let mut settings = insta::Settings::new();
+    let snapshot_path = Path::new(SYNCBACK_TESTS_PATH)
+        .parent()
+        .unwrap()
+        .join("syncback-test-snapshots");
+    settings.set_snapshot_path(snapshot_path);
+    settings.set_sort_maps(true);
+
+    settings.bind(|| {
+        assert_snapshot!(
+            format!("{name}-stdout"),
+            String::from_utf8_lossy(&output.stdout)
+        )
+    });
+
+    settings.bind(|| callback(project_path.as_path()))
+}
+
+pub fn snapshot_rbxm(name: &str, input: Vec<u8>, file_name: &str) {
+    assert_yaml_snapshot!(
+        name,
+        rbx_binary::text_format::DecodedModel::from_reader(input.as_slice()),
+        file_name
+    )
+}