use serde_json::{Map, Number, Value};
use crate::{Bounds, FieldRules, LengthUnit, ParamValue, Problem, Rules, ValueRules};
pub fn write_rules(rules: &Rules, schema: &mut Map<String, Value>) {
for field in rules.fields() {
write_field_rules(field, schema);
}
}
fn write_field_rules(field: &FieldRules, schema: &mut Map<String, Value>) {
let Some(property) = property_named(field.name(), schema) else {
return;
};
write_value_rules(field.rules(), property);
let is_broken_by_its_absence = field.rules().problems().contains(&Problem::Required) && !field.has_default();
if is_broken_by_its_absence {
list_as_required(field.name(), schema);
}
}
fn property_named<'a>(name: &str, schema: &'a mut Map<String, Value>) -> Option<&'a mut Map<String, Value>> {
schema.get_mut("properties")?.get_mut(name)?.as_object_mut()
}
fn list_as_required(name: &str, schema: &mut Map<String, Value>) {
let required = schema.entry("required").or_insert_with(|| Value::Array(Vec::new()));
let Value::Array(required) = required else {
return;
};
if !required.iter().any(|listed| listed == name) {
required.push(name.into());
}
}
fn write_value_rules(rules: &ValueRules, schema: &mut Map<String, Value>) {
for problem in rules.problems() {
write_problem(problem, rules.is_optional(), schema);
}
let Some(element_rules) = rules.elements() else {
return;
};
if let Some(element_schema) = element_schema_of(schema) {
write_value_rules(element_rules, element_schema);
}
}
fn element_schema_of(schema: &mut Map<String, Value>) -> Option<&mut Map<String, Value>> {
let elements = if accepts("array", schema) {
"items"
} else if accepts("object", schema) {
"additionalProperties"
} else {
return None;
};
schema.get_mut(elements)?.as_object_mut()
}
fn write_problem(problem: &Problem, is_value_optional: bool, schema: &mut Map<String, Value>) {
match problem {
Problem::Required if is_value_optional => refuse_null(schema),
Problem::Required => {
write_counts("string", "Length", Some(1), None, schema);
write_counts("array", "Items", Some(1), None, schema);
write_counts("object", "Properties", Some(1), None, schema);
}
Problem::Length { bounds, unit } => write_length(bounds, *unit, schema),
Problem::Range { bounds } => write_range(bounds, schema),
Problem::Email => write_format("email", schema),
Problem::Url { .. } => write_format("iri", schema),
Problem::Ipv4 => write_format("ipv4", schema),
Problem::Ipv6 => write_format("ipv6", schema),
Problem::Pattern { pattern } => write_pattern((*pattern).to_owned(), schema),
Problem::Contains { text } => write_pattern(matching_exactly(text), schema),
Problem::Prefix { prefix } => write_pattern(format!("^{}", matching_exactly(prefix)), schema),
Problem::Suffix { suffix } => write_pattern(format!("{}$", matching_exactly(suffix)), schema),
_ => {}
}
}
fn accepts(value_type: &str, schema: &Map<String, Value>) -> bool {
match schema.get("type") {
Some(Value::String(only_type)) => only_type == value_type,
Some(Value::Array(types)) => types.iter().any(|accepted| accepted == value_type),
_ => false,
}
}
fn refuse_null(schema: &mut Map<String, Value>) {
if let Some(Value::Array(types)) = schema.get_mut("type") {
types.retain(|accepted| accepted != "null");
if let [only_type] = types.as_slice() {
let only_type = only_type.clone();
schema.insert("type".to_owned(), only_type);
}
}
for alternatives in ["oneOf", "anyOf"] {
if let Some(Value::Array(schemas)) = schema.get_mut(alternatives) {
schemas.retain(|alternative| !accepts_only_null(alternative));
}
replace_by_its_only_alternative(alternatives, schema);
}
}
fn replace_by_its_only_alternative(alternatives: &str, schema: &mut Map<String, Value>) {
let Some(Value::Array(schemas)) = schema.get(alternatives) else {
return;
};
let [Value::Object(only_alternative)] = schemas.as_slice() else {
return;
};
if only_alternative.keys().any(|keyword| schema.contains_key(keyword)) {
return;
}
let only_alternative = only_alternative.clone();
schema.remove(alternatives);
schema.extend(only_alternative);
}
fn accepts_only_null(schema: &Value) -> bool {
schema
.as_object()
.is_some_and(|schema| schema.len() == 1 && schema.get("type").is_some_and(|only_type| only_type == "null"))
}
fn write_length(bounds: &Bounds<usize>, unit: LengthUnit, schema: &mut Map<String, Value>) {
let (shortest, longest) = bounds.ends();
let (shortest, longest) = (shortest.copied(), longest.copied());
match unit {
LengthUnit::Chars => write_counts("string", "Length", shortest, longest, schema),
LengthUnit::Bytes => {
let fewest_chars = shortest.map(|bytes| bytes.div_ceil(char::MAX_LEN_UTF8));
write_counts("string", "Length", fewest_chars, longest, schema);
}
LengthUnit::Graphemes => write_counts("string", "Length", shortest, None, schema),
LengthUnit::Elements => {
write_counts("array", "Items", shortest, longest, schema);
write_counts("object", "Properties", shortest, longest, schema);
}
}
}
fn write_counts(
counted_type: &str,
counted: &str,
fewest: Option<usize>,
most: Option<usize>,
schema: &mut Map<String, Value>,
) {
if !accepts(counted_type, schema) {
return;
}
if let Some(fewest) = fewest {
raise_to(Number::from(fewest), &format!("min{counted}"), schema);
}
if let Some(most) = most {
lower_to(Number::from(most), &format!("max{counted}"), schema);
}
}
fn write_range(bounds: &Bounds<ParamValue>, schema: &mut Map<String, Value>) {
if !accepts("integer", schema) && !accepts("number", schema) {
return;
}
let (least, greatest) = bounds.ends();
if let Some(least) = least.and_then(as_number) {
raise_to(least, "minimum", schema);
}
if let Some(greatest) = greatest.and_then(as_number) {
lower_to(greatest, "maximum", schema);
}
}
fn as_number(bound: &ParamValue) -> Option<Number> {
match bound {
ParamValue::Integer(integer) => Number::from_i128(*integer),
ParamValue::Float(float) => Number::from_f64(*float),
ParamValue::Text(_) => None,
}
}
fn raise_to(minimum: Number, keyword: &str, schema: &mut Map<String, Value>) {
let is_high_enough_already =
matches!(schema.get(keyword), Some(Value::Number(current)) if !is_less(current, &minimum));
if !is_high_enough_already {
schema.insert(keyword.to_owned(), Value::Number(minimum));
}
}
fn lower_to(maximum: Number, keyword: &str, schema: &mut Map<String, Value>) {
let is_low_enough_already =
matches!(schema.get(keyword), Some(Value::Number(current)) if !is_less(&maximum, current));
if !is_low_enough_already {
schema.insert(keyword.to_owned(), Value::Number(maximum));
}
}
fn is_less(left: &Number, right: &Number) -> bool {
match (left.as_i128(), right.as_i128()) {
(Some(left), Some(right)) => left < right,
_ => left.as_f64() < right.as_f64(),
}
}
fn write_format(format: &str, schema: &mut Map<String, Value>) {
if accepts("string", schema) && !schema.contains_key("format") {
schema.insert("format".to_owned(), format.into());
}
}
fn write_pattern(pattern: String, schema: &mut Map<String, Value>) {
if !accepts("string", schema) {
return;
}
let Some(first_pattern) = schema.get("pattern") else {
schema.insert("pattern".to_owned(), pattern.into());
return;
};
if *first_pattern == pattern {
return;
}
let also_required = schema.entry("allOf").or_insert_with(|| Value::Array(Vec::new()));
let Value::Array(also_required) = also_required else {
return;
};
let requiring_the_pattern = Value::Object(Map::from_iter([("pattern".to_owned(), Value::String(pattern))]));
if !also_required.contains(&requiring_the_pattern) {
also_required.push(requiring_the_pattern);
}
}
fn matching_exactly(text: &str) -> String {
let mut expression = String::with_capacity(text.len());
for character in text.chars() {
if r"\^$.*+?()[]{}|".contains(character) {
expression.push('\\');
}
expression.push(character);
}
expression
}