Release 0.5.0-alpha.12

* Support for .meta.json files other than init

* Localize .meta.json application

.gitignore

@@ -2,4 +2,8 @@
 /target
 /scratch-project
 **/*.rs.bk
-/server/failed-snapshots/
+/server/failed-snapshots/
+/*.rbxm
+/*.rbxmx
+/*.rbxl
+/*.rbxlx

.gitmodules

@@ -12,4 +12,7 @@
 	url = https://github.com/LPGhatguy/roblox-lua-promise.git
 [submodule "plugin/modules/t"]
 	path = plugin/modules/t
-	url = https://github.com/osyrisrblx/t.git
+	url = https://github.com/osyrisrblx/t.git
+[submodule "plugin/modules/rbx-dom"]
+	path = plugin/modules/rbx-dom
+	url = http://github.com/LPGhatguy/rbx-dom

CHANGELOG.md

@@ -1,8 +1,46 @@
 # Rojo Changelog
 
-## [Unreleased]
+## [0.5.0 Alpha 12](https://github.com/rojo-rbx/rojo/releases/tag/v0.5.0-alpha.12) (July 2, 2019)
+* Added `.meta.json` files
+    * `init.meta.json` files replace `init.model.json` files from Rojo 0.4.x ([#183](https://github.com/rojo-rbx/rojo/pull/183))
+    * Other `.meta.json` files allow attaching extra data to other files ([#189](https://github.com/rojo-rbx/rojo/pull/189))
+* Added support for infinite and NaN values in types like `Vector2` when building models and places.
+    * These types aren't supported for live-syncing yet due to limitations around JSON encoding.
+* Added support for using `SharedString` values when building XML models and places.
+* Added support for live-syncing `CollectionService` tags.
+* Added a warning when building binary place files, since they're still experimental and have bugs.
+* Added a warning when trying to use Rojo 0.5.x with a Rojo 0.4.x-only project.
+* Added a warning when a Rojo project contains keys that start with `$`, which are reserved names. ([#191](https://github.com/rojo-rbx/rojo/issues/191))
+* Rojo now throws an error if unknown keys are found most files.
+* Added an icon to the plugin's toolbar button
+* Changed the plugin to use a docking widget for all UI.
+* Changed the plugin to ignore unknown properties when live-syncing.
+    * Rojo's approach to this problem might change later, like with a strict model mode ([#190](https://github.com/rojo-rbx/rojo/issues/190)) or another approach.
+* Upgraded to reflection database from client release 388.
+* Updated Rojo's branding to shift the color palette to make it work better on dark backgrounds
 
-## [0.5.0 Alpha 8](https://github.com/LPGhatguy/rojo/releases/tag/v0.5.0-alpha.8) (March 29, 2019)
+## [0.5.0 Alpha 11](https://github.com/rojo-rbx/rojo/releases/tag/v0.5.0-alpha.11) (May 29, 2019)
+* Added support for implicit property values in JSON model files ([#154](https://github.com/rojo-rbx/rojo/pull/154))
+* `Content` propertyes can now be specified in projects and model files as regular string literals.
+* Added support for `BrickColor` properties.
+* Added support for properties added in client release 384, like `Lighting.Technology` being set to `"ShadowMap"`.
+* Improved performance when working with XML models and places
+* Fixed serializing empty `Content` properties as XML
+* Fixed serializing infinite and NaN floating point properties in XML
+* Improved compatibility with XML models
+* Plugin should now be able to live-sync more properties, and ignore ones it can't, like `Lighting.Technology`.
+
+## 0.5.0 Alpha 10
+* This release was a dud due to [issue #176](https://github.com/rojo-rbx/rojo/issues/176) and was rolled back.
+
+## [0.5.0 Alpha 9](https://github.com/rojo-rbx/rojo/releases/tag/v0.5.0-alpha.9) (April 4, 2019)
+* Changed `rojo build` to use buffered I/O, which can make it up to 2x faster in some cases.
+    * Building [*Road Not Taken*](https://github.com/rojo-rbx/roads) to an `rbxlx` file dropped from 150ms to 70ms on my machine
+* Fixed `LocalizationTable` instances being made from `csv` files incorrectly interpreting empty rows and columns. ([#149](https://github.com/rojo-rbx/rojo/pull/149))
+* Fixed CSV files with entries that parse as numbers causing Rojo to panic. ([#152](https://github.com/rojo-rbx/rojo/pull/152))
+* Improved error messages when malformed CSV files are found in a Rojo project.
+
+## [0.5.0 Alpha 8](https://github.com/rojo-rbx/rojo/releases/tag/v0.5.0-alpha.8) (March 29, 2019)
 * Added support for a bunch of new types when dealing with XML model/place files:
     * `ColorSequence`
     * `Float64`
@@ -13,13 +51,13 @@
     * `Ray`
     * `Rect`
     * `Ref`
-* Improved server instance ordering behavior when files are added during a live session ([#135](https://github.com/LPGhatguy/rojo/pull/135))
+* Improved server instance ordering behavior when files are added during a live session ([#135](https://github.com/rojo-rbx/rojo/pull/135))
 * Fixed error being thrown when trying to unload the Rojo plugin.
-* Added partial fix for [issue #141](https://github.com/LPGhatguy/rojo/issues/141) for `Lighting.Technology`, which should restore live sync functionality for the default project file.
+* Added partial fix for [issue #141](https://github.com/rojo-rbx/rojo/issues/141) for `Lighting.Technology`, which should restore live sync functionality for the default project file.
 
-## [0.5.0 Alpha 6](https://github.com/LPGhatguy/rojo/releases/tag/v0.5.0-alpha.6) (March 19, 2019)
+## [0.5.0 Alpha 6](https://github.com/rojo-rbx/rojo/releases/tag/v0.5.0-alpha.6) (March 19, 2019)
 * Fixed `rojo init` giving unexpected results by upgrading to `rbx_dom_weak` 1.1.0
-* Fixed live server not responding when the Rojo plugin is connected ([#133](https://github.com/LPGhatguy/rojo/issues/133))
+* Fixed live server not responding when the Rojo plugin is connected ([#133](https://github.com/rojo-rbx/rojo/issues/133))
 * Updated default place file:
     * Improved default properties to be closer to Studio's built-in 'Baseplate' template
     * Added a baseplate to the project file (Thanks, [@AmaranthineCodices](https://github.com/AmaranthineCodices/)!)
@@ -27,40 +65,40 @@
 * Fixed some cases where the Rojo plugin would leave around objects that it knows should be deleted
 * Updated plugin to correctly listen to `Plugin.Unloading` when installing or uninstalling new plugins
 
-## [0.5.0 Alpha 5](https://github.com/LPGhatguy/rojo/releases/tag/v0.5.0-alpha.5) (March 1, 2019)
+## [0.5.0 Alpha 5](https://github.com/rojo-rbx/rojo/releases/tag/v0.5.0-alpha.5) (March 1, 2019)
 * Upgraded core dependencies, which improves compatibility for lots of instance types
     * Upgraded from `rbx_tree` 0.2.0 to `rbx_dom_weak` 1.0.0
     * Upgraded from `rbx_xml` 0.2.0 to `rbx_xml` 0.4.0
     * Upgraded from `rbx_binary` 0.2.0 to `rbx_binary` 0.4.0
 * Added support for non-primitive types in the Rojo plugin.
     * Types like `Color3` and `CFrame` can now be updated live!
-* Fixed plugin assets flashing in on first load ([#121](https://github.com/LPGhatguy/rojo/issues/121))
+* Fixed plugin assets flashing in on first load ([#121](https://github.com/rojo-rbx/rojo/issues/121))
 * Changed Rojo's HTTP server from Rouille to Hyper, which reduced the release size by around a megabyte.
-* Added property type inference to projects, which makes specifying services a lot easier ([#130](https://github.com/LPGhatguy/rojo/pull/130))
+* Added property type inference to projects, which makes specifying services a lot easier ([#130](https://github.com/rojo-rbx/rojo/pull/130))
 * Made error messages from invalid and missing files more user-friendly
 
-## [0.5.0 Alpha 4](https://github.com/LPGhatguy/rojo/releases/tag/v0.5.0-alpha.4) (February 8, 2019)
+## [0.5.0 Alpha 4](https://github.com/rojo-rbx/rojo/releases/tag/v0.5.0-alpha.4) (February 8, 2019)
-* Added support for nested partitions ([#102](https://github.com/LPGhatguy/rojo/issues/102))
+* Added support for nested partitions ([#102](https://github.com/rojo-rbx/rojo/issues/102))
-* Added support for 'transmuting' partitions ([#112](https://github.com/LPGhatguy/rojo/issues/112))
+* Added support for 'transmuting' partitions ([#112](https://github.com/rojo-rbx/rojo/issues/112))
-* Added support for aliasing filesystem paths ([#105](https://github.com/LPGhatguy/rojo/issues/105))
+* Added support for aliasing filesystem paths ([#105](https://github.com/rojo-rbx/rojo/issues/105))
-* Changed Windows builds to statically link the CRT ([#89](https://github.com/LPGhatguy/rojo/issues/89))
+* Changed Windows builds to statically link the CRT ([#89](https://github.com/rojo-rbx/rojo/issues/89))
 
-## [0.5.0 Alpha 3](https://github.com/LPGhatguy/rojo/releases/tag/v0.5.0-alpha.3) (February 1, 2019)
+## [0.5.0 Alpha 3](https://github.com/rojo-rbx/rojo/releases/tag/v0.5.0-alpha.3) (February 1, 2019)
-* Changed default project file name from `roblox-project.json` to `default.project.json` ([#120](https://github.com/LPGhatguy/rojo/pull/120))
+* Changed default project file name from `roblox-project.json` to `default.project.json` ([#120](https://github.com/rojo-rbx/rojo/pull/120))
     * The old file name will still be supported until 0.5.0 is fully released.
 * Added warning when loading project files that don't end in `.project.json`
     * This new extension enables Rojo to distinguish project files from random JSON files, which is necessary to support nested projects.
 * Added new (empty) diagnostic page served from the server
 * Added better error messages for when a file is missing that's referenced by a Rojo project
 * Added support for visualization endpoints returning GraphViz source when Dot is not available
-* Fixed an in-memory filesystem regression introduced recently ([#119](https://github.com/LPGhatguy/rojo/pull/119))
+* Fixed an in-memory filesystem regression introduced recently ([#119](https://github.com/rojo-rbx/rojo/pull/119))
 
-## [0.5.0 Alpha 2](https://github.com/LPGhatguy/rojo/releases/tag/v0.5.0-alpha.2) (January 28, 2019)
+## [0.5.0 Alpha 2](https://github.com/rojo-rbx/rojo/releases/tag/v0.5.0-alpha.2) (January 28, 2019)
 * Added support for `.model.json` files, compatible with 0.4.x
 * Fixed in-memory filesystem not handling out-of-order filesystem change events
-* Fixed long-polling error caused by a promise mixup ([#110](https://github.com/LPGhatguy/rojo/issues/110))
+* Fixed long-polling error caused by a promise mixup ([#110](https://github.com/rojo-rbx/rojo/issues/110))
 
-## [0.5.0 Alpha 1](https://github.com/LPGhatguy/rojo/releases/tag/v0.5.0-alpha.1) (January 25, 2019)
+## [0.5.0 Alpha 1](https://github.com/rojo-rbx/rojo/releases/tag/v0.5.0-alpha.1) (January 25, 2019)
 * Changed plugin UI to be way prettier
     * Thanks to [Reselim](https://github.com/Reselim) for the design!
 * Changed plugin error messages to be a little more useful
@@ -68,7 +106,7 @@
 * Fixed bug where bad server responses could cause the plugin to be in a bad state
 * Upgraded to rbx\_tree, rbx\_xml, and rbx\_binary 0.2.0, which dramatically expands the kinds of properties that Rojo can handle, especially in XML.
 
-## [0.5.0 Alpha 0](https://github.com/LPGhatguy/rojo/releases/tag/v0.5.0-alpha.0) (January 14, 2019)
+## [0.5.0 Alpha 0](https://github.com/rojo-rbx/rojo/releases/tag/v0.5.0-alpha.0) (January 14, 2019)
 * "Epiphany" rewrite, in progress since the beginning of time
 * New live sync protocol
     * Uses HTTP long polling to reduce request count and improve responsiveness
@@ -93,105 +131,105 @@
     * Multiple places can be specified, like when building a multi-place game
 * Added support for specifying properties on services in project files
 
-## [0.4.13](https://github.com/LPGhatguy/rojo/releases/tag/v0.4.13) (November 12, 2018)
+## [0.4.13](https://github.com/rojo-rbx/rojo/releases/tag/v0.4.13) (November 12, 2018)
 * When `rojo.json` points to a file or directory that does not exist, Rojo now issues a warning instead of throwing an error and exiting
 
-## [0.4.12](https://github.com/LPGhatguy/rojo/releases/tag/v0.4.12) (June 21, 2018)
+## [0.4.12](https://github.com/rojo-rbx/rojo/releases/tag/v0.4.12) (June 21, 2018)
-* Fixed obscure assertion failure when renaming or deleting files ([#78](https://github.com/LPGhatguy/rojo/issues/78))
+* Fixed obscure assertion failure when renaming or deleting files ([#78](https://github.com/rojo-rbx/rojo/issues/78))
-* Added a `PluginAction` for the sync in command, which should help with some automation scripts ([#80](https://github.com/LPGhatguy/rojo/pull/80))
+* Added a `PluginAction` for the sync in command, which should help with some automation scripts ([#80](https://github.com/rojo-rbx/rojo/pull/80))
 
-## [0.4.11](https://github.com/LPGhatguy/rojo/releases/tag/v0.4.11) (June 10, 2018)
+## [0.4.11](https://github.com/rojo-rbx/rojo/releases/tag/v0.4.11) (June 10, 2018)
 * Defensively insert existing instances into RouteMap; should fix most duplication cases when syncing into existing trees.
 * Fixed incorrect synchronization from `Plugin:_pull` that would cause polling to create issues
 * Fixed incorrect file routes being assigned to `init.lua` and `init.model.json` files
 * Untangled route handling-internals slightly
 
-## [0.4.10](https://github.com/LPGhatguy/rojo/releases/tag/v0.4.10) (June 2, 2018)
+## [0.4.10](https://github.com/rojo-rbx/rojo/releases/tag/v0.4.10) (June 2, 2018)
-* Added support for `init.model.json` files, which enable versioning `Tool` instances (among other things) with Rojo. ([#66](https://github.com/LPGhatguy/rojo/issues/66))
+* Added support for `init.model.json` files, which enable versioning `Tool` instances (among other things) with Rojo. ([#66](https://github.com/rojo-rbx/rojo/issues/66))
 * Fixed obscure error when syncing into an invalid service.
 * Fixed multiple sync processes occurring when a server ID mismatch is detected.
 
-## [0.4.9](https://github.com/LPGhatguy/rojo/releases/tag/v0.4.9) (May 26, 2018)
+## [0.4.9](https://github.com/rojo-rbx/rojo/releases/tag/v0.4.9) (May 26, 2018)
-* Fixed warning when renaming or removing files that would sometimes corrupt the instance cache ([#72](https://github.com/LPGhatguy/rojo/pull/72))
+* Fixed warning when renaming or removing files that would sometimes corrupt the instance cache ([#72](https://github.com/rojo-rbx/rojo/pull/72))
 * JSON models are no longer as strict -- `Children` and `Properties` are now optional.
 
-## [0.4.8](https://github.com/LPGhatguy/rojo/releases/tag/v0.4.8) (May 26, 2018)
+## [0.4.8](https://github.com/rojo-rbx/rojo/releases/tag/v0.4.8) (May 26, 2018)
 * Hotfix to prevent errors from being thrown when objects managed by Rojo are deleted
 
-## [0.4.7](https://github.com/LPGhatguy/rojo/releases/tag/v0.4.7) (May 25, 2018)
+## [0.4.7](https://github.com/rojo-rbx/rojo/releases/tag/v0.4.7) (May 25, 2018)
-* Added icons to the Rojo plugin, made by [@Vorlias](https://github.com/Vorlias)! ([#70](https://github.com/LPGhatguy/rojo/pull/70))
+* Added icons to the Rojo plugin, made by [@Vorlias](https://github.com/Vorlias)! ([#70](https://github.com/rojo-rbx/rojo/pull/70))
-* Server will now issue a warning if no partitions are specified in `rojo serve` ([#40](https://github.com/LPGhatguy/rojo/issues/40))
+* Server will now issue a warning if no partitions are specified in `rojo serve` ([#40](https://github.com/rojo-rbx/rojo/issues/40))
 
-## [0.4.6](https://github.com/LPGhatguy/rojo/releases/tag/v0.4.6) (May 21, 2018)
+## [0.4.6](https://github.com/rojo-rbx/rojo/releases/tag/v0.4.6) (May 21, 2018)
-* Rojo handles being restarted by Roblox Studio more gracefully ([#67](https://github.com/LPGhatguy/rojo/issues/67))
+* Rojo handles being restarted by Roblox Studio more gracefully ([#67](https://github.com/rojo-rbx/rojo/issues/67))
 * Folders should no longer get collapsed when syncing occurs.
 * **Significant** robustness improvements with regards to caching.
     * **This should catch all existing script duplication bugs.**
     * If there are any bugs with script duplication or caching in the future, restarting the Rojo server process will fix them for that session.
 * Fixed message in plugin not being prefixed with `Rojo: `.
 
-## [0.4.5](https://github.com/LPGhatguy/rojo/releases/tag/v0.4.5) (May 1, 2018)
+## [0.4.5](https://github.com/rojo-rbx/rojo/releases/tag/v0.4.5) (May 1, 2018)
 * Rojo messages are now prefixed with `Rojo: ` to make them stand out in the output more.
 * Fixed server to notice file changes *much* more quickly. (200ms vs 1000ms)
 * Server now lists name of project when starting up.
-* Rojo now throws an error if no project file is found. ([#63](https://github.com/LPGhatguy/rojo/issues/63))
+* Rojo now throws an error if no project file is found. ([#63](https://github.com/rojo-rbx/rojo/issues/63))
-* Fixed multiple sync operations occuring at the same time. ([#61](https://github.com/LPGhatguy/rojo/issues/61))
+* Fixed multiple sync operations occuring at the same time. ([#61](https://github.com/rojo-rbx/rojo/issues/61))
-* Partitions targeting files directly now work as expected. ([#57](https://github.com/LPGhatguy/rojo/issues/57))
+* Partitions targeting files directly now work as expected. ([#57](https://github.com/rojo-rbx/rojo/issues/57))
 
-## [0.4.4](https://github.com/LPGhatguy/rojo/releases/tag/v0.4.4) (April 7, 2018)
+## [0.4.4](https://github.com/rojo-rbx/rojo/releases/tag/v0.4.4) (April 7, 2018)
 * Fix small regression introduced in 0.4.3
 
-## [0.4.3](https://github.com/LPGhatguy/rojo/releases/tag/v0.4.3) (April 7, 2018)
+## [0.4.3](https://github.com/rojo-rbx/rojo/releases/tag/v0.4.3) (April 7, 2018)
-* Plugin now automatically selects `HttpService` if it determines that HTTP isn't enabled ([#58](https://github.com/LPGhatguy/rojo/pull/58))
+* Plugin now automatically selects `HttpService` if it determines that HTTP isn't enabled ([#58](https://github.com/rojo-rbx/rojo/pull/58))
 * Plugin now has much more robust handling and will wipe all state when the server changes.
     * This should fix issues that would otherwise be solved by restarting Roblox Studio.
 
-## [0.4.2](https://github.com/LPGhatguy/rojo/releases/tag/v0.4.2) (April 4, 2018)
+## [0.4.2](https://github.com/rojo-rbx/rojo/releases/tag/v0.4.2) (April 4, 2018)
 * Fixed final case of duplicated instance insertion, caused by reconciled instances not being inserted into `RouteMap`.
     * The reconciler is still not a perfect solution, especially if script instances get moved around without being destroyed. I don't think this can be fixed before a big refactor.
 
-## [0.4.1](https://github.com/LPGhatguy/rojo/releases/tag/v0.4.1) (April 1, 2018)
+## [0.4.1](https://github.com/rojo-rbx/rojo/releases/tag/v0.4.1) (April 1, 2018)
 * Merged plugin repository into main Rojo repository for easier tracking.
 * Improved `RouteMap` object tracking; this should fix some cases of duplicated instances being synced into the tree.
 
-## [0.4.0](https://github.com/LPGhatguy/rojo/releases/tag/v0.4.0) (March 27, 2018)
+## [0.4.0](https://github.com/rojo-rbx/rojo/releases/tag/v0.4.0) (March 27, 2018)
 * Protocol version 1, which shifts more responsibility onto the server
     * This is a **major breaking** change!
     * The server now has a content of 'filter plugins', which transform data at various stages in the pipeline
     * The server now exposes Roblox instance objects instead of file contents, which lines up with how `rojo pack` will work, and paves the way for more robust syncing.
 * Added `*.model.json` files, which let you embed small Roblox objects into your Rojo tree.
-* Improved error messages in some cases ([#46](https://github.com/LPGhatguy/rojo/issues/46))
+* Improved error messages in some cases ([#46](https://github.com/rojo-rbx/rojo/issues/46))
 
-## [0.3.2](https://github.com/LPGhatguy/rojo/releases/tag/v0.3.2) (December 20, 2017)
+## [0.3.2](https://github.com/rojo-rbx/rojo/releases/tag/v0.3.2) (December 20, 2017)
 * Fixed `rojo serve` failing to correctly construct an absolute root path when passed as an argument
 * Fixed intense CPU usage when running `rojo serve`
 
-## [0.3.1](https://github.com/LPGhatguy/rojo/releases/tag/v0.3.1) (December 14, 2017)
+## [0.3.1](https://github.com/rojo-rbx/rojo/releases/tag/v0.3.1) (December 14, 2017)
 * Improved error reporting when invalid JSON is found in a `rojo.json` project
     * These messages are passed on from Serde
 
-## [0.3.0](https://github.com/LPGhatguy/rojo/releases/tag/v0.3.0) (December 12, 2017)
+## [0.3.0](https://github.com/rojo-rbx/rojo/releases/tag/v0.3.0) (December 12, 2017)
 * Factored out the plugin into a separate repository
 * Fixed server when using a file as a partition
     * Previously, trailing slashes were put on the end of a partition even if the read request was an empty string. This broke file reading on Windows when a partition pointed to a file instead of a directory!
 * Started running automatic tests on Travis CI (#9)
 
-## [0.2.3](https://github.com/LPGhatguy/rojo/releases/tag/v0.2.3) (December 4, 2017)
+## [0.2.3](https://github.com/rojo-rbx/rojo/releases/tag/v0.2.3) (December 4, 2017)
 * Plugin only release
 * Tightened `init` file rules to only match script files
     * Previously, Rojo would sometimes pick up the wrong file when syncing
 
-## [0.2.2](https://github.com/LPGhatguy/rojo/releases/tag/v0.2.2) (December 1, 2017)
+## [0.2.2](https://github.com/rojo-rbx/rojo/releases/tag/v0.2.2) (December 1, 2017)
 * Plugin only release
 * Fixed broken reconciliation behavior with `init` files
 
-## [0.2.1](https://github.com/LPGhatguy/rojo/releases/tag/v0.2.1) (December 1, 2017)
+## [0.2.1](https://github.com/rojo-rbx/rojo/releases/tag/v0.2.1) (December 1, 2017)
 * Plugin only release
 * Changes default port to 8000
 
-## [0.2.0](https://github.com/LPGhatguy/rojo/releases/tag/v0.2.0) (December 1, 2017)
+## [0.2.0](https://github.com/rojo-rbx/rojo/releases/tag/v0.2.0) (December 1, 2017)
 * Support for `init.lua` like rbxfs and rbxpacker
 * More robust syncing with a new reconciler
 
-## [0.1.0](https://github.com/LPGhatguy/rojo/releases/tag/v0.1.0) (November 29, 2017)
+## [0.1.0](https://github.com/rojo-rbx/rojo/releases/tag/v0.1.0) (November 29, 2017)
-* Initial release, functionally very similar to [rbxfs](https://github.com/LPGhatguy/rbxfs)
+* Initial release, functionally very similar to [rbxfs](https://github.com/rojo-rbx/rbxfs)

Cargo.toml

@@ -1,5 +1,7 @@
 [workspace]
 members = [
 	"server",
-	"rojo-e2e",
+]
-]
+
+[profile.dev]
+opt-level = 1

README.md

@@ -1,68 +1,56 @@
 <div align="center">
-    <img src="assets/rojo-logo.png" alt="Rojo" height="217" />
+    <a href="https://rojo.space">
+        <img src="assets/rojo-logo.png" alt="Rojo" height="217" />
+    </a>
 </div>
 
 <div>&nbsp;</div>
 
 <div align="center">
-    <a href="https://travis-ci.org/LPGhatguy/rojo">
+    <a href="https://travis-ci.org/rojo-rbx/rojo">
-        <img src="https://api.travis-ci.org/LPGhatguy/rojo.svg?branch=master" alt="Travis-CI Build Status" />
+        <img src="https://api.travis-ci.org/rojo-rbx/rojo.svg?branch=master" alt="Travis-CI Build Status" />
     </a>
     <a href="https://crates.io/crates/rojo">
         <img src="https://img.shields.io/crates/v/rojo.svg?label=version" alt="Latest server version" />
     </a>
-    <a href="https://lpghatguy.github.io/rojo/0.4.x">
+    <a href="https://rojo.space/docs/0.4.x">
-        <img src="https://img.shields.io/badge/docs-0.4.x-brightgreen.svg" alt="Rojo Documentation" />
+        <img src="https://img.shields.io/badge/docs-0.4.x-brightgreen.svg" alt="Rojo 0.4.x Documentation" />
     </a>
-    <a href="https://lpghatguy.github.io/rojo/0.5.x">
+    <a href="https://rojo.space/docs/0.5.x">
-        <img src="https://img.shields.io/badge/docs-0.5.x-brightgreen.svg" alt="Rojo Documentation" />
+        <img src="https://img.shields.io/badge/docs-0.5.x-brightgreen.svg" alt="Rojo 0.5.x Documentation" />
     </a>
 </div>
 
 <hr />
 
-**Rojo** is a flexible multi-tool designed for creating robust Roblox projects.
+**Rojo** is a tool designed to enable Roblox developers to use professional-grade software engineering tools.
 
-It lets Roblox developers use industry-leading tools like Git and VS Code, and crucial utilities like Luacheck.
+With Rojo, it's possible to use industry-leading tools like **Visual Studio Code** and **Git**.
 
-Rojo is designed for **power users** who want to use the **best tools available** for building games, libraries, and plugins.
+Rojo is designed for power users who want to use the best tools available for building games, libraries, and plugins.
 
 ## Features
-Rojo lets you:
+Rojo enables:
 
-* Work on scripts from the filesystem, in your favorite editor
+* Working on scripts and models from the filesystem, in your favorite editor
-* Version your place, model, or plugin using Git or another VCS
+* Versioning your game, library, or plugin using Git or another VCS
-* Sync `rbxmx` and `rbxm` models into your game in real time
+* Streaming `rbxmx` and `rbxm` models into your game in real time
-* Package and deploy your project to Roblox.com from the command line
+* Packaging and deploying your project to Roblox.com from the command line
 
 Soon, Rojo will be able to:
 
+* Automatically convert your existing game to work with Rojo
 * Sync instances from Roblox Studio to the filesystem
-* Compile MoonScript and other custom things for your project
+* Automatically manage your assets on Roblox.com, like images and sounds
+* Import custom instances like MoonScript code
 
-## [Documentation](https://lpghatguy.github.io/rojo)
+## [Documentation](https://rojo.space/docs/latest)
-You can also view the documentation by browsing the [docs](https://github.com/LPGhatguy/rojo/tree/master/docs) folder of the repository, but because it uses a number of Markdown extensions, it may not be very readable.
+If you find any mistakes, feel free to make changes in the [docs](https://github.com/rojo-rbx/rojo/tree/master/docs) folder of this repository and submit a pull request!
-
-## Inspiration and Alternatives
-There are lots of other tools that sync scripts into Roblox or provide other tools for working with Roblox places.
-
-Here are a few, if you're looking for alternatives or supplements to Rojo:
-
-* [rbxmk by Anaminus](https://github.com/anaminus/rbxmk)
-* [Rofresh by Osyris](https://github.com/osyrisrblx/rofresh)
-* [RbxRefresh by Osyris](https://github.com/osyrisrblx/RbxRefresh)
-* [Studio Bridge by Vocksel](https://github.com/vocksel/studio-bridge)
-* [Elixir by Vocksel](https://github.com/vocksel/elixir)
-* [RbxSync by evaera](https://github.com/evaera/RbxSync)
-* [CodeSync by MemoryPenguin](https://github.com/MemoryPenguin/CodeSync)
-* [rbx-exteditor by MemoryPenguin](https://github.com/MemoryPenguin/rbx-exteditor)
-
-If you use a plugin that _isn't_ Rojo for syncing code, open an issue and let me know why! I'd like Rojo to be the end-all tool so that people stop reinventing solutions to this problem.
 
 ## Contributing
 Pull requests are welcome!
 
-Rojo supports Rust 1.32 and newer. Any changes to the minimum required compiler version require a _minor_ version bump.
+Rojo supports Rust 1.32 and newer.
 
 ## License
 Rojo is available under the terms of the Mozilla Public License, Version 2.0. See [LICENSE.txt](LICENSE.txt) for details.

design.gv

@@ -1,39 +0,0 @@
-digraph G {
-	graph [
-		ranksep = "0.7",
-		nodesep = "1.0",
-	];
-	node [
-		fontname = "Hack",
-		shape = "record",
-	];
-
-	roblox_studio -> plugin [dir = "both"];
-	plugin -> web_server [style = "dashed", dir = "both"];
-
-	web_server -> session;
-
-	session -> rbx_session;
-	session -> fs_watcher;
-	session -> message_queue;
-
-	fs_watcher -> imfs [weight = "10"];
-	fs_watcher -> rbx_session [constraint = "false"];
-
-	imfs -> fs;
-
-	rbx_session -> imfs;
-	rbx_session -> middlewares [weight = "10"];
-	rbx_session -> message_queue [constraint = "false"];
-
-	plugin [label = "Studio Plugin"];
-	roblox_studio [label = "Roblox Studio"];
-	fs [label = "Filesystem"];
-	fs_watcher [label = "Filesystem Watcher"];
-	session [label = "Session"];
-	web_server [label = "Web API"];
-	imfs [label = "In-Memory Filesystem"];
-	rbx_session [label = "RbxSession"];
-	message_queue [label = "MessageQueue"];
-	middlewares [label = "Middlewares"];
-}

docs/creating-a-place.md

@@ -1,68 +0,0 @@
-[TOC]
-
-## Creating the Rojo Project
-
-To use Rojo to build a place, you'll need to create a new project file, which tells Rojo how your project is structured on-disk and in Roblox.
-
-Create a new folder, then run `rojo init` inside that folder to initialize an empty project.
-
-```sh
-mkdir my-new-project
-cd my-new-project
-
-rojo init
-```
-
-Rojo will make a small project file in your directory, named `default.project.json`. It'll make sure that any code in the directory `src` will get put into `ReplicatedStorage.Source`.
-
-Speaking of, let's make sure we create a directory named `src`, and maybe a Lua file inside of it:
-
-```sh
-mkdir src
-echo 'print("Hello, world!")' > src/hello.lua
-```
-
-## Building Your Place
-Now that we have a project, one thing we can do is build a Roblox place file for our project. This is a great way to get started with a project quickly with no fuss.
-
-All we have to do is call `rojo build`:
-
-```sh
-rojo build -o MyNewProject.rbxl
-```
-
-If you open `MyNewProject.rbxl` in Roblox Studio now, you should see a `Folder` containing a `ModuleScript` under `ReplicatedStorage`!
-
-!!! info
-    To generate an XML place file instead, like if you're checking the place file into version control, just use `rbxlx` as the extension on the output file instead.
-
-## Live-Syncing into Studio
-Building a place file is great for the initial build, but for actively working on your place, you'll want something quicker.
-
-In Roblox Studio, make sure the Rojo plugin is installed. If you need it, check out [the installation guide](installation) to learn how to install it.
-
-To expose your project to the plugin, you'll need to _serve_ it from the command line:
-
-```sh
-rojo serve
-```
-
-This will start up a web server that tells Roblox Studio what instances are in your project and sends notifications if any of them change.
-
-Note the port number, then switch into Roblox Studio and press the Rojo **Connect** button in the plugins tab. Type in the port number, if necessary, and press **Start**.
-
-If everything went well, you should now be able to change files in the `src` directory and watch them sync into Roblox Studio in real time!
-
-## Uploading Your Place
-Aimed at teams that want serious levels of automation, Rojo can upload places to Roblox.com automatically.
-
-You'll need an existing place on Roblox.com as well as the `.ROBLOSECURITY` cookie of an account that has write access to that place.
-
-!!! warning
-    It's recommended that you set up a Roblox account dedicated to deploying your place instead of your personal account in case your security cookie is compromised.
-
-Generating and uploading your place file is as simple as:
-
-```sh
-rojo upload --asset_id [PLACE ID] --cookie "[SECURITY COOKIE]"
-```

docs/extra.css

@@ -1,3 +1,13 @@
 .md-typeset__table {
   width: 100%;
+}
+
+.feature-image img {
+  border: 1px solid rgba(0, 0, 0, 0.2);
+  box-shadow: 1px 1px 4px rgba(0, 0, 0, 0.2);
+}
+
+.codehilite {
+  border: 1px solid rgba(0, 0, 0, 0.2);
+  box-shadow: 1px 1px 4px rgba(0, 0, 0, 0.2);
 }

docs/guide/existing-game.md

@@ -0,0 +1,11 @@
+**This page is under construction!**
+
+## Summary
+* Tools to port existing games are in progress!
+    * [rbxlx-to-rojo](https://github.com/rojo/rbxlx-to-rojo)
+    * `rojo export` ([issue #208](https://github.com/rojo-rbx/rojo/issues/208))
+* Can port as much or as little of your game as you like
+    * Rojo can manage just a slice of your game!
+* Some Roblox idioms aren't very well supported
+    * Redundant copies of scripts don't work well with files
+    * Having only a couple places with scripts simplifies your project dramatically!

docs/guide/installation.md

@@ -1,7 +1,8 @@
+This is this installation guide for Rojo **0.5.x**.
+
 [TOC]
 
 ## Overview
-
 Rojo has two components:
 
 * The command line interface (CLI)
@@ -12,6 +13,9 @@ Rojo has two components:
 
     The plugin will show errors in the Roblox Studio output window if there is a version mismatch.
 
+## Visual Studio Code Extension
+If you use Visual Studio Code, you can install [the Rojo VS Code extension](https://marketplace.visualstudio.com/items?itemName=evaera.vscode-rojo), which will install both halves of Rojo for you. It even has a nifty UI to sync files and start/stop the Rojo server!
+
 ## Installing the CLI
 
 ### Installing from GitHub
@@ -25,21 +29,18 @@ If you have Rust installed, the easiest way to get Rojo is with Cargo!
 To install the latest 0.5.0 alpha, use:
 
 ```sh
-cargo install rojo --version 0.5.0-alpha.8
+cargo install rojo --version 0.5.0-alpha.12
 ```
 
 ## Installing the Plugin
 
 ### Installing from GitHub
-The Rojo Roblox Studio plugin is available available from Rojo's [GitHub Releases page](https://github.com/LPGhatguy/rojo/releases).
+The Rojo Roblox Studio plugin is available from Rojo's [GitHub Releases page](https://github.com/LPGhatguy/rojo/releases).
 
 Download the attached `rbxm` file and put it into your Roblox Studio plugins folder. You can find that folder by pressing **Plugins Folder** from your Plugins toolbar in Roblox Studio:
 
-!['Plugins Folder' button in Roblox Studio](images/plugins-folder-in-studio.png)
+!['Plugins Folder' button in Roblox Studio](../images/plugins-folder-in-studio.png)
 {: align="center" }
 
 ### Installing from Roblox.com
-Visit [Rojo's Roblox.com Plugin page](https://www.roblox.com/library/1997686364/Rojo-0-5-0-alpha-3) in Roblox Studio and press **Install**.
+Visit [Rojo's Roblox.com Plugin page](https://www.roblox.com/library/1997686364/Rojo-0-5-0-alpha-3) in Roblox Studio and press **Install**.
-
-## Visual Studio Code Extension
-If you use Visual Studio Code on Windows, you can install [Evaera's unofficial Rojo extension](https://marketplace.visualstudio.com/items?itemName=evaera.vscode-rojo), which will install both halves of Rojo for you. It even has a nifty UI to add partitions and start/stop the Rojo server!

docs/guide/migrating-to-epiphany.md

@@ -55,4 +55,9 @@ All other values are considered children, where the key is the instance's name,
 ## Migrating Unknown Files
 If you used Rojo to sync in files as `StringValue` objects, you'll need to make sure those files end with the `txt` extension to preserve this in Rojo 0.5.x.
 
-Unknown files are now ignored in Rojo instead of being converted to `StringValue` objects.
+Unknown files are now ignored in Rojo instead of being converted to `StringValue` objects.
+
+## Migrating `init.model.json` files
+In Rojo 0.4.x, it's possible to create a file named `init.model.json` that lets you describe a model that becomes the container for all of the other files in the folder, just like `init.lua`.
+
+In Rojo 0.5.x, this feature has been replaced with `init.meta.json` files. See [Sync Details](../reference/sync-details) for more information about these new files.

docs/guide/new-game.md

@@ -0,0 +1,90 @@
+[TOC]
+
+## Creating the Rojo Project
+To use Rojo to build a game, you'll need to create a new project file, which tells Rojo how to turn your files into a Roblox place.
+
+First, create a new folder to contain the files for your game and open up a new terminal inside of it, like cmd.exe or Bash.
+
+It's convenient to make the folder from the command line:
+
+```sh
+mkdir my-new-project
+cd my-new-project
+```
+
+Inside the folder, initialize a new Rojo project:
+
+```sh
+rojo init
+```
+
+Rojo will make a small project file in your directory, named `default.project.json`. It matches the "Baseplate" template from Roblox Studio, except that it'll take any files you put in a folder called `src` and put it into `ReplicatedStorage.Source`.
+
+Speaking of files, make sure to create a directory named `src` in this folder, or Rojo will be upset about missing files!
+
+```sh
+mkdir src
+```
+
+Let's also add a Lua file, `hello.lua` to the `src` folder, so that we can make this project our own.
+
+```sh
+echo 'return "Hello, Rojo!"' > src/hello.lua
+```
+
+## Building Your Place
+Now that we have a project, one thing we can do is build a Roblox place file for our project. This is a great way to get started with a project quickly with no fuss.
+
+All we have to do is call `rojo build`:
+
+```sh
+rojo build -o MyNewProject.rbxlx
+```
+
+If you open `MyNewProject.rbxlx` in Roblox Studio now, you should see a `Folder` containing a `ModuleScript` under `ReplicatedStorage`!
+
+!!! info
+    To generate a binary place file instead, use `rbxl`. Note that support for binary model/place files (`rbxm` and `rbxl`) is very limited in Rojo presently.
+
+## Live-Syncing into Studio
+Building a place file is great for starting to work on a game, but for active iteration, you'll want something faster.
+
+In Roblox Studio, make sure the Rojo plugin is installed. If you need it, check out [the installation guide](installation) to learn how to install it.
+
+To expose your project to the plugin, you'll need to start a new **live sync session** from the command line:
+
+```sh
+rojo serve
+```
+
+You should see output like this in your terminal:
+
+```sh
+$ rojo serve
+Rojo server listening on port 34872
+```
+
+Switch into Roblox Studio and press the **Connect** button on the Rojo plugin toolbar. A dialog should appear:
+
+![Rojo plugin connection dialog](../images/connection-dialog.png)
+{: class="feature-image" align="center" }
+
+If the port number doesn't match the output from the command line, change it, and then press **Connect**.
+
+If all went well, you should now be able to change files in the `src` directory and watch them sync into Roblox Studio in real time!
+
+## Uploading Your Place
+Aimed at teams that want serious levels of automation, Rojo can upload places to Roblox.com automatically.
+
+You'll need an existing game on Roblox.com as well as the `.ROBLOSECURITY` cookie of an account that has write access to that game.
+
+!!! warning
+    It's recommended that you set up a Roblox account dedicated to deploying your game instead of your personal account in case your security cookie is compromised.
+
+Generating and publishing your game is as simple as:
+
+```sh
+rojo upload --asset_id [PLACE ID] --cookie "[SECURITY COOKIE]"
+```
+
+An example project is available on GitHub that deploys to Roblox.com from GitHub and Travis-CI automatically: [https://github.com/LPGhatguy/roads](https://github.com/LPGhatguy/roads)

docs/index.md

@@ -2,10 +2,10 @@ This is the documentation home for Rojo 0.5.x.
 
 Available versions of these docs:
 
-* [Latest version (currently 0.5.x)](https://lpghatguy.github.io/rojo)
+* [Latest version (currently 0.5.x)](https://rojo.space/docs/latest)
-* [0.5.x](https://lpghatguy.github.io/rojo/0.5.x)
+* [0.5.x](https://rojo.space/docs/0.5.x)
-* [0.4.x](https://lpghatguy.github.io/rojo/0.4.x)
+* [0.4.x](https://rojo.space/docs/0.4.x)
 
 **Rojo** is a flexible multi-tool designed for creating robust Roblox projects.
 
-This documentation is a continual work in progress. If you find any issues, please file an issue on [Rojo's issue tracker](https://github.com/LPGhatguy/rojo/issues)!
+This documentation is a continual work in progress. If you find any issues, please file an issue on [Rojo's issue tracker](https://github.com/rojo-rbx/rojo/issues)!

docs/reference/full-vs-partial.md

@@ -0,0 +1,37 @@
+Rojo is designed to be adopted incrementally. How much of your project Rojo manages is up to you!
+
+There are two primary categories of ways to use Rojo: *Fully Managed*, where everything is managed by Rojo, and *Partially Managed*, where Rojo only manages a slice of your project.
+
+## Fully Managed
+In a fully managed game project, Rojo controls every instance. A fully managed Rojo project can be built from scratch using `rojo build`.
+
+Fully managed projects are most practical for libraries, plugins, and simple games.
+
+Rojo's goal is to make it practical and easy for _every_ project to be fully managed, but we're not quite there yet!
+
+### Pros
+* Fully reproducible builds from scratch
+* Everything checked into version control
+
+### Cons
+* Without two-way sync, models have to be saved manually
+    * This can be done with the 'Save to File...' menu in Roblox Studio
+    * This will be solved by Two-Way Sync ([issue #164](https://github.com/LPGhatguy/rojo/issues/164))
+* Rojo can't manage everything yet
+    * Refs are currently broken ([issue #142](https://github.com/LPGhatguy/rojo/issues/142))
+
+## Partially Managed
+In a partially managed project, Rojo only handles a slice of the game. This could be as small as a couple scripts, or as large as everything except `Workspace`!
+
+The rest of the place's content can be versioned using Team Create or checked into source control.
+
+Partially managed projects are most practical for complicated games, or games that are migrating to use Rojo.
+
+### Pros
+* Easier to adopt gradually
+* Integrates with Team Create
+
+### Cons
+* Not everything is in version control, which makes merges tougher
+* Rojo can't live-sync instances like Terrain, MeshPart, or CSG operations yet
+    * Will be fixed with plugin escalation ([issue #169](https://github.com/LPGhatguy/rojo/issues/169))

docs/reference/project-format.md

@@ -24,19 +24,70 @@ Instance Descriptions correspond one-to-one with the actual Roblox Instances in
 
 All other fields in an Instance Description are turned into instances whose name is the key. These values should also be Instance Descriptions!
 
-Instance Descriptions are fairly verbose and strict. In the future, it'll be possible for Rojo to infer class names for known services like `Workspace`.
+Instance Descriptions are fairly verbose and strict. In the future, it'll be possible for Rojo to [infer class names for known services like `Workspace`](https://github.com/LPGhatguy/rojo/issues/179).
 
 ## Instance Property Value
-The shape of Instance Property Values is defined by the [rbx_tree](https://github.com/LPGhatguy/rbx-tree) library, so it uses slightly different conventions than the rest of Rojo.
+There are two kinds of property values on instances, **implicit** and **explicit**.
+
+In the vast majority of cases, you should be able to use **implicit** property values. To use them, just use a value that's the same shape as the type that the property has:
+
+```json
+"MyPart": {
+    "$className": "Part",
+    "$properties": {
+        "Size": [3, 5, 3],
+        "Color": [0.5, 0, 0.5],
+        "Anchored": true,
+        "Material": "Granite"
+    }
+}
+```
+
+`Vector3` and `Color3` properties can just be arrays of numbers, as can types like `Vector2`, `CFrame`, and more!
+
+Enums can be set to a string containing the enum variant. Rojo will raise an error if the string isn't a valid variant for the enum.
+
+There are some cases where this syntax for assigning properties _doesn't_ work. In these cases, Rojo requires you to use the **explicit** property syntax.
+
+Some reasons why you might need to use an **explicit** property:
+
+* Using exotic property types like `BinaryString`
+* Using properties added to Roblox recently that Rojo doesn't know about yet
+
+The shape of explicit property values is defined by the [rbx-dom](https://github.com/LPGhatguy/rbx-dom) library, so it uses slightly different conventions than the rest of Rojo.
 
 Each value should be an object with the following required fields:
 
 * `Type`: The type of property to represent.
     * [Supported types can be found here](https://github.com/LPGhatguy/rbx-tree#property-type-coverage).
 * `Value`: The value of the property.
-    * The shape of this field depends on which property type is being used. `Vector3` and `Color3` values are both represented as a list of numbers, for example.
+    * The shape of this field depends on which property type is being used. `Vector3` and `Color3` values are both represented as a list of numbers, while `BinaryString` expects a base64-encoded string, for example.
 
-Instance Property Values are intentionally very strict. Rojo will eventually be able to infer types for you!
+Here's the same object, but with explicit properties:
+
+```json
+"MyPart": {
+    "$className": "Part",
+    "$properties": {
+        "Size": {
+            "Type": "Vector3",
+            "Value": [3, 5, 3]
+        },
+        "Color": {
+            "Type": "Color3",
+            "Value": [0.5, 0, 0.5]
+        },
+        "Anchored": {
+            "Type": "Bool",
+            "Value": true
+        },
+        "Material": {
+            "Type": "Enum",
+            "Value": 832
+        }
+    }
+}
+```
 
 ## Example Projects
 This project bundles up everything in the `src` directory. It'd be suitable for making a plugin or model:
@@ -61,10 +112,7 @@ This project describes the layout you might use if you were making the next hit
         "HttpService": {
             "$className": "HttpService",
             "$properties": {
-                "HttpEnabled": {
+                "HttpEnabled": true
-                    "Type": "Bool",
-                    "Value": true
-                }
             }
         },
 
@@ -85,10 +133,7 @@ This project describes the layout you might use if you were making the next hit
         "Workspace": {
             "$className": "Workspace",
             "$properties": {
-                "Gravity": {
+                "Gravity": 67.3
-                    "Type": "Float32",
-                    "Value": 67.3
-                }
             },
 
             "Terrain": {

docs/reference/sync-details.md

@@ -0,0 +1,144 @@
+This page aims to describe how Rojo turns files on the filesystem into Roblox objects.
+
+[TOC]
+
+## Overview
+| File Name      | Instance Type             |
+| -------------- | ------------------------- |
+| any directory  | `Folder`                  |
+| `*.server.lua` | `Script`                  |
+| `*.client.lua` | `LocalScript`             |
+| `*.lua`        | `ModuleScript`            |
+| `*.csv`        | `LocalizationTable`       |
+| `*.txt`        | `StringValue`             |
+| `*.model.json` | Any                       |
+| `*.rbxm`       | Any                       |
+| `*.rbxmx`      | Any                       |
+| `*.meta.json`  | Modifies another instance |
+
+## Limitations
+Not all property types can be synced by Rojo in real-time due to limitations of the Roblox Studio plugin API. In these cases, you can usually generate a place file and open it when you start working on a project.
+
+Some common cases you might hit are:
+
+* Binary data (Terrain, CSG, CollectionService tags)
+* `MeshPart.MeshId`
+* `HttpService.HttpEnabled`
+
+For a list of all property types that Rojo can reason about, both when live-syncing and when building place files, look at [rbx-dom's type coverage chart](https://github.com/rojo-rbx/rbx-dom#property-type-coverage).
+
+This limitation may be solved by [issue #205](https://github.com/rojo-rbx/rojo/issues/205) in the future.
+
+## Folders
+Any directory on the filesystem will turn into a `Folder` instance unless it contains an 'init' script, described below.
+
+## Scripts
+The default script type in Rojo projects is `ModuleScript`, since most scripts in well-structued Roblox projects will be modules.
+
+If a directory contains a file named `init.server.lua`, `init.client.lua`, or `init.lua`, that folder will be transformed into a `*Script` instance with the contents of the 'init' file. This can be used to create scripts inside of scripts.
+
+For example, these files:
+
+![Tree of files on disk](../images/sync-example-files.svg)
+{: align="center" }
+
+Will turn into these instances in Roblox:
+
+![Tree of instances in Roblox](../images/sync-example-instances.svg)
+{: align="center" }
+
+## Localization Tables
+Any CSV files are transformed into `LocalizationTable` instances. Rojo expects these files to follow the same format that Roblox does when importing and exporting localization information.
+
+## Plain Text Files
+Plain text files (`.txt`) files are transformed into `StringValue` instances. This is useful for bringing in text data that can be read by scripts at runtime.
+
+## JSON Models
+Files ending in `.model.json` can be used to describe simple models. They're designed to be hand-written and are useful for instances like `RemoteEvent`.
+
+A JSON model describing a folder containing a `Part` and a `RemoteEvent` could be described as:
+
+```json
+{
+    "Name": "My Cool Model",
+    "ClassName": "Folder",
+    "Children": [
+        {
+            "Name": "RootPart",
+            "ClassName": "Part",
+            "Properties": {
+                "Size": {
+                    "Type": "Vector3",
+                    "Value": [4, 4, 4]
+                }
+            }
+        },
+        {
+            "Name": "SendMoney",
+            "ClassName": "RemoteEvent"
+        }
+    ]
+}
+```
+
+It would turn into instances in this shape:
+
+![Tree of instances in Roblox](../images/sync-example-json-model.svg)
+{: align="center" }
+
+## Binary and XML Models
+Rojo supports both binary (`.rbxm`) and XML (`.rbxmx`) models generated by Roblox Studio or another tool.
+
+Support for the `rbxmx` is very good, while support for `rbxm` is still very early, buggy, and lacking features.
+
+For a rundown of supported types, check out [rbx-dom's type coverage chart](https://github.com/rojo-rbx/rbx-dom#property-type-coverage).
+
+## Meta Files
+New in Rojo 0.5.0-alpha.12 are meta files, named `.meta.json`.
+
+Meta files allow attaching extra Rojo data to models defined in other formats, like Roblox's `rbxm` and `rbxmx` model formats, or even Lua scripts.
+
+This can be used to set Rojo-specific settings like `ignoreUnknownInstances`, or can be used to set properties like `Disabled` on a script.
+
+Meta files can contain:
+
+* `className`: Changes the `className` of a containing `Folder` into something else.
+    * Usable only in `init.meta.json` files
+* `properties`: A map of properties to set on the instance, just like projects
+    * Usable on anything except `.rbxmx`, `.rbxm`, and `.model.json` files, which already have properties
+* `ignoreUnknownInstances`: Works just like `$ignoreUnknownInstances` in project files
+
+### Meta Files to set Rojo metadata
+Sometimes it's useful to apply properties like `ignoreUnknownInstances` on instances that are defined on the filesystem instead of within the project itself.
+
+### Meta Files for Disabled Scripts
+Meta files can be used to set properties on `Script` instances, like `Disabled`.
+
+If your project had `foo.server.lua` and you wanted to make sure it would be disabled, you could create a `foo.meta.json` next to it with:
+
+```json
+{
+    "properties": {
+        "Disabled": true
+    }
+}
+```
+
+### Meta Files for Tools
+If you wanted to represent a tool containing a script and a model for its handle, create a directory with an `init.meta.json` file in it:
+
+```json
+{
+    "className": "Tool",
+    "properties": {
+        "Grip": [
+            0, 0, 0,
+            1, 0, 0,
+            0, 1, 0,
+            0, 0, 1,
+        ]
+    }
+}
+```
+
+Instead of a `Folder` instance, you'll end up with a `Tool` instance with the `Grip` property set!

docs/rojo-alternatives.md

@@ -0,0 +1,23 @@
+There are a number of existing plugins for Roblox that move code from the filesystem into Roblox.
+
+Besides Rojo, you might consider:
+
+* [rbxmk by Anaminus](https://github.com/anaminus/rbxmk)
+* [Rofresh by Osyris](https://github.com/osyrisrblx/rofresh)
+* [RbxRefresh by Osyris](https://github.com/osyrisrblx/RbxRefresh)
+* [Studio Bridge by Vocksel](https://github.com/vocksel/studio-bridge)
+* [Elixir by Vocksel](https://github.com/vocksel/elixir)
+* [RbxSync by evaera](https://github.com/evaera/RbxSync)
+* [CodeSync by MemoryPenguin](https://github.com/MemoryPenguin/CodeSync)
+* [rbx-exteditor by MemoryPenguin](https://github.com/MemoryPenguin/rbx-exteditor)
+
+So why did I build Rojo?
+
+Each of these tools solves what is essentially the same problem from a few different angles. The goal of Rojo is to take all of the lessons and ideas learned from these projects and build a tool that can solve this problem for good.
+
+Additionally:
+
+* I think that this tool needs to be built in a compiled language without a runtime, for easy distribution and good performance.
+* I think that the conventions promoted by other sync plugins (`.module.lua` for modules, as well a single sync point) are sub-optimal.
+* I think that I have a good enough understanding of the problem to build something robust.
+* I think that Rojo should be able to do more than just sync code.

docs/sync-details.md

@@ -1,91 +0,0 @@
-This page aims to describe how Rojo turns files on the filesystem into Roblox objects.
-
-[TOC]
-
-## Overview
-| File Name      | Instance Type       |
-| -------------- | ------------------- |
-| any directory  | `Folder`            |
-| `*.server.lua` | `Script`            |
-| `*.client.lua` | `LocalScript`       |
-| `*.lua`        | `ModuleScript`      |
-| `*.csv`        | `LocalizationTable` |
-| `*.txt`        | `StringValue`       |
-| `*.model.json` | Any                 |
-| `*.rbxm`       | Any                 |
-| `*.rbxmx`      | Any                 |
-
-## Limitations
-Not all property types can be synced by Rojo in real-time due to limitations of the Roblox Studio plugin API. In these cases, you can usually generate a place file and open it when you start working on a project.
-
-Some common cases you might hit are:
-
-* Binary data (Terrain, CSG, CollectionService tags)
-* `MeshPart.MeshId`
-* `HttpService.HttpEnabled`
-
-For a list of all property types that Rojo can reason about, both when live-syncing and when building place files, look at [rbx_tree's type coverage chart](https://github.com/LPGhatguy/rbx-tree#property-type-coverage).
-
-## Folders
-Any directory on the filesystem will turn into a `Folder` instance unless it contains an 'init' script, described below.
-
-## Scripts
-The default script type in Rojo projects is `ModuleScript`, since most scripts in well-structued Roblox projects will be modules.
-
-If a directory contains a file named `init.server.lua`, `init.client.lua`, or `init.lua`, that folder will be transformed into a `*Script` instance with the contents of the 'init' file. This can be used to create scripts inside of scripts.
-
-For example, these files:
-
-![Tree of files on disk](images/sync-example-files.svg)
-{: align="center" }
-
-Will turn into these instances in Roblox:
-
-![Tree of instances in Roblox](images/sync-example-instances.svg)
-{: align="center" }
-
-## Localization Tables
-Any CSV files are transformed into `LocalizationTable` instances. Rojo expects these files to follow the same format that Roblox does when importing and exporting localization information.
-
-## Plain Text Files
-Plain text files (`.txt`) files are transformed into `StringValue` instances. This is useful for bringing in text data that can be read by scripts at runtime.
-
-## JSON Models
-Files ending in `.model.json` can be used to describe simple models. They're designed to be hand-written and are useful for instances like `RemoteEvent`.
-
-A JSON model describing a folder containing a `Part` and a `RemoteEvent` could be described as:
-
-```json
-{
-    "Name": "My Cool Model",
-    "ClassName": "Folder",
-    "Children": [
-        {
-            "Name": "RootPart",
-            "ClassName": "Part",
-            "Properties": {
-                "Size": {
-                    "Type": "Vector3",
-                    "Value": [4, 4, 4]
-                }
-            }
-        },
-        {
-            "Name": "SendMoney",
-            "ClassName": "RemoteEvent"
-        }
-    ]
-}
-```
-
-It would turn into instances in this shape:
-
-![Tree of instances in Roblox](images/sync-example-json-model.svg)
-{: align="center" }
-
-## Binary and XML Models
-Rojo supports both binary (`.rbxm`) and XML (`.rbxmx`) models generated by Roblox Studio or another tool.
-
-Not all property types are supported for all formats!
-
-For a rundown of supported types, check out [rbx_tree's type coverage chart](https://github.com/LPGhatguy/rbx-tree#property-type-coverage).

docs/why-rojo.md

@@ -1,23 +1,39 @@
-There are a number of existing plugins for Roblox that move code from the filesystem into Roblox.
+Adding a tool like Rojo to your Roblox workflow can be daunting, but it comes with some key advantages.
 
-Besides Rojo, you might consider:
+[TOC]
 
-* [rbxmk by Anaminus](https://github.com/anaminus/rbxmk)
+## External Text Editors
-* [Rofresh by Osyris](https://github.com/osyrisrblx/rofresh)
+Rojo opens the door to use the absolute best text editors in the world and their rich plugin ecosystems.
-* [RbxRefresh by Osyris](https://github.com/osyrisrblx/RbxRefresh)
-* [Studio Bridge by Vocksel](https://github.com/vocksel/studio-bridge)
-* [Elixir by Vocksel](https://github.com/vocksel/elixir)
-* [RbxSync by evaera](https://github.com/evaera/RbxSync)
-* [CodeSync by MemoryPenguin](https://github.com/MemoryPenguin/CodeSync)
-* [rbx-exteditor by MemoryPenguin](https://github.com/MemoryPenguin/rbx-exteditor)
 
-So why did I build Rojo?
+Some very popular editors include [Visual Studio Code](https://code.visualstudio.com) and [Sublime Text](https://www.sublimetext.com).
 
-Each of these tools solves what is essentially the same problem from a few different angles. The goal of Rojo is to take all of the lessons and ideas learned from these projects and build a tool that can solve this problem for good.
+These advanced text editors have features like multi-cursor editing, goto symbol, multi-file regex find and replace, bookmarks and much more.
 
-Additionally:
+Many Rojo VS Code users also use extensions like:
 
-* I think that this tool needs to be built in a compiled language without a runtime, for easy distribution and good performance.
+* [vscode-rbxlua](https://marketplace.visualstudio.com/items?itemName=AmaranthineCodices.vscode-rbxlua)
-* I think that the conventions promoted by other sync plugins (`.module.lua` for modules, as well a single sync point) are sub-optimal.
+* [Roblox Lua Autocompletes](https://marketplace.visualstudio.com/items?itemName=Kampfkarren.roblox-lua-autofills)
-* I think that I have a good enough understanding of the problem to build something robust.
+* [TabNine](https://tabnine.com)
-* I think that Rojo should be able to do more than just sync code.
+
+## Version Control
+By building your game (or just the scripts) as individual files on the filesystem, it becomes easy to start using professional-grade version control tools like [Git](https://git-scm.com) and [GitHub](https://github.com).
+
+Hundreds of thousands of companies and individual developers use Git to version their software projects. With Rojo, Roblox developers can take advantage of the best collaboration tool around.
+
+Using a repository hosting service like GitHub or GitLab brings powerful features to Roblox developers like code reviews and issue tracking that professional engineers can't live without.
+
+## TypeScript
+TypeScript enables static type safety, which helps prevent typos and adds unparalleled autocompletion. It also brings features like arrow functions, object destructuring, functional programming methods, and more!
+
+With Rojo, you can use [roblox-ts](https://roblox-ts.github.io) to compile TypeScript to Lua and take advantage of a huge ecosystem of TypeScript tooling.
+
+It's also possible to use other languages that compile to Lua like [MoonScript](https://moonscript.org) and [Haxe](https://haxe.org).
+
+## Other Tools
+There are decades of excellent tools available that operate on files. With Rojo, it's possible to take advantage of any of them!
+
+Popular tools include:
+
+* [luacheck](https://github.com/mpeterv/luacheck), a static analysis tool to help you write better Lua
+* [ripgrep](https://github.com/BurntSushi/ripgrep), an extremely fast code search tool
+* [Tokei](https://github.com/XAMPPRocky/tokei), a tool for statistics like lines of code

generate-docs

@@ -1,35 +0,0 @@
-#!/bin/sh
-
-# Kludged documentation generator to support multiple versions.
-# Make sure the `site` folder is a checkout of this repository's `gh-pages`
-# branch.
-
-set -e
-
-REMOTE=$(git remote get-url origin)
-CHECKOUT="$(mktemp -d)"
-OUTPUT="$(pwd)/site"
-
-if [ -d site ]
-then
-	cd site
-	git pull
-else
-	git clone "$REMOTE" site
-	cd site
-	git checkout gh-pages
-fi
-
-git clone "$REMOTE" "$CHECKOUT"
-cd "$CHECKOUT"
-
-echo "Building master"
-git checkout master
-mkdocs build --site-dir "$OUTPUT"
-
-echo "Building 0.5.x"
-mkdocs build --site-dir "$OUTPUT/0.5.x"
-
-echo "Building 0.4.x"
-git checkout v0.4.x
-mkdocs build --site-dir "$OUTPUT/0.4.x"

mkdocs.yml

@@ -1,6 +1,6 @@
 site_name: Rojo Documentation
-repo_name: LPGhatguy/rojo
+repo_name: rojo-rbx/rojo
-repo_url: https://github.com/LPGhatguy/rojo
+repo_url: https://github.com/rojo-rbx/rojo
 
 theme:
   name: material
@@ -11,11 +11,16 @@ theme:
 nav:
   - Home: index.md
   - Why Rojo?: why-rojo.md
-  - Installation: installation.md
+  - Guide:
-  - Creating a Place with Rojo: creating-a-place.md
+    - Installation: guide/installation.md
-  - Migrating from 0.4.x to 0.5.x: migrating-to-epiphany.md
+    - Creating a Game with Rojo: guide/new-game.md
-  - Project Format: project-format.md
+    - Porting an Existing Game to Rojo: guide/existing-game.md
-  - Sync Details: sync-details.md
+    - Migrating from 0.4.x to 0.5.x: guide/migrating-to-epiphany.md
+  - Reference:
+    - Fully vs Partially Managed Rojo: reference/full-vs-partial.md
+    - Project Format: reference/project-format.md
+    - Sync Details: reference/sync-details.md
+  - Rojo Alternatives: rojo-alternatives.md
   - Rojo Internals:
     - Internals Overview: internals/overview.md
 

plugin/default.project.json

@@ -6,13 +6,16 @@
       "$path": "src"
     },
     "Roact": {
-      "$path": "modules/roact/lib"
+      "$path": "modules/roact/src"
     },
     "Promise": {
       "$path": "modules/promise/lib"
     },
     "t": {
-      "$path": "modules/t/lib/t.lua"
+      "$path": "modules/t/lib"
+    },
+    "RbxDom": {
+      "$path": "modules/rbx-dom/rbx_dom_lua/src"
     }
   }
 }

plugin/place.project.json

@@ -13,13 +13,13 @@
           "$path": "src"
         },
         "Roact": {
-          "$path": "modules/roact/lib"
+          "$path": "modules/roact/src"
         },
         "Promise": {
           "$path": "modules/promise/lib"
         },
         "t": {
-          "$path": "modules/t/lib/t.lua"
+          "$path": "modules/t/lib"
         }
       },
       "TestEZ": {

plugin/rojo.json

@@ -1,34 +0,0 @@
-{
-  "name": "rojo",
-  "servePort": 8000,
-  "partitions": {
-    "plugin": {
-      "path": "src",
-      "target": "ReplicatedStorage.Rojo.Plugin"
-    },
-    "modules/roact": {
-      "path": "modules/roact/lib",
-      "target": "ReplicatedStorage.Rojo.Roact"
-    },
-    "modules/rodux": {
-      "path": "modules/rodux/lib",
-      "target": "ReplicatedStorage.Rojo.Rodux"
-    },
-    "modules/roact-rodux": {
-      "path": "modules/roact-rodux/lib",
-      "target": "ReplicatedStorage.Rojo.RoactRodux"
-    },
-    "modules/promise": {
-      "path": "modules/promise/lib",
-      "target": "ReplicatedStorage.Rojo.Promise"
-    },
-    "modules/testez": {
-      "path": "modules/testez/lib",
-      "target": "ReplicatedStorage.TestEZ"
-    },
-    "tests": {
-      "path": "testBootstrap.server.lua",
-      "target": "TestService.testBootstrap"
-    }
-  }
-}

plugin/src/Assets.lua

@@ -15,7 +15,8 @@ local Assets = {
 		},
 	},
 	Images = {
-		Logo = "rbxassetid://2773210620",
+		Logo = "rbxassetid://3405346157",
+		Icon = "rbxassetid://3405341609",
 	},
 	StartSession = "",
 	SessionActive = "",

plugin/src/Components/App.lua

@@ -1,13 +1,14 @@
-local Roact = require(script:FindFirstAncestor("Rojo").Roact)
+local Rojo = script:FindFirstAncestor("Rojo")
+local Plugin = Rojo.Plugin
 
-local Plugin = script:FindFirstAncestor("Plugin")
+local Roact = require(Rojo.Roact)
 
 local Assets = require(Plugin.Assets)
-local Session = require(Plugin.Session)
 local Config = require(Plugin.Config)
-local Version = require(Plugin.Version)
-local Logging = require(Plugin.Logging)
 local DevSettings = require(Plugin.DevSettings)
+local Logging = require(Plugin.Logging)
+local Session = require(Plugin.Session)
+local Version = require(Plugin.Version)
 local preloadAssets = require(Plugin.preloadAssets)
 
 local ConnectPanel = require(Plugin.Components.ConnectPanel)
@@ -54,8 +55,6 @@ end
 local SessionStatus = {
 	Disconnected = "Disconnected",
 	Connected = "Connected",
-	ConfiguringSession = "ConfiguringSession",
-	-- TODO: Error?
 }
 
 setmetatable(SessionStatus, {
@@ -71,12 +70,41 @@ function App:init()
 		sessionStatus = SessionStatus.Disconnected,
 	})
 
-	self.connectButton = nil
+	self.signals = {}
 	self.currentSession = nil
 
 	self.displayedVersion = DevSettings:isEnabled()
 		and Config.codename
 		or Version.display(Config.version)
+
+	local toolbar = self.props.plugin:CreateToolbar("Rojo " .. self.displayedVersion)
+
+	self.toggleButton = toolbar:CreateButton(
+		"Rojo",
+		"Show or hide the Rojo panel",
+		Assets.Images.Icon)
+	self.toggleButton.ClickableWhenViewportHidden = true
+	self.toggleButton.Click:Connect(function()
+		self.dockWidget.Enabled = not self.dockWidget.Enabled
+	end)
+
+	local widgetInfo = DockWidgetPluginGuiInfo.new(
+		Enum.InitialDockState.Right,
+		false, -- Initially enabled state
+		false, -- Whether to override the widget's previous state
+		360, 190, -- Floating size
+		360, 190 -- Minimum size
+	)
+
+	self.dockWidget = self.props.plugin:CreateDockWidgetPluginGui("Rojo-0.5.x", widgetInfo)
+	self.dockWidget.Name = "Rojo " .. self.displayedVersion
+	self.dockWidget.Title = "Rojo " .. self.displayedVersion
+	self.dockWidget.AutoLocalize = false
+	self.dockWidget.ZIndexBehavior = Enum.ZIndexBehavior.Sibling
+
+	self.signals.dockWidgetEnabled = self.dockWidget:GetPropertyChangedSignal("Enabled"):Connect(function()
+		self.toggleButton:SetActive(self.dockWidget.Enabled)
+	end)
 end
 
 function App:render()
@@ -98,7 +126,7 @@ function App:render()
 				end,
 			}),
 		}
-	elseif self.state.sessionStatus == SessionStatus.ConfiguringSession then
+	elseif self.state.sessionStatus == SessionStatus.Disconnected then
 		children = {
 			ConnectPanel = e(ConnectPanel, {
 				startSession = function(address, port)
@@ -135,50 +163,15 @@ function App:render()
 		}
 	end
 
-	return e("ScreenGui", {
+	return Roact.createElement(Roact.Portal, {
-		AutoLocalize = false,
+		target = self.dockWidget,
-		ZIndexBehavior = Enum.ZIndexBehavior.Sibling,
 	}, children)
 end
 
 function App:didMount()
 	Logging.trace("Rojo %s initializing", self.displayedVersion)
 
-	local toolbar = self.props.plugin:CreateToolbar("Rojo " .. self.displayedVersion)
+	checkUpgrade(self.props.plugin)
-
-	self.connectButton = toolbar:CreateButton(
-		"Connect",
-		"Connect to a running Rojo session",
-		Assets.StartSession)
-	self.connectButton.ClickableWhenViewportHidden = false
-	self.connectButton.Click:Connect(function()
-		checkUpgrade(self.props.plugin)
-
-		if self.state.sessionStatus == SessionStatus.Connected then
-			Logging.trace("Disconnecting session")
-
-			self.currentSession:disconnect()
-			self.currentSession = nil
-			self:setState({
-				sessionStatus = SessionStatus.Disconnected,
-			})
-
-			Logging.trace("Session terminated by user")
-		elseif self.state.sessionStatus == SessionStatus.Disconnected then
-			Logging.trace("Starting session configuration")
-
-			self:setState({
-				sessionStatus = SessionStatus.ConfiguringSession,
-			})
-		elseif self.state.sessionStatus == SessionStatus.ConfiguringSession then
-			Logging.trace("Canceling session configuration")
-
-			self:setState({
-				sessionStatus = SessionStatus.Disconnected,
-			})
-		end
-	end)
-
 	preloadAssets()
 end
 
@@ -187,18 +180,9 @@ function App:willUnmount()
 		self.currentSession:disconnect()
 		self.currentSession = nil
 	end
-end
 
-function App:didUpdate()
+	for _, signal in pairs(self.signals) do
-	local connectActive = self.state.sessionStatus == SessionStatus.ConfiguringSession
+		signal:Disconnect()
-		or self.state.sessionStatus == SessionStatus.Connected
-
-	self.connectButton:SetActive(connectActive)
-
-	if self.state.sessionStatus == SessionStatus.Connected then
-		self.connectButton.Icon = Assets.SessionActive
-	else
-		self.connectButton.Icon = Assets.StartSession
 	end
 end
 

plugin/src/Components/ConnectPanel.lua

@@ -4,39 +4,19 @@ local Plugin = Rojo.Plugin
 local Roact = require(Rojo.Roact)
 
 local Config = require(Plugin.Config)
-local Version = require(Plugin.Version)
-local Assets = require(Plugin.Assets)
 local Theme = require(Plugin.Theme)
-local joinBindings = require(Plugin.joinBindings)
 
+local Panel = require(Plugin.Components.Panel)
 local FitList = require(Plugin.Components.FitList)
 local FitText = require(Plugin.Components.FitText)
 local FormButton = require(Plugin.Components.FormButton)
 local FormTextInput = require(Plugin.Components.FormTextInput)
 
-local RoundBox = Assets.Slices.RoundBox
-
 local e = Roact.createElement
 
 local ConnectPanel = Roact.Component:extend("ConnectPanel")
 
 function ConnectPanel:init()
-	self.footerSize, self.setFooterSize = Roact.createBinding(Vector2.new())
-	self.footerVersionSize, self.setFooterVersionSize = Roact.createBinding(Vector2.new())
-
-	-- This is constructed in init because 'joinBindings' is a hack and we'd
-	-- leak memory constructing it every render. When this kind of feature lands
-	-- in Roact properly, we can do this inline in render without fear.
-	self.footerRestSize = joinBindings(
-		{
-			self.footerSize,
-			self.footerVersionSize,
-		},
-		function(container, other)
-			return UDim2.new(0, container.X - other.X - 16, 0, 32)
-		end
-	)
-
 	self:setState({
 		address = "",
 		port = "",
@@ -45,24 +25,14 @@ end
 
 function ConnectPanel:render()
 	local startSession = self.props.startSession
-	local cancel = self.props.cancel
 
-	return e(FitList, {
+	return e(Panel, nil, {
-		containerKind = "ImageLabel",
+		Layout = e("UIListLayout", {
-		containerProps = {
+			SortOrder = Enum.SortOrder.LayoutOrder,
-			Image = RoundBox.asset,
-			ImageRectOffset = RoundBox.offset,
-			ImageRectSize = RoundBox.size,
-			SliceCenter = RoundBox.center,
-			ScaleType = Enum.ScaleType.Slice,
-			BackgroundTransparency = 1,
-			Position = UDim2.new(0.5, 0, 0.5, 0),
-			AnchorPoint = Vector2.new(0.5, 0.5),
-		},
-		layoutProps = {
 			HorizontalAlignment = Enum.HorizontalAlignment.Center,
-		},
+			VerticalAlignment = Enum.VerticalAlignment.Center,
-	}, {
+		}),
+
 		Inputs = e(FitList, {
 			containerProps = {
 				BackgroundTransparency = 1,
@@ -96,7 +66,7 @@ function ConnectPanel:render()
 					Font = Theme.TitleFont,
 					TextSize = 20,
 					Text = "Address",
-					TextColor3 = Theme.AccentColor,
+					TextColor3 = Theme.PrimaryColor,
 				}),
 
 				Input = e(FormTextInput, {
@@ -129,7 +99,7 @@ function ConnectPanel:render()
 					Font = Theme.TitleFont,
 					TextSize = 20,
 					Text = "Port",
-					TextColor3 = Theme.AccentColor,
+					TextColor3 = Theme.PrimaryColor,
 				}),
 
 				Input = e(FormTextInput, {
@@ -165,17 +135,6 @@ function ConnectPanel:render()
 				PaddingRight = UDim.new(0, 24),
 			},
 		}, {
-			e(FormButton, {
-				layoutOrder = 1,
-				text = "Cancel",
-				onClick = function()
-					if cancel ~= nil then
-						cancel()
-					end
-				end,
-				secondary = true,
-			}),
-
 			e(FormButton, {
 				layoutOrder = 2,
 				text = "Connect",
@@ -196,65 +155,6 @@ function ConnectPanel:render()
 				end,
 			}),
 		}),
-
-		Footer = e(FitList, {
-			fitAxes = "Y",
-			containerKind = "ImageLabel",
-			containerProps = {
-				Image = RoundBox.asset,
-				ImageRectOffset = RoundBox.offset + Vector2.new(0, RoundBox.size.Y / 2),
-				ImageRectSize = RoundBox.size * Vector2.new(1, 0.5),
-				SliceCenter = RoundBox.center,
-				ScaleType = Enum.ScaleType.Slice,
-				ImageColor3 = Theme.SecondaryColor,
-				Size = UDim2.new(1, 0, 0, 0),
-				LayoutOrder = 3,
-				BackgroundTransparency = 1,
-
-				[Roact.Change.AbsoluteSize] = function(rbx)
-					self.setFooterSize(rbx.AbsoluteSize)
-				end,
-			},
-			layoutProps = {
-				FillDirection = Enum.FillDirection.Horizontal,
-				HorizontalAlignment = Enum.HorizontalAlignment.Center,
-				VerticalAlignment = Enum.VerticalAlignment.Center,
-			},
-			paddingProps = {
-				PaddingTop = UDim.new(0, 4),
-				PaddingBottom = UDim.new(0, 4),
-				PaddingLeft = UDim.new(0, 8),
-				PaddingRight = UDim.new(0, 8),
-			},
-		}, {
-			LogoContainer = e("Frame", {
-				BackgroundTransparency = 1,
-
-				Size = self.footerRestSize,
-			}, {
-				Logo = e("ImageLabel", {
-					Image = Assets.Images.Logo,
-					Size = UDim2.new(0, 80, 0, 40),
-					ScaleType = Enum.ScaleType.Fit,
-					BackgroundTransparency = 1,
-					Position = UDim2.new(0, 0, 1, -10),
-					AnchorPoint = Vector2.new(0, 1),
-				}),
-			}),
-
-			Version = e(FitText, {
-				Font = Theme.TitleFont,
-				TextSize = 18,
-				Text = Version.display(Config.version),
-				TextXAlignment = Enum.TextXAlignment.Right,
-				TextColor3 = Theme.LightTextColor,
-				BackgroundTransparency = 1,
-
-				[Roact.Change.AbsoluteSize] = function(rbx)
-					self.setFooterVersionSize(rbx.AbsoluteSize)
-				end,
-			}),
-		}),
 	})
 end
 

plugin/src/Components/ConnectionActivePanel.lua

@@ -3,63 +3,42 @@ local Roact = require(script:FindFirstAncestor("Rojo").Roact)
 local Plugin = script:FindFirstAncestor("Plugin")
 
 local Theme = require(Plugin.Theme)
-local Assets = require(Plugin.Assets)
 
-local FitList = require(Plugin.Components.FitList)
+local Panel = require(Plugin.Components.Panel)
 local FitText = require(Plugin.Components.FitText)
+local FormButton = require(Plugin.Components.FormButton)
 
 local e = Roact.createElement
 
-local RoundBox = Assets.Slices.RoundBox
+local ConnectionActivePanel = Roact.Component:extend("ConnectionActivePanel")
-local WhiteCross = Assets.Sprites.WhiteCross
 
-local function ConnectionActivePanel(props)
+function ConnectionActivePanel:render()
-	local stopSession = props.stopSession
+	local stopSession = self.props.stopSession
 
-	return e(FitList, {
+	return e(Panel, nil, {
-		containerKind = "ImageLabel",
+		Layout = Roact.createElement("UIListLayout", {
-		containerProps = {
+			HorizontalAlignment = Enum.HorizontalAlignment.Center,
-			Image = RoundBox.asset,
-			ImageRectOffset = RoundBox.offset + Vector2.new(0, RoundBox.size.Y / 2),
-			ImageRectSize = RoundBox.size * Vector2.new(1, 0.5),
-			SliceCenter = Rect.new(4, 4, 4, 4),
-			ScaleType = Enum.ScaleType.Slice,
-			BackgroundTransparency = 1,
-			Position = UDim2.new(0.5, 0, 0, 0),
-			AnchorPoint = Vector2.new(0.5, 0),
-		},
-		layoutProps = {
-			FillDirection = Enum.FillDirection.Horizontal,
 			VerticalAlignment = Enum.VerticalAlignment.Center,
-		},
+			SortOrder = Enum.SortOrder.LayoutOrder,
-	}, {
+			Padding = UDim.new(0, 8),
+		}),
+
 		Text = e(FitText, {
 			Padding = Vector2.new(12, 6),
 			Font = Theme.ButtonFont,
 			TextSize = 18,
-			Text = "Rojo Connected",
+			Text = "Connected to Live-Sync Server",
 			TextColor3 = Theme.PrimaryColor,
 			BackgroundTransparency = 1,
 		}),
 
-		CloseContainer = e("ImageButton", {
+		DisconnectButton = e(FormButton, {
-			Size = UDim2.new(0, 30, 0, 30),
+			layoutOrder = 2,
-			BackgroundTransparency = 1,
+			text = "Disconnect",
-
+			secondary = true,
-			[Roact.Event.Activated] = function()
+			onClick = function()
 				stopSession()
 			end,
-		}, {
-			CloseImage = e("ImageLabel", {
-				Size = UDim2.new(0, 16, 0, 16),
-				Position = UDim2.new(0.5, 0, 0.5, 0),
-				AnchorPoint = Vector2.new(0.5, 0.5),
-				Image = WhiteCross.asset,
-				ImageRectOffset = WhiteCross.offset,
-				ImageRectSize = WhiteCross.size,
-				ImageColor3 = Theme.PrimaryColor,
-				BackgroundTransparency = 1,
-			}),
 		}),
 	})
 end

plugin/src/Components/FormTextInput.lua

@@ -57,8 +57,8 @@ function FormTextInput:render()
 			TextSize = TEXT_SIZE,
 			Text = value,
 			PlaceholderText = shownPlaceholder,
-			PlaceholderColor3 = Theme.AccentLightColor,
+			PlaceholderColor3 = Theme.LightTextColor,
-			TextColor3 = Theme.AccentColor,
+			TextColor3 = Theme.PrimaryColor,
 
 			[Roact.Change.Text] = function(rbx)
 				onValueChange(rbx.Text)

plugin/src/Components/Panel.lua

@@ -0,0 +1,34 @@
+local Roact = require(script:FindFirstAncestor("Rojo").Roact)
+
+local Plugin = script:FindFirstAncestor("Plugin")
+
+local RojoFooter = require(Plugin.Components.RojoFooter)
+
+local e = Roact.createElement
+
+local Panel = Roact.Component:extend("Panel")
+
+function Panel:init()
+	self.footerSize, self.setFooterSize = Roact.createBinding(Vector2.new())
+end
+
+function Panel:render()
+	return e("Frame", {
+		Size = UDim2.new(1, 0, 1, 0),
+		BackgroundTransparency = 1,
+	}, {
+		Layout = Roact.createElement("UIListLayout", {
+			HorizontalAlignment = Enum.HorizontalAlignment.Center,
+			SortOrder = Enum.SortOrder.LayoutOrder,
+		}),
+
+		Body = e("Frame", {
+			Size = UDim2.new(0, 360, 1, -32),
+			BackgroundTransparency = 1,
+		}, self.props[Roact.Children]),
+
+		Footer = e(RojoFooter),
+	})
+end
+
+return Panel

plugin/src/Components/RojoFooter.lua

@@ -0,0 +1,69 @@
+local Rojo = script:FindFirstAncestor("Rojo")
+local Plugin = Rojo.Plugin
+
+local Roact = require(Rojo.Roact)
+
+local Config = require(Plugin.Config)
+local Version = require(Plugin.Version)
+local Assets = require(Plugin.Assets)
+local Theme = require(Plugin.Theme)
+
+local FitText = require(Plugin.Components.FitText)
+
+local e = Roact.createElement
+
+local RojoFooter = Roact.Component:extend("RojoFooter")
+
+function RojoFooter:init()
+	self.footerSize, self.setFooterSize = Roact.createBinding(Vector2.new())
+	self.footerVersionSize, self.setFooterVersionSize = Roact.createBinding(Vector2.new())
+end
+
+function RojoFooter:render()
+	return e("Frame", {
+		LayoutOrder = 3,
+		Size = UDim2.new(1, 0, 0, 32),
+		BackgroundColor3 = Theme.SecondaryColor,
+		BorderSizePixel = 0,
+	}, {
+		Padding = e("UIPadding", {
+			PaddingTop = UDim.new(0, 4),
+			PaddingBottom = UDim.new(0, 4),
+			PaddingLeft = UDim.new(0, 8),
+			PaddingRight = UDim.new(0, 8),
+		}),
+
+		LogoContainer = e("Frame", {
+			BackgroundTransparency = 1,
+
+			Size = UDim2.new(0, 0, 0, 32),
+		}, {
+			Logo = e("ImageLabel", {
+				Image = Assets.Images.Logo,
+				Size = UDim2.new(0, 80, 0, 40),
+				ScaleType = Enum.ScaleType.Fit,
+				BackgroundTransparency = 1,
+				Position = UDim2.new(0, 0, 1, -10),
+				AnchorPoint = Vector2.new(0, 1),
+			}),
+		}),
+
+		Version = e("TextLabel", {
+			Position = UDim2.new(1, 0, 0, 0),
+			Size = UDim2.new(0, 0, 1, 0),
+			AnchorPoint = Vector2.new(1, 0),
+			Font = Theme.TitleFont,
+			TextSize = 18,
+			Text = Version.display(Config.version),
+			TextXAlignment = Enum.TextXAlignment.Right,
+			TextColor3 = Theme.LightTextColor,
+			BackgroundTransparency = 1,
+
+			[Roact.Change.AbsoluteSize] = function(rbx)
+				self.setFooterVersionSize(rbx.AbsoluteSize)
+			end,
+		}),
+	})
+end
+
+return RojoFooter

plugin/src/Config.lua

@@ -1,6 +1,6 @@
 return {
 	codename = "Epiphany",
-	version = {0, 5, 0, "-alpha.8"},
+	version = {0, 5, 0, "-alpha.12"},
 	expectedServerVersionString = "0.5.0 or newer",
 	protocolVersion = 2,
 	defaultHost = "localhost",

plugin/src/Reconciler.lua

@@ -6,6 +6,12 @@ local setCanonicalProperty = require(script.Parent.setCanonicalProperty)
 local rojoValueToRobloxValue = require(script.Parent.rojoValueToRobloxValue)
 local Types = require(script.Parent.Types)
 
+local function setParent(instance, newParent)
+	pcall(function()
+		instance.Parent = newParent
+	end)
+end
+
 local Reconciler = {}
 Reconciler.__index = Reconciler
 
@@ -117,7 +123,7 @@ function Reconciler:reconcile(virtualInstancesById, id, instance)
 
 		-- Some instances, like services, don't like having their Parent
 		-- property poked, even if we're setting it to the same value.
-		setCanonicalProperty(instance, "Parent", parent)
+		setParent(instance, parent)
 	end
 
 	return instance
@@ -154,7 +160,7 @@ function Reconciler:__reify(virtualInstancesById, id, parent)
 		self:__reify(virtualInstancesById, childId, instance)
 	end
 
-	setCanonicalProperty(instance, "Parent", parent)
+	setParent(instance, parent)
 	self.instanceMap:insert(id, instance)
 
 	return instance

plugin/src/Theme.lua

@@ -4,11 +4,11 @@ local Theme = {
 	TitleFont = Enum.Font.GothamBold,
 	MainFont = Enum.Font.Gotham,
 
-	AccentColor = Color3.fromRGB(136, 0, 27),
+	AccentColor = Color3.fromRGB(225, 56, 53),
-	AccentLightColor = Color3.fromRGB(210, 145, 157),
+	AccentLightColor = Color3.fromRGB(255, 146, 145),
-	PrimaryColor = Color3.fromRGB(20, 20, 20),
+	PrimaryColor = Color3.fromRGB(64, 64, 64),
 	SecondaryColor = Color3.fromRGB(235, 235, 235),
-	LightTextColor = Color3.fromRGB(140, 140, 140),
+	LightTextColor = Color3.fromRGB(160, 160, 160),
 }
 
 setmetatable(Theme, {

plugin/src/joinBindings.lua

@@ -1,34 +0,0 @@
---[[
-	joinBindings is a crazy hack that allows combining multiple Roact bindings
-	in the same spirit as `map`.
-
-	It's implemented in terms of Roact internals that will probably break at
-	some point; please don't do that or use this module in your own code!
-]]
-
-local Binding = require(script:FindFirstAncestor("Rojo").Roact.Binding)
-
-local function evaluate(fun, bindings)
-	local input = {}
-
-	for index, binding in ipairs(bindings) do
-		input[index] = binding:getValue()
-	end
-
-	return fun(unpack(input, 1, #bindings))
-end
-
-local function joinBindings(bindings, joinFunction)
-	local initialValue = evaluate(joinFunction, bindings)
-	local binding, setValue = Binding.create(initialValue)
-
-	for _, binding in ipairs(bindings) do
-		Binding.subscribe(binding, function()
-			setValue(evaluate(joinFunction, bindings))
-		end)
-	end
-
-	return binding
-end
-
-return joinBindings

plugin/src/rojoValueToRobloxValue.lua

@@ -1,38 +1,19 @@
-local primitiveTypes = {
+local RbxDom = require(script:FindFirstAncestor("Rojo").RbxDom)
-	Bool = true,
-	Enum = true,
-	Float32 = true,
-	Float64 = true,
-	Int32 = true,
-	Int64 = true,
-	String = true,
-}
-
-local directConstructors = {
-	CFrame = CFrame.new,
-	Color3 = Color3.new,
-	Color3uint8 = Color3.fromRGB,
-	Rect = Rect.new,
-	UDim = UDim.new,
-	UDim2 = UDim2.new,
-	Vector2 = Vector2.new,
-	Vector2int16 = Vector2int16.new,
-	Vector3 = Vector3.new,
-	Vector3int16 = Vector3int16.new,
-}
 
 local function rojoValueToRobloxValue(value)
-	if primitiveTypes[value.Type] then
+	-- TODO: Manually decode this value by looking up its GUID The Rojo server
-		return value.Value
+	-- doesn't give us valid ref values yet, so this isn't important yet.
+	if value.Type == "Ref" then
+		return nil
 	end
 
-	local constructor = directConstructors[value.Type]
+	local success, decodedValue = RbxDom.EncodedValue.decode(value)
-	if constructor ~= nil then
+
-		return constructor(unpack(value.Value))
+	if not success then
+		error(decodedValue, 2)
 	end
 
-	local errorMessage = ("The Rojo plugin doesn't know how to handle values of type %q yet!"):format(tostring(value.Type))
+	return decodedValue
-	error(errorMessage)
 end
 
 return rojoValueToRobloxValue

plugin/src/setCanonicalProperty.lua

@@ -1,54 +1,34 @@
-local Logging = require(script.Parent.Logging)
+local RbxDom = require(script:FindFirstAncestor("Rojo").RbxDom)
 
 --[[
 	Attempts to set a property on the given instance.
-
-	This method deals in terms of what Rojo calls 'canonical properties', which
-	don't necessarily exist either in serialization or in Lua-reflected APIs,
-	but may be present in the API dump.
-
-	Ideally, canonical properties map 1:1 with properties we can assign, but in
-	some cases like LocalizationTable contents and CollectionService tags, we
-	have to read/write properties a little differently.
 ]]
-local function setCanonicalProperty(instance, key, value)
+local function setCanonicalProperty(instance, propertyName, value)
-	-- The 'Contents' property of LocalizationTable isn't directly exposed, but
+	local descriptor = RbxDom.findCanonicalPropertyDescriptor(instance.ClassName, propertyName)
-	-- has corresponding (deprecated) getters and setters.
+
-	if instance.ClassName == "LocalizationTable" and key == "Contents" then
+	-- We can skip unknown properties; they're not likely reflected to Lua.
-		instance:SetContents(value)
+	--
-		return
+	-- A good example of a property like this is `Model.ModelInPrimary`, which
+	-- is serialized but not reflected to Lua.
+	if descriptor == nil then
+		return false, "unknown property"
 	end
 
-	-- Temporary workaround for fixing issue #141 in this specific case.
+	if descriptor.scriptability == "None" or descriptor.scriptability == "Read" then
-	if instance.ClassName == "Lighting" and key == "Technology" then
+		return false, "unwritable property"
-		return
 	end
 
-	-- If we don't have permissions to access this value at all, we can skip it.
+	local success, err = descriptor:write(instance, value)
-	local readSuccess, existingValue = pcall(function()
-		return instance[key]
-	end)
 
-	if not readSuccess then
+	if not success then
-		-- An error will be thrown if there was a permission issue or if the
+		-- If we don't have permission to write a property, we just silently
-		-- property doesn't exist. In the latter case, we should tell the user
+		-- ignore it.
-		-- because it's probably their fault.
+		if err.kind == RbxDom.Error.Kind.Roblox and err.extra:find("lacking permission") then
-		if existingValue:find("lacking permission") then
+			return false, "permission error"
-			Logging.trace("Permission error reading property %s on class %s", tostring(key), instance.ClassName)
-			return
-		else
-			error(("Invalid property %s on class %s: %s"):format(tostring(key), instance.ClassName, existingValue), 2)
 		end
-	end
 
-	local writeSuccess, err = pcall(function()
+		local message = ("Invalid property %s.%s: %s"):format(descriptor.className, descriptor.name, tostring(err))
-		if existingValue ~= value then
+		error(message, 2)
-			instance[key] = value
-		end
-	end)
-
-	if not writeSuccess then
-		error(("Cannot set property %s on class %s: %s"):format(tostring(key), instance.ClassName, err), 2)
 	end
 
 	return true

rojo-e2e/Cargo.toml

@@ -1,6 +0,0 @@
-[package]
-name = "rojo-e2e"
-version = "0.1.0"
-authors = ["Lucien Greathouse <me@lpghatguy.com>"]
-
-[dependencies]

rojo-e2e/README.md

@@ -1,2 +0,0 @@
-# Rojo End-to-End
-This is a WIP test runner designed for Rojo. It will eventually start up the Rojo server and plugin and test functionality end-to-end.

rojo-e2e/src/lib.rs

@@ -1,32 +0,0 @@
-use std::{
-    path::Path,
-    process::Command,
-    thread,
-    time::Duration,
-};
-
-fn main() {
-    let plugin_path = Path::new("../plugin");
-    let server_path = Path::new("../server");
-    let tests_path = Path::new("../tests");
-
-    let server = Command::new("cargo")
-        .args(&["run", "--", "serve", "../test-projects/empty"])
-        .current_dir(server_path)
-        .spawn();
-
-    thread::sleep(Duration::from_millis(1000));
-
-    // TODO: Wait for server to start responding on the right port
-
-    let test_client = Command::new("lua")
-        .args(&["runTest.lua", "tests/empty.lua"])
-        .current_dir(plugin_path)
-        .spawn();
-
-    thread::sleep(Duration::from_millis(300));
-
-    // TODO: Collect output from the client for success/failure?
-
-    println!("Dying!");
-}

server/Cargo.toml

@@ -1,10 +1,10 @@
 [package]
 name = "rojo"
-version = "0.5.0-alpha.8"
+version = "0.5.0-alpha.12"
 authors = ["Lucien Greathouse <me@lpghatguy.com>"]
-description = "A tool to create robust Roblox projects"
+description = "Enables professional-grade development tools for Roblox developers"
 license = "MIT"
-repository = "https://github.com/LPGhatguy/rojo"
+repository = "https://github.com/rojo-rbx/rojo"
 edition = "2018"
 
 [features]
@@ -29,16 +29,15 @@ hyper = "0.12"
 log = "0.4"
 maplit = "1.0.1"
 notify = "4.0"
-rbx_binary = "0.4.0"
+rbx_binary = "0.4.1"
-rbx_dom_weak = "1.3.0"
+rbx_dom_weak = "1.8.0"
-rbx_xml = "0.6.0"
+rbx_xml = "0.10.0"
-rbx_reflection = "2.0.374"
+rbx_reflection = "3.1.388"
 regex = "1.0"
 reqwest = "0.9.5"
 rlua = "0.16"
 ritz = "0.1.0"
-serde = "1.0"
+serde = { version = "1.0", features = ["derive"] }
-serde_derive = "1.0"
 serde_json = "1.0"
 uuid = { version = "0.7", features = ["v4", "serde"] }
 

server/src/commands/build.rs

@@ -1,7 +1,7 @@
 use std::{
     path::PathBuf,
     fs::File,
-    io,
+    io::{self, Write, BufWriter},
 };
 
 use log::info;
@@ -9,7 +9,7 @@ use failure::Fail;
 
 use crate::{
     imfs::{Imfs, FsError},
-    project::{Project, ProjectLoadFuzzyError},
+    project::{Project, ProjectLoadError},
     rbx_session::construct_oneoff_tree,
     rbx_snapshot::SnapshotError,
 };
@@ -47,7 +47,7 @@ pub enum BuildError {
     UnknownOutputKind,
 
     #[fail(display = "Project load error: {}", _0)]
-    ProjectLoadError(#[fail(cause)] ProjectLoadFuzzyError),
+    ProjectLoadError(#[fail(cause)] ProjectLoadError),
 
     #[fail(display = "IO error: {}", _0)]
     IoError(#[fail(cause)] io::Error),
@@ -66,7 +66,7 @@ pub enum BuildError {
 }
 
 impl_from!(BuildError {
-    ProjectLoadFuzzyError => ProjectLoadError,
+    ProjectLoadError => ProjectLoadError,
     io::Error => IoError,
     rbx_xml::EncodeError => XmlModelEncodeError,
     rbx_binary::EncodeError => BinaryModelEncodeError,
@@ -74,6 +74,11 @@ impl_from!(BuildError {
     SnapshotError => SnapshotError,
 });
 
+fn xml_encode_config() -> rbx_xml::EncodeOptions {
+    rbx_xml::EncodeOptions::new()
+        .property_behavior(rbx_xml::EncodePropertyBehavior::WriteUnknown)
+}
+
 pub fn build(options: &BuildOptions) -> Result<(), BuildError> {
     let output_kind = options.output_kind
         .or_else(|| detect_output_kind(options))
@@ -84,7 +89,6 @@ pub fn build(options: &BuildOptions) -> Result<(), BuildError> {
     info!("Looking for project at {}", options.fuzzy_project_path.display());
 
     let project = Project::load_fuzzy(&options.fuzzy_project_path)?;
-    project.check_compatibility();
 
     info!("Found project at {}", project.file_location.display());
     info!("Using project {:#?}", project);
@@ -92,7 +96,7 @@ pub fn build(options: &BuildOptions) -> Result<(), BuildError> {
     let mut imfs = Imfs::new();
     imfs.add_roots_from_project(&project)?;
     let tree = construct_oneoff_tree(&project, &imfs)?;
-    let mut file = File::create(&options.output_file)?;
+    let mut file = BufWriter::new(File::create(&options.output_file)?);
 
     match output_kind {
         OutputKind::Rbxmx => {
@@ -100,7 +104,7 @@ pub fn build(options: &BuildOptions) -> Result<(), BuildError> {
             // descendants.
 
             let root_id = tree.get_root_id();
-            rbx_xml::encode(&tree, &[root_id], &mut file)?;
+            rbx_xml::to_writer(&mut file, &tree, &[root_id], xml_encode_config())?;
         },
         OutputKind::Rbxlx => {
             // Place files don't contain an entry for the DataModel, but our
@@ -108,18 +112,24 @@ pub fn build(options: &BuildOptions) -> Result<(), BuildError> {
 
             let root_id = tree.get_root_id();
             let top_level_ids = tree.get_instance(root_id).unwrap().get_children_ids();
-            rbx_xml::encode(&tree, top_level_ids, &mut file)?;
+            rbx_xml::to_writer(&mut file, &tree, top_level_ids, xml_encode_config())?;
         },
         OutputKind::Rbxm => {
             let root_id = tree.get_root_id();
             rbx_binary::encode(&tree, &[root_id], &mut file)?;
         },
         OutputKind::Rbxl => {
+            log::warn!("Support for building binary places (rbxl) is still experimental.");
+            log::warn!("Using the XML place format (rbxlx) is recommended instead.");
+            log::warn!("For more info, see https://github.com/LPGhatguy/rojo/issues/180");
+
             let root_id = tree.get_root_id();
             let top_level_ids = tree.get_instance(root_id).unwrap().get_children_ids();
             rbx_binary::encode(&tree, top_level_ids, &mut file)?;
         },
     }
 
+    file.flush()?;
+
     Ok(())
 }

server/src/commands/serve.rs

@@ -7,7 +7,7 @@ use log::info;
 use failure::Fail;
 
 use crate::{
-    project::{Project, ProjectLoadFuzzyError},
+    project::{Project, ProjectLoadError},
     web::LiveServer,
     imfs::FsError,
     live_session::{LiveSession, LiveSessionError},
@@ -24,7 +24,7 @@ pub struct ServeOptions {
 #[derive(Debug, Fail)]
 pub enum ServeError {
    #[fail(display = "Project load error: {}", _0)]
-   ProjectLoadError(#[fail(cause)] ProjectLoadFuzzyError),
+   ProjectLoadError(#[fail(cause)] ProjectLoadError),
 
    #[fail(display = "{}", _0)]
    FsError(#[fail(cause)] FsError),
@@ -34,7 +34,7 @@ pub enum ServeError {
 }
 
 impl_from!(ServeError {
-    ProjectLoadFuzzyError => ProjectLoadError,
+    ProjectLoadError => ProjectLoadError,
     FsError => FsError,
     LiveSessionError => LiveSessionError,
 });
@@ -43,7 +43,6 @@ pub fn serve(options: &ServeOptions) -> Result<(), ServeError> {
     info!("Looking for project at {}", options.fuzzy_project_path.display());
 
     let project = Arc::new(Project::load_fuzzy(&options.fuzzy_project_path)?);
-    project.check_compatibility();
 
     info!("Found project at {}", project.file_location.display());
     info!("Using project {:#?}", project);

server/src/commands/upload.rs

@@ -10,7 +10,7 @@ use reqwest::header::{ACCEPT, USER_AGENT, CONTENT_TYPE, COOKIE};
 
 use crate::{
     imfs::{Imfs, FsError},
-    project::{Project, ProjectLoadFuzzyError},
+    project::{Project, ProjectLoadError},
     rbx_session::construct_oneoff_tree,
     rbx_snapshot::SnapshotError,
 };
@@ -24,7 +24,7 @@ pub enum UploadError {
     InvalidKind(String),
 
     #[fail(display = "Project load error: {}", _0)]
-    ProjectLoadError(#[fail(cause)] ProjectLoadFuzzyError),
+    ProjectLoadError(#[fail(cause)] ProjectLoadError),
 
     #[fail(display = "IO error: {}", _0)]
     IoError(#[fail(cause)] io::Error),
@@ -43,7 +43,7 @@ pub enum UploadError {
 }
 
 impl_from!(UploadError {
-    ProjectLoadFuzzyError => ProjectLoadError,
+    ProjectLoadError => ProjectLoadError,
     io::Error => IoError,
     reqwest::Error => HttpError,
     rbx_xml::EncodeError => XmlModelEncodeError,
@@ -65,7 +65,6 @@ pub fn upload(options: &UploadOptions) -> Result<(), UploadError> {
     info!("Looking for project at {}", options.fuzzy_project_path.display());
 
     let project = Project::load_fuzzy(&options.fuzzy_project_path)?;
-    project.check_compatibility();
 
     info!("Found project at {}", project.file_location.display());
     info!("Using project {:#?}", project);
@@ -80,10 +79,10 @@ pub fn upload(options: &UploadOptions) -> Result<(), UploadError> {
     match options.kind {
         Some("place") | None => {
             let top_level_ids = tree.get_instance(root_id).unwrap().get_children_ids();
-            rbx_xml::encode(&tree, top_level_ids, &mut contents)?;
+            rbx_xml::to_writer_default(&mut contents, &tree, top_level_ids)?;
         },
         Some("model") => {
-            rbx_xml::encode(&tree, &[root_id], &mut contents)?;
+            rbx_xml::to_writer_default(&mut contents, &tree, &[root_id])?;
         },
         Some(invalid) => return Err(UploadError::InvalidKind(invalid.to_owned())),
     }

server/src/imfs.rs

@@ -8,7 +8,7 @@ use std::{
 };
 
 use failure::Fail;
-use serde_derive::{Serialize, Deserialize};
+use serde::{Serialize, Deserialize};
 
 use crate::project::{Project, ProjectNode};
 
@@ -89,11 +89,13 @@ impl Imfs {
 
     pub fn add_root(&mut self, path: &Path) -> Result<(), FsError> {
         debug_assert!(path.is_absolute());
-        debug_assert!(!self.is_within_roots(path));
 
-        self.roots.insert(path.to_path_buf());
+        if !self.is_within_roots(path) {
+            self.roots.insert(path.to_path_buf());
+            self.descend_and_read_from_disk(path)?;
+        }
 
-        self.descend_and_read_from_disk(path)
+        Ok(())
     }
 
     pub fn remove_root(&mut self, path: &Path) {

server/src/path_map.rs

@@ -3,7 +3,7 @@ use std::{
     collections::{HashMap, HashSet},
 };
 
-use serde_derive::Serialize;
+use serde::Serialize;
 use log::warn;
 
 #[derive(Debug, Serialize)]

server/src/path_serializer.rs

@@ -10,7 +10,7 @@
 //!
 //! ```
 //! # use std::path::PathBuf;
-//! # use serde_derive::{Serialize, Deserialize};
+//! # use serde::{Serialize, Deserialize};
 //!
 //! #[derive(Serialize, Deserialize)]
 //! struct Mine {

server/src/project.rs

@@ -9,8 +9,7 @@ use std::{
 use log::warn;
 use failure::Fail;
 use rbx_dom_weak::{UnresolvedRbxValue, RbxValue};
-use serde_derive::{Serialize, Deserialize};
+use serde::{Serialize, Serializer, Deserialize};
-use serde::{Serialize, Serializer};
 
 static DEFAULT_PLACE: &'static str = include_str!("../assets/place.project.json");
 
@@ -21,7 +20,7 @@ pub static COMPAT_PROJECT_FILENAME: &'static str = "roblox-project.json";
 /// want to do things like transforming paths to be absolute before handing them
 /// off to the rest of Rojo, we use this intermediate struct.
 #[derive(Debug, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
+#[serde(deny_unknown_fields, rename_all = "camelCase")]
 struct SourceProject {
     name: String,
     tree: SourceProjectNode,
@@ -89,7 +88,6 @@ fn serialize_unresolved_minimal<S>(unresolved: &UnresolvedRbxValue, serializer:
                 RbxValue::Color3 { value } => value.serialize(serializer),
                 RbxValue::Color3uint8 { value } => value.serialize(serializer),
                 RbxValue::Content { value } => value.serialize(serializer),
-                RbxValue::Enum { value } => value.serialize(serializer),
                 RbxValue::Float32 { value } => value.serialize(serializer),
                 RbxValue::Int32 { value } => value.serialize(serializer),
                 RbxValue::String { value } => value.serialize(serializer),
@@ -199,34 +197,37 @@ impl SourcePlugin {
     }
 }
 
-/// Error returned by Project::load_exact
 #[derive(Debug, Fail)]
-pub enum ProjectLoadExactError {
+pub enum ProjectLoadError {
-    #[fail(display = "IO error: {}", _0)]
-    IoError(#[fail(cause)] io::Error),
-
-    #[fail(display = "JSON error: {}", _0)]
-    JsonError(#[fail(cause)] serde_json::Error),
-}
-
-/// Error returned by Project::load_fuzzy
-#[derive(Debug, Fail)]
-pub enum ProjectLoadFuzzyError {
-    #[fail(display = "Project not found")]
     NotFound,
 
-    #[fail(display = "IO error: {}", _0)]
+    Io {
-    IoError(#[fail(cause)] io::Error),
+        #[fail(cause)]
+        inner: io::Error,
+        path: PathBuf,
+    },
 
-    #[fail(display = "JSON error: {}", _0)]
+    Json {
-    JsonError(#[fail(cause)] serde_json::Error),
+        #[fail(cause)]
+        inner: serde_json::Error,
+        path: PathBuf,
+    },
 }
 
-impl From<ProjectLoadExactError> for ProjectLoadFuzzyError {
+impl fmt::Display for ProjectLoadError {
-    fn from(error: ProjectLoadExactError) -> ProjectLoadFuzzyError {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        match error {
+        use self::ProjectLoadError::*;
-            ProjectLoadExactError::IoError(inner) => ProjectLoadFuzzyError::IoError(inner),
+
-            ProjectLoadExactError::JsonError(inner) => ProjectLoadFuzzyError::JsonError(inner),
+        match self {
+            NotFound => {
+                write!(formatter, "Project file not found")
+            }
+            Io { inner, path } => {
+                write!(formatter, "I/O error: {} in path {}", inner, path.display())
+            }
+            Json { inner, path } => {
+                write!(formatter, "JSON error: {} in path {}", inner, path.display())
+            }
         }
     }
 }
@@ -273,6 +274,17 @@ pub struct ProjectNode {
 }
 
 impl ProjectNode {
+    fn validate_reserved_names(&self) {
+        for (name, child) in &self.children {
+            if name.starts_with('$') {
+                warn!("Keys starting with '$' are reserved by Rojo to ensure forward compatibility.");
+                warn!("This project uses the key '{}', which should be renamed.", name);
+            }
+
+            child.validate_reserved_names();
+        }
+    }
+
     fn to_source_node(&self, project_file_location: &Path) -> SourceProjectNode {
         let children = self.children.iter()
             .map(|(key, value)| (key.clone(), value.to_source_node(project_file_location)))
@@ -335,11 +347,17 @@ pub struct Project {
 
 impl Project {
     pub fn init_place(project_fuzzy_path: &Path) -> Result<PathBuf, ProjectInitError> {
-        let project_path = Project::init_pick_path(project_fuzzy_path)?;
+        let project_path = Project::pick_path_for_init(project_fuzzy_path)?;
+
         let project_name = if project_fuzzy_path == project_path {
-            project_fuzzy_path.parent().unwrap().file_name().unwrap().to_str().unwrap()
+            project_fuzzy_path
+                .parent().expect("Path did not have a parent directory")
+                .file_name().expect("Path did not have a file name")
+                .to_str().expect("Path had invalid Unicode")
         } else {
-            project_fuzzy_path.file_name().unwrap().to_str().unwrap()
+            project_fuzzy_path
+                .file_name().expect("Path did not have a file name")
+                .to_str().expect("Path had invalid Unicode")
         };
 
         let mut project = Project::load_from_str(DEFAULT_PLACE, &project_path)
@@ -354,14 +372,22 @@ impl Project {
     }
 
     pub fn init_model(project_fuzzy_path: &Path) -> Result<PathBuf, ProjectInitError> {
-        let project_path = Project::init_pick_path(project_fuzzy_path)?;
+        let project_path = Project::pick_path_for_init(project_fuzzy_path)?;
-        let project_folder_path = project_path.parent().unwrap();
+
         let project_name = if project_fuzzy_path == project_path {
-            project_fuzzy_path.parent().unwrap().file_name().unwrap().to_str().unwrap()
+            project_fuzzy_path
+                .parent().expect("Path did not have a parent directory")
+                .file_name().expect("Path did not have a file name")
+                .to_str().expect("Path had invalid Unicode")
         } else {
-            project_fuzzy_path.file_name().unwrap().to_str().unwrap()
+            project_fuzzy_path
+                .file_name().expect("Path did not have a file name")
+                .to_str().expect("Path had invalid Unicode")
         };
 
+        let project_folder_path = project_path
+            .parent().expect("Path did not have a parent directory");
+
         let tree = ProjectNode {
             path: Some(project_folder_path.join("src")),
             ..Default::default()
@@ -382,7 +408,7 @@ impl Project {
         Ok(project_path)
     }
 
-    fn init_pick_path(project_fuzzy_path: &Path) -> Result<PathBuf, ProjectInitError> {
+    fn pick_path_for_init(project_fuzzy_path: &Path) -> Result<PathBuf, ProjectInitError> {
         let is_exact = project_fuzzy_path.extension().is_some();
 
         let project_path = if is_exact {
@@ -402,7 +428,7 @@ impl Project {
         Ok(project_path)
     }
 
-    pub fn locate(start_location: &Path) -> Option<PathBuf> {
+    fn locate(start_location: &Path) -> Option<PathBuf> {
         // TODO: Check for specific error kinds, convert 'not found' to Result.
         let location_metadata = fs::metadata(start_location).ok()?;
 
@@ -439,21 +465,35 @@ impl Project {
         Ok(parsed.into_project(project_file_location))
     }
 
-    pub fn load_fuzzy(fuzzy_project_location: &Path) -> Result<Project, ProjectLoadFuzzyError> {
+    pub fn load_fuzzy(fuzzy_project_location: &Path) -> Result<Project, ProjectLoadError> {
-        let project_path = Self::locate(fuzzy_project_location)
+        if let Some(project_path) = Self::locate(fuzzy_project_location) {
-            .ok_or(ProjectLoadFuzzyError::NotFound)?;
+            Self::load_exact(&project_path)
-
+        } else {
-        Self::load_exact(&project_path).map_err(From::from)
+            Project::warn_if_4x_project_present(fuzzy_project_location);
+            Err(ProjectLoadError::NotFound)
+        }
     }
 
-    pub fn load_exact(project_file_location: &Path) -> Result<Project, ProjectLoadExactError> {
+    pub fn load_exact(project_file_location: &Path) -> Result<Project, ProjectLoadError> {
         let contents = fs::read_to_string(project_file_location)
-            .map_err(ProjectLoadExactError::IoError)?;
+            .map_err(|error| match error.kind() {
+                io::ErrorKind::NotFound => ProjectLoadError::NotFound,
+                _ => ProjectLoadError::Io {
+                    inner: error,
+                    path: project_file_location.to_path_buf(),
+                }
+            })?;
 
         let parsed: SourceProject = serde_json::from_str(&contents)
-            .map_err(ProjectLoadExactError::JsonError)?;
+            .map_err(|error| ProjectLoadError::Json {
+                inner: error,
+                path: project_file_location.to_path_buf(),
+            })?;
 
-        Ok(parsed.into_project(project_file_location))
+        let project = parsed.into_project(project_file_location);
+        project.check_compatibility();
+
+        Ok(project)
     }
 
     pub fn save(&self) -> Result<(), ProjectSaveError> {
@@ -469,10 +509,10 @@ impl Project {
 
     /// Checks if there are any compatibility issues with this project file and
     /// warns the user if there are any.
-    pub fn check_compatibility(&self) {
+    fn check_compatibility(&self) {
         let file_name = self.file_location
-            .file_name().unwrap()
+            .file_name().expect("Project file path did not have a file name")
-            .to_str().expect("Project file path was not valid Unicode!");
+            .to_str().expect("Project file path was not valid Unicode");
 
         if file_name == COMPAT_PROJECT_FILENAME {
             warn!("Rojo's default project file name changed in 0.5.0-alpha3.");
@@ -484,6 +524,23 @@ impl Project {
             warn!(".project.json extension. This helps Rojo differentiate project files from");
             warn!("other JSON files!");
         }
+
+        self.tree.validate_reserved_names();
+    }
+
+    /// Issues a warning if no Rojo 0.5.x project is found, but there's a legacy
+    /// 0.4.x project in the directory.
+    fn warn_if_4x_project_present(folder: &Path) {
+        let file_path = folder.join("rojo.json");
+
+        if fs::metadata(file_path).is_ok() {
+            warn!("No Rojo 0.5 project file was found, but a Rojo 0.4 project was.");
+            warn!("Rojo 0.5.x uses 'default.project.json' files");
+            warn!("Rojo 0.5.x uses 'rojo.json' files");
+            warn!("");
+            warn!("For help upgrading, see:");
+            warn!("https://lpghatguy.github.io/rojo/guide/migrating-to-epiphany/");
+        }
     }
 
     pub fn folder_location(&self) -> &Path {

server/src/rbx_session.rs

@@ -7,7 +7,7 @@ use std::{
 };
 
 use rlua::Lua;
-use serde_derive::{Serialize, Deserialize};
+use serde::{Serialize, Deserialize};
 use log::{info, trace, error};
 use rbx_dom_weak::{RbxTree, RbxId};
 

server/src/rbx_snapshot.rs

@@ -13,8 +13,8 @@ use rlua::Lua;
 use failure::Fail;
 use log::info;
 use maplit::hashmap;
-use rbx_dom_weak::{RbxTree, RbxValue, RbxInstanceProperties};
+use rbx_dom_weak::{RbxTree, RbxValue, RbxInstanceProperties, UnresolvedRbxValue};
-use serde_derive::{Serialize, Deserialize};
+use serde::{Serialize, Deserialize};
 use rbx_reflection::{try_resolve_value, ValueResolveError};
 
 use crate::{
@@ -105,7 +105,23 @@ pub enum SnapshotError {
         path: PathBuf,
     },
 
+    ExtraMetadataError {
+        #[fail(cause)]
+        inner: serde_json::Error,
+        path: PathBuf,
+    },
+
+    InvalidMetadataModelField {
+        field_name: String,
+        path: PathBuf,
+    },
+
+    MetadataClassNameNonInit {
+        path: PathBuf,
+    },
+
     XmlModelDecodeError {
+        #[fail(cause)]
         inner: rbx_xml::DecodeError,
         path: PathBuf,
     },
@@ -115,6 +131,12 @@ pub enum SnapshotError {
         path: PathBuf,
     },
 
+    CsvDecodeError {
+        #[fail(cause)]
+        inner: csv::Error,
+        path: PathBuf,
+    },
+
     ProjectNodeUnusable,
 
     ProjectNodeInvalidTransmute {
@@ -145,12 +167,26 @@ impl fmt::Display for SnapshotError {
             SnapshotError::JsonModelDecodeError { inner, path } => {
                 write!(output, "Malformed .model.json model: {} in path {}", inner, path.display())
             },
+            SnapshotError::ExtraMetadataError { inner, path } => {
+                write!(output, "Malformed init.meta.json: {} in path {}", inner, path.display())
+            },
+            SnapshotError::InvalidMetadataModelField { field_name, path } => {
+                writeln!(output, "The field '{}' cannot be specified on .meta.json files attached to models.", field_name)?;
+                writeln!(output, "Model path: {}", path.display())
+            },
+            SnapshotError::MetadataClassNameNonInit { path } => {
+                writeln!(output, "The field 'className' cannot be specified on .meta.json files besides init.meta.json")?;
+                writeln!(output, "Model path: {}", path.display())
+            },
             SnapshotError::XmlModelDecodeError { inner, path } => {
-                write!(output, "Malformed rbxmx model: {:?} in path {}", inner, path.display())
+                write!(output, "Malformed rbxmx model: {} in path {}", inner, path.display())
             },
             SnapshotError::BinaryModelDecodeError { inner, path } => {
                 write!(output, "Malformed rbxm model: {:?} in path {}", inner, path.display())
             },
+            SnapshotError::CsvDecodeError { inner, path } => {
+                write!(output, "Malformed csv file: {} in path {}", inner, path.display())
+            },
             SnapshotError::ProjectNodeUnusable => {
                 write!(output, "Rojo project nodes must specify either $path or $className.")
             },
@@ -275,7 +311,7 @@ fn snapshot_imfs_item<'source>(
     instance_name: Option<Cow<'source, str>>,
 ) -> SnapshotResult<'source> {
     match item {
-        ImfsItem::File(file) => snapshot_imfs_file(context, file, instance_name),
+        ImfsItem::File(file) => snapshot_imfs_file(context, imfs, file, instance_name),
         ImfsItem::Directory(directory) => snapshot_imfs_directory(context, imfs, directory, instance_name),
     }
 }
@@ -317,6 +353,10 @@ fn snapshot_imfs_directory<'source>(
         }
     };
 
+    if let Some(meta) = ExtraMetadata::locate(&imfs, &directory.path.join("init"))? {
+        meta.apply(&mut snapshot)?;
+    }
+
     snapshot.metadata.source_path = Some(directory.path.to_owned());
 
     for child_path in &directory.children {
@@ -324,25 +364,105 @@ fn snapshot_imfs_directory<'source>(
             .file_name().expect("Couldn't extract file name")
             .to_str().expect("Couldn't convert file name to UTF-8");
 
+        if child_name.ends_with(".meta.json") {
+            // meta.json files don't turn into instances themselves, they just
+            // modify other instances.
+            continue;
+        }
+
         match child_name {
             INIT_MODULE_NAME | INIT_SERVER_NAME | INIT_CLIENT_NAME => {
                 // The existence of files with these names modifies the
                 // parent instance and is handled above, so we can skip
                 // them here.
-            },
+                continue;
-            _ => {
+            }
-                if let Some(child) = snapshot_imfs_path(context, imfs, child_path, None)? {
+            _ => {}
-                    snapshot.children.push(child);
+        }
-                }
+
-            },
+        if let Some(child) = snapshot_imfs_path(context, imfs, child_path, None)? {
+            snapshot.children.push(child);
         }
     }
 
     Ok(Some(snapshot))
 }
 
+#[derive(Debug, Default, Deserialize)]
+#[serde(rename_all = "camelCase", deny_unknown_fields)]
+struct ExtraMetadata {
+    class_name: Option<String>,
+    ignore_unknown_instances: Option<bool>,
+
+    #[serde(default = "HashMap::new")]
+    properties: HashMap<String, UnresolvedRbxValue>,
+}
+
+impl ExtraMetadata {
+    fn apply(self, snapshot: &mut RbxSnapshotInstance) -> Result<(), SnapshotError> {
+        if let Some(meta_class) = self.class_name {
+            snapshot.class_name = Cow::Owned(meta_class);
+        }
+
+        if let Some(meta_ignore_instances) = self.ignore_unknown_instances {
+            snapshot.metadata.ignore_unknown_instances = meta_ignore_instances;
+        }
+
+        for (key, value) in self.properties {
+            let resolved_value = try_resolve_value(&snapshot.class_name, &key, &value)?;
+            snapshot.properties.insert(key, resolved_value);
+        }
+
+        Ok(())
+    }
+
+    fn locate(imfs: &Imfs, path: &Path) -> Result<Option<ExtraMetadata>, SnapshotError> {
+        match imfs.get(&path.with_extension("meta.json")) {
+            Some(ImfsItem::File(file)) => {
+                let meta: ExtraMetadata = serde_json::from_slice(&file.contents)
+                    .map_err(|inner| SnapshotError::ExtraMetadataError {
+                        inner,
+                        path: file.path.to_path_buf(),
+                    })?;
+
+                Ok(Some(meta))
+            }
+            _ => Ok(None)
+        }
+    }
+
+    fn validate_for_non_init(&self, path: &Path) -> Result<(), SnapshotError> {
+        if self.class_name.is_some() {
+            return Err(SnapshotError::MetadataClassNameNonInit {
+                path: path.to_owned(),
+            });
+        }
+
+        Ok(())
+    }
+
+    fn validate_for_model(&self, path: &Path) -> Result<(), SnapshotError> {
+        if self.class_name.is_some() {
+            return Err(SnapshotError::InvalidMetadataModelField {
+                field_name: "className".to_owned(),
+                path: path.to_owned(),
+            });
+        }
+
+        if !self.properties.is_empty() {
+            return Err(SnapshotError::InvalidMetadataModelField {
+                field_name: "properties".to_owned(),
+                path: path.to_owned(),
+            });
+        }
+
+        Ok(())
+    }
+}
+
 fn snapshot_imfs_file<'source>(
     context: &SnapshotContext,
+    imfs: &'source Imfs,
     file: &'source ImfsFile,
     instance_name: Option<Cow<'source, str>>,
 ) -> SnapshotResult<'source> {
@@ -350,11 +470,11 @@ fn snapshot_imfs_file<'source>(
         .map(|v| v.to_str().expect("Could not convert extension to UTF-8"));
 
     let mut maybe_snapshot = match extension {
-        Some("lua") => snapshot_lua_file(file)?,
+        Some("lua") => snapshot_lua_file(file, imfs)?,
-        Some("csv") => snapshot_csv_file(file)?,
+        Some("csv") => snapshot_csv_file(file, imfs)?,
-        Some("txt") => snapshot_txt_file(file)?,
+        Some("txt") => snapshot_txt_file(file, imfs)?,
-        Some("rbxmx") => snapshot_xml_model_file(file)?,
+        Some("rbxmx") => snapshot_xml_model_file(file, imfs)?,
-        Some("rbxm") => snapshot_binary_model_file(file)?,
+        Some("rbxm") => snapshot_binary_model_file(file, imfs)?,
         Some("json") => {
             let file_stem = file.path
                 .file_stem().expect("Could not extract file stem")
@@ -369,7 +489,7 @@ fn snapshot_imfs_file<'source>(
         Some(_) | None => None,
     };
 
-    if let Some(snapshot) = maybe_snapshot.as_mut() {
+    if let Some(mut snapshot) = maybe_snapshot.as_mut() {
         // Carefully preserve name from project manifest if present.
         if let Some(snapshot_name) = instance_name {
             snapshot.name = snapshot_name;
@@ -397,6 +517,7 @@ fn snapshot_imfs_file<'source>(
 
 fn snapshot_lua_file<'source>(
     file: &'source ImfsFile,
+    imfs: &'source Imfs,
 ) -> SnapshotResult<'source> {
     let file_stem = file.path
         .file_stem().expect("Could not extract file stem")
@@ -416,7 +537,7 @@ fn snapshot_lua_file<'source>(
             path: file.path.to_path_buf(),
         })?;
 
-    Ok(Some(RbxSnapshotInstance {
+    let mut snapshot = RbxSnapshotInstance {
         name: Cow::Borrowed(instance_name),
         class_name: Cow::Borrowed(class_name),
         properties: hashmap! {
@@ -430,7 +551,14 @@ fn snapshot_lua_file<'source>(
             ignore_unknown_instances: false,
             project_definition: None,
         },
-    }))
+    };
+
+    if let Some(meta) = ExtraMetadata::locate(&imfs, &file.path.with_file_name(instance_name))? {
+        meta.validate_for_non_init(&file.path)?;
+        meta.apply(&mut snapshot)?;
+    }
+
+    Ok(Some(snapshot))
 }
 
 fn match_trailing<'a>(input: &'a str, trailer: &str) -> Option<&'a str> {
@@ -444,6 +572,7 @@ fn match_trailing<'a>(input: &'a str, trailer: &str) -> Option<&'a str> {
 
 fn snapshot_txt_file<'source>(
     file: &'source ImfsFile,
+    imfs: &'source Imfs,
 ) -> SnapshotResult<'source> {
     let instance_name = file.path
         .file_stem().expect("Could not extract file stem")
@@ -455,7 +584,7 @@ fn snapshot_txt_file<'source>(
             path: file.path.to_path_buf(),
         })?;
 
-    Ok(Some(RbxSnapshotInstance {
+    let mut snapshot = RbxSnapshotInstance {
         name: Cow::Borrowed(instance_name),
         class_name: Cow::Borrowed("StringValue"),
         properties: hashmap! {
@@ -469,27 +598,106 @@ fn snapshot_txt_file<'source>(
             ignore_unknown_instances: false,
             project_definition: None,
         },
-    }))
+    };
+
+    if let Some(meta) = ExtraMetadata::locate(&imfs, &file.path)? {
+        meta.validate_for_non_init(&file.path)?;
+        meta.apply(&mut snapshot)?;
+    }
+
+    Ok(Some(snapshot))
 }
 
 fn snapshot_csv_file<'source>(
     file: &'source ImfsFile,
+    imfs: &'source Imfs,
 ) -> SnapshotResult<'source> {
+    /// Struct that holds any valid row from a Roblox CSV translation table.
+    ///
+    /// We manually deserialize into this table from CSV, but let JSON handle
+    /// serializing.
+    #[derive(Debug, Default, Serialize)]
+    #[serde(rename_all = "camelCase")]
+    struct LocalizationEntry<'a> {
+        #[serde(skip_serializing_if = "Option::is_none")]
+        key: Option<&'a str>,
+
+        #[serde(skip_serializing_if = "Option::is_none")]
+        context: Option<&'a str>,
+
+        #[serde(skip_serializing_if = "Option::is_none")]
+        example: Option<&'a str>,
+
+        #[serde(skip_serializing_if = "Option::is_none")]
+        source: Option<&'a str>,
+
+        values: HashMap<&'a str, &'a str>,
+    }
+
     let instance_name = file.path
         .file_stem().expect("Could not extract file stem")
         .to_str().expect("Could not convert path to UTF-8");
 
-    let entries: Vec<LocalizationEntryJson> = csv::Reader::from_reader(file.contents.as_slice())
+    // Normally, we'd be able to let the csv crate construct our struct for us.
-        .deserialize()
+    //
-        // TODO: Propagate error upward instead of panicking
+    // However, because of a limitation with Serde's 'flatten' feature, it's not
-        .map(|result| result.expect("Malformed localization table found!"))
+    // possible presently to losslessly collect extra string values while using
-        .map(LocalizationEntryCsv::to_json)
+    // csv+Serde.
-        .collect();
+    //
+    // https://github.com/BurntSushi/rust-csv/issues/151
+    let mut reader = csv::Reader::from_reader(file.contents.as_slice());
+
+    let headers = reader.headers()
+        .map_err(|inner| SnapshotError::CsvDecodeError {
+            inner,
+            path: file.path.to_path_buf(),
+        })?
+        .clone();
+
+    let mut records = Vec::new();
+
+    for record in reader.into_records() {
+        let record = record
+            .map_err(|inner| SnapshotError::CsvDecodeError {
+                inner,
+                path: file.path.to_path_buf(),
+            })?;
+
+        records.push(record);
+    }
+
+    let mut entries = Vec::new();
+
+    for record in &records {
+        let mut entry = LocalizationEntry::default();
+
+        for (header, value) in headers.iter().zip(record.into_iter()) {
+            if header.is_empty() || value.is_empty() {
+                continue;
+            }
+
+            match header {
+                "Key" => entry.key = Some(value),
+                "Source" => entry.source = Some(value),
+                "Context" => entry.context = Some(value),
+                "Example" => entry.example = Some(value),
+                _ => {
+                    entry.values.insert(header, value);
+                }
+            }
+        }
+
+        if entry.key.is_none() && entry.source.is_none() {
+            continue;
+        }
+
+        entries.push(entry);
+    }
 
     let table_contents = serde_json::to_string(&entries)
         .expect("Could not encode JSON for localization table");
 
-    Ok(Some(RbxSnapshotInstance {
+    let mut snapshot = RbxSnapshotInstance {
         name: Cow::Borrowed(instance_name),
         class_name: Cow::Borrowed("LocalizationTable"),
         properties: hashmap! {
@@ -503,40 +711,14 @@ fn snapshot_csv_file<'source>(
             ignore_unknown_instances: false,
             project_definition: None,
         },
-    }))
+    };
-}
 
-#[derive(Debug, Serialize, Deserialize)]
+    if let Some(meta) = ExtraMetadata::locate(&imfs, &file.path)? {
-#[serde(rename_all = "PascalCase")]
+        meta.validate_for_non_init(&file.path)?;
-struct LocalizationEntryCsv {
+        meta.apply(&mut snapshot)?;
-    key: String,
-    context: String,
-    example: String,
-    source: String,
-    #[serde(flatten)]
-    values: HashMap<String, String>,
-}
-
-impl LocalizationEntryCsv {
-    fn to_json(self) -> LocalizationEntryJson {
-        LocalizationEntryJson {
-            key: self.key,
-            context: self.context,
-            example: self.example,
-            source: self.source,
-            values: self.values,
-        }
     }
-}
 
-#[derive(Debug, Serialize, Deserialize)]
+    Ok(Some(snapshot))
-#[serde(rename_all = "camelCase")]
-struct LocalizationEntryJson {
-    key: String,
-    context: String,
-    example: String,
-    source: String,
-    values: HashMap<String, String>,
 }
 
 fn snapshot_json_model_file<'source>(
@@ -554,7 +736,7 @@ fn snapshot_json_model_file<'source>(
             path: file.path.to_owned(),
         })?;
 
-    let mut snapshot = json_instance.into_snapshot();
+    let mut snapshot = json_instance.into_snapshot()?;
     snapshot.metadata.source_path = Some(file.path.to_owned());
 
     Ok(Some(snapshot))
@@ -570,47 +752,52 @@ struct JsonModelInstance {
     children: Vec<JsonModelInstance>,
 
     #[serde(default = "HashMap::new", skip_serializing_if = "HashMap::is_empty")]
-    properties: HashMap<String, RbxValue>,
+    properties: HashMap<String, UnresolvedRbxValue>,
 }
 
 impl JsonModelInstance {
-    fn into_snapshot(mut self) -> RbxSnapshotInstance<'static> {
+    fn into_snapshot(self) -> Result<RbxSnapshotInstance<'static>, SnapshotError> {
-        let children = self.children
+        let mut children = Vec::with_capacity(self.children.len());
-            .drain(..)
-            .map(JsonModelInstance::into_snapshot)
-            .collect();
 
-        RbxSnapshotInstance {
+        for child in self.children {
+            children.push(child.into_snapshot()?);
+        }
+
+        let mut properties = HashMap::with_capacity(self.properties.len());
+
+        for (key, value) in self.properties {
+            let resolved_value = try_resolve_value(&self.class_name, &key, &value)?;
+            properties.insert(key, resolved_value);
+        }
+
+        Ok(RbxSnapshotInstance {
             name: Cow::Owned(self.name),
             class_name: Cow::Owned(self.class_name),
-            properties: self.properties,
+            properties,
             children,
             metadata: Default::default(),
-        }
+        })
     }
 }
 
 fn snapshot_xml_model_file<'source>(
     file: &'source ImfsFile,
+    imfs: &'source Imfs,
 ) -> SnapshotResult<'source> {
     let instance_name = file.path
         .file_stem().expect("Could not extract file stem")
         .to_str().expect("Could not convert path to UTF-8");
 
-    let mut temp_tree = RbxTree::new(RbxInstanceProperties {
+    let options = rbx_xml::DecodeOptions::new()
-        name: "Temp".to_owned(),
+        .property_behavior(rbx_xml::DecodePropertyBehavior::ReadUnknown);
-        class_name: "Folder".to_owned(),
-        properties: HashMap::new(),
-    });
 
-    let root_id = temp_tree.get_root_id();
+    let temp_tree = rbx_xml::from_reader(file.contents.as_slice(), options)
-    rbx_xml::decode(&mut temp_tree, root_id, file.contents.as_slice())
         .map_err(|inner| SnapshotError::XmlModelDecodeError {
             inner,
             path: file.path.clone(),
         })?;
 
-    let root_instance = temp_tree.get_instance(root_id).unwrap();
+    let root_instance = temp_tree.get_instance(temp_tree.get_root_id()).unwrap();
     let children = root_instance.get_children_ids();
 
     match children.len() {
@@ -618,6 +805,13 @@ fn snapshot_xml_model_file<'source>(
         1 => {
             let mut snapshot = snapshot_from_tree(&temp_tree, children[0]).unwrap();
             snapshot.name = Cow::Borrowed(instance_name);
+            snapshot.metadata.source_path = Some(file.path.clone());
+
+            if let Some(meta) = ExtraMetadata::locate(&imfs, &file.path)? {
+                meta.validate_for_model(&file.path)?;
+                meta.apply(&mut snapshot)?;
+            }
+
             Ok(Some(snapshot))
         },
         _ => panic!("Rojo doesn't have support for model files with multiple roots yet"),
@@ -626,6 +820,7 @@ fn snapshot_xml_model_file<'source>(
 
 fn snapshot_binary_model_file<'source>(
     file: &'source ImfsFile,
+    imfs: &'source Imfs,
 ) -> SnapshotResult<'source> {
     let instance_name = file.path
         .file_stem().expect("Could not extract file stem")
@@ -652,6 +847,13 @@ fn snapshot_binary_model_file<'source>(
         1 => {
             let mut snapshot = snapshot_from_tree(&temp_tree, children[0]).unwrap();
             snapshot.name = Cow::Borrowed(instance_name);
+            snapshot.metadata.source_path = Some(file.path.clone());
+
+            if let Some(meta) = ExtraMetadata::locate(&imfs, &file.path)? {
+                meta.validate_for_model(&file.path)?;
+                meta.apply(&mut snapshot)?;
+            }
+
             Ok(Some(snapshot))
         },
         _ => panic!("Rojo doesn't have support for model files with multiple roots yet"),

server/src/session_id.rs

@@ -1,4 +1,4 @@
-use serde_derive::{Serialize, Deserialize};
+use serde::{Serialize, Deserialize};
 use uuid::Uuid;
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]

server/src/snapshot_reconciler.rs

@@ -11,7 +11,7 @@ use std::{
 };
 
 use rbx_dom_weak::{RbxTree, RbxId, RbxInstanceProperties, RbxValue};
-use serde_derive::{Serialize, Deserialize};
+use serde::{Serialize, Deserialize};
 
 use crate::{
     path_map::PathMap,

server/src/web/api.rs

@@ -21,7 +21,7 @@ use hyper::{
     Request,
     Response,
 };
-use serde_derive::{Serialize, Deserialize};
+use serde::{Serialize, Deserialize};
 use rbx_dom_weak::{RbxId, RbxInstance};
 
 use crate::{

server/tests/malformed_projects.rs

@@ -0,0 +1,55 @@
+use std::{
+    path::{Path, PathBuf},
+    sync::Arc,
+};
+
+use librojo::{
+    live_session::LiveSession,
+    project::Project,
+};
+
+lazy_static::lazy_static! {
+    static ref TEST_PROJECTS_ROOT: PathBuf = {
+        Path::new(env!("CARGO_MANIFEST_DIR")).join("../test-projects")
+    };
+}
+
+#[test]
+fn bad_json_model() {
+    let project = Project::load_fuzzy(&TEST_PROJECTS_ROOT.join("bad_json_model"))
+        .expect("Project file didn't load");
+
+    if LiveSession::new(Arc::new(project)).is_ok() {
+        panic!("Project should not have succeeded");
+    }
+}
+
+#[test]
+fn bad_meta_lua_classname() {
+    let project = Project::load_fuzzy(&TEST_PROJECTS_ROOT.join("bad_meta_lua_classname"))
+        .expect("Project file didn't load");
+
+    if LiveSession::new(Arc::new(project)).is_ok() {
+        panic!("Project should not have succeeded");
+    }
+}
+
+#[test]
+fn bad_meta_rbxmx_properties() {
+    let project = Project::load_fuzzy(&TEST_PROJECTS_ROOT.join("bad_meta_rbxmx_properties"))
+        .expect("Project file didn't load");
+
+    if LiveSession::new(Arc::new(project)).is_ok() {
+        panic!("Project should not have succeeded");
+    }
+}
+
+#[test]
+fn bad_missing_files() {
+    let project = Project::load_fuzzy(&TEST_PROJECTS_ROOT.join("bad_missing_files"))
+        .expect("Project file didn't load");
+
+    if LiveSession::new(Arc::new(project)).is_ok() {
+        panic!("Project should not have succeeded");
+    }
+}

server/tests/snapshot_snapshots.rs

@@ -33,6 +33,9 @@ macro_rules! generate_snapshot_tests {
 
 generate_snapshot_tests!(
     empty,
+    json_model,
+    localization,
+    meta_files,
     multi_partition_game,
     nested_partitions,
     single_partition_game,

server/tests/test_util/tree.rs

@@ -20,7 +20,7 @@ use std::{
 };
 
 use log::error;
-use serde_derive::{Serialize, Deserialize};
+use serde::{Serialize, Deserialize};
 use rbx_dom_weak::{RbxId, RbxTree};
 
 use librojo::{

test-projects/bad_json_model/default.project.json

@@ -1,5 +1,5 @@
 {
-  "name": "malformed-stuff",
+  "name": "bad_json_model",
   "tree": {
     "$path": "src"
   }

test-projects/bad_meta_lua_classname/default.project.json

@@ -0,0 +1,6 @@
+{
+  "name": "bad_meta_lua_classname",
+  "tree": {
+    "$path": "src"
+  }
+}

test-projects/bad_meta_lua_classname/src/foo.lua

@@ -0,0 +1 @@
+-- foo.lua

test-projects/bad_meta_lua_classname/src/foo.meta.json

@@ -0,0 +1,3 @@
+{
+  "className": "Script"
+}

test-projects/bad_meta_rbxmx_properties/default.project.json

@@ -0,0 +1,6 @@
+{
+  "name": "bad_meta_rbxmx_properties",
+  "tree": {
+    "$path": "src"
+  }
+}

test-projects/bad_meta_rbxmx_properties/src/RobloxInstance.meta.json

@@ -0,0 +1,5 @@
+{
+  "properties": {
+    "x": true
+  }
+}

test-projects/bad_meta_rbxmx_properties/src/RobloxInstance.rbxmx

@@ -0,0 +1,11 @@
+<roblox xmlns:xmime="http://www.w3.org/2005/05/xmlmime" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="http://www.roblox.com/roblox.xsd" version="4">
+	<Meta name="ExplicitAutoJoints">true</Meta>
+	<External>null</External>
+	<External>nil</External>
+	<Item class="Folder" referent="RBXFC73D3B1B4524E729A1563A276CBC702">
+		<Properties>
+			<string name="Name">Folder</string>
+			<BinaryString name="Tags"></BinaryString>
+		</Properties>
+	</Item>
+</roblox>

test-projects/bad_missing_files/default.project.json

@@ -1,5 +1,5 @@
 {
-  "name": "missing-files",
+  "name": "bad_missing_files",
   "tree": {
     "$path": "does-not-exist"
   }

test-projects/json_model/default.project.json

@@ -0,0 +1,6 @@
+{
+  "name": "json_model",
+  "tree": {
+    "$path": "src"
+  }
+}

test-projects/json_model/expected-snapshot.json

@@ -0,0 +1,76 @@
+{
+  "name": "json_model",
+  "class_name": "Folder",
+  "properties": {},
+  "children": [
+    {
+      "name": "children",
+      "class_name": "Folder",
+      "properties": {},
+      "children": [
+        {
+          "name": "The Child",
+          "class_name": "StringValue",
+          "properties": {},
+          "children": [],
+          "metadata": {
+            "ignore_unknown_instances": false,
+            "source_path": null,
+            "project_definition": null
+          }
+        }
+      ],
+      "metadata": {
+        "ignore_unknown_instances": false,
+        "source_path": "src/children.model.json",
+        "project_definition": null
+      }
+    },
+    {
+      "name": "explicit",
+      "class_name": "StringValue",
+      "properties": {
+        "Value": {
+          "Type": "String",
+          "Value": "Hello, world!"
+        }
+      },
+      "children": [],
+      "metadata": {
+        "ignore_unknown_instances": false,
+        "source_path": "src/explicit.model.json",
+        "project_definition": null
+      }
+    },
+    {
+      "name": "implicit",
+      "class_name": "StringValue",
+      "properties": {
+        "Value": {
+          "Type": "String",
+          "Value": "What's happenin', Earth?"
+        }
+      },
+      "children": [],
+      "metadata": {
+        "ignore_unknown_instances": false,
+        "source_path": "src/implicit.model.json",
+        "project_definition": null
+      }
+    }
+  ],
+  "metadata": {
+    "ignore_unknown_instances": false,
+    "source_path": "src",
+    "project_definition": [
+      "json_model",
+      {
+        "class_name": null,
+        "children": {},
+        "properties": {},
+        "ignore_unknown_instances": null,
+        "path": "src"
+      }
+    ]
+  }
+}

test-projects/json_model/src/children.model.json

@@ -0,0 +1,10 @@
+{
+  "Name": "children",
+  "ClassName": "Folder",
+  "Children": [
+    {
+      "Name": "The Child",
+      "ClassName": "StringValue"
+    }
+  ]
+}

test-projects/json_model/src/explicit.model.json

@@ -0,0 +1,11 @@
+{
+  "Name": "explicit",
+  "ClassName": "StringValue",
+  "Properties": {
+    "Value": {
+      "Type": "String",
+      "Value": "Hello, world!"
+    }
+  },
+  "Children": []
+}

test-projects/json_model/src/implicit.model.json

@@ -0,0 +1,7 @@
+{
+  "Name": "implicit",
+  "ClassName": "StringValue",
+  "Properties": {
+    "Value": "What's happenin', Earth?"
+  }
+}

test-projects/legacy-0.4.x/rojo.json

@@ -0,0 +1,4 @@
+{
+  "name": "legacy",
+  "parittions": {}
+}

test-projects/legacy-0.5.x-reserved-names/default.project.json

@@ -0,0 +1,9 @@
+{
+  "name": "legacy-0.5.x-reserved-names",
+  "tree": {
+    "$className": "Folder",
+    "$warn-about-me": {
+      "$className": "Folder"
+    }
+  }
+}

test-projects/legacy-0.5.x-unknown-names/default.project.json

@@ -0,0 +1,7 @@
+{
+  "name": "legacy-0.5.x-reserved-names",
+  "tree": {
+    "$className": "Folder"
+  },
+  "some field Rojo doesn't have": true
+}

test-projects/legacy-old-0.5.x/roblox-project.json

@@ -0,0 +1,6 @@
+{
+  "name": "Foo",
+  "tree": {
+    "$className": "Folder"
+  }
+}

test-projects/localization/default.project.json

@@ -0,0 +1,6 @@
+{
+  "name": "localization",
+  "tree": {
+    "$path": "src"
+  }
+}

test-projects/localization/expected-snapshot.json

@@ -0,0 +1,69 @@
+{
+  "name": "localization",
+  "class_name": "Folder",
+  "properties": {},
+  "children": [
+    {
+      "name": "empty-column-bug-147",
+      "class_name": "LocalizationTable",
+      "properties": {
+        "Contents": {
+          "Type": "String",
+          "Value": "[{\"key\":\"Language.Name\",\"source\":\"English\",\"values\":{}},{\"key\":\"Language.Region\",\"source\":\"United States\",\"values\":{}},{\"key\":\"Label.Thickness\",\"source\":\"Thickness\",\"values\":{}},{\"key\":\"Label.Opacity\",\"source\":\"Opacity\",\"values\":{}},{\"key\":\"Toolbar.Undo\",\"source\":\"Undo\",\"values\":{}},{\"key\":\"Toolbar.Redo\",\"source\":\"Redo\",\"values\":{}},{\"key\":\"Toolbar.Camera\",\"source\":\"Top-down camera\",\"values\":{}},{\"key\":\"Toolbar.Saves\",\"source\":\"Saved drawings\",\"values\":{}},{\"key\":\"Toolbar.Preferences\",\"source\":\"Settings\",\"values\":{}},{\"key\":\"Toolbar.Mode.Vector\",\"source\":\"Vector mode\",\"values\":{}},{\"key\":\"Toolbar.Mode.Pixel\",\"source\":\"Pixel mode\",\"values\":{}}]"
+        }
+      },
+      "children": [],
+      "metadata": {
+        "ignore_unknown_instances": false,
+        "source_path": "src/empty-column-bug-147.csv",
+        "project_definition": null
+      }
+    },
+    {
+      "name": "integers-bug-145",
+      "class_name": "LocalizationTable",
+      "properties": {
+        "Contents": {
+          "Type": "String",
+          "Value": "[{\"key\":\"Count\",\"example\":\"A number demonstrating issue 145\",\"source\":\"3\",\"values\":{\"es\":\"7\"}}]"
+        }
+      },
+      "children": [],
+      "metadata": {
+        "ignore_unknown_instances": false,
+        "source_path": "src/integers-bug-145.csv",
+        "project_definition": null
+      }
+    },
+    {
+      "name": "normal",
+      "class_name": "LocalizationTable",
+      "properties": {
+        "Contents": {
+          "Type": "String",
+          "Value": "[{\"key\":\"Ack\",\"example\":\"An exclamation of despair\",\"source\":\"Ack!\",\"values\":{\"es\":\"¡Ay!\"}}]"
+        }
+      },
+      "children": [],
+      "metadata": {
+        "ignore_unknown_instances": false,
+        "source_path": "src/normal.csv",
+        "project_definition": null
+      }
+    }
+  ],
+  "metadata": {
+    "ignore_unknown_instances": false,
+    "source_path": "src",
+    "project_definition": [
+      "localization",
+      {
+        "class_name": null,
+        "children": {},
+        "properties": {},
+        "ignore_unknown_instances": null,
+        "path": "src"
+      }
+    ]
+  }
+}

test-projects/localization/src/empty-column-bug-147.csv

@@ -0,0 +1,17 @@
+,Key,Source,Context,Example
+,,,,
+Metadata,Language.Name,English,,
+,Language.Region,United States,,
+,,,,
+Options,Label.Thickness,Thickness,,
+,Label.Opacity,Opacity,,
+,,,,
+Toolbar,Toolbar.Undo,Undo,,
+,Toolbar.Redo,Redo,,
+,,,,
+,Toolbar.Camera,Top-down camera,,
+,Toolbar.Saves,Saved drawings,,
+,Toolbar.Preferences,Settings,,
+,,,,
+,Toolbar.Mode.Vector,Vector mode,,
+,Toolbar.Mode.Pixel,Pixel mode,,

test-projects/localization/src/integers-bug-145.csv

@@ -0,0 +1,2 @@
+Key,Source,Context,Example,es
+Count,3,,A number demonstrating issue 145,7

test-projects/localization/src/normal.csv

@@ -0,0 +1,2 @@
+Key,Source,Context,Example,es
+Ack,Ack!,,An exclamation of despair,¡Ay!

test-projects/meta_files/default.project.json

@@ -0,0 +1,6 @@
+{
+  "name": "test-model",
+  "tree": {
+    "$path": "src"
+  }
+}

test-projects/meta_files/expected-snapshot.json

@@ -0,0 +1,129 @@
+{
+  "name": "test-model",
+  "class_name": "Tool",
+  "properties": {
+    "Enabled": {
+      "Type": "Bool",
+      "Value": true
+    }
+  },
+  "children": [
+    {
+      "name": "A",
+      "class_name": "Folder",
+      "properties": {},
+      "children": [],
+      "metadata": {
+        "ignore_unknown_instances": true,
+        "source_path": "src/A",
+        "project_definition": null
+      }
+    },
+    {
+      "name": "DisableMe",
+      "class_name": "Script",
+      "properties": {
+        "Disabled": {
+          "Type": "Bool",
+          "Value": true
+        },
+        "Source": {
+          "Type": "String",
+          "Value": ""
+        }
+      },
+      "children": [],
+      "metadata": {
+        "ignore_unknown_instances": true,
+        "source_path": "src/DisableMe.server.lua",
+        "project_definition": null
+      }
+    },
+    {
+      "name": "LocalizationTable",
+      "class_name": "LocalizationTable",
+      "properties": {
+        "Contents": {
+          "Type": "String",
+          "Value": "[{\"key\":\"Doge\",\"example\":\"A funny dog\",\"source\":\"Perro!\",\"values\":{\"en\":\"Doge!\"}}]"
+        },
+        "SourceLocaleId": {
+          "Type": "String",
+          "Value": "es"
+        }
+      },
+      "children": [],
+      "metadata": {
+        "ignore_unknown_instances": false,
+        "source_path": "src/LocalizationTable.csv",
+        "project_definition": null
+      }
+    },
+    {
+      "name": "RobloxInstance",
+      "class_name": "Folder",
+      "properties": {
+        "Tags": {
+          "Type": "BinaryString",
+          "Value": ""
+        }
+      },
+      "children": [],
+      "metadata": {
+        "ignore_unknown_instances": true,
+        "source_path": "src/RobloxInstance.rbxmx",
+        "project_definition": null
+      }
+    },
+    {
+      "name": "Script",
+      "class_name": "Script",
+      "properties": {
+        "Source": {
+          "Type": "String",
+          "Value": "print(\"Hello, world\")"
+        },
+        "Disabled": {
+          "Type": "Bool",
+          "Value": true
+        }
+      },
+      "children": [],
+      "metadata": {
+        "ignore_unknown_instances": false,
+        "source_path": "src/Script",
+        "project_definition": null
+      }
+    },
+    {
+      "name": "StringValue",
+      "class_name": "StringValue",
+      "properties": {
+        "Value": {
+          "Type": "String",
+          "Value": "I'm supposed to put funny text here, aren't I? Oh well."
+        }
+      },
+      "children": [],
+      "metadata": {
+        "ignore_unknown_instances": true,
+        "source_path": "src/StringValue.txt",
+        "project_definition": null
+      }
+    }
+  ],
+  "metadata": {
+    "ignore_unknown_instances": false,
+    "source_path": "src",
+    "project_definition": [
+      "test-model",
+      {
+        "class_name": null,
+        "children": {},
+        "properties": {},
+        "ignore_unknown_instances": null,
+        "path": "src"
+      }
+    ]
+  }
+}

test-projects/meta_files/src/A/init.meta.json

@@ -0,0 +1,3 @@
+{
+  "ignoreUnknownInstances": true
+}

test-projects/meta_files/src/DisableMe.meta.json

@@ -0,0 +1,6 @@
+{
+  "ignoreUnknownInstances": true,
+  "properties": {
+    "Disabled": true
+  }
+}

test-projects/meta_files/src/LocalizationTable.csv

@@ -0,0 +1,2 @@
+Key,Source,Context,Example,en
+Doge,Perro!,,A funny dog,Doge!

test-projects/meta_files/src/LocalizationTable.meta.json

@@ -0,0 +1,5 @@
+{
+  "properties": {
+    "SourceLocaleId": "es"
+  }
+}

test-projects/meta_files/src/RobloxInstance.meta.json

@@ -0,0 +1,3 @@
+{
+  "ignoreUnknownInstances": true
+}

test-projects/meta_files/src/RobloxInstance.rbxmx

@@ -0,0 +1,11 @@
+<roblox xmlns:xmime="http://www.w3.org/2005/05/xmlmime" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="http://www.roblox.com/roblox.xsd" version="4">
+	<Meta name="ExplicitAutoJoints">true</Meta>
+	<External>null</External>
+	<External>nil</External>
+	<Item class="Folder" referent="RBXFC73D3B1B4524E729A1563A276CBC702">
+		<Properties>
+			<string name="Name">Folder</string>
+			<BinaryString name="Tags"></BinaryString>
+		</Properties>
+	</Item>
+</roblox>

test-projects/meta_files/src/Script/init.meta.json

@@ -0,0 +1,5 @@
+{
+  "properties": {
+    "Disabled": true
+  }
+}