Reorganize some of the unwieldly parts of the codebase

* Moved commands into their own folder to reduce `bin.rs`'s size
* Moved all of the VFS-related functionality into its own folder
* Documented a lot of functions, including a few very obscure ones

src/web.rs

@@ -5,14 +5,20 @@ use rouille;
 use serde;
 use serde_json;
 
-use core::Config;
 use project::Project;
-use vfs::{Vfs, VfsChange};
+use vfs::{VfsSession, VfsChange};
 use rbx::RbxInstance;
 use plugin::PluginChain;
 
 static MAX_BODY_SIZE: usize = 25 * 1024 * 1024; // 25 MiB
 
+/// The set of configuration the web server needs to start.
+pub struct WebConfig {
+    pub port: u64,
+    pub verbose: bool,
+    pub server_id: u64,
+}
+
 #[derive(Debug, Serialize)]
 #[serde(rename_all = "camelCase")]
 struct ServerInfo<'a> {
@@ -51,7 +57,12 @@ fn json<T: serde::Serialize>(value: T) -> rouille::Response {
     rouille::Response::from_data("application/json", data)
 }
 
+/// Pulls text that may be JSON out of a Rouille Request object.
+///
+/// Doesn't do any actual parsing -- all this method does is verify the content
+/// type of the request and read the request's body.
 fn read_json_text(request: &rouille::Request) -> Option<String> {
+    // Bail out if the request body isn't marked as JSON
     match request.header("Content-Type") {
         Some(header) => if !header.starts_with("application/json") {
             return None;
@@ -64,14 +75,15 @@ fn read_json_text(request: &rouille::Request) -> Option<String> {
         None => return None,
     };
 
+    // Allocate a buffer and read up to MAX_BODY_SIZE+1 bytes into it.
     let mut out = Vec::new();
-    match body.take(MAX_BODY_SIZE.saturating_add(1) as u64)
-        .read_to_end(&mut out)
-    {
+    match body.take(MAX_BODY_SIZE.saturating_add(1) as u64).read_to_end(&mut out) {
         Ok(_) => {},
         Err(_) => return None,
     }
 
+    // If the body was too big (MAX_BODY_SIZE+1), we abort instead of trying to
+    // process it.
     if out.len() > MAX_BODY_SIZE {
         return None;
     }
@@ -84,6 +96,7 @@ fn read_json_text(request: &rouille::Request) -> Option<String> {
     Some(parsed)
 }
 
+/// Reads the body out of a Rouille Request and attempts to turn it into JSON.
 fn read_json<T>(request: &rouille::Request) -> Option<T>
 where
     T: serde::de::DeserializeOwned,
@@ -98,10 +111,13 @@ where
         Err(_) => return None,
     };
 
+    // TODO: Change return type to some sort of Result
+
     Some(parsed)
 }
 
-pub fn start(config: Config, project: Project, plugin_chain: &'static PluginChain, vfs: Arc<Mutex<Vfs>>) {
+/// Start the Rojo web server and park our current thread.
+pub fn start(config: WebConfig, project: Project, plugin_chain: &'static PluginChain, vfs: Arc<Mutex<VfsSession>>) {
     let address = format!("localhost:{}", config.port);
 
     let server_id = config.server_id.to_string();
@@ -109,6 +125,8 @@ pub fn start(config: Config, project: Project, plugin_chain: &'static PluginChai
     rouille::start_server(address, move |request| {
         router!(request,
             (GET) (/) => {
+                // Get a summary of information about the server.
+
                 let current_time = {
                     let vfs = vfs.lock().unwrap();
 
@@ -125,6 +143,8 @@ pub fn start(config: Config, project: Project, plugin_chain: &'static PluginChai
             },
 
             (GET) (/changes/{ last_time: f64 }) => {
+                // Get the list of changes since the given time.
+
                 let vfs = vfs.lock().unwrap();
                 let current_time = vfs.current_time();
                 let changes = vfs.changes_since(last_time);
@@ -137,11 +157,16 @@ pub fn start(config: Config, project: Project, plugin_chain: &'static PluginChai
             },
 
             (POST) (/read) => {
+                // Read some instances from the server according to a JSON
+                // format body.
+
                 let read_request: Vec<Vec<String>> = match read_json(&request) {
                     Some(v) => v,
                     None => return rouille::Response::empty_400(),
                 };
 
+                // Read the files off of the filesystem that the client
+                // requested.
                 let (items, current_time) = {
                     let vfs = vfs.lock().unwrap();
 
@@ -159,6 +184,8 @@ pub fn start(config: Config, project: Project, plugin_chain: &'static PluginChai
                     (items, current_time)
                 };
 
+                // Transform all of our VfsItem objects into Roblox instances
+                // the client can use.
                 let rbx_items = items
                     .iter()
                     .map(|item| {
@@ -182,6 +209,8 @@ pub fn start(config: Config, project: Project, plugin_chain: &'static PluginChai
             },
 
             (POST) (/write) => {
+                // Not yet implemented.
+
                 let _write_request: Vec<WriteSpecifier> = match read_json(&request) {
                     Some(v) => v,
                     None => return rouille::Response::empty_400(),