use crate::{BuildError, BuiltinLevenshteinSuggester, Diagnostic, ParseTree, RawValue, codes};
use dsl_kit_core::Suggester;
use dsl_kit_schema::{Multiplicity, NodeSchema, VariantSchema};
use serde_json::Value;
pub mod serde_codes {
pub const NOT_OBJECT: &str = "dsl_kit::parse::serde::not_object";
pub const TYPE_MISSING: &str = "dsl_kit::parse::serde::type_missing";
pub const TYPE_NOT_STRING: &str = "dsl_kit::parse::serde::type_not_string";
pub const CHILD_SHAPE: &str = "dsl_kit::parse::serde::child_shape";
}
pub fn from_json_str(input: &str, schema: &NodeSchema) -> Result<ParseTree, BuildError> {
from_json_str_with(input, schema, &BuiltinLevenshteinSuggester)
}
pub fn from_json_str_with(
input: &str,
schema: &NodeSchema,
suggester: &dyn Suggester,
) -> Result<ParseTree, BuildError> {
let value: Value = serde_json::from_str(input).map_err(|e| {
BuildError::single(Diagnostic::error(
serde_codes::NOT_OBJECT,
format!("invalid JSON: {e}"),
))
})?;
from_json_value_with(&value, schema, suggester)
}
pub fn from_json_value(value: &Value, schema: &NodeSchema) -> Result<ParseTree, BuildError> {
from_json_value_with(value, schema, &BuiltinLevenshteinSuggester)
}
pub fn from_json_value_with(
value: &Value,
schema: &NodeSchema,
suggester: &dyn Suggester,
) -> Result<ParseTree, BuildError> {
let mut diags = Vec::new();
let tree = build_tree(value, schema, &mut diags, suggester);
if diags.is_empty() {
Ok(tree.unwrap_or_else(|| ParseTree::new("")))
} else {
Err(BuildError::new(diags))
}
}
fn build_tree(
value: &Value,
schema: &NodeSchema,
diags: &mut Vec<Diagnostic>,
suggester: &dyn Suggester,
) -> Option<ParseTree> {
let obj = match value {
Value::Object(map) => map,
_ => {
diags.push(Diagnostic::error(
serde_codes::NOT_OBJECT,
format!(
"expected a JSON object with a `type` tag, got {}",
kind(value)
),
));
return None;
}
};
let variant_name = match obj.get("type") {
None => {
diags.push(Diagnostic::error(
serde_codes::TYPE_MISSING,
"object is missing the `type` tag (expected a variant name)".to_string(),
));
return None;
}
Some(Value::String(s)) => s.clone(),
Some(other) => {
diags.push(Diagnostic::error(
serde_codes::TYPE_NOT_STRING,
format!("`type` tag must be a string, got {}", kind(other)),
));
return None;
}
};
let variant = match schema.variant(&variant_name) {
Some(v) => v,
None => {
let msg = crate::format_unknown_variant(&variant_name, schema, suggester);
diags.push(Diagnostic::error(codes::UNKNOWN_VARIANT, msg));
return None;
}
};
let mut tree = ParseTree::new(variant_name);
for (key, val) in obj {
if key == "type" {
continue;
}
if let Some(_field) = variant.fields.iter().find(|f| &f.name == key) {
tree.fields.push((key.clone(), RawValue::Json(val.clone())));
} else if let Some(child) = variant.children.iter().find(|c| &c.name == key) {
let subtrees = build_child_slot(
child.multiplicity,
val,
variant,
key,
schema,
diags,
suggester,
);
tree.children.push((key.clone(), subtrees));
} else {
let all_slots = crate::all_slot_names(variant);
let hint = suggester.enrich_unknown(key, &all_slots);
let msg = match hint {
Some(h) => format!(
"unknown key `{}` on variant `{}` (not a declared field or child slot; {})",
key, variant.name, h
),
None => format!(
"unknown key `{}` on variant `{}` (not a declared field or child slot)",
key, variant.name
),
};
diags.push(Diagnostic::error(codes::UNKNOWN_FIELD, msg));
}
}
Some(tree)
}
fn build_child_slot(
m: Multiplicity,
val: &Value,
variant: &VariantSchema,
slot: &str,
schema: &NodeSchema,
diags: &mut Vec<Diagnostic>,
suggester: &dyn Suggester,
) -> Vec<ParseTree> {
match m {
Multiplicity::One => match val {
Value::Object(_) => build_tree(val, schema, diags, suggester)
.into_iter()
.collect(),
_ => {
diags.push(Diagnostic::error(
serde_codes::CHILD_SHAPE,
format!(
"child slot `{}` on variant `{}` requires exactly one object, got {}",
slot,
variant.name,
kind(val)
),
));
Vec::new()
}
},
Multiplicity::Optional => match val {
Value::Null => Vec::new(),
Value::Object(_) => build_tree(val, schema, diags, suggester)
.into_iter()
.collect(),
_ => {
diags.push(Diagnostic::error(
serde_codes::CHILD_SHAPE,
format!(
"child slot `{}` on variant `{}` requires null or an object, got {}",
slot,
variant.name,
kind(val)
),
));
Vec::new()
}
},
Multiplicity::Many => match val {
Value::Array(items) => items
.iter()
.filter_map(|item| build_tree(item, schema, diags, suggester))
.collect(),
_ => {
diags.push(Diagnostic::error(
serde_codes::CHILD_SHAPE,
format!(
"child slot `{}` on variant `{}` requires an array of objects, got {}",
slot,
variant.name,
kind(val)
),
));
Vec::new()
}
},
}
}
fn kind(v: &Value) -> &'static str {
match v {
Value::Null => "null",
Value::Bool(_) => "a boolean",
Value::Number(_) => "a number",
Value::String(_) => "a string",
Value::Array(_) => "an array",
Value::Object(_) => "an object",
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::{check_conformance, codes};
use dsl_kit_schema::{ChildSchema, FieldSchema, Multiplicity, NodeSchema, VariantSchema};
use serde_json::json;
fn schema() -> NodeSchema {
NodeSchema {
name: "Expr".into(),
variants: vec![
VariantSchema {
name: "Lit".into(),
fields: vec![FieldSchema {
name: "value".into(),
ty: "i64".into(),
optional: false,
}],
children: vec![],
},
VariantSchema {
name: "Add".into(),
fields: vec![],
children: vec![
ChildSchema {
name: "lhs".into(),
multiplicity: Multiplicity::One,
},
ChildSchema {
name: "rhs".into(),
multiplicity: Multiplicity::One,
},
],
},
VariantSchema {
name: "Let".into(),
fields: vec![FieldSchema {
name: "name".into(),
ty: "String".into(),
optional: false,
}],
children: vec![
ChildSchema {
name: "value".into(),
multiplicity: Multiplicity::One,
},
ChildSchema {
name: "body".into(),
multiplicity: Multiplicity::One,
},
],
},
VariantSchema {
name: "Group".into(),
fields: vec![],
children: vec![ChildSchema {
name: "items".into(),
multiplicity: Multiplicity::Many,
}],
},
VariantSchema {
name: "Wrap".into(),
fields: vec![],
children: vec![ChildSchema {
name: "inner".into(),
multiplicity: Multiplicity::Optional,
}],
},
],
}
}
#[test]
fn simple_lit() {
let tree = from_json_value(&json!({ "type": "Lit", "value": 7 }), &schema()).unwrap();
assert_eq!(tree.variant, "Lit");
assert_eq!(tree.fields.len(), 1);
assert_eq!(tree.children.len(), 0);
assert!(matches!(
tree.field("value").unwrap(),
RawValue::Json(v) if v.as_i64() == Some(7)
));
assert!(check_conformance(&tree, &schema()).is_empty());
}
#[test]
fn nested_add() {
let value = json!({
"type": "Add",
"lhs": { "type": "Lit", "value": 1 },
"rhs": { "type": "Lit", "value": 2 },
});
let tree = from_json_value(&value, &schema()).unwrap();
assert_eq!(tree.variant, "Add");
assert_eq!(tree.child_slot("lhs").unwrap().len(), 1);
assert_eq!(tree.child_slot("rhs").unwrap().len(), 1);
assert!(check_conformance(&tree, &schema()).is_empty());
}
#[test]
fn many_slot_from_array() {
let value = json!({
"type": "Group",
"items": [
{ "type": "Lit", "value": 1 },
{ "type": "Lit", "value": 2 },
{ "type": "Lit", "value": 3 },
],
});
let tree = from_json_value(&value, &schema()).unwrap();
assert_eq!(tree.child_slot("items").unwrap().len(), 3);
}
#[test]
fn optional_slot_from_null_is_empty() {
let tree = from_json_value(&json!({ "type": "Wrap", "inner": null }), &schema()).unwrap();
assert_eq!(tree.child_slot("inner").unwrap().len(), 0);
}
#[test]
fn optional_slot_from_object_is_one() {
let tree = from_json_value(
&json!({ "type": "Wrap", "inner": { "type": "Lit", "value": 9 } }),
&schema(),
)
.unwrap();
assert_eq!(tree.child_slot("inner").unwrap().len(), 1);
}
#[test]
fn unknown_variant_lists_candidates() {
let err = from_json_value(&json!({ "type": "Ad" }), &schema()).unwrap_err();
assert_eq!(err.diagnostics.len(), 1);
assert_eq!(err.diagnostics[0].code, codes::UNKNOWN_VARIANT);
assert!(err.diagnostics[0].message.contains("Add"));
}
#[test]
fn unknown_key_suggests_declared_slot() {
let value = json!({ "type": "Lit", "vlue": 1 });
let err = from_json_value(&value, &schema()).unwrap_err();
let d = err
.diagnostics
.iter()
.find(|d| d.code == codes::UNKNOWN_FIELD)
.expect("expected UNKNOWN_FIELD");
assert!(
d.message.contains("did you mean") && d.message.contains("value"),
"expected `value` in the hint, got: {}",
d.message
);
}
#[test]
fn missing_type_tag_reports() {
let err = from_json_value(&json!({ "value": 1 }), &schema()).unwrap_err();
assert_eq!(err.diagnostics[0].code, serde_codes::TYPE_MISSING);
}
#[test]
fn type_not_string_reports() {
let err = from_json_value(&json!({ "type": 42 }), &schema()).unwrap_err();
assert_eq!(err.diagnostics[0].code, serde_codes::TYPE_NOT_STRING);
}
#[test]
fn non_object_at_root_reports() {
let err = from_json_value(&json!(42), &schema()).unwrap_err();
assert_eq!(err.diagnostics[0].code, serde_codes::NOT_OBJECT);
}
#[test]
fn many_slot_from_object_fails_shape() {
let value = json!({
"type": "Group",
"items": { "type": "Lit", "value": 1 },
});
let err = from_json_value(&value, &schema()).unwrap_err();
assert!(
err.diagnostics
.iter()
.any(|d| d.code == serde_codes::CHILD_SHAPE)
);
}
#[test]
fn one_slot_missing_reports_via_conformance() {
let value = json!({
"type": "Add",
"lhs": { "type": "Lit", "value": 1 },
});
let tree = from_json_value(&value, &schema()).unwrap();
let diags = check_conformance(&tree, &schema());
assert!(diags.iter().any(|d| d.code == codes::ARITY_ONE));
}
#[test]
fn unknown_key_reports() {
let value = json!({ "type": "Lit", "value": 1, "extra": 2 });
let err = from_json_value(&value, &schema()).unwrap_err();
assert_eq!(err.diagnostics[0].code, codes::UNKNOWN_FIELD);
}
#[test]
fn multiple_errors_collected() {
let value = json!({
"type": "Add",
"lhs": { "type": "Lit", "value": 1, "bogus": 0 },
"rhs": { "type": "Nope" },
});
let err = from_json_value(&value, &schema()).unwrap_err();
assert!(
err.diagnostics
.iter()
.any(|d| d.code == codes::UNKNOWN_FIELD)
);
assert!(
err.diagnostics
.iter()
.any(|d| d.code == codes::UNKNOWN_VARIANT)
);
}
#[test]
fn from_json_str_wraps_syntax_errors() {
let err = from_json_str("{ not: valid }", &schema()).unwrap_err();
assert_eq!(err.diagnostics[0].code, serde_codes::NOT_OBJECT);
}
}