Implement support for turning .json files into Lua modules (#308)

* Stub implementation

* Flesh out feature and add tests. Other snapshots currently failing.

* Blacklist .meta.json in JSON handler

* Write to correct property (Source) instead of Value

* Update changelog

src/snapshot_middleware/error.rs

@@ -7,30 +7,36 @@ pub enum SnapshotError {
     #[error("file name had malformed Unicode")]
     FileNameBadUnicode { path: PathBuf },
 
-    #[error("file had malformed Unicode contents")]
+    #[error("file had malformed Unicode contents at path {}", .path.display())]
     FileContentsBadUnicode {
         source: std::str::Utf8Error,
         path: PathBuf,
     },
 
-    #[error("malformed project file")]
+    #[error("malformed project file at path {}", .path.display())]
     MalformedProject {
         source: serde_json::Error,
         path: PathBuf,
     },
 
-    #[error("malformed .model.json file")]
+    #[error("malformed .model.json file at path {}", .path.display())]
     MalformedModelJson {
         source: serde_json::Error,
         path: PathBuf,
     },
 
-    #[error("malformed .meta.json file")]
+    #[error("malformed .meta.json file at path {}", .path.display())]
     MalformedMetaJson {
         source: serde_json::Error,
         path: PathBuf,
     },
 
+    #[error("malformed JSON at path {}", .path.display())]
+    MalformedJson {
+        source: serde_json::Error,
+        path: PathBuf,
+    },
+
     #[error(transparent)]
     Io {
         #[from]
@@ -76,4 +82,11 @@ impl SnapshotError {
             path: path.into(),
         }
     }
+
+    pub(crate) fn malformed_json(source: serde_json::Error, path: impl Into<PathBuf>) -> Self {
+        Self::MalformedJson {
+            source,
+            path: path.into(),
+        }
+    }
 }

src/snapshot_middleware/json.rs

@@ -0,0 +1,142 @@
+use std::path::Path;
+
+use maplit::hashmap;
+use memofs::{IoResultExt, Vfs};
+use rbx_dom_weak::RbxValue;
+
+use crate::{
+    lua_ast::{Expression, Statement},
+    snapshot::{InstanceContext, InstanceMetadata, InstanceSnapshot},
+};
+
+use super::{
+    error::SnapshotError,
+    meta_file::AdjacentMetadata,
+    middleware::{SnapshotInstanceResult, SnapshotMiddleware},
+    util::match_file_name,
+};
+
+/// Catch-all middleware for snapshots on JSON files that aren't used for other
+/// features, like Rojo projects, JSON models, or meta files.
+pub struct SnapshotJson;
+
+impl SnapshotMiddleware for SnapshotJson {
+    fn from_vfs(context: &InstanceContext, vfs: &Vfs, path: &Path) -> SnapshotInstanceResult {
+        let meta = vfs.metadata(path)?;
+
+        if meta.is_dir() {
+            return Ok(None);
+        }
+
+        // FIXME: This middleware should not need to know about the .meta.json
+        // middleware. Should there be a way to signal "I'm not returning an
+        // instance and no one should"?
+        if match_file_name(path, ".meta.json").is_some() {
+            return Ok(None);
+        }
+
+        let instance_name = match match_file_name(path, ".json") {
+            Some(name) => name,
+            None => return Ok(None),
+        };
+
+        let contents = vfs.read(path)?;
+
+        let value: serde_json::Value = serde_json::from_slice(&contents)
+            .map_err(|err| SnapshotError::malformed_json(err, path))?;
+
+        let as_lua = json_to_lua(value).to_string();
+
+        let properties = hashmap! {
+            "Source".to_owned() => RbxValue::String {
+                value: as_lua,
+            },
+        };
+
+        let meta_path = path.with_file_name(format!("{}.meta.json", instance_name));
+
+        let mut snapshot = InstanceSnapshot::new()
+            .name(instance_name)
+            .class_name("ModuleScript")
+            .properties(properties)
+            .metadata(
+                InstanceMetadata::new()
+                    .instigating_source(path)
+                    .relevant_paths(vec![path.to_path_buf(), meta_path.clone()])
+                    .context(context),
+            );
+
+        if let Some(meta_contents) = vfs.read(&meta_path).with_not_found()? {
+            let mut metadata = AdjacentMetadata::from_slice(&meta_contents, &meta_path)?;
+            metadata.apply_all(&mut snapshot);
+        }
+
+        Ok(Some(snapshot))
+    }
+}
+
+fn json_to_lua(value: serde_json::Value) -> Statement {
+    Statement::Return(json_to_lua_value(value))
+}
+
+fn json_to_lua_value(value: serde_json::Value) -> Expression {
+    use serde_json::Value;
+
+    match value {
+        Value::Null => Expression::Nil,
+        Value::Bool(value) => Expression::Bool(value),
+        Value::Number(value) => Expression::Number(value.as_f64().unwrap()),
+        Value::String(value) => Expression::String(value),
+        Value::Array(values) => {
+            Expression::Array(values.into_iter().map(json_to_lua_value).collect())
+        }
+        Value::Object(values) => Expression::table(
+            values
+                .into_iter()
+                .map(|(key, value)| (key.into(), json_to_lua_value(value)))
+                .collect(),
+        ),
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    use memofs::{InMemoryFs, VfsSnapshot};
+
+    #[test]
+    fn instance_from_vfs() {
+        let mut imfs = InMemoryFs::new();
+        imfs.load_snapshot(
+            "/foo.json",
+            VfsSnapshot::file(
+                r#"{
+                  "array": [1, 2, 3],
+                  "object": {
+                    "hello": "world"
+                  },
+                  "true": true,
+                  "false": false,
+                  "null": null,
+                  "int": 1234,
+                  "float": 1234.5452,
+                  "1invalidident": "nice"
+                }"#,
+            ),
+        )
+        .unwrap();
+
+        let mut vfs = Vfs::new(imfs.clone());
+
+        let instance_snapshot = SnapshotJson::from_vfs(
+            &InstanceContext::default(),
+            &mut vfs,
+            Path::new("/foo.json"),
+        )
+        .unwrap()
+        .unwrap();
+
+        insta::assert_yaml_snapshot!(instance_snapshot);
+    }
+}

src/snapshot_middleware/mod.rs

@@ -6,6 +6,7 @@
 mod csv;
 mod dir;
 mod error;
+mod json;
 mod json_model;
 mod lua;
 mod meta_file;
@@ -26,6 +27,7 @@ use crate::snapshot::InstanceContext;
 use self::{
     csv::SnapshotCsv,
     dir::SnapshotDir,
+    json::SnapshotJson,
     json_model::SnapshotJsonModel,
     lua::SnapshotLua,
     middleware::{SnapshotInstanceResult, SnapshotMiddleware},
@@ -71,5 +73,6 @@ middlewares! {
     SnapshotLua,
     SnapshotCsv,
     SnapshotTxt,
+    SnapshotJson,
     SnapshotDir,
 }

src/snapshot_middleware/snapshots/librojo__snapshot_middleware__json__test__instance_from_vfs.snap

@@ -0,0 +1,20 @@
+---
+source: src/snapshot_middleware/json.rs
+expression: instance_snapshot
+---
+snapshot_id: ~
+metadata:
+  ignore_unknown_instances: false
+  instigating_source:
+    Path: /foo.json
+  relevant_paths:
+    - /foo.json
+    - /foo.meta.json
+  context: {}
+name: foo
+class_name: ModuleScript
+properties:
+  Source:
+    Type: String
+    Value: "return {\n\t[\"1invalidident\"] = \"nice\",\n\tarray = {1, 2, 3},\n\t[\"false\"] = false,\n\tfloat = 1234.5452,\n\tint = 1234,\n\tnull = nil,\n\tobject = {\n\t\thello = \"world\",\n\t},\n\t[\"true\"] = true,\n}"
+children: []