Refactor project file into its own crate

* Port release workflow from Aftman to test

* Checkout submodules in plugin build step

* ...and build with submodules for other builds too

* Fix ci.yml; we use master branch still

* CI with submodules too

.github/FUNDING.yml

@@ -0,0 +1 @@
+patreon: lpghatguy

.github/workflows/ci.yml

@@ -11,29 +11,49 @@ on:
 
 jobs:
   build:
-
+    name: Build and Test
     runs-on: ubuntu-latest
 
     strategy:
       matrix:
-        rust_version: [stable, "1.55.0"]
+        rust_version: [stable, 1.55.0]
 
     steps:
-    - uses: actions/checkout@v1
+    - uses: actions/checkout@v3
       with:
         submodules: true
 
-    - name: Setup Rust toolchain
-      run: rustup default ${{ matrix.rust_version }}
+    - name: Install Rust
+      uses: actions-rs/toolchain@v1
+      with:
+        toolchain: ${{ matrix.rust_version }}
+        override: true
+        profile: minimal
 
     - name: Build
       run: cargo build --locked --verbose
 
-    - name: Run tests
+    - name: Test
       run: cargo test --locked --verbose
 
-    - name: Rustfmt and Clippy
-      run: |
-        cargo fmt -- --check
-        cargo clippy
-      if: matrix.rust_version == 'stable'
+  lint:
+    name: Rustfmt and Clippy
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v3
+      with:
+        submodules: true
+
+    - name: Install Rust
+      uses: actions-rs/toolchain@v1
+      with:
+        toolchain: stable
+        override: true
+        components: rustfmt, clippy
+
+    - name: Rustfmt
+      run: cargo fmt -- --check
+
+    - name: Clippy
+      run: cargo clippy

.github/workflows/release.yml

@@ -2,65 +2,152 @@ name: Release
 
 on:
   push:
-    tags: ["*"]
+    tags: ["v*"]
 
 jobs:
-  windows:
-    runs-on: windows-latest
-
-    steps:
-    - uses: actions/checkout@v1
-      with:
-        submodules: true
-
-    - name: Build release binary
-      run: cargo build --verbose --locked --release
-
-    - name: Upload artifacts
-      uses: actions/upload-artifact@v1
-      with:
-        name: rojo-win64
-        path: target/release/rojo.exe
-
-  macos:
-    runs-on: macos-latest
-
-    steps:
-    - uses: actions/checkout@v1
-      with:
-        submodules: true
-
-    - name: Install Rust
-      run: curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y
-
-    - name: Build release binary
-      run: |
-        source $HOME/.cargo/env
-        cargo build --verbose --locked --release
-      env:
-        OPENSSL_STATIC: 1
-
-    - name: Upload artifacts
-      uses: actions/upload-artifact@v1
-      with:
-        name: rojo-macos
-        path: target/release/rojo
-
-  linux:
+  create-release:
+    name: Create Release
     runs-on: ubuntu-latest
-
+    outputs:
+      upload_url: ${{ steps.create_release.outputs.upload_url }}
     steps:
-    - uses: actions/checkout@v1
-      with:
-        submodules: true
+      - name: Create Release
+        id: create_release
+        uses: actions/create-release@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          tag_name: ${{ github.ref }}
+          release_name: ${{ github.ref }}
+          draft: true
+          prerelease: false
 
-    - name: Build
-      run: cargo build --locked --verbose --release
-      env:
-        OPENSSL_STATIC: 1
+  build-plugin:
+    needs: ["create-release"]
+    name: Build Roblox Studio Plugin
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          submodules: true
 
-    - name: Upload artifacts
-      uses: actions/upload-artifact@v1
-      with:
-        name: rojo-linux
-        path: target/release/rojo
+      - name: Setup Foreman
+        uses: Roblox/setup-foreman@v1
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Build Plugin
+        run: rojo build plugin --output Rojo.rbxm
+
+      - name: Upload Plugin to Release
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ needs.create-release.outputs.upload_url }}
+          asset_path: Rojo.rbxm
+          asset_name: Rojo.rbxm
+          asset_content_type: application/octet-stream
+
+      - name: Upload Plugin to Artifacts
+        uses: actions/upload-artifact@v3
+        with:
+          name: Rojo.rbxm
+          path: Rojo.rbxm
+
+  build:
+    needs: ["create-release"]
+    strategy:
+      fail-fast: false
+      matrix:
+        # https://doc.rust-lang.org/rustc/platform-support.html
+        #
+        # FIXME: After the Rojo VS Code extension updates, add architecture
+        # names to each of these releases. We'll rename win64 to windows and add
+        # -x86_64 to each release.
+        include:
+          - host: linux
+            os: ubuntu-latest
+            target: x86_64-unknown-linux-gnu
+            label: linux
+
+          - host: windows
+            os: windows-latest
+            target: x86_64-pc-windows-msvc
+            label: win64
+
+          - host: macos
+            os: macos-latest
+            target: x86_64-apple-darwin
+            label: macos
+
+          - host: macos
+            os: macos-latest
+            target: aarch64-apple-darwin
+            label: macos-aarch64
+
+    name: Build (${{ matrix.target }})
+    runs-on: ${{ matrix.os }}
+    env:
+      BIN: rojo
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          submodules: true
+
+      - name: Get Version from Tag
+        shell: bash
+        # https://github.community/t/how-to-get-just-the-tag-name/16241/7#M1027
+        run: |
+          echo "PROJECT_VERSION=${GITHUB_REF#refs/tags/v}" >> $GITHUB_ENV
+          echo "Version is: ${{ env.PROJECT_VERSION }}"
+
+      - name: Install Rust
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+          target: ${{ matrix.target }}
+          override: true
+          profile: minimal
+
+      - name: Build Release
+        run: cargo build --release --locked --verbose
+        env:
+          # Build into a known directory so we can find our build artifact more
+          # easily.
+          CARGO_TARGET_DIR: output
+
+          # On platforms that use OpenSSL, ensure it is statically linked to
+          # make binaries more portable.
+          OPENSSL_STATIC: 1
+
+      - name: Create Release Archive
+        shell: bash
+        run: |
+          mkdir staging
+
+          if [ "${{ matrix.host }}" = "windows" ]; then
+            cp "output/release/$BIN.exe" staging/
+            cd staging
+            7z a ../release.zip *
+          else
+            cp "output/release/$BIN" staging/
+            cd staging
+            zip ../release.zip *
+          fi
+
+      - name: Upload Archive to Release
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ needs.create-release.outputs.upload_url }}
+          asset_path: release.zip
+          asset_name: ${{ env.BIN }}-${{ env.PROJECT_VERSION }}-${{ matrix.label }}.zip
+          asset_content_type: application/octet-stream
+
+      - name: Upload Archive to Artifacts
+        uses: actions/upload-artifact@v3
+        with:
+          name: ${{ env.BIN }}-${{ env.PROJECT_VERSION }}-${{ matrix.label }}.zip
+          path: release.zip

CHANGELOG.md

@@ -1,6 +1,15 @@
 # Rojo Changelog
 
 ## Unreleased Changes
