Merge branch 'master' into impl-v2

.editorconfig

@@ -8,3 +8,8 @@ charset = utf-8
 indent_style = space
 indent_size = 2
 trim_trailing_whitespace = true
+
+[*.md]
+indent_style = space
+indent_size = 4
+trim_trailing_whitespace = true

README.md

@@ -9,6 +9,9 @@
         <img src="https://api.travis-ci.org/LPGhatguy/rojo.svg?branch=master" alt="Travis-CI Build Status" />
     </a>
     <img src="https://img.shields.io/badge/latest_version-0.4.4-brightgreen.svg" alt="Current server version" />
+    <a href="https://lpghatguy.github.io/rojo">
+        <img src="https://img.shields.io/badge/documentation-website-brightgreen.svg" alt="Rojo Documentation" />
+    </a>
 </div>
 
 <hr />
@@ -29,157 +32,8 @@ Later this year, Rojo will be able to:
 * Sync `rbxmx` models between the filesystem and Roblox Studio
 * Package projects into `rbxmx` files from the command line
 
-## Installation
+## [Documentation Website](https://lpghatguy.github.io/rojo)
-Rojo has two components:
+You can also view the documentation by browsing the [docs folder of the repository](https://github.com/LPGhatguy/rojo/tree/master/docs), but because it uses a number of Markdown extensions, it may not be very readable.
-
-* The server, a binary written in Rust
-* The plugin, a Roblox Studio plugin written in Lua
-
-It's important that the plugin and server are compatible. The plugin will show errors in the Roblox Studio Output window if there is a version mismatch.
-
-To install the server, either:
-
-* If you have Rust installed, use `cargo install rojo`
-* Or, download a pre-built Windows binary from [the GitHub releases page](https://github.com/LPGhatguy/rojo/releases)
-
-To install the plugin, either:
-
-* Install the plugin from the [Roblox plugin page](https://www.roblox.com/library/1211549683/Rojo).
-  * This gives you less control over what version you install -- you will always have the latest version.
-* Or, download the latest release from [the GitHub releases section](https://github.com/LPGhatguy/rojo/releases) and install it into your Roblox plugins folder
-  * You can open this folder by clicking the "Plugins Folder" button from the Plugins toolbar in Roblox Studio
-
-## Server Usage
-For more help, use `rojo help`.
-
-### New Project
-Create a new folder, then use `rojo init` inside that folder to initialize an empty project:
-
-```sh
-mkdir my-new-project
-cd my-new-project
-
-rojo init
-```
-
-Rojo will create an empty project file named `rojo.json` in the directory.
-
-The default project file is:
-
-```json
-{
-  "name": "my-new-project",
-  "servePort": 8000,
-  "partitions": {}
-}
-```
-
-### Start Dev Server
-To start the Rojo dev server, use:
-
-```sh
-rojo serve
-```
-
-The tool will tell you whether it found an existing project. You should then be able to connect and use the project from within Roblox Studio!
-
-### Migrating an Existing Roblox Project
-[Bi-directional script syncing](https://github.com/LPGhatguy/rojo/issues/5) is on the roadmap for Rojo this year, but isn't implemented.
-
-In the mean-time, manually migrating scripts is probably the best route forward.
-
-### Syncing into Roblox
-In order to sync code into Roblox, you'll need to add one or more *partitions* to your configuration. A partition tells Rojo how to map directories on your filesystem to Roblox objects.
-
-Each entry in the `partitions` map has a unique name, a filesystem path, and the full name of the Roblox object to sync into.
-
-For example, if you want to map your `src` directory to an object named `My Cool Game` in `ReplicatedStorage`, you could use this configuration:
-
-```json
-{
-  "name": "rojo",
-  "servePort": 8000,
-  "partitions": {
-    "game": {
-      "path": "src",
-      "target": "ReplicatedStorage.My Cool Game"
-    }
-  }
-}
-```
-
-The `path` parameter is relative to the project file.
-
-The `target` parameter is a path to a Roblox object to link the partition to, starting at `game`. If any objects don't exist along the way, Rojo will try to create them.
-
-**Any objects in a partition may be wiped away by Rojo after syncing! If this is not desired, use multiple, smaller partitions.**
-
-Run `rojo serve` in the directory containing this project, then press the "Sync In" or "Toggle Polling" buttons in the Roblox Studio plugin to sync into your game.
-
-### Sync Details
-The structure of files and diectories on the filesystem are preserved when syncing into game.
-
-Creation of Roblox instances follows a simple set of rules. The first rule that matches the file name is chosen:
-
-| File Name      | Instance Type  | Notes                                     |
-| -------------- | -------------- | ----------------------------------------- |
-| `*.server.lua` | `Script`       | `Source` will contain the file's contents |
-| `*.client.lua` | `LocalScript`  | `Source` will contain the file's contents |
-| `*.lua`        | `ModuleScript` | `Source` will contain the file's contents |
-| `*.model.json` | *Varies*       | See the example below                     |
-| `*`            | `StringValue`  | `Value` will contain the file's contents  |
-
-Any directories on the filesystem will turn into `Folder` objects.
-
-Any directory containing one of these files will instead be a `ModuleScript`, `Script`, `LocalScript` containing the directory's contents:
-
-* `init.lua`
-* `init.server.lua`
-* `init.client.lua`
-
-For example, this file tree:
-
-* my-game
-	* init.client.lua
-	* foo.lua
-
-Will turn into these instances in Roblox:
-
-* `my-game` (`LocalScript` with source from `my-game/init.client.lua`)
-	* `foo` (`ModuleScript` with source from `my-game/foo.lua`)
-
-`*.model.json` files are a way to represent simple Roblox instances on the filesystem until `rbxmx` and `rbxlx` support is implemented in Rojo.
-
-This feature is intended for small instances, like `RemoteEvent` or `*Value` objects.
-
-JSON Model files are strict, with every property being required. They look like this:
-
-```json
-{
-  "Name": "hello",
-  "ClassName": "Model",
-  "Children": [
-    {
-      "Name": "Some Part",
-      "ClassName": "Part",
-      "Children": [],
-      "Properties": {}
-    },
-    {
-      "Name": "Some StringValue",
-      "ClassName": "StringValue",
-      "Children": [],
-      "Properties": {
-        "Value": {
-          "Type": "String",
-          "Value": "Hello, world!"
-        }
-      }
-    }
-  ],
-  "Properties": {}
-}
-```
 
 ## Inspiration
 There are lots of other tools that sync scripts into Roblox or provide other tools for working with Roblox places.

docs/getting-started/creating-a-project.md

@@ -0,0 +1,77 @@
+# Creating a Project
+To use Rojo, you'll need to create a new project file, which tells Rojo what your project is, and how to load it into Roblox Studio.
+
+## New Project
+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 create an empty project file named `rojo.json` in the directory.
+
+The default configuration doesn't do anything. We need to tell Rojo where our code is on the filesystem, and where we want to put it in the Roblox tree.
+
+To do that, open up `rojo.json` and add an entry to the `partitions` table:
+
+```json
+{
+    "name": "your-project-name-here",
+    "servePort": 8000,
+    "partitions": {
+        "src": {
+            "path": "src",
+            "target": "ReplicatedStorage.Project"
+        }
+    }
+}
+```
+
+!!! warning
+    Make sure that the `src` directory exists in your project, or Rojo will throw an error!
+
+!!! warning
+    Any objects contained in the `target` of a partition will be destroyed by Rojo if not found on the filesystem!
+
+A Rojo project has one or more *partitions*. Partitions define how code should be transferred between the filesystem and Roblox by mapping directories and files to Roblox objects.
+
+Each partition has:
+
+* A name (the key in the `partitions` object), which is used for debugging
+* `path`, the location on the filesystem relative to `rojo.json`
+* `target`, the location in Roblox relative to `game`
+
+## Syncing into Studio
+
+Once you've added your partition to the project file, you can start the Rojo dev server by running a command in your project's directory:
+
+```sh
+rojo serve
+```
+
+If your project is in the right place, Rojo will let you know that it was found and start an HTTP server that the plugin can connect to.
+
+In Roblox Studio, open the plugins tab and find Rojo's buttons.
+
+![Location of Rojo's plugin buttons in Roblox Studio](/images/plugin-buttons.png)
+{: align="center" }
+
+Press **Test Connection** to verify that the plugin can communicate with the dev server. Watch the Output panel for the results.
+
+!!! info
+    If you see an error message, return to the previous steps and make sure that the Rojo dev server is running.
+
+    ![Rojo error in Roblox Studio Output](/images/connection-error.png)
+    {: align="center" }
+
+After your connection was successful, press **Sync In** to move code from the filesystem into Studio, or use **Toggle Polling** to have Rojo automatically sync in changes as they happen.
+
+## Importing an Existing Project
+Rojo will eventually support importing an existing Roblox project onto the filesystem for use with Rojo.
+
+Rojo doesn't currently support converting an existing project or syncing files from Roblox Studio onto the filesystem. In the mean time, you can manually copy your files into the structure that Rojo expects.
+
+Up-to-date information will be available on [issue #5](https://github.com/LPGhatguy/rojo/issues/5) as this is worked on.

docs/getting-started/installation.md

@@ -0,0 +1,23 @@
+# Installation
+Rojo has two components:
+
+* The server, a binary written in Rust
+* The plugin, a Roblox Studio plugin written in Lua
+
+It's important that the plugin and server are compatible. The plugin will show errors in the Roblox Studio Output window if there is a version mismatch.
+
+## Installing the Server
+To install the server, either:
+
+* If you have Rust installed, use `cargo install rojo`
+* Or, download a pre-built Windows binary from [the GitHub releases page](https://github.com/LPGhatguy/rojo/releases)
+
+**The Rojo binary must be run from the command line, like Terminal on MacOS or `cmd.exe` on Windows. It's recommended that you put the Rojo binary on your `PATH` to make this easier.**
+
+## Installing the Plugin
+To install the plugin, either:
+
+* Install the plugin from the [Roblox plugin page](https://www.roblox.com/library/1211549683/Rojo).
+  * This gives you less control over what version you install -- you will always have the latest version.
+* Or, download the latest release from [the GitHub releases section](https://github.com/LPGhatguy/rojo/releases) and install it into your Roblox plugins folder
+  * You can open this folder by clicking the "Plugins Folder" button from the Plugins toolbar in Roblox Studio

docs/sync-details.md

@@ -0,0 +1,61 @@
+# Sync Details
+This page aims to describe how Rojo turns files on the filesystem into Roblox objects.
+
+## Folders
+Any directory on the filesystem will turn into a `Folder` instance in Roblox, unless that folder matches the name of a service or other existing instance. In those cases, that instance will be preserved.
+
+## Scripts
+Rojo can represent `ModuleScript`, `Script`, and `LocalScript` objects. The default script type is `ModuleScript`, since most scripts in well-structued Roblox projects will be modules.
+
+| File Name      | Instance Type  |
+| -------------- | -------------- |
+| `*.server.lua` | `Script`       |
+| `*.client.lua` | `LocalScript`  |
+| `*.lua`        | `ModuleScript` |
+
+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 conents of the `init` file. This can be used to create scripts inside of scripts.
+
+For example, this file tree:
+
+* my-game
+    * init.client.lua
+    * foo.lua
+
+Will turn into these instances in Roblox:
+
+![Example of Roblox instances](/images/sync-example.png)
+
+## Models
+Rojo supports a JSON model format for representing simple models. It's designed for instance types like `BindableEvent` or `*Value` objects, and is not suitable for larger models.
+
+!!! info
+    In the future, Rojo will support `.rbxmx` models. See [issue #7](https://github.com/LPGhatguy/rojo/issues/7) for more details and updates on this feature.
+
+JSON model files are strict, with every property being required. They look like this:
+
+```json
+{
+    "Name": "hello",
+    "ClassName": "Model",
+    "Children": [
+        {
+            "Name": "Some Part",
+            "ClassName": "Part",
+            "Children": [],
+            "Properties": {}
+        },
+        {
+            "Name": "Some StringValue",
+            "ClassName": "StringValue",
+            "Children": [],
+            "Properties": {
+                "Value": {
+                    "Type": "String",
+                    "Value": "Hello, world!"
+                }
+            }
+        }
+    ],
+    "Properties": {}
+}
+```

docs/why-rojo.md

@@ -0,0 +1,21 @@
+# Why Rojo?
+There are a number of existing plugins for Roblox that move code from the filesystem into Roblox.
+
+Besides Rojo, there is:
+
+* [Studio Bridge](https://github.com/vocksel/studio-bridge) by [Vocksel](https://github.com/vocksel)
+* [RbxRefresh](https://github.com/osyrisrblx/RbxRefresh) by [Osyris](https://github.com/osyrisrblx)
+* [RbxSync](https://github.com/evaera/RbxSync) by [evaera](https://github.com/evaera)
+* [CodeSync](https://github.com/MemoryPenguin/CodeSync) and [rbx-exteditor](https://github.com/MemoryPenguin/rbx-exteditor) by [MemoryPenguin](https://github.com/MemoryPenguin)
+* [rbxmk](https://github.com/anaminus/rbxmk) by [Anaminus](https://github.com/anaminus)
+
+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 the 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.

mkdocs.yml

@@ -11,8 +11,14 @@ theme:
 
 pages:
   - Home: index.md
+  - Why Rojo?: why-rojo.md
+  - Getting Started:
+    - Installation: getting-started/installation.md
+    - Creating a Project: getting-started/creating-a-project.md
+  - Sync Details: sync-details.md
 
 markdown_extensions:
+  - attr_list
   - admonition
   - codehilite:
       guess_lang: false