use crate::allow::{self, codes as allow_codes};
use crate::import::{self, import_codes};
use crate::{BuildError, BuiltinLevenshteinSuggester, Diagnostic, ParseTree, RawValue, codes};
use dsl_kit_core::Suggester;
use dsl_kit_schema::{
ChildSchema, ChildValueShape, Multiplicity, NodeSchema, ScalarKind, ScalarShorthand,
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 const CANONICAL_TEXT: &str = "dsl_kit::parse::serde::canonical_text";
pub const DUMP_FIELD: &str = "dsl_kit::parse::serde::dump_field";
}
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;
}
};
if let Some(spec) = obj.get(import::IMPORT_VARIANT) {
if obj.len() != 1 {
diags.push(Diagnostic::error(
import_codes::SPEC_SHAPE,
format!(
"`{}` must be the object's only key ({} other key(s) present)",
import::IMPORT_VARIANT,
obj.len() - 1
),
));
return None;
}
return match spec {
Value::String(_) => {
let mut tree = ParseTree::new(import::IMPORT_VARIANT);
tree.fields.push((
import::IMPORT_SPEC_FIELD.to_string(),
RawValue::Json(spec.clone()),
));
Some(tree)
}
other => {
diags.push(Diagnostic::error(
import_codes::SPEC_SHAPE,
format!(
"`{}` value must be a literal string, got {}",
import::IMPORT_VARIANT,
kind(other)
),
));
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 key == allow::ALLOW_KEY {
match allow_names(val) {
Ok(names) => tree.allows = names,
Err(reason) => diags.push(Diagnostic::error(
allow_codes::ALLOW_SHAPE,
format!(
"`{}` on variant `{}` {}",
allow::ALLOW_KEY,
variant.name,
reason
),
)),
}
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) {
if child.multiplicity == Multiplicity::Map {
let entries = match &child.value_shape {
ChildValueShape::Scalar { .. } => {
build_scalar_keyed_slot(val, variant, key, diags)
}
ChildValueShape::Recursive => {
build_keyed_child_slot(val, variant, key, schema, diags, suggester)
}
_ => {
diags.push(Diagnostic::error(
codes::UNKNOWN_MULTIPLICITY,
format!(
"keyed child slot `{}` on variant `{}` declares a \
ChildValueShape variant this build does not recognise \
(upgrade dsl-kit-parse to a version that knows about it)",
key, variant.name
),
));
build_keyed_child_slot(val, variant, key, schema, diags, suggester)
}
};
tree.keyed_children.push((key.clone(), entries));
} else {
let subtrees = build_child_slot(child, 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 scalar_kind_of(val: &Value) -> Option<ScalarKind> {
match val {
Value::String(_) => Some(ScalarKind::Str),
Value::Number(n) if n.is_i64() || n.is_u64() => Some(ScalarKind::Int),
Value::Bool(_) => Some(ScalarKind::Bool),
_ => None,
}
}
fn lower_scalar_shorthand(val: &Value, shorthand: &ScalarShorthand) -> ParseTree {
let mut tree = ParseTree::new(shorthand.variant.clone());
tree.fields
.push((shorthand.field.clone(), RawValue::Json(val.clone())));
tree
}
fn shorthand_for<'a>(child: &'a ChildSchema, val: &Value) -> Option<&'a ScalarShorthand> {
scalar_kind_of(val).and_then(|k| child.scalar_shorthand(k))
}
fn build_child_slot(
child: &ChildSchema,
val: &Value,
variant: &VariantSchema,
slot: &str,
schema: &NodeSchema,
diags: &mut Vec<Diagnostic>,
suggester: &dyn Suggester,
) -> Vec<ParseTree> {
match child.multiplicity {
Multiplicity::One => match val {
Value::Object(_) => build_tree(val, schema, diags, suggester)
.into_iter()
.collect(),
_ => {
if let Some(shorthand) = shorthand_for(child, val) {
return vec![lower_scalar_shorthand(val, shorthand)];
}
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(),
_ => {
if let Some(shorthand) = shorthand_for(child, val) {
return vec![lower_scalar_shorthand(val, shorthand)];
}
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()
}
},
Multiplicity::Map => {
diags.push(Diagnostic::error(
serde_codes::CHILD_SHAPE,
format!(
"child slot `{}` on variant `{}` declares Multiplicity::Map but was \
routed through the positional builder",
slot, variant.name
),
));
Vec::new()
}
_ => {
diags.push(Diagnostic::error(
codes::UNKNOWN_MULTIPLICITY,
format!(
"child slot `{}` on variant `{}` uses an unrecognised \
Multiplicity variant (upgrade dsl-kit-parse to a version \
that knows about it)",
slot, variant.name
),
));
Vec::new()
}
}
}
fn build_keyed_child_slot(
val: &Value,
variant: &VariantSchema,
slot: &str,
schema: &NodeSchema,
diags: &mut Vec<Diagnostic>,
suggester: &dyn Suggester,
) -> Vec<(String, ParseTree)> {
let Value::Object(map) = val else {
diags.push(Diagnostic::error(
serde_codes::CHILD_SHAPE,
format!(
"keyed child slot `{}` on variant `{}` requires an object mapping keys \
to child objects, got {}",
slot,
variant.name,
kind(val)
),
));
return Vec::new();
};
let mut out = Vec::with_capacity(map.len());
for (key, item) in map {
match item {
Value::Object(_) => {
if let Some(child) = build_tree(item, schema, diags, suggester) {
out.push((key.clone(), child));
}
}
_ => diags.push(Diagnostic::error(
serde_codes::CHILD_SHAPE,
format!(
"keyed child slot `{}` on variant `{}`: entry `{}` requires an object, got {}",
slot,
variant.name,
key,
kind(item)
),
)),
}
}
out.sort_by(|(a, _), (b, _)| a.cmp(b));
out
}
fn build_scalar_keyed_slot(
val: &Value,
variant: &VariantSchema,
slot: &str,
diags: &mut Vec<Diagnostic>,
) -> Vec<(String, ParseTree)> {
let Value::Object(map) = val else {
diags.push(Diagnostic::error(
serde_codes::CHILD_SHAPE,
format!(
"scalar keyed child slot `{}` on variant `{}` requires an object mapping keys \
to scalar values, got {}",
slot,
variant.name,
kind(val)
),
));
return Vec::new();
};
let mut out = Vec::with_capacity(map.len());
for (key, item) in map {
let mut leaf = ParseTree::new("");
leaf.fields
.push(("value".into(), RawValue::Json(item.clone())));
out.push((key.clone(), leaf));
}
out.sort_by(|(a, _), (b, _)| a.cmp(b));
out
}
fn allow_names(val: &Value) -> Result<Vec<String>, String> {
let Value::Array(items) = val else {
return Err(format!(
"must be an array of rule-name strings, got {}",
kind(val)
));
};
items
.iter()
.map(|item| match item {
Value::String(s) => Ok(s.clone()),
other => Err(format!(
"must be an array of rule-name strings, but one entry is {}",
kind(other)
)),
})
.collect()
}
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",
}
}
pub fn to_canonical_json(tree: &ParseTree, schema: &NodeSchema) -> Result<Value, BuildError> {
let mut diags = Vec::new();
let value = canonical_node(tree, schema, &mut diags);
match value {
Some(v) if diags.is_empty() => Ok(v),
_ => {
if diags.is_empty() {
diags.push(Diagnostic::error(
serde_codes::CANONICAL_TEXT,
"tree shape not renderable as canonical JSON".to_string(),
));
}
Err(BuildError::new(diags))
}
}
}
fn canonical_node(
tree: &ParseTree,
schema: &NodeSchema,
diags: &mut Vec<Diagnostic>,
) -> Option<Value> {
let level = crate::check_conformance(tree, schema);
if !level.is_empty() {
diags.extend(level);
return None;
}
let variant = schema.variant(&tree.variant)?;
let mut obj = serde_json::Map::new();
obj.insert("type".to_string(), Value::String(tree.variant.clone()));
if !tree.allows.is_empty() {
obj.insert(
allow::ALLOW_KEY.to_string(),
Value::Array(
tree.allows
.iter()
.map(|name| Value::String(name.clone()))
.collect(),
),
);
}
for (name, raw) in &tree.fields {
let field = variant.fields.iter().find(|f| &f.name == name)?;
match raw {
RawValue::Json(v) => {
obj.insert(name.clone(), v.clone());
}
RawValue::Text(text) => match canonical_json_from_text(text, &field.ty) {
Ok(Some(v)) => {
obj.insert(name.clone(), v);
}
Ok(None) => {} Err(reason) => {
diags.push(Diagnostic::error(
serde_codes::CANONICAL_TEXT,
format!("field `{}` on variant `{}`: {}", name, variant.name, reason),
));
}
},
}
}
for (slot, subtrees) in &tree.children {
let child = variant.children.iter().find(|c| &c.name == slot)?;
match child.multiplicity {
Multiplicity::One => {
let v = canonical_node(&subtrees[0], schema, diags)?;
obj.insert(slot.clone(), v);
}
Multiplicity::Optional => {
if let Some(sub) = subtrees.first() {
let v = canonical_node(sub, schema, diags)?;
obj.insert(slot.clone(), v);
}
}
_ => {
let items: Option<Vec<Value>> = subtrees
.iter()
.map(|sub| canonical_node(sub, schema, diags))
.collect();
obj.insert(slot.clone(), Value::Array(items?));
}
}
}
for (slot, entries) in &tree.keyed_children {
let child = variant.children.iter().find(|c| &c.name == slot)?;
let mut map = serde_json::Map::new();
for (key, entry) in entries {
let v = match &child.value_shape {
ChildValueShape::Scalar { ty } => match entry.field("value") {
Some(RawValue::Json(v)) => Some(v.clone()),
Some(RawValue::Text(text)) => match canonical_json_from_text(text, ty) {
Ok(v) => v,
Err(reason) => {
diags.push(Diagnostic::error(
serde_codes::CANONICAL_TEXT,
format!(
"keyed slot `{}` entry `{}` on variant `{}`: {}",
slot, key, variant.name, reason
),
));
None
}
},
None => None,
},
_ => canonical_node(entry, schema, diags),
};
map.insert(key.clone(), v?);
}
obj.insert(slot.clone(), Value::Object(map));
}
Some(Value::Object(obj))
}
fn canonical_json_from_text(text: &str, ty: &str) -> Result<Option<Value>, String> {
const INT_TYPES: &[&str] = &[
"i8", "i16", "i32", "i64", "i128", "u8", "u16", "u32", "u64", "u128", "usize", "isize",
];
let ty: String = ty.chars().filter(|c| !c.is_whitespace()).collect();
if ty == "String" {
Ok(Some(Value::String(text.to_string())))
} else if INT_TYPES.contains(&ty.as_str()) {
if let Ok(n) = text.parse::<i64>() {
Ok(Some(Value::Number(n.into())))
} else if let Ok(n) = text.parse::<u64>() {
Ok(Some(Value::Number(n.into())))
} else {
Err(format!("text `{text}` does not parse as `{ty}`"))
}
} else if ty == "bool" {
match text {
"true" => Ok(Some(Value::Bool(true))),
"false" => Ok(Some(Value::Bool(false))),
_ => Err(format!("text `{text}` does not parse as `bool`")),
}
} else if ty == "Option<String>" {
if text == "none" {
Ok(None)
} else {
Ok(Some(Value::String(text.to_string())))
}
} else if ty == "Vec<String>" {
serde_json::from_str::<Value>(text)
.map(Some)
.map_err(|e| format!("text `{text}` does not parse as `Vec<String>`: {e}"))
} else {
Err(format!(
"type `{ty}` has no canonical text → JSON mapping (supported: String, the \
integer types, bool, Option<String>, Vec<String>)"
))
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::{check_conformance, codes};
use dsl_kit_schema::{
ChildSchema, ChildValueShape, 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,
value_shape: ChildValueShape::Recursive,
scalar_shorthands: vec![],
non_empty: false,
},
ChildSchema {
name: "rhs".into(),
multiplicity: Multiplicity::One,
value_shape: ChildValueShape::Recursive,
scalar_shorthands: vec![],
non_empty: false,
},
],
},
VariantSchema {
name: "Let".into(),
fields: vec![FieldSchema {
name: "name".into(),
ty: "String".into(),
optional: false,
}],
children: vec![
ChildSchema {
name: "value".into(),
multiplicity: Multiplicity::One,
value_shape: ChildValueShape::Recursive,
scalar_shorthands: vec![],
non_empty: false,
},
ChildSchema {
name: "body".into(),
multiplicity: Multiplicity::One,
value_shape: ChildValueShape::Recursive,
scalar_shorthands: vec![],
non_empty: false,
},
],
},
VariantSchema {
name: "Group".into(),
fields: vec![],
children: vec![ChildSchema {
name: "items".into(),
multiplicity: Multiplicity::Many,
value_shape: ChildValueShape::Recursive,
scalar_shorthands: vec![],
non_empty: false,
}],
},
VariantSchema {
name: "Wrap".into(),
fields: vec![],
children: vec![ChildSchema {
name: "inner".into(),
multiplicity: Multiplicity::Optional,
value_shape: ChildValueShape::Recursive,
scalar_shorthands: vec![],
non_empty: false,
}],
},
],
}
}
#[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);
}
}