+* Switched from structopt to clap for command line argument parsing.
+
+## [7.1.1] - May 26, 2022
+* Fixed sourcemap command not stripping paths correctly ([#544])
+* Fixed Studio plugin settings not saving correctly.
+
+[#544]: https://github.com/rojo-rbx/rojo/pull/544
+[#545]: https://github.com/rojo-rbx/rojo/pull/545
+[7.1.1]: https://github.com/rojo-rbx/rojo/releases/tag/v7.1.1
 
 ## [7.1.0] - May 22, 2022
 * Added support for specifying an address to be used by default in project files. ([#507])

CONTRIBUTING.md

@@ -49,11 +49,9 @@ The Rojo release process is pretty manual right now. If you need to do it, here'
     * `cargo publish`
 8. Publish the Plugin
     * `cargo run -- upload plugin --asset_id 6415005344`
-    * `cargo run -- build plugin --output Rojo.rbxm`
 9. Push commits and tags
     * `git push && git push --tags`
 10. Copy GitHub release content from previous release
     * Update the leading text with a summary about the release
     * Paste the changelog notes (as-is!) from [`CHANGELOG.md`](CHANGELOG.md)
-    * Write a small summary of each major feature
-    * Attach release artifacts from GitHub Actions for each platform
+    * Write a small summary of each major feature

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rojo"
-version = "7.1.0"
+version = "7.1.1"
 authors = ["Lucien Greathouse <me@lpghatguy.com>"]
 description = "Enables professional-grade development tools for Roblox developers"
 license = "MPL-2.0"
@@ -28,10 +28,7 @@ default = []
 dev_live_assets = []
 
 [workspace]
-members = [
-    "rojo-insta-ext",
-    "memofs",
-]
+members = ["crates/*"]
 
 [lib]
 name = "librojo"
@@ -42,7 +39,8 @@ name = "build"
 harness = false
 
 [dependencies]
-memofs = { version = "0.2.0", path = "memofs" }
+rojo-project = { path = "crates/rojo-project" }
+memofs = { version = "0.2.0", path = "crates/memofs" }
 
 # These dependencies can be uncommented when working on rbx-dom simultaneously
 # rbx_binary = { path = "../rbx-dom/rbx_binary" }
@@ -69,29 +67,26 @@ globset = "0.4.8"
 humantime = "2.1.0"
 hyper = { version = "0.14.13", features = ["server", "tcp", "http1"] }
 jod-thread = "0.1.2"
-lazy_static = "1.4.0"
 log = "0.4.14"
 maplit = "1.0.2"
 notify = "4.0.17"
 opener = "0.5.0"
-regex = "1.5.4"
-reqwest = "0.9.24"
+reqwest = { version = "0.11.10", features = ["blocking", "json"] }
 ritz = "0.1.0"
-rlua = "0.17.1"
 roblox_install = "1.0.0"
 serde = { version = "1.0.130", features = ["derive", "rc"] }
 serde_json = "1.0.68"
-structopt = "0.3.23"
 termcolor = "1.1.2"
 thiserror = "1.0.30"
 tokio = { version = "1.12.0", features = ["rt", "rt-multi-thread"] }
-uuid = { version = "0.8.2", features = ["v4", "serde"] }
+uuid = { version = "1.0.0", features = ["v4", "serde"] }
+clap = { version = "3.1.18", features = ["derive"] }
 
 [target.'cfg(windows)'.dependencies]
-winreg = "0.9.0"
+winreg = "0.10.1"
 
 [build-dependencies]
-memofs = { version = "0.2.0", path = "memofs" }
+memofs = { version = "0.2.0", path = "crates/memofs" }
 
 embed-resource = "1.6.4"
 anyhow = "1.0.44"
@@ -100,13 +95,12 @@ fs-err = "2.6.0"
 maplit = "1.0.2"
 
 [dev-dependencies]
-rojo-insta-ext = { path = "rojo-insta-ext" }
+rojo-insta-ext = { path = "crates/rojo-insta-ext" }
 
 criterion = "0.3.5"
 insta = { version = "1.8.0", features = ["redactions"] }
-lazy_static = "1.4.0"
 paste = "1.0.5"
-pretty_assertions = "0.7.2"
+pretty_assertions = "1.2.1"
 serde_yaml = "0.8.21"
 tempfile = "3.2.0"
 walkdir = "2.3.2"

bin/dev-plugin.sh

@@ -1,5 +0,0 @@
-#!/bin/sh
-
-set -e
-
-watchexec -c -w plugin "sh -c './bin/install-dev-plugin.sh'"

bin/install-dev-plugin.sh

@@ -1,13 +0,0 @@
-#!/bin/sh
-
-set -e
-
-DIR="$( mktemp -d )"
-PLUGIN_FILE="$DIR/Rojo.rbxm"
-TESTEZ_FILE="$DIR/TestEZ.rbxm"
-
-rojo build plugin -o "$PLUGIN_FILE"
-rojo build plugin/testez.project.json -o "$TESTEZ_FILE"
-remodel bin/mark-plugin-as-dev.lua "$PLUGIN_FILE" "$TESTEZ_FILE" 2>/dev/null
-
-cp "$PLUGIN_FILE" "$LOCALAPPDATA/Roblox/Plugins/Rojo.rbxm"

bin/install-release-plugin.sh

@@ -1,5 +0,0 @@
-#!/bin/sh
-
-set -e
-
-rojo build plugin -o "$LOCALAPPDATA/Roblox/Plugins/Rojo.rbxm"

bin/mark-plugin-as-dev.lua

@@ -1,12 +0,0 @@
-local pluginPath, testezPath = ...
-
-local plugin = remodel.readModelFile(pluginPath)[1]
-local testez = remodel.readModelFile(testezPath)[1]
-
-local marker = Instance.new("Folder")
-marker.Name = "ROJO_DEV_BUILD"
-marker.Parent = plugin
-
-testez.Parent = plugin
-
-remodel.writeModelFile(plugin, pluginPath)

bin/put-plugin-in-test-place.lua

@@ -1,8 +0,0 @@
-local pluginPath, placePath = ...
-
-local plugin = remodel.readModelFile(pluginPath)[1]
-local place = remodel.readPlaceFile(placePath)
-
-plugin.Parent = place:GetService("ReplicatedStorage")
-
-remodel.writePlaceFile(place, placePath)

bin/run-all-tests.sh

@@ -1,6 +0,0 @@
-#!/bin/sh
-
-set -e
-
-./bin/run-cli-tests.sh
-./bin/run-plugin-tests.sh

bin/run-cli-tests.sh

@@ -1,9 +0,0 @@
-#!/bin/sh
-
-set -e
-
-cargo test --all --locked
-cargo fmt -- --check
-
-touch src/lib.rs # Nudge Rust source to make Clippy actually check things
-cargo clippy

bin/run-plugin-tests.sh

@@ -1,16 +0,0 @@
-#!/bin/sh
-
-set -e
-
-DIR="$( mktemp -d )"
-PLUGIN_FILE="$DIR/Rojo.rbxmx"
-PLACE_FILE="$DIR/RojoTestPlace.rbxlx"
-
-rojo build plugin -o "$PLUGIN_FILE"
-rojo build plugin/place.project.json -o "$PLACE_FILE"
-
-remodel bin/put-plugin-in-test-place.lua "$PLUGIN_FILE" "$PLACE_FILE"
-
-run-in-roblox -s plugin/testBootstrap.server.lua "$PLACE_FILE"
-
-luacheck plugin/src plugin/log plugin/http

crates/rojo-project/Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "rojo-project"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+anyhow = "1.0.57"
+globset = { version = "0.4.8", features = ["serde1"] }
+log = "0.4.17"
+rbx_dom_weak = "2.3.0"
+rbx_reflection = "4.2.0"
+rbx_reflection_database = "0.2.4"
+serde = { version = "1.0.137", features = ["derive"] }
+serde_json = "1.0.81"

crates/rojo-project/README.md

@@ -0,0 +1,4 @@
+# rojo-project
+Project file format crate for [Rojo].
+
+[Rojo]: https://rojo.space

crates/rojo-project/src/glob.rs

@@ -1,6 +1,3 @@
-//! Wrapper around globset's Glob type that has better serialization
-//! characteristics by coupling Glob and GlobMatcher into a single type.
-
 use std::path::Path;
 
 use globset::{Glob as InnerGlob, GlobMatcher};
@@ -8,6 +5,8 @@ use serde::{de::Error as _, Deserialize, Deserializer, Serialize, Serializer};
 
 pub use globset::Error;
 
+/// Wrapper around globset's Glob type that has better serialization
+/// characteristics by coupling Glob and GlobMatcher into a single type.
 #[derive(Debug, Clone)]
 pub struct Glob {
     inner: InnerGlob,

crates/rojo-project/src/lib.rs

@@ -0,0 +1,7 @@
+pub mod glob;
+mod path_serializer;
+mod project;
+mod resolution;
+
+pub use project::{OptionalPathNode, PathNode, Project, ProjectNode};
+pub use resolution::{AmbiguousValue, UnresolvedValue};

crates/rojo-project/src/path_serializer.rs

@@ -0,0 +1,21 @@
+//! Path serializer is used to serialize absolute paths in a cross-platform way,
+//! by replacing all directory separators with /.
+
+use std::path::Path;
+
+use serde::Serializer;
+
+pub fn serialize_absolute<S, T>(path: T, serializer: S) -> Result<S::Ok, S::Error>
+where
+    S: Serializer,
+    T: AsRef<Path>,
+{
+    let as_str = path
+        .as_ref()
+        .as_os_str()
+        .to_str()
+        .expect("Invalid Unicode in file path, cannot serialize");
+    let replaced = as_str.replace("\\", "/");
+
+    serializer.serialize_str(&replaced)
+}

crates/rojo-project/src/project.rs

@@ -0,0 +1,363 @@
+use std::collections::{BTreeMap, HashMap, HashSet};
+use std::fs;
+use std::net::IpAddr;
+use std::path::{Path, PathBuf};
+
+use anyhow::Context;
+use serde::{Deserialize, Serialize};
+
+use crate::glob::Glob;
+use crate::resolution::UnresolvedValue;
+
+static PROJECT_FILENAME: &str = "default.project.json";
+
+/// Contains all of the configuration for a Rojo-managed project.
+///
+/// Rojo project files are stored in `.project.json` files.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(deny_unknown_fields, rename_all = "camelCase")]
+pub struct Project {
+    /// The name of the top-level instance described by the project.
+    pub name: String,
+
+    /// The tree of instances described by this project. Projects always
+    /// describe at least one instance.
+    pub tree: ProjectNode,
+
+    /// If specified, sets the default port that `rojo serve` should use when
+    /// using this project for live sync.
+    ///
+    /// Can be overriden with the `--port` flag.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub serve_port: Option<u16>,
+
+    /// If specified, sets the default IP address that `rojo serve` should use
+    /// when using this project for live sync.
+    ///
+    /// Can be overridden with the `--address` flag.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub serve_address: Option<IpAddr>,
+
+    /// If specified, contains the set of place IDs that this project is
+    /// compatible with when doing live sync.
+    ///
+    /// This setting is intended to help prevent syncing a Rojo project into the
+    /// wrong Roblox place.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub serve_place_ids: Option<HashSet<u64>>,
+
+    /// If specified, sets the current place's place ID when connecting to the
+    /// Rojo server from Roblox Studio.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub place_id: Option<u64>,
+
+    /// If specified, sets the current place's game ID when connecting to the
+    /// Rojo server from Roblox Studio.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub game_id: Option<u64>,
+
+    /// A list of globs, relative to the folder the project file is in, that
+    /// match files that should be excluded if Rojo encounters them.
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub glob_ignore_paths: Vec<Glob>,
+
+    /// The path to the file that this project came from. Relative paths in the
+    /// project should be considered relative to the parent of this field, also
+    /// given by `Project::folder_location`.
+    #[serde(skip)]
+    pub file_location: PathBuf,
+}
+
+impl Project {
+    /// Tells whether the given path describes a Rojo project.
+    pub fn is_project_file(path: &Path) -> bool {
+        path.file_name()
+            .and_then(|name| name.to_str())
+            .map(|name| name.ends_with(".project.json"))
+            .unwrap_or(false)
+    }
+
+    /// Loads a project file from a slice and a path that indicates where the
+    /// project should resolve paths relative to.
+    pub fn load_from_slice(contents: &[u8], project_file_location: &Path) -> anyhow::Result<Self> {
+        let mut project: Self = serde_json::from_slice(&contents).with_context(|| {
+            format!(
+                "Error parsing Rojo project at {}",
+                project_file_location.display()
+            )
+        })?;
+
+        project.file_location = project_file_location.to_path_buf();
+        project.check_compatibility();
+        Ok(project)
+    }
+
+    /// Fuzzy-find a Rojo project and load it.
+    pub fn load_fuzzy(fuzzy_project_location: &Path) -> anyhow::Result<Option<Self>> {
+        if let Some(project_path) = Self::locate(fuzzy_project_location) {
+            let project = Self::load_exact(&project_path)?;
+
+            Ok(Some(project))
+        } else {
+            Ok(None)
+        }
+    }
+
+    /// Gives the path that all project file paths should resolve relative to.
+    pub fn folder_location(&self) -> &Path {
+        self.file_location.parent().unwrap()
+    }
+
+    /// Attempt to locate a project represented by the given path.
+    ///
+    /// This will find a project if the path refers to a `.project.json` file,
+    /// or is a folder that contains a `default.project.json` file.
+    fn locate(path: &Path) -> Option<PathBuf> {
+        let meta = fs::metadata(path).ok()?;
+
+        if meta.is_file() {
+            if Project::is_project_file(path) {
+                Some(path.to_path_buf())
+            } else {
+                None
+            }
+        } else {
+            let child_path = path.join(PROJECT_FILENAME);
+            let child_meta = fs::metadata(&child_path).ok()?;
+
+            if child_meta.is_file() {
+                Some(child_path)
+            } else {
+                // This is a folder with the same name as a Rojo default project
+                // file.
+                //
+                // That's pretty weird, but we can roll with it.
+                None
+            }
+        }
+    }
+
+    fn load_exact(project_file_location: &Path) -> anyhow::Result<Self> {
+        let contents = fs::read_to_string(project_file_location)?;
+
+        let mut project: Project = serde_json::from_str(&contents).with_context(|| {
+            format!(
+                "Error parsing Rojo project at {}",
+                project_file_location.display()
+            )
+        })?;
+
+        project.file_location = project_file_location.to_path_buf();
+        project.check_compatibility();
+
+        Ok(project)
+    }
+
+    /// Checks if there are any compatibility issues with this project file and
+    /// warns the user if there are any.
+    fn check_compatibility(&self) {
+        self.tree.validate_reserved_names();
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+pub struct OptionalPathNode {
+    #[serde(serialize_with = "crate::path_serializer::serialize_absolute")]
+    pub optional: PathBuf,
+}
+
+impl OptionalPathNode {
+    pub fn new(optional: PathBuf) -> Self {
+        OptionalPathNode { optional }
+    }
+}
+
+/// Describes a path that is either optional or required
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(untagged)]
+pub enum PathNode {
+    Required(#[serde(serialize_with = "crate::path_serializer::serialize_absolute")] PathBuf),
+    Optional(OptionalPathNode),
+}
+
+impl PathNode {
+    pub fn path(&self) -> &Path {
+        match self {
+            PathNode::Required(pathbuf) => &pathbuf,
+            PathNode::Optional(OptionalPathNode { optional }) => &optional,
+        }
+    }
+}
+
+/// Describes an instance and its descendants in a project.
+#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+pub struct ProjectNode {
+    /// If set, defines the ClassName of the described instance.
+    ///
+    /// `$className` MUST be set if `$path` is not set.
+    ///
+    /// `$className` CANNOT be set if `$path` is set and the instance described
+    /// by that path has a ClassName other than Folder.
+    #[serde(rename = "$className", skip_serializing_if = "Option::is_none")]
+    pub class_name: Option<String>,
+
+    /// Contains all of the children of the described instance.
+    #[serde(flatten)]
+    pub children: BTreeMap<String, ProjectNode>,
+
+    /// The properties that will be assigned to the resulting instance.
+    #[serde(
+        rename = "$properties",
+        default,
+        skip_serializing_if = "HashMap::is_empty"
+    )]
+    pub properties: HashMap<String, UnresolvedValue>,
+
+    /// Defines the behavior when Rojo encounters unknown instances in Roblox
+    /// Studio during live sync. `$ignoreUnknownInstances` should be considered
+    /// a large hammer and used with care.
+    ///
+    /// If set to `true`, those instances will be left alone. This may cause
+    /// issues when files that turn into instances are removed while Rojo is not
+    /// running.
+    ///
+    /// If set to `false`, Rojo will destroy any instances it does not
+    /// recognize.
+    ///
+    /// If unset, its default value depends on other settings:
+    /// - If `$path` is not set, defaults to `true`
+    /// - If `$path` is set, defaults to `false`
+    #[serde(
+        rename = "$ignoreUnknownInstances",
+        skip_serializing_if = "Option::is_none"
+    )]
+    pub ignore_unknown_instances: Option<bool>,
+
+    /// Defines that this instance should come from the given file path. This
+    /// path can point to any file type supported by Rojo, including Lua files
+    /// (`.lua`), Roblox models (`.rbxm`, `.rbxmx`), and localization table
+    /// spreadsheets (`.csv`).
+    #[serde(rename = "$path", skip_serializing_if = "Option::is_none")]
+    pub path: Option<PathNode>,
+}
+
+impl ProjectNode {
+    fn validate_reserved_names(&self) {
+        for (name, child) in &self.children {
+            if name.starts_with('$') {
+                log::warn!(
+                    "Keys starting with '$' are reserved by Rojo to ensure forward compatibility."
+                );
+                log::warn!(
+                    "This project uses the key '{}', which should be renamed.",
+                    name
+                );
+            }
+
+            child.validate_reserved_names();
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn path_node_required() {
+        let path_node: PathNode = serde_json::from_str(r#""src""#).unwrap();
+        assert_eq!(path_node, PathNode::Required(PathBuf::from("src")));
+    }
+
+    #[test]
+    fn path_node_optional() {
+        let path_node: PathNode = serde_json::from_str(r#"{ "optional": "src" }"#).unwrap();
+        assert_eq!(
+            path_node,
+            PathNode::Optional(OptionalPathNode::new(PathBuf::from("src")))
+        );
+    }
+
+    #[test]
+    fn project_node_required() {
+        let project_node: ProjectNode = serde_json::from_str(
+            r#"{
+                "$path": "src"
+            }"#,
+        )
+        .unwrap();
+
+        assert_eq!(
+            project_node.path,
+            Some(PathNode::Required(PathBuf::from("src")))
+        );
+    }
+
+    #[test]
+    fn project_node_optional() {
+        let project_node: ProjectNode = serde_json::from_str(
+            r#"{
+                "$path": { "optional": "src" }
+            }"#,
+        )
+        .unwrap();
+
+        assert_eq!(
+            project_node.path,
+            Some(PathNode::Optional(OptionalPathNode::new(PathBuf::from(
+                "src"
+            ))))
+        );
+    }
+
+    #[test]
+    fn project_node_none() {
+        let project_node: ProjectNode = serde_json::from_str(
+            r#"{
+                "$className": "Folder"
+            }"#,
+        )
+        .unwrap();
+
+        assert_eq!(project_node.path, None);
+    }
+
+    #[test]
+    fn project_node_optional_serialize_absolute() {
+        let project_node: ProjectNode = serde_json::from_str(
+            r#"{
+                "$path": { "optional": "..\\src" }
+            }"#,
+        )
+        .unwrap();
+
+        let serialized = serde_json::to_string(&project_node).unwrap();
+        assert_eq!(serialized, r#"{"$path":{"optional":"../src"}}"#);
+    }
+
+    #[test]
+    fn project_node_optional_serialize_absolute_no_change() {
+        let project_node: ProjectNode = serde_json::from_str(
+            r#"{
+                "$path": { "optional": "../src" }
+            }"#,
+        )
+        .unwrap();
+
+        let serialized = serde_json::to_string(&project_node).unwrap();
+        assert_eq!(serialized, r#"{"$path":{"optional":"../src"}}"#);
+    }
+
+    #[test]
+    fn project_node_optional_serialize_optional() {
+        let project_node: ProjectNode = serde_json::from_str(
+            r#"{
+                "$path": "..\\src"
+            }"#,
+        )
+        .unwrap();
+
+        let serialized = serde_json::to_string(&project_node).unwrap();
+        assert_eq!(serialized, r#"{"$path":"../src"}"#);
+    }
+}

crates/rojo-project/src/resolution.rs

@@ -0,0 +1,294 @@
+use std::borrow::Borrow;
+
+use anyhow::format_err;
+use rbx_dom_weak::types::{
+    CFrame, Color3, Content, Enum, Matrix3, Tags, Variant, VariantType, Vector2, Vector3,
+};
+use rbx_reflection::{DataType, PropertyDescriptor};
+use serde::{Deserialize, Serialize};
+
+/// A user-friendly version of `Variant` that supports specifying ambiguous
+/// values. Ambiguous values need a reflection database to be resolved to a
+/// usable value.
+///
+/// This type is used in Rojo projects and JSON models to make specifying the
+/// most common types of properties, like strings or vectors, much easier.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(untagged)]
+pub enum UnresolvedValue {
+    FullyQualified(Variant),
+    Ambiguous(AmbiguousValue),
+}
+
+impl UnresolvedValue {
+    pub fn resolve(self, class_name: &str, prop_name: &str) -> anyhow::Result<Variant> {
+        match self {
+            UnresolvedValue::FullyQualified(full) => Ok(full),
+            UnresolvedValue::Ambiguous(partial) => partial.resolve(class_name, prop_name),
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(untagged)]
+pub enum AmbiguousValue {
+    Bool(bool),
+    String(String),
+    StringArray(Vec<String>),
+    Number(f64),
+    Array2([f64; 2]),
+    Array3([f64; 3]),
+    Array4([f64; 4]),
+    Array12([f64; 12]),
+}
+
+impl AmbiguousValue {
+    pub fn resolve(self, class_name: &str, prop_name: &str) -> anyhow::Result<Variant> {
+        let property = find_descriptor(class_name, prop_name)
+            .ok_or_else(|| format_err!("Unknown property {}.{}", class_name, prop_name))?;
+
+        match &property.data_type {
+            DataType::Enum(enum_name) => {
+                let database = rbx_reflection_database::get();
+
+                let enum_descriptor = database.enums.get(enum_name).ok_or_else(|| {
+                    format_err!("Unknown enum {}. This is a Rojo bug!", enum_name)
+                })?;
+
+                let error = |what: &str| {
+                    let mut all_values = enum_descriptor
+                        .items
+                        .keys()
+                        .map(|value| value.borrow())
+                        .collect::<Vec<_>>();
+                    all_values.sort();
+
+                    let examples = nonexhaustive_list(&all_values);
+
+                    format_err!(
+                        "Invalid value for property {}.{}. Got {} but \
+                         expected a member of the {} enum such as {}",
+                        class_name,
+                        prop_name,
+                        what,
+                        enum_name,
+                        examples,
+                    )
+                };
+
+                let value = match self {
+                    AmbiguousValue::String(value) => value,
+                    unresolved => return Err(error(unresolved.describe())),
+                };
+
+                let resolved = enum_descriptor
+                    .items
+                    .get(value.as_str())
+                    .ok_or_else(|| error(value.as_str()))?;
+
+                Ok(Enum::from_u32(*resolved).into())
+            }
+            DataType::Value(variant_ty) => match (variant_ty, self) {
+                (VariantType::Bool, AmbiguousValue::Bool(value)) => Ok(value.into()),
+
+                (VariantType::Float32, AmbiguousValue::Number(value)) => Ok((value as f32).into()),
+                (VariantType::Float64, AmbiguousValue::Number(value)) => Ok(value.into()),
+                (VariantType::Int32, AmbiguousValue::Number(value)) => Ok((value as i32).into()),
+                (VariantType::Int64, AmbiguousValue::Number(value)) => Ok((value as i64).into()),
+
+                (VariantType::String, AmbiguousValue::String(value)) => Ok(value.into()),
+                (VariantType::Tags, AmbiguousValue::StringArray(value)) => {
+                    Ok(Tags::from(value).into())
+                }
+                (VariantType::Content, AmbiguousValue::String(value)) => {
+                    Ok(Content::from(value).into())
+                }
+
+                (VariantType::Vector2, AmbiguousValue::Array2(value)) => {
+                    Ok(Vector2::new(value[0] as f32, value[1] as f32).into())
+                }
+
+                (VariantType::Vector3, AmbiguousValue::Array3(value)) => {
+                    Ok(Vector3::new(value[0] as f32, value[1] as f32, value[2] as f32).into())
+                }
+
+                (VariantType::Color3, AmbiguousValue::Array3(value)) => {
+                    Ok(Color3::new(value[0] as f32, value[1] as f32, value[2] as f32).into())
+                }
+
+                (VariantType::CFrame, AmbiguousValue::Array12(value)) => {
+                    let value = value.map(|v| v as f32);
+                    let pos = Vector3::new(value[0], value[1], value[2]);
+                    let orientation = Matrix3::new(
+                        Vector3::new(value[3], value[4], value[5]),
+                        Vector3::new(value[6], value[7], value[8]),
+                        Vector3::new(value[9], value[10], value[11]),
+                    );
+
+                    Ok(CFrame::new(pos, orientation).into())
+                }
+
+                (_, unresolved) => Err(format_err!(
+                    "Wrong type of value for property {}.{}. Expected {:?}, got {}",
+                    class_name,
+                    prop_name,
+                    variant_ty,
+                    unresolved.describe(),
+                )),
+            },
+            _ => Err(format_err!(
+                "Unknown data type for property {}.{}",
+                class_name,
+                prop_name
+            )),
+        }
+    }
+
+    fn describe(&self) -> &'static str {
+        match self {
+            AmbiguousValue::Bool(_) => "a bool",
+            AmbiguousValue::String(_) => "a string",
+            AmbiguousValue::StringArray(_) => "an array of strings",
+            AmbiguousValue::Number(_) => "a number",
+            AmbiguousValue::Array2(_) => "an array of two numbers",
+            AmbiguousValue::Array3(_) => "an array of three numbers",
+            AmbiguousValue::Array4(_) => "an array of four numbers",
+            AmbiguousValue::Array12(_) => "an array of twelve numbers",
+        }
+    }
+}
+
+fn find_descriptor(
+    class_name: &str,
+    prop_name: &str,
+) -> Option<&'static PropertyDescriptor<'static>> {
+    let database = rbx_reflection_database::get();
+    let mut current_class_name = class_name;
+
+    loop {
+        let class = database.classes.get(current_class_name)?;
+        if let Some(descriptor) = class.properties.get(prop_name) {
+            return Some(descriptor);
+        }
+
+        current_class_name = class.superclass.as_deref()?;
+    }
+}
+
+/// Outputs a string containing up to MAX_ITEMS entries from the given list. If
+/// there are more than MAX_ITEMS items, the number of remaining items will be
+/// listed.
+fn nonexhaustive_list(values: &[&str]) -> String {
+    use std::fmt::Write;
+
+    const MAX_ITEMS: usize = 8;
+
+    let mut output = String::new();
+
+    let last_index = values.len() - 1;
+    let main_length = last_index.min(9);
+
+    let main_list = &values[..main_length];
+    for value in main_list {
+        output.push_str(value);
+        output.push_str(", ");
+    }
+
+    if values.len() > MAX_ITEMS {
+        write!(output, "or {} more", values.len() - main_length).unwrap();
+    } else {
+        output.push_str("or ");
+        output.push_str(values[values.len() - 1]);
+    }
+
+    output
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    fn resolve(class: &str, prop: &str, json_value: &str) -> Variant {
+        let unresolved: UnresolvedValue = serde_json::from_str(json_value).unwrap();
+        unresolved.resolve(class, prop).unwrap()
+    }
+
+    #[test]
+    fn bools() {
+        assert_eq!(resolve("BoolValue", "Value", "false"), Variant::Bool(false));
+
+        // Script.Disabled is inherited from BaseScript
+        assert_eq!(resolve("Script", "Disabled", "true"), Variant::Bool(true));
+    }
+
+    #[test]
+    fn strings() {
+        // String literals can stay as strings
+        assert_eq!(
+            resolve("StringValue", "Value", "\"Hello!\""),
+            Variant::String("Hello!".into()),
+        );
+
+        // String literals can also turn into Content
+        assert_eq!(
+            resolve("Sky", "MoonTextureId", "\"rbxassetid://12345\""),
+            Variant::Content("rbxassetid://12345".into()),
+        );
+
+        // What about BinaryString values? For forward-compatibility reasons, we
+        // don't support any shorthands for BinaryString.
+        //
+        // assert_eq!(
+        //     resolve("Folder", "Tags", "\"a\\u0000b\\u0000c\""),
+        //     Variant::BinaryString(b"a\0b\0c".to_vec().into()),
+        // );
+    }
+
+    #[test]
+    fn numbers() {
+        assert_eq!(
+            resolve("Part", "CollisionGroupId", "123"),
+            Variant::Int32(123),
+        );
+
+        assert_eq!(
+            resolve("Folder", "SourceAssetId", "532413"),
+            Variant::Int64(532413),
+        );
+
+        assert_eq!(resolve("Part", "Transparency", "1"), Variant::Float32(1.0));
+        assert_eq!(resolve("NumberValue", "Value", "1"), Variant::Float64(1.0));
+    }
+
+    #[test]
+    fn vectors() {
+        assert_eq!(
+            resolve("ParticleEmitter", "SpreadAngle", "[1, 2]"),
+            Variant::Vector2(Vector2::new(1.0, 2.0)),
+        );
+
+        assert_eq!(
+            resolve("Part", "Position", "[4, 5, 6]"),
+            Variant::Vector3(Vector3::new(4.0, 5.0, 6.0)),
+        );
+    }
+
+    #[test]
+    fn colors() {
+        assert_eq!(
+            resolve("Part", "Color", "[1, 1, 1]"),
+            Variant::Color3(Color3::new(1.0, 1.0, 1.0)),
+        );
+
+        // There aren't any user-facing Color3uint8 properties. If there are
+        // some, we should treat them the same in the future.
+    }
+
+    #[test]
+    fn enums() {
+        assert_eq!(
+            resolve("Lighting", "Technology", "\"Voxel\""),
+            Variant::Enum(Enum::from_u32(1)),
+        );
+    }
+}

foreman.toml

@@ -1,3 +1,4 @@
 [tools]
-rojo = { source = "rojo-rbx/rojo", version = "6.1.0" }
+rojo = { source = "rojo-rbx/rojo", version = "7.1.1" }
 run-in-roblox = { source = "rojo-rbx/run-in-roblox", version = "0.3.0" }
+selene = { source = "Kampfkarren/selene", version = "0.17.0" }

plugin/src/App/init.lua

@@ -154,150 +154,146 @@ function App:render()
 		value = self.props.plugin,
 	}, {
 		e(Theme.StudioProvider, nil, {
-			e(PluginSettings.StudioProvider, {
-				plugin = self.props.plugin,
+			gui = e(StudioPluginGui, {
+				id = pluginName,
+				title = pluginName,
+				active = self.state.guiEnabled,
+
+				initDockState = Enum.InitialDockState.Right,
+				initEnabled = false,
+				overridePreviousState = false,
+				floatingSize = Vector2.new(300, 200),
+				minimumSize = Vector2.new(300, 200),
+
+				zIndexBehavior = Enum.ZIndexBehavior.Sibling,
+
+				onInitialState = function(initialState)
+					self:setState({
+						guiEnabled = initialState,
+					})
+				end,
+
+				onClose = function()
+					self:setState({
+						guiEnabled = false,
+					})
+				end,
 			}, {
-				gui = e(StudioPluginGui, {
-					id = pluginName,
-					title = pluginName,
-					active = self.state.guiEnabled,
+				NotConnectedPage = createPageElement(AppStatus.NotConnected, {
+					host = self.host,
+					onHostChange = self.setHost,
+					port = self.port,
+					onPortChange = self.setPort,
 
-					initDockState = Enum.InitialDockState.Right,
-					initEnabled = false,
-					overridePreviousState = false,
-					floatingSize = Vector2.new(300, 200),
-					minimumSize = Vector2.new(300, 200),
+					onConnect = function()
+						self:startSession()
+					end,
 
-					zIndexBehavior = Enum.ZIndexBehavior.Sibling,
-
-					onInitialState = function(initialState)
+					onNavigateSettings = function()
 						self:setState({
-							guiEnabled = initialState,
+							appStatus = AppStatus.Settings,
 						})
 					end,
+				}),
+
+				Connecting = createPageElement(AppStatus.Connecting),
+
+				Connected = createPageElement(AppStatus.Connected, {
+					projectName = self.state.projectName,
+					address = self.state.address,
+
+					onDisconnect = function()
+						self:endSession()
+					end,
+				}),
+
+				Settings = createPageElement(AppStatus.Settings, {
+					onBack = function()
+						self:setState({
+							appStatus = AppStatus.NotConnected,
+						})
+					end,
+				}),
+
+				Error = createPageElement(AppStatus.Error, {
+					errorMessage = self.state.errorMessage,
 
 					onClose = function()
 						self:setState({
-							guiEnabled = false,
+							appStatus = AppStatus.NotConnected,
+							toolbarIcon = Assets.Images.PluginButton,
 						})
 					end,
-				}, {
-					NotConnectedPage = createPageElement(AppStatus.NotConnected, {
-						host = self.host,
-						onHostChange = self.setHost,
-						port = self.port,
-						onPortChange = self.setPort,
-
-						onConnect = function()
-							self:startSession()
-						end,
-
-						onNavigateSettings = function()
-							self:setState({
-								appStatus = AppStatus.Settings,
-							})
-						end,
-					}),
-
-					Connecting = createPageElement(AppStatus.Connecting),
-
-					Connected = createPageElement(AppStatus.Connected, {
-						projectName = self.state.projectName,
-						address = self.state.address,
-
-						onDisconnect = function()
-							self:endSession()
-						end,
-					}),
-
-					Settings = createPageElement(AppStatus.Settings, {
-						onBack = function()
-							self:setState({
-								appStatus = AppStatus.NotConnected,
-							})
-						end,
-					}),
-
-					Error = createPageElement(AppStatus.Error, {
-						errorMessage = self.state.errorMessage,
-
-						onClose = function()
-							self:setState({
-								appStatus = AppStatus.NotConnected,
-								toolbarIcon = Assets.Images.PluginButton,
-							})
-						end,
-					}),
-
-					Background = Theme.with(function(theme)
-						return e("Frame", {
-							Size = UDim2.new(1, 0, 1, 0),
-							BackgroundColor3 = theme.BackgroundColor,
-							ZIndex = 0,
-							BorderSizePixel = 0,
-						})
-					end),
 				}),
 
-				toggleAction = e(StudioPluginAction, {
-					name = "RojoConnection",
-					title = "Rojo: Connect/Disconnect",
-					description = "Toggles the server for a Rojo sync session",
-					icon = Assets.Images.PluginButton,
-					bindable = true,
-					onTriggered = function()
-						if self.serveSession == nil or self.serveSession:getStatus() == ServeSession.Status.NotStarted then
-							self:startSession()
-						elseif self.serveSession ~= nil and self.serveSession:getStatus() == ServeSession.Status.Connected then
-							self:endSession()
-						end
-					end,
-				}),
-
-				connectAction = e(StudioPluginAction, {
-					name = "RojoConnect",
-					title = "Rojo: Connect",
-					description = "Connects the server for a Rojo sync session",
-					icon = Assets.Images.PluginButton,
-					bindable = true,
-					onTriggered = function()
-						if self.serveSession == nil or self.serveSession:getStatus() == ServeSession.Status.NotStarted then
-							self:startSession()
-						end
-					end,
-				}),
-
-				disconnectAction = e(StudioPluginAction, {
-					name = "RojoDisconnect",
-					title = "Rojo: Disconnect",
-					description = "Disconnects the server for a Rojo sync session",
-					icon = Assets.Images.PluginButton,
-					bindable = true,
-					onTriggered = function()
-						if self.serveSession ~= nil and self.serveSession:getStatus() == ServeSession.Status.Connected then
-							self:endSession()
-						end
-					end,
-				}),
-
-				toolbar = e(StudioToolbar, {
-					name = pluginName,
-				}, {
-					button = e(StudioToggleButton, {
-						name = "Rojo",
-						tooltip = "Show or hide the Rojo panel",
-						icon = self.state.toolbarIcon,
-						active = self.state.guiEnabled,
-						enabled = true,
-						onClick = function()
-							self:setState(function(state)
-								return {
-									guiEnabled = not state.guiEnabled,
-								}
-							end)
-						end,
+				Background = Theme.with(function(theme)
+					return e("Frame", {
+						Size = UDim2.new(1, 0, 1, 0),
+						BackgroundColor3 = theme.BackgroundColor,
+						ZIndex = 0,
+						BorderSizePixel = 0,
 					})
-				}),
+				end),
+			}),
+
+			toggleAction = e(StudioPluginAction, {
+				name = "RojoConnection",
+				title = "Rojo: Connect/Disconnect",
+				description = "Toggles the server for a Rojo sync session",
+				icon = Assets.Images.PluginButton,
+				bindable = true,
+				onTriggered = function()
+					if self.serveSession == nil or self.serveSession:getStatus() == ServeSession.Status.NotStarted then
+						self:startSession()
+					elseif self.serveSession ~= nil and self.serveSession:getStatus() == ServeSession.Status.Connected then
+						self:endSession()
+					end
+				end,
+			}),
+
+			connectAction = e(StudioPluginAction, {
+				name = "RojoConnect",
+				title = "Rojo: Connect",
+				description = "Connects the server for a Rojo sync session",
+				icon = Assets.Images.PluginButton,
+				bindable = true,
+				onTriggered = function()
+					if self.serveSession == nil or self.serveSession:getStatus() == ServeSession.Status.NotStarted then
+						self:startSession()
+					end
+				end,
+			}),
+
+			disconnectAction = e(StudioPluginAction, {
+				name = "RojoDisconnect",
+				title = "Rojo: Disconnect",
+				description = "Disconnects the server for a Rojo sync session",
+				icon = Assets.Images.PluginButton,
+				bindable = true,
+				onTriggered = function()
+					if self.serveSession ~= nil and self.serveSession:getStatus() == ServeSession.Status.Connected then
+						self:endSession()
+					end
+				end,
+			}),
+
+			toolbar = e(StudioToolbar, {
+				name = pluginName,
+			}, {
+				button = e(StudioToggleButton, {
+					name = "Rojo",
+					tooltip = "Show or hide the Rojo panel",
+					icon = self.state.toolbarIcon,
+					active = self.state.guiEnabled,
+					enabled = true,
+					onClick = function()
+						self:setState(function(state)
+							return {
+								guiEnabled = not state.guiEnabled,
+							}
+						end)
+					end,
+				})
 			}),
 		}),
 	})
@@ -314,4 +310,4 @@ return function(props)
 			return e(App, settingsProps)
 		end),
 	})
-end
+end

plugin/src/Config.lua

@@ -5,7 +5,7 @@ local isDevBuild = script.Parent.Parent:FindFirstChild("ROJO_DEV_BUILD") ~= nil
 return strict("Config", {
 	isDevBuild = isDevBuild,
 	codename = "Epiphany",
-	version = {7, 1, 0},
+	version = {7, 1, 1},
 	expectedServerVersionString = "7.0 or newer",
 	protocolVersion = 4,
 	defaultHost = "localhost",

src/cli/build.rs

@@ -4,9 +4,9 @@ use std::{
 };
 
 use anyhow::Context;
+use clap::Parser;
 use fs_err::File;
 use memofs::Vfs;
-use structopt::StructOpt;
 use tokio::runtime::Runtime;
 
 use crate::serve_session::ServeSession;
@@ -17,20 +17,20 @@ const UNKNOWN_OUTPUT_KIND_ERR: &str = "Could not detect what kind of file to bui
                                        Expected output file to end in .rbxl, .rbxlx, .rbxm, or .rbxmx.";
 
 /// Generates a model or place file from the Rojo project.
-#[derive(Debug, StructOpt)]
+#[derive(Debug, Parser)]
 pub struct BuildCommand {
     /// Path to the project to serve. Defaults to the current directory.
-    #[structopt(default_value = "")]
+    #[clap(default_value = "")]
     pub project: PathBuf,
 
     /// Where to output the result.
     ///
     /// Should end in .rbxm, .rbxl, .rbxmx, or .rbxlx.
-    #[structopt(long, short)]
+    #[clap(long, short)]
     pub output: PathBuf,
 
     /// Whether to automatically rebuild when any input files change.
-    #[structopt(long)]
+    #[clap(long)]
     pub watch: bool,
 }
 

src/cli/doc.rs

@@ -1,7 +1,7 @@
-use structopt::StructOpt;
+use clap::Parser;
 
 /// Open Rojo's documentation in your browser.
-#[derive(Debug, StructOpt)]
+#[derive(Debug, Parser)]
 pub struct DocCommand {}
 
 impl DocCommand {

src/cli/fmt_project.rs

@@ -1,15 +1,15 @@
 use std::path::PathBuf;
 
 use anyhow::Context;
-use structopt::StructOpt;
+use clap::Parser;
 
 use crate::project::Project;
 
 /// Reformat a Rojo project using the standard JSON formatting rules.
-#[derive(Debug, StructOpt)]
+#[derive(Debug, Parser)]
 pub struct FmtProjectCommand {
     /// Path to the project to format. Defaults to the current directory.
-    #[structopt(default_value = "")]
+    #[clap(default_value = "")]
     pub project: PathBuf,
 }
 

src/cli/init.rs

@@ -4,9 +4,9 @@ use std::process::{Command, Stdio};
 use std::str::FromStr;
 
 use anyhow::{bail, format_err};
+use clap::Parser;
 use fs_err as fs;
 use fs_err::OpenOptions;
-use structopt::StructOpt;
 
 use super::resolve_path;
 
@@ -22,14 +22,14 @@ static PLACE_README: &str = include_str!("../../assets/default-place-project/REA
 static PLACE_GIT_IGNORE: &str = include_str!("../../assets/default-place-project/gitignore.txt");
 
 /// Initializes a new Rojo project.
-#[derive(Debug, StructOpt)]
+#[derive(Debug, Parser)]
 pub struct InitCommand {
     /// Path to the place to create the project. Defaults to the current directory.
-    #[structopt(default_value = "")]
+    #[clap(default_value = "")]
     pub path: PathBuf,
 
     /// The kind of project to create, 'place' or 'model'. Defaults to place.
-    #[structopt(long, default_value = "place")]
+    #[clap(long, default_value = "place")]
     pub kind: InitKind,
 }
 

src/cli/mod.rs

@@ -1,4 +1,4 @@
-//! Defines Rojo's CLI through structopt types.
+//! Defines Rojo's CLI through clap types.
 
 mod build;
 mod doc;
@@ -11,7 +11,7 @@ mod upload;
 
 use std::{borrow::Cow, env, path::Path, str::FromStr};
 
-use structopt::StructOpt;
+use clap::Parser;
 use thiserror::Error;
 
 pub use self::build::BuildCommand;
@@ -23,15 +23,15 @@ pub use self::serve::ServeCommand;
 pub use self::sourcemap::SourcemapCommand;
 pub use self::upload::UploadCommand;
 
-/// Command line options that Rojo accepts, defined using the structopt crate.
-#[derive(Debug, StructOpt)]
-#[structopt(name = "Rojo", about, author)]
+/// Command line options that Rojo accepts, defined using the clap crate.
+#[derive(Debug, Parser)]
+#[clap(name = "Rojo", version, about, author)]
 pub struct Options {
-    #[structopt(flatten)]
+    #[clap(flatten)]
     pub global: GlobalOptions,
 
     /// Subcommand to run in this invocation.
-    #[structopt(subcommand)]
+    #[clap(subcommand)]
     pub subcommand: Subcommand,
 }
 
@@ -50,14 +50,14 @@ impl Options {
     }
 }
 
-#[derive(Debug, StructOpt)]
+#[derive(Debug, Parser)]
 pub struct GlobalOptions {
     /// Sets verbosity level. Can be specified multiple times.
-    #[structopt(long("verbose"), short, global(true), parse(from_occurrences))]
+    #[clap(long("verbose"), short, global(true), parse(from_occurrences))]
     pub verbosity: u8,
 
     /// Set color behavior. Valid values are auto, always, and never.
-    #[structopt(long("color"), global(true), default_value("auto"))]
+    #[clap(long("color"), global(true), default_value("auto"))]
     pub color: ColorChoice,
 }
 
@@ -109,7 +109,7 @@ pub struct ColorChoiceParseError {
     attempted: String,
 }
 
-#[derive(Debug, StructOpt)]
+#[derive(Debug, Parser)]
 pub enum Subcommand {
     Init(InitCommand),
     Serve(ServeCommand),

src/cli/plugin.rs

@@ -3,9 +3,9 @@ use std::{
     io::BufWriter,
 };
 
+use clap::Parser;
 use memofs::{InMemoryFs, Vfs, VfsSnapshot};
 use roblox_install::RobloxStudio;
-use structopt::StructOpt;
 
 use crate::serve_session::ServeSession;
 
@@ -13,14 +13,14 @@ static PLUGIN_BINCODE: &[u8] = include_bytes!(concat!(env!("OUT_DIR"), "/plugin.
 static PLUGIN_FILE_NAME: &str = "RojoManagedPlugin.rbxm";
 
 /// Install Rojo's plugin.
-#[derive(Debug, StructOpt)]
+#[derive(Debug, Parser)]
 pub struct PluginCommand {
-    #[structopt(subcommand)]
+    #[clap(subcommand)]
     subcommand: PluginSubcommand,
 }
 
 /// Manages Rojo's Roblox Studio plugin.
-#[derive(Debug, StructOpt)]
+#[derive(Debug, Parser)]
 pub enum PluginSubcommand {
     /// Install the plugin in Roblox Studio's plugins folder. If the plugin is
     /// already installed, installing it again will overwrite the current plugin

src/cli/serve.rs

@@ -5,8 +5,8 @@ use std::{
     sync::Arc,
 };
 
+use clap::Parser;
 use memofs::Vfs;
-use structopt::StructOpt;
 use termcolor::{BufferWriter, Color, ColorChoice, ColorSpec, WriteColor};
 
 use crate::{serve_session::ServeSession, web::LiveServer};
@@ -17,19 +17,19 @@ const DEFAULT_BIND_ADDRESS: Ipv4Addr = Ipv4Addr::new(127, 0, 0, 1);
 const DEFAULT_PORT: u16 = 34872;
 
 /// Expose a Rojo project to the Rojo Studio plugin.
-#[derive(Debug, StructOpt)]
+#[derive(Debug, Parser)]
 pub struct ServeCommand {
     /// Path to the project to serve. Defaults to the current directory.
-    #[structopt(default_value = "")]
+    #[clap(default_value = "")]
     pub project: PathBuf,
 
     /// The IP address to listen on. Defaults to `127.0.0.1`.
-    #[structopt(long)]
+    #[clap(long)]
     pub address: Option<IpAddr>,
 
     /// The port to listen on. Defaults to the project's preference, or `34872` if
     /// it has none.
-    #[structopt(long)]
+    #[clap(long)]
     pub port: Option<u16>,
 }
 

src/cli/sourcemap.rs

@@ -3,11 +3,11 @@ use std::{
     path::{Path, PathBuf},
 };
 
+use clap::Parser;
 use fs_err::File;
 use memofs::Vfs;
 use rbx_dom_weak::types::Ref;
 use serde::Serialize;
-use structopt::StructOpt;
 
 use crate::{
     serve_session::ServeSession,
@@ -33,22 +33,22 @@ struct SourcemapNode {
 }
 
 /// Generates a sourcemap file from the Rojo project.
-#[derive(Debug, StructOpt)]
+#[derive(Debug, Parser)]
 pub struct SourcemapCommand {
     /// Path to the project to use for the sourcemap. Defaults to the current
     /// directory.
-    #[structopt(default_value = "")]
+    #[clap(default_value = "")]
     pub project: PathBuf,
 
     /// Where to output the sourcemap. Omit this to use stdout instead of
     /// writing to a file.
     ///
     /// Should end in .json.
-    #[structopt(long, short)]
+    #[clap(long, short)]
     pub output: Option<PathBuf>,
 
     /// If non-script files should be included or not. Defaults to false.
-    #[structopt(long)]
+    #[clap(long)]
     pub include_non_scripts: bool,
 }
 
@@ -56,9 +56,6 @@ impl SourcemapCommand {
     pub fn run(self) -> anyhow::Result<()> {
         let project_path = resolve_path(&self.project);
 
-        let mut project_dir = project_path.to_path_buf();
-        project_dir.pop();
-
         log::trace!("Constructing in-memory filesystem");
         let vfs = Vfs::new_default();
 
@@ -71,7 +68,7 @@ impl SourcemapCommand {
             filter_non_scripts
         };
 
-        let root_node = recurse_create_node(&tree, tree.get_root_id(), &project_dir, filter);
+        let root_node = recurse_create_node(&tree, tree.get_root_id(), session.root_dir(), filter);
 
         if let Some(output_path) = self.output {
             let mut file = BufWriter::new(File::create(&output_path)?);

src/cli/upload.rs

@@ -2,38 +2,38 @@ use std::path::PathBuf;
 use std::str::FromStr;
 
 use anyhow::{bail, format_err, Context};
+use clap::Parser;
 use memofs::Vfs;
 use reqwest::{
     header::{ACCEPT, CONTENT_TYPE, COOKIE, USER_AGENT},
     StatusCode,
 };
-use structopt::StructOpt;
 
 use crate::{auth_cookie::get_auth_cookie, serve_session::ServeSession};
 
 use super::resolve_path;
 
 /// Builds the project and uploads it to Roblox.
-#[derive(Debug, StructOpt)]
+#[derive(Debug, Parser)]
 pub struct UploadCommand {
     /// Path to the project to upload. Defaults to the current directory.
-    #[structopt(default_value = "")]
+    #[clap(default_value = "")]
     pub project: PathBuf,
 
     /// Authenication cookie to use. If not specified, Rojo will attempt to find one from the system automatically.
-    #[structopt(long)]
+    #[clap(long)]
     pub cookie: Option<String>,
 
     /// API key obtained from create.roblox.com/credentials. Rojo will use the Open Cloud API when this is provided. Only supports uploading to a place.
-    #[structopt(long = "api_key")]
+    #[clap(long = "api_key")]
     pub api_key: Option<String>,
 
     /// The Universe ID of the given place. Required when using the Open Cloud API.
-    #[structopt(long = "universe_id")]
+    #[clap(long = "universe_id")]
     pub universe_id: Option<u64>,
 
     /// Asset ID to upload to.
-    #[structopt(long = "asset_id")]
+    #[clap(long = "asset_id")]
     pub asset_id: u64,
 }
 
@@ -123,7 +123,7 @@ fn do_upload(buffer: Vec<u8>, asset_id: u64, cookie: &str) -> anyhow::Result<()>
         asset_id
     );
 
-    let client = reqwest::Client::new();
+    let client = reqwest::blocking::Client::new();
 
     let build_request = move || {
         client
@@ -172,10 +172,10 @@ fn do_upload_open_cloud(
         universe_id, asset_id
     );
 
-    let client = reqwest::Client::new();
+    let client = reqwest::blocking::Client::new();
 
     log::debug!("Uploading to Roblox...");
-    let mut response = client
+    let response = client
         .post(&url)
         .header("x-api-key", api_key)
         .header(CONTENT_TYPE, "application/xml")

src/lib.rs

@@ -9,7 +9,6 @@ mod tree_view;
 
 mod auth_cookie;
 mod change_processor;
-mod glob;
 mod lua_ast;
 mod message_queue;
 mod multimap;

src/main.rs

@@ -1,7 +1,7 @@
 use std::{env, panic, process};
 
 use backtrace::Backtrace;
-use structopt::StructOpt;
+use clap::Parser;
 
 use librojo::cli::Options;
 
@@ -49,7 +49,7 @@ fn main() {
         process::exit(1);
     }));
 
-    let options = Options::from_args();
+    let options = Options::parse();
 
     let log_filter = match options.global.verbosity {
         0 => "info",

src/message_queue.rs

@@ -64,6 +64,7 @@ impl<T: Clone> MessageQueue<T> {
     /// This method is only useful in tests. Non-test code should use subscribe
     /// instead.
     #[cfg(test)]
+    #[allow(unused)]
     pub fn subscribe_any(&self) -> oneshot::Receiver<(u32, Vec<T>)> {
         let cursor = {
             let messages = self.messages.read().unwrap();

src/path_serializer.rs

@@ -36,17 +36,3 @@ where
 
     seq.end()
 }
-
-pub fn serialize_option_absolute<S, T>(
-    maybe_path: &Option<T>,
-    serializer: S,
-) -> Result<S::Ok, S::Error>
-where
-    S: Serializer,
-    T: AsRef<Path>,
-{
-    match maybe_path {
-        Some(path) => serialize_absolute(path, serializer),
-        None => serializer.serialize_none(),
-    }
-}

src/project.rs

@@ -1,379 +1,3 @@
-use std::{
-    collections::{BTreeMap, HashMap, HashSet},
-    fs, io,
-    net::IpAddr,
-    path::{Path, PathBuf},
-};
+pub use rojo_project::{OptionalPathNode, PathNode, Project, ProjectNode};
 
-use serde::{Deserialize, Serialize};
-use thiserror::Error;
-
-use crate::{glob::Glob, resolution::UnresolvedValue};
-
-static PROJECT_FILENAME: &str = "default.project.json";
-
-/// Error type returned by any function that handles projects.
-#[derive(Debug, Error)]
-#[error(transparent)]
-pub struct ProjectError(#[from] Error);
-
-#[derive(Debug, Error)]
-enum Error {
-    #[error(transparent)]
-    Io {
-        #[from]
-        source: io::Error,
-    },
-
-    #[error("Error parsing Rojo project in path {}", .path.display())]
-    Json {
-        source: serde_json::Error,
-        path: PathBuf,
-    },
-}
-
-/// Contains all of the configuration for a Rojo-managed project.
-///
-/// Project files are stored in `.project.json` files.
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-#[serde(deny_unknown_fields, rename_all = "camelCase")]
-pub struct Project {
-    /// The name of the top-level instance described by the project.
-    pub name: String,
-
-    /// The tree of instances described by this project. Projects always
-    /// describe at least one instance.
-    pub tree: ProjectNode,
-
-    /// If specified, sets the default port that `rojo serve` should use when
-    /// using this project for live sync.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub serve_port: Option<u16>,
-
-    /// If specified, contains the set of place IDs that this project is
-    /// compatible with when doing live sync.
-    ///
-    /// This setting is intended to help prevent syncing a Rojo project into the
-    /// wrong Roblox place.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub serve_place_ids: Option<HashSet<u64>>,
-
-    /// If specified, sets the current place's place ID when connecting to the
-    /// Rojo server from Roblox Studio.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub place_id: Option<u64>,
-
-    /// If specified, sets the current place's game ID when connecting to the
-    /// Rojo server from Roblox Studio.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub game_id: Option<u64>,
-
-    /// If specified, this address will be used in place of the default address
-    /// As long as --address is unprovided.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub serve_address: Option<IpAddr>,
-
-    /// A list of globs, relative to the folder the project file is in, that
-    /// match files that should be excluded if Rojo encounters them.
-    #[serde(default, skip_serializing_if = "Vec::is_empty")]
-    pub glob_ignore_paths: Vec<Glob>,
-
-    /// The path to the file that this project came from. Relative paths in the
-    /// project should be considered relative to the parent of this field, also
-    /// given by `Project::folder_location`.
-    #[serde(skip)]
-    pub file_location: PathBuf,
-}
-
-impl Project {
-    /// Tells whether the given path describes a Rojo project.
-    pub fn is_project_file(path: &Path) -> bool {
-        path.file_name()
-            .and_then(|name| name.to_str())
-            .map(|name| name.ends_with(".project.json"))
-            .unwrap_or(false)
-    }
-
-    /// Attempt to locate a project represented by the given path.
-    ///
-    /// This will find a project if the path refers to a `.project.json` file,
-    /// or is a folder that contains a `default.project.json` file.
-    fn locate(path: &Path) -> Option<PathBuf> {
-        let meta = fs::metadata(path).ok()?;
-
-        if meta.is_file() {
-            if Project::is_project_file(path) {
-                Some(path.to_path_buf())
-            } else {
-                None
-            }
-        } else {
-            let child_path = path.join(PROJECT_FILENAME);
-            let child_meta = fs::metadata(&child_path).ok()?;
-
-            if child_meta.is_file() {
-                Some(child_path)
-            } else {
-                // This is a folder with the same name as a Rojo default project
-                // file.
-                //
-                // That's pretty weird, but we can roll with it.
-                None
-            }
-        }
-    }
-
-    pub fn load_from_slice(
-        contents: &[u8],
-        project_file_location: &Path,
-    ) -> Result<Self, ProjectError> {
-        let mut project: Self =
-            serde_json::from_slice(&contents).map_err(|source| Error::Json {
-                source,
-                path: project_file_location.to_owned(),
-            })?;
-
-        project.file_location = project_file_location.to_path_buf();
-        project.check_compatibility();
-        Ok(project)
-    }
-
-    pub fn load_fuzzy(fuzzy_project_location: &Path) -> Result<Option<Self>, ProjectError> {
-        if let Some(project_path) = Self::locate(fuzzy_project_location) {
-            let project = Self::load_exact(&project_path)?;
-
-            Ok(Some(project))
-        } else {
-            Ok(None)
-        }
-    }
-
-    fn load_exact(project_file_location: &Path) -> Result<Self, Error> {
-        let contents = fs::read_to_string(project_file_location)?;
-
-        let mut project: Project =
-            serde_json::from_str(&contents).map_err(|source| Error::Json {
-                source,
-                path: project_file_location.to_owned(),
-            })?;
-
-        project.file_location = project_file_location.to_path_buf();
-        project.check_compatibility();
-
-        Ok(project)
-    }
-
-    /// Checks if there are any compatibility issues with this project file and
-    /// warns the user if there are any.
-    fn check_compatibility(&self) {
-        self.tree.validate_reserved_names();
-    }
-
-    pub fn folder_location(&self) -> &Path {
-        self.file_location.parent().unwrap()
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
-pub struct OptionalPathNode {
-    #[serde(serialize_with = "crate::path_serializer::serialize_absolute")]
-    pub optional: PathBuf,
-}
-
-impl OptionalPathNode {
-    pub fn new(optional: PathBuf) -> Self {
-        OptionalPathNode { optional }
-    }
-}
-
-/// Describes a path that is either optional or required
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-#[serde(untagged)]
-pub enum PathNode {
-    Required(#[serde(serialize_with = "crate::path_serializer::serialize_absolute")] PathBuf),
-    Optional(OptionalPathNode),
-}
-
-impl PathNode {
-    pub fn path(&self) -> &Path {
-        match self {
-            PathNode::Required(pathbuf) => &pathbuf,
-            PathNode::Optional(OptionalPathNode { optional }) => &optional,
-        }
-    }
-}
-
-/// Describes an instance and its descendants in a project.
-#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
-pub struct ProjectNode {
-    /// If set, defines the ClassName of the described instance.
-    ///
-    /// `$className` MUST be set if `$path` is not set.
-    ///
-    /// `$className` CANNOT be set if `$path` is set and the instance described
-    /// by that path has a ClassName other than Folder.
-    #[serde(rename = "$className", skip_serializing_if = "Option::is_none")]
-    pub class_name: Option<String>,
-
-    /// Contains all of the children of the described instance.
-    #[serde(flatten)]
-    pub children: BTreeMap<String, ProjectNode>,
-
-    /// The properties that will be assigned to the resulting instance.
-    ///
-    // TODO: Is this legal to set if $path is set?
-    #[serde(
-        rename = "$properties",
-        default,
-        skip_serializing_if = "HashMap::is_empty"
-    )]
-    pub properties: HashMap<String, UnresolvedValue>,
-
-    /// Defines the behavior when Rojo encounters unknown instances in Roblox
-    /// Studio during live sync. `$ignoreUnknownInstances` should be considered
-    /// a large hammer and used with care.
-    ///
-    /// If set to `true`, those instances will be left alone. This may cause
-    /// issues when files that turn into instances are removed while Rojo is not
-    /// running.
-    ///
-    /// If set to `false`, Rojo will destroy any instances it does not
-    /// recognize.
-    ///
-    /// If unset, its default value depends on other settings:
-    /// - If `$path` is not set, defaults to `true`
-    /// - If `$path` is set, defaults to `false`
-    #[serde(
-        rename = "$ignoreUnknownInstances",
-        skip_serializing_if = "Option::is_none"
-    )]
-    pub ignore_unknown_instances: Option<bool>,
-
-    /// Defines that this instance should come from the given file path. This
-    /// path can point to any file type supported by Rojo, including Lua files
-    /// (`.lua`), Roblox models (`.rbxm`, `.rbxmx`), and localization table
-    /// spreadsheets (`.csv`).
-    #[serde(rename = "$path", skip_serializing_if = "Option::is_none")]
-    pub path: Option<PathNode>,
-}
-
-impl ProjectNode {
-    fn validate_reserved_names(&self) {
-        for (name, child) in &self.children {
-            if name.starts_with('$') {
-                log::warn!(
-                    "Keys starting with '$' are reserved by Rojo to ensure forward compatibility."
-                );
-                log::warn!(
-                    "This project uses the key '{}', which should be renamed.",
-                    name
-                );
-            }
-
-            child.validate_reserved_names();
-        }
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-
-    #[test]
-    fn path_node_required() {
-        let path_node: PathNode = serde_json::from_str(r#""src""#).unwrap();
-        assert_eq!(path_node, PathNode::Required(PathBuf::from("src")));
-    }
-
-    #[test]
-    fn path_node_optional() {
-        let path_node: PathNode = serde_json::from_str(r#"{ "optional": "src" }"#).unwrap();
-        assert_eq!(
-            path_node,
-            PathNode::Optional(OptionalPathNode::new(PathBuf::from("src")))
-        );
-    }
-
-    #[test]
-    fn project_node_required() {
-        let project_node: ProjectNode = serde_json::from_str(
-            r#"{
-                "$path": "src"
-            }"#,
-        )
-        .unwrap();
-
-        assert_eq!(
-            project_node.path,
-            Some(PathNode::Required(PathBuf::from("src")))
-        );
-    }
-
-    #[test]
-    fn project_node_optional() {
-        let project_node: ProjectNode = serde_json::from_str(
-            r#"{
-                "$path": { "optional": "src" }
-            }"#,
-        )
-        .unwrap();
-
-        assert_eq!(
-            project_node.path,
-            Some(PathNode::Optional(OptionalPathNode::new(PathBuf::from(
-                "src"
-            ))))
-        );
-    }
-
-    #[test]
-    fn project_node_none() {
-        let project_node: ProjectNode = serde_json::from_str(
-            r#"{
-                "$className": "Folder"
-            }"#,
-        )
-        .unwrap();
-
-        assert_eq!(project_node.path, None);
-    }
-
-    #[test]
-    fn project_node_optional_serialize_absolute() {
-        let project_node: ProjectNode = serde_json::from_str(
-            r#"{
-                "$path": { "optional": "..\\src" }
-            }"#,
-        )
-        .unwrap();
-
-        let serialized = serde_json::to_string(&project_node).unwrap();
-        assert_eq!(serialized, r#"{"$path":{"optional":"../src"}}"#);
-    }
-
-    #[test]
-    fn project_node_optional_serialize_absolute_no_change() {
-        let project_node: ProjectNode = serde_json::from_str(
-            r#"{
-                "$path": { "optional": "../src" }
-            }"#,
-        )
-        .unwrap();
-
-        let serialized = serde_json::to_string(&project_node).unwrap();
-        assert_eq!(serialized, r#"{"$path":{"optional":"../src"}}"#);
-    }
-
-    #[test]
-    fn project_node_optional_serialize_optional() {
-        let project_node: ProjectNode = serde_json::from_str(
-            r#"{
-                "$path": "..\\src"
-            }"#,
-        )
-        .unwrap();
-
-        let serialized = serde_json::to_string(&project_node).unwrap();
-        assert_eq!(serialized, r#"{"$path":"../src"}"#);
-    }
-}
+pub use anyhow::Error as ProjectError;

src/serve_session.rs

@@ -16,7 +16,7 @@ use thiserror::Error;
 use crate::{
     change_processor::ChangeProcessor,
     message_queue::MessageQueue,
-    project::{Project, ProjectError},
+    project::Project,
     session_id::SessionId,
     snapshot::{
         apply_patch_set, compute_patch_set, AppliedPatchSet, InstanceContext, InstanceSnapshot,
@@ -216,6 +216,10 @@ impl ServeSession {
     pub fn serve_address(&self) -> Option<IpAddr> {
         self.root_project.serve_address
     }
+
+    pub fn root_dir(&self) -> &Path {
+        self.root_project.folder_location()
+    }
 }
 
 #[derive(Debug, Error)]
@@ -233,12 +237,6 @@ pub enum ServeSessionError {
         source: io::Error,
     },
 
-    #[error(transparent)]
-    Project {
-        #[from]
-        source: ProjectError,
-    },
-
     #[error(transparent)]
     Other {
         #[from]

src/snapshot/metadata.rs

@@ -4,9 +4,10 @@ use std::{
     sync::Arc,
 };
 
+use rojo_project::glob::Glob;
 use serde::{Deserialize, Serialize};
 
-use crate::{glob::Glob, path_serializer, project::ProjectNode};
+use crate::{path_serializer, project::ProjectNode};
 
 /// Rojo-specific metadata that can be associated with an instance or a snapshot
 /// of an instance.

tests/rojo_test/serve_util.rs

@@ -141,14 +141,14 @@ impl TestServeSession {
 
     pub fn get_api_rojo(&self) -> Result<ServerInfoResponse, reqwest::Error> {
         let url = format!("http://localhost:{}/api/rojo", self.port);
-        let body = reqwest::get(&url)?.text()?;
+        let body = reqwest::blocking::get(&url)?.text()?;
 
         Ok(serde_json::from_str(&body).expect("Server returned malformed response"))
     }
 
     pub fn get_api_read(&self, id: Ref) -> Result<ReadResponse, reqwest::Error> {
         let url = format!("http://localhost:{}/api/read/{}", self.port, id);
-        let body = reqwest::get(&url)?.text()?;
+        let body = reqwest::blocking::get(&url)?.text()?;
 
         Ok(serde_json::from_str(&body).expect("Server returned malformed response"))
     }
@@ -159,7 +159,7 @@ impl TestServeSession {
     ) -> Result<SubscribeResponse<'static>, reqwest::Error> {
         let url = format!("http://localhost:{}/api/subscribe/{}", self.port, cursor);
 
-        reqwest::get(&url)?.json()
+        reqwest::blocking::get(&url)?.json()
     }
 }