use mlua::{Lua, Table, UserData, UserDataMethods, Value};
mod compile;
mod format;
#[cfg(test)]
mod tests;
use compile::compile_fields;
use format::Format;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum Kind {
String,
Number,
Integer,
Boolean,
Array,
Table,
}
impl Kind {
fn parse(name: &str) -> Option<Self> {
Some(match name {
"string" => Self::String,
"number" => Self::Number,
"integer" => Self::Integer,
"boolean" => Self::Boolean,
"array" => Self::Array,
"table" => Self::Table,
_ => None?,
})
}
fn name(self) -> &'static str {
match self {
Self::String => "string",
Self::Number => "number",
Self::Integer => "integer",
Self::Boolean => "boolean",
Self::Array => "array",
Self::Table => "table",
}
}
}
#[derive(Debug, Clone, PartialEq)]
enum Literal {
String(String),
Number(f64),
}
impl std::fmt::Display for Literal {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::String(s) => write!(f, "\"{s}\""),
Self::Number(n) => write!(f, "{n}"),
}
}
}
#[derive(Debug)]
struct Rule {
kind: Kind,
required: bool,
min: Option<f64>,
max: Option<f64>,
min_len: Option<usize>,
max_len: Option<usize>,
format: Option<Format>,
one_of: Option<Vec<Literal>>,
items: Option<Box<Rule>>,
min_items: Option<usize>,
max_items: Option<usize>,
fields: Option<Vec<(String, Rule)>>,
}
fn check_value(
lua: &Lua,
rule: &Rule,
value: Value,
path: &str,
errors: &Table,
) -> mlua::Result<Option<Value>> {
let fail = |msg: String| -> mlua::Result<Option<Value>> {
errors.set(path, msg)?;
Ok(None)
};
match rule.kind {
Kind::String => {
let Value::String(s) = &value else {
return fail(format!("must be a string, got {}", value.type_name()));
};
let s = s.to_string_lossy().to_string();
let len = s.chars().count();
if let Some(min) = rule.min_len
&& len < min
{
return fail(format!("must be at least {min} characters"));
}
if let Some(max) = rule.max_len
&& len > max
{
return fail(format!("must be at most {max} characters"));
}
if let Some(format) = rule.format
&& !format.check(&s)
{
return fail(format!("must be {}", format.describe()));
}
if let Some(one_of) = &rule.one_of
&& !one_of.contains(&Literal::String(s.clone()))
{
return fail(format!("must be one of: {}", literals(one_of)));
}
Ok(Some(value))
}
Kind::Number | Kind::Integer => {
let n = match &value {
Value::Integer(n) => *n as f64,
Value::Number(n) => *n,
other => {
return fail(format!("must be a number, got {}", other.type_name()));
}
};
if rule.kind == Kind::Integer && n.fract() != 0.0 {
return fail("must be an integer".into());
}
if let Some(min) = rule.min
&& n < min
{
return fail(format!("must be >= {min}"));
}
if let Some(max) = rule.max
&& n > max
{
return fail(format!("must be <= {max}"));
}
if let Some(one_of) = &rule.one_of
&& !one_of.contains(&Literal::Number(n))
{
return fail(format!("must be one of: {}", literals(one_of)));
}
Ok(Some(value))
}
Kind::Boolean => match value {
Value::Boolean(_) => Ok(Some(value)),
other => fail(format!("must be a boolean, got {}", other.type_name())),
},
Kind::Array => {
let Value::Table(t) = &value else {
return fail(format!("must be an array, got {}", value.type_name()));
};
let len = t.raw_len();
if let Some(min) = rule.min_items
&& len < min
{
return fail(format!("must have at least {min} items"));
}
if let Some(max) = rule.max_items
&& len > max
{
return fail(format!("must have at most {max} items"));
}
#[allow(clippy::expect_used)]
let items = rule.items.as_ref().expect("array rules carry `items`");
let out = lua.create_table_with_capacity(len, 0)?;
let mut ok = true;
for i in 1..=len {
let item: Value = t.raw_get(i)?;
match check_value(lua, items, item, &format!("{path}[{i}]"), errors)? {
Some(item) => out.raw_set(i, item)?,
None => ok = false,
}
}
Ok(ok.then_some(Value::Table(out)))
}
Kind::Table => {
let Value::Table(t) = &value else {
return fail(format!("must be a table, got {}", value.type_name()));
};
#[allow(clippy::expect_used)]
let fields = rule.fields.as_ref().expect("table rules carry `fields`");
check_fields(lua, fields, t, path, errors).map(|v| v.map(Value::Table))
}
}
}
fn check_fields(
lua: &Lua,
fields: &[(String, Rule)],
input: &Table,
path: &str,
errors: &Table,
) -> mlua::Result<Option<Table>> {
let out = lua.create_table()?;
let mut ok = true;
for (name, rule) in fields {
let field_path = if path.is_empty() {
name.clone()
} else {
format!("{path}.{name}")
};
let value: Value = input.get(name.as_str())?;
if value.is_nil() {
if rule.required {
errors.set(field_path, "is required")?;
ok = false;
}
continue;
}
match check_value(lua, rule, value, &field_path, errors)? {
Some(value) => out.set(name.as_str(), value)?,
None => ok = false,
}
}
Ok(ok.then_some(out))
}
fn literals(list: &[Literal]) -> String {
list.iter()
.map(Literal::to_string)
.collect::<Vec<_>>()
.join(", ")
}
struct LuaSchema {
fields: Vec<(String, Rule)>,
}
impl UserData for LuaSchema {
fn add_methods<M: UserDataMethods<Self>>(methods: &mut M) {
methods.add_method("check", |lua, this, value: Value| {
let errors = lua.create_table()?;
let checked = match &value {
Value::Table(input) => check_fields(lua, &this.fields, input, "", &errors)?,
other => {
errors.set("$", format!("must be a table, got {}", other.type_name()))?;
None
}
};
match checked {
Some(data) => Ok((Value::Table(data), Value::Nil)),
None => {
let err = lua.create_table()?;
err.set("message", "validation failed")?;
err.set("fields", errors)?;
Ok((Value::Nil, Value::Table(err)))
}
}
});
}
}
pub(crate) fn create_validate_table(lua: &Lua) -> mlua::Result<Table> {
let validate = lua.create_table()?;
validate.set(
"schema",
lua.create_function(|_, fields: Table| {
Ok(LuaSchema {
fields: compile_fields(&fields, "")?,
})
})?,
)?;
Ok(validate)
}