mod fold;
mod limits;
mod nodes;
mod place;
pub(crate) mod select;
mod values;
use std::borrow::Cow;
use std::collections::{BTreeSet, HashMap};
use std::ops::Range;
use std::path::Path;
use std::sync::{Arc, OnceLock};
use jsonschema::error::ValidationErrorKind;
use jsonschema::json::{Array, Json, Node, Object};
use jsonschema::{
JsonType, PatternOptions, ReferencingError, ValidationError, ValidationOptions, Validator,
};
use jsonvet::{Config, Dialect, Event, Report, Rule, Severity};
use serde_json::{Map, Value};
use crate::messages;
use crate::settings::Settings;
use fold::Fold;
use limits::{MAX_SCHEMA_DEPTH, PATTERN_BYTES, Reach, registry};
use nodes::{Nd, Own, Tree};
use place::{place_found, pointer_path, segments};
pub(crate) const SCHEMA_MAX_DEPTH: usize = 512;
const MAX_ERRORS: usize = 100;
const MAX_MESSAGE: usize = 200;
const BACKTRACK_LIMIT: usize = 5_000;
const NOT_CHECKS: [&str; 9] = [
"$schema",
"$id",
"id",
"$defs",
"definitions",
"$anchor",
"$dynamicAnchor",
"$vocabulary",
"$comment",
];
const ON_CHILDREN: [&str; 13] = [
"allOf",
"anyOf",
"oneOf",
"not",
"if",
"then",
"else",
"$ref",
"$dynamicRef",
"$recursiveRef",
"dependentSchemas",
"dependencies",
"extends",
];
const ON_MEMBERS: [&str; 3] = ["properties", "patternProperties", "additionalProperties"];
const EACH: &str = "jsonvet-each";
pub(crate) struct Schema {
compiled: Compiled,
items: OnceLock<Option<Split>>,
members: OnceLock<Option<Split>>,
kept: bool,
key_patterns: Regexes,
string_patterns: Regexes,
linear: bool,
quiet: Option<Quiet>,
}
struct Quiet {
name: String,
places: HashMap<String, (usize, usize)>,
base: Option<String>,
}
const QUOTED: [&str; 21] = [
"const",
"enum",
"pattern",
"required",
"not",
"maximum",
"minimum",
"exclusiveMaximum",
"exclusiveMinimum",
"maxItems",
"minItems",
"maxLength",
"minLength",
"maxProperties",
"minProperties",
"multipleOf",
"$ref",
"$dynamicRef",
"$recursiveRef",
"dependentRequired",
"dependencies",
];
const QUOTED_MEMBERS: [&str; 2] = ["dependentRequired", "dependencies"];
const NAMES: [&str; 6] = [
"properties",
"patternProperties",
"$defs",
"definitions",
"dependentSchemas",
"dependencies",
];
impl Quiet {
fn new(name: &str, schema: &Value, tree: &Tree<'_>, report: &jsonvet::Report<'_>) -> Quiet {
let mut targets = Vec::new();
quoted(schema, &mut Vec::new(), None, &mut targets);
let places = tree
.place(&targets)
.into_iter()
.zip(targets)
.map(|((offset, _), (path, _))| {
let at = report.location(offset);
let mut pointer = String::new();
for segment in path {
pointer.push('/');
pointer.push_str(&segment.replace('~', "~0").replace('/', "~1"));
}
(pointer, (at.line, at.column))
})
.collect();
Quiet {
name: name.to_owned(),
places,
base: limits::base(schema),
}
}
fn message(
&self,
error: &ValidationError<'_>,
moved: Option<&str>,
node: Option<Nd<'_>>,
) -> String {
use ValidationErrorKind as K;
match error.kind() {
K::PropertyNames { error } => return self.message(error, moved, None),
K::AdditionalItems { .. }
| K::AdditionalProperties { .. }
| K::AnyOf { .. }
| K::OneOfMultipleValid { .. }
| K::OneOfNotValid { .. }
| K::Contains
| K::ContentEncoding { .. }
| K::ContentMediaType { .. }
| K::FalseSchema
| K::Format { .. }
| K::FromUtf8 { .. }
| K::Type { .. }
| K::UnevaluatedItems { .. }
| K::UnevaluatedProperties { .. }
| K::UniqueItems => return message_at(error, node),
K::BacktrackLimitExceeded { .. }
| K::RegexEngineFailure { .. }
| K::Constant { .. }
| K::Custom { .. }
| K::Enum { .. }
| K::ExclusiveMaximum { .. }
| K::ExclusiveMinimum { .. }
| K::Maximum { .. }
| K::Minimum { .. }
| K::MaxItems { .. }
| K::MaxLength { .. }
| K::MaxProperties { .. }
| K::MinItems { .. }
| K::MinLength { .. }
| K::MinProperties { .. }
| K::MultipleOf { .. }
| K::Not { .. }
| K::Pattern { .. }
| K::Required { .. }
| K::Referencing(_) => {}
}
let keyword = match error.kind() {
K::Custom { .. } => messages::text("schema.custom-keyword"),
kind => kind.keyword(),
};
let path = error.schema_path().as_str();
let path = match (moved, path.strip_prefix(&format!("/{EACH}"))) {
(Some(moved), Some(rest)) => Cow::Owned(format!("{moved}{rest}")),
_ => Cow::Borrowed(path),
};
let name = &self.name;
let at_root = error
.absolute_keyword_location()
.is_none_or(|uri| uri.as_str().split('#').next() == self.base.as_deref());
match self.places.get(path.as_ref()).filter(|_| at_root) {
Some((line, column)) => messages::fill(
"schema.value-fails-at",
&[
("keyword", &keyword),
("path", name),
("line", line),
("column", column),
],
),
None => messages::fill(
"schema.value-fails",
&[("keyword", &keyword), ("path", name)],
),
}
}
}
fn quoted(
schema: &Value,
path: &mut Vec<String>,
parent: Option<&str>,
targets: &mut Vec<(Vec<String>, Vec<String>)>,
) {
let members = parent.is_some_and(|parent| QUOTED_MEMBERS.contains(&parent));
let names = parent.is_some_and(|parent| NAMES.contains(&parent));
for (key, member) in children(schema) {
path.push(key.clone().into_owned());
if members || (!names && QUOTED.contains(&key.as_ref())) {
targets.push((path.clone(), Vec::new()));
}
if names || !["enum", "const"].contains(&key.as_ref()) {
quoted(member, path, (!names).then_some(key.as_ref()), targets);
}
path.pop();
}
}
struct Split {
whole: Compiled,
each: Compiled,
}
struct Compiled {
validator: Validator<Own>,
schema: Value,
moved: Option<&'static str>,
}
impl Compiled {
fn errors<'i>(&'i self, value: Nd<'i>) -> impl Iterator<Item = ValidationError<'i>> {
let invalid = !self.validator.is_valid(value);
invalid
.then(|| self.validator.iter_errors(value))
.into_iter()
.flatten()
}
}
fn children(value: &Value) -> impl Iterator<Item = (Cow<'_, str>, &Value)> {
let members = value.as_object().into_iter().flatten();
let items = value.as_array().into_iter().flatten().enumerate();
members
.map(|(key, member)| (Cow::Borrowed(key.as_str()), member))
.chain(items.map(|(i, item)| (Cow::Owned(i.to_string()), item)))
}
fn backtracked(error: &ValidationError<'_>) -> bool {
matches!(
error.kind(),
ValidationErrorKind::BacktrackLimitExceeded { .. }
)
}
fn pattern_at(schema: &Value, schema_path: &str) -> Option<String> {
let segments: Vec<String> = segments(schema_path).collect();
match segments.as_slice() {
[.., parent, regex] if parent == "patternProperties" => Some(regex.clone()),
_ => schema.pointer(schema_path)?.as_str().map(str::to_owned),
}
}
fn costly(what: &str, regex: Option<&str>) -> String {
let pattern = regex.map_or_else(
|| messages::text("schema.a-pattern").to_owned(),
|r| messages::fill("schema.the-pattern", &[("regex", &r)]),
);
messages::fill(
&format!("schema.costly.{what}"),
&[("pattern", &pattern), ("limit", &BACKTRACK_LIMIT)],
)
}
fn build(schema: &Value) -> (Result<Validator<Own>, ValidationError<'_>>, bool) {
if let Ok(validator) = options::<Own>(true).build(schema) {
return (Ok(validator), true);
}
(options::<Own>(false).build(schema), false)
}
fn options<F: Json>(linear: bool) -> ValidationOptions<'static, Arc<dyn jsonschema::Retrieve>, F> {
if !linear {
return fancy();
}
jsonschema::options_for::<F>()
.offline()
.with_pattern_options(
PatternOptions::regex()
.size_limit(PATTERN_BYTES)
.dfa_size_limit(PATTERN_BYTES),
)
}
fn fancy<F: Json>() -> ValidationOptions<'static, Arc<dyn jsonschema::Retrieve>, F> {
jsonschema::options_for::<F>()
.offline()
.with_pattern_options(
PatternOptions::fancy_regex()
.backtrack_limit(BACKTRACK_LIMIT)
.size_limit(PATTERN_BYTES)
.dfa_size_limit(PATTERN_BYTES),
)
}
struct Regex {
text: String,
validator: OnceLock<Option<Validator>>,
}
impl Regex {
fn validator(&self) -> Option<&Validator> {
self.validator
.get_or_init(|| {
let schema = serde_json::json!({ "pattern": self.text });
fancy::<jsonschema::json::SerdeJson>().build(&schema).ok()
})
.as_ref()
}
}
type Regexes = Vec<Arc<Regex>>;
fn regexes<'v>(schema: &'v Value) -> (Regexes, Regexes) {
let (mut keys, mut strings) = (BTreeSet::new(), BTreeSet::new());
patterns(schema, false, &mut keys, &mut strings);
let mut all: HashMap<&'v str, Arc<Regex>> = HashMap::new();
let mut each = |regexes: BTreeSet<&'v str>| {
regexes
.into_iter()
.map(|regex| {
let shared = all.entry(regex).or_insert_with(|| {
Arc::new(Regex {
text: regex.to_owned(),
validator: OnceLock::new(),
})
});
Arc::clone(shared)
})
.collect()
};
(each(keys), each(strings))
}
fn patterns<'v>(
schema: &'v Value,
names: bool,
keys: &mut BTreeSet<&'v str>,
strings: &mut BTreeSet<&'v str>,
) {
for (key, member) in children(schema) {
match (key.as_ref(), member) {
("patternProperties", Value::Object(regexes)) => {
keys.extend(regexes.keys().map(String::as_str));
}
("pattern", Value::String(regex)) => {
strings.insert(regex);
if names {
keys.insert(regex);
}
}
_ => {}
}
patterns(member, names || key == "propertyNames", keys, strings);
}
}
struct Found {
path: Vec<String>,
keys: Vec<String>,
key: bool,
message: String,
}
#[derive(Default)]
struct Errors {
kept: Vec<Found>,
more: bool,
}
impl Errors {
fn add(&mut self, found: impl IntoIterator<Item = Found>) -> bool {
for found in found {
if self.kept.len() == MAX_ERRORS {
self.more = true;
break;
}
self.kept.push(found);
}
!self.more
}
}
fn found(
index: Option<usize>,
value: Nd<'_>,
error: &ValidationError<'_>,
message: impl FnOnce() -> String,
) -> Vec<Found> {
let path = pointer_path(index, error);
if let Some(keys) = unexpected(value, error) {
return keys
.into_iter()
.take(MAX_ERRORS + 1)
.map(|key| Found {
path: path.clone(),
message: format!("Additional properties are not allowed ('{key}' was unexpected)"),
keys: vec![key],
key: true,
})
.collect();
}
let keys = match error.kind() {
ValidationErrorKind::UnevaluatedProperties { unexpected } => unexpected.clone(),
ValidationErrorKind::PropertyNames { error } => error
.instance()
.as_str()
.map(|key| vec![key.to_owned()])
.unwrap_or_default(),
_ => Vec::new(),
};
vec![Found {
path,
keys,
key: false,
message: message(),
}]
}
fn unexpected(value: Nd<'_>, error: &ValidationError<'_>) -> Option<Vec<String>> {
match error.kind() {
ValidationErrorKind::AdditionalProperties { unexpected } => Some(unexpected.clone()),
ValidationErrorKind::FalseSchema
if error
.schema_path()
.as_str()
.ends_with("/additionalProperties") =>
{
let path: Vec<String> = segments(error.instance_path().as_str()).collect();
let object = value.at(path.iter().map(String::as_str))?;
object.as_object()?;
(*object.to_value() != **error.instance()).then(|| object.keys())
}
_ => None,
}
}
struct Checking<'s, 'e> {
schema: &'s Schema,
fold: Fold<'e>,
errors: Vec<(usize, String, bool)>,
}
impl<'e> Checking<'_, 'e> {
fn event(&mut self, event: &Event<'e>) {
let Some(document) = self.fold.event(event) else {
return;
};
if let Some((offset, reason)) = document.unchecked {
self.errors.push((
offset,
messages::fill("schema.unchecked", &[("reason", &reason)]),
false,
));
return;
}
let found = self.schema.collect(&document.tree);
if found.kept.is_empty() {
return;
}
let spots = place_found(&document.tree, &found.kept);
let mut placed: Vec<(usize, String, bool)> = found
.kept
.into_iter()
.zip(spots)
.map(|(found, (offset, at))| {
let message = messages::fill(
"schema.found-at",
&[("message", &found.message), ("at", &at)],
);
(offset, cut(message), false)
})
.collect();
placed.sort_by_key(|(offset, ..)| *offset);
self.errors.append(&mut placed);
if found.more {
self.errors.push((
document.offset,
messages::text("schema.more").to_owned(),
true,
));
}
}
}
fn outside(error: &ReferencingError, name: &str, quiet: bool) -> Option<String> {
match error {
ReferencingError::Unretrievable { .. } if quiet => {
Some(messages::fill("schema.ref-outside", &[("path", &name)]))
}
ReferencingError::Unretrievable { uri, .. } => Some(messages::fill(
"schema.ref-outside-to",
&[("path", &name), ("uri", uri)],
)),
_ => None,
}
}
impl Schema {
pub(crate) fn load(
path: &Path,
settings: &Settings,
quiet: bool,
admit: impl FnOnce(usize) -> Result<(), String>,
) -> Result<Schema, String> {
let name = path.to_string_lossy();
let text = crate::read_small(path, crate::MAX_SCHEMA_BYTES)
.map_err(|e| messages::fill("schema.unreadable", &[("path", &name), ("error", &e)]))?;
Self::load_text(path, &text, settings, quiet, admit)
}
pub(crate) fn load_text(
path: &Path,
text: &str,
settings: &Settings,
quiet: bool,
admit: impl FnOnce(usize) -> Result<(), String>,
) -> Result<Schema, String> {
let name = path.to_string_lossy();
let mut config = settings.config_for(&name);
if config.dialect() == Dialect::JsonLines
&& Dialect::for_path(path) != Some(Dialect::JsonLines)
{
config = settings.config(&name, Dialect::Json5);
}
let config = config.max_depth(MAX_SCHEMA_DEPTH);
let (report, events) = jsonvet::parse(text, &config);
let at = |offset, problem: &dyn std::fmt::Display| {
let at = report.location(offset);
let place: [(&str, &dyn std::fmt::Display); 3] =
[("path", &name), ("line", &at.line), ("column", &at.column)];
if quiet {
return messages::fill("schema.unusable", &place);
}
messages::fill(
"schema.problem",
&[place[0], place[1], place[2], ("problem", problem)],
)
};
if let Some(problem) = report
.problems()
.iter()
.find(|p| p.severity() == Severity::Error)
{
return Err(at(problem.offset(), &messages::problem(problem)));
}
let events = events.unwrap_or_default();
let mut documents: Vec<_> = values::documents(&events).collect();
if documents.len() != 1 {
return Err(messages::fill("schema.one-value", &[("path", &name)]));
}
let document = documents.swap_remove(0);
let events = &events[document.events.clone()];
if let Some((offset, reason)) = document.unchecked {
return Err(at(offset, &reason));
}
let schema = &document.value;
let tree = || {
fold::documents(events)
.next()
.map(|d| d.tree)
.unwrap_or_default()
};
let outside = |error: &ReferencingError| outside(error, &name, quiet);
let registry = registry(schema)
.map_err(|error| outside(&error).unwrap_or_else(|| at(events[0].offset, &error)))?;
let refuse = |over: limits::Over| {
let target = (over.path.clone(), vec![over.key.clone()]);
at(tree().place(&[target])[0].0, &over.message())
};
let kept = Reach::new(schema).measure(®istry).map_err(refuse)?;
admit(limits::patterns(schema).map_err(refuse)?)?;
let (built, linear) = build(schema);
let error = match built {
Ok(validator) => {
let (key_patterns, string_patterns) = if linear {
(Vec::new(), Vec::new())
} else {
regexes(schema)
};
return Ok(Schema {
compiled: Compiled {
validator,
schema: schema.clone(),
moved: None,
},
items: OnceLock::new(),
members: OnceLock::new(),
kept,
key_patterns,
string_patterns,
linear,
quiet: quiet.then(|| Quiet::new(&name, schema, &tree(), &report)),
});
}
Err(error) => error,
};
if let ValidationErrorKind::Referencing(error) = error.kind()
&& let Some(message) = outside(error)
{
return Err(message);
}
let tree = tree();
let errors = found(None, tree.root(), &error, String::new);
let (offset, _) = place_found(&tree, &errors)[0];
if matches!(error.kind(), ValidationErrorKind::Format { format } if format == "regex") {
let mb = PATTERN_BYTES >> 20;
return Err(at(
offset,
&messages::fill("schema.regex-too-big", &[("error", &error), ("mb", &mb)]),
));
}
Err(at(offset, &error))
}
pub(crate) fn check<'t>(
&self,
text: &'t str,
config: &Config,
) -> (Report<'t>, Vec<(usize, String, bool)>) {
let config = config.clone().max_depth(SCHEMA_MAX_DEPTH);
self.check_with(
|sink| jsonvet::parse_with(text, &config, sink),
|report| report.problems().iter().any(|p| p.rule() == Rule::Syntax),
(text, config.dialect()),
)
}
pub(crate) fn check_lines(
&self,
text: &str,
lines: Range<usize>,
config: &Config,
) -> (jsonvet::Lines, Vec<(usize, String, bool)>) {
let config = config.clone().max_depth(SCHEMA_MAX_DEPTH);
self.check_with(
|sink| jsonvet::parse_lines(text, lines.clone(), &config, Some(sink)),
jsonvet::Lines::syntax_error,
(text, config.dialect()),
)
}
fn check_with<'t, R>(
&self,
read: impl FnOnce(&mut dyn FnMut(Event<'t>)) -> R,
syntax_error: impl FnOnce(&R) -> bool,
(text, dialect): (&'t str, Dialect),
) -> (R, Vec<(usize, String, bool)>) {
let mut checking = self.checking(text, dialect);
let first = read(&mut |event| checking.event(&event));
if syntax_error(&first) {
return (first, Vec::new());
}
(first, checking.errors)
}
fn checking<'e>(&self, text: &'e str, dialect: Dialect) -> Checking<'_, 'e> {
Checking {
schema: self,
fold: Fold::new(text, dialect),
errors: Vec::new(),
}
}
fn collect(&self, tree: &Tree<'_>) -> Errors {
let value = tree.root();
let mut errors = Errors::default();
if self.linear && self.compiled.validator.is_valid(value) {
return errors;
}
let parts = if value.as_array().is_some() {
self.split(false)
} else if value.as_object().is_some() {
self.split(true)
} else {
None
};
match (value.as_array(), value.as_object(), parts) {
(Some(items), _, Some(Split { whole, each })) => {
let mut after = Vec::new();
for error in whole.errors(value) {
let found = self.found(whole, None, value, &error);
let keyword = segments(error.schema_path().as_str()).next();
if keyword.is_some_and(|k| {
["contains", "minContains", "maxContains"].contains(&k.as_str())
}) {
after.extend(found);
} else if !errors.add(found) {
return errors;
}
}
for (i, item) in items.elements().enumerate() {
for error in each.errors(item) {
if !errors.add(self.found(each, Some(i), item, &error)) {
return errors;
}
}
}
errors.add(after);
}
(_, Some(members), Some(Split { whole, each })) => {
for error in whole.errors(value) {
if !errors.add(self.found(whole, None, value, &error)) {
return errors;
}
}
for position in 0..members.len() {
let one = value.only(u32::try_from(position).unwrap_or(u32::MAX));
for error in each.errors(one) {
if !errors.add(self.found(each, None, one, &error)) {
return errors;
}
}
}
}
_ => {
for error in self.compiled.errors(value) {
if !errors.add(self.found(&self.compiled, None, value, &error)) {
break;
}
}
}
}
errors
}
fn split(&self, members: bool) -> Option<&Split> {
let parts = if members { &self.members } else { &self.items };
parts
.get_or_init(|| {
let options = options::<Own>(self.linear);
split(&self.compiled.schema, self.kept, members, &options)
})
.as_ref()
}
fn found(
&self,
compiled: &Compiled,
index: Option<usize>,
value: Nd<'_>,
error: &ValidationError<'_>,
) -> Vec<Found> {
if !backtracked(error) {
return found(index, value, error, || {
let path: Vec<String> = segments(error.instance_path().as_str()).collect();
let node = value.at(path.iter().map(String::as_str));
match &self.quiet {
Some(quiet) => quiet.message(error, compiled.moved, node),
None => message_at(error, node),
}
});
}
let path = pointer_path(index, error);
let at = pattern_at(&compiled.schema, error.schema_path().as_str());
let named = |patterns: &[Arc<Regex>], subject: &str| {
let subject = Value::String(subject.to_owned());
let known = patterns
.iter()
.any(|regex| Some(®ex.text) == at.as_ref());
patterns
.iter()
.filter(|regex| !known || Some(®ex.text) == at.as_ref())
.find(|regex| {
regex
.validator()
.is_some_and(|v| v.validate(&subject).is_err_and(|e| backtracked(&e)))
})
.map(|regex| regex.text.clone())
};
let shown = |regex: Option<String>| regex.filter(|_| self.quiet.is_none());
let keys: Vec<Found> = match error.instance().as_ref() {
Value::Object(members) => members
.keys()
.filter_map(|key| {
let regex = named(&self.key_patterns, key)?;
Some(Found {
path: path.clone(),
message: costly("key", shown(Some(regex)).as_deref()),
keys: vec![key.clone()],
key: true,
})
})
.take(MAX_ERRORS + 1)
.collect(),
_ => Vec::new(),
};
if !keys.is_empty() {
return keys;
}
let message = match error.instance().as_ref() {
Value::String(string) => costly(
"string",
shown(named(&self.string_patterns, string)).as_deref(),
),
_ => costly("value", shown(at.clone()).as_deref()),
};
vec![Found {
path,
keys: Vec::new(),
key: false,
message,
}]
}
}
fn split(
schema: &Value,
kept: bool,
members: bool,
options: &ValidationOptions<'_, Arc<dyn jsonschema::Retrieve>, Own>,
) -> Option<Split> {
let all = schema.as_object()?;
let (moved, also): (&[&str], &[&str]) = if members {
(&ON_MEMBERS, &["unevaluatedProperties"])
} else {
(&["items"], &["prefixItems", "unevaluatedItems"])
};
let checks = |key: &&str| all.contains_key(*key);
if !kept || ON_CHILDREN.iter().chain(also).any(checks) || !moved.iter().any(checks) {
return None;
}
let mut whole = all.clone();
let mut part = Map::new();
for key in moved {
if let Some(value) = whole.remove(*key) {
part.insert((*key).to_owned(), value);
}
}
let part = match (members, part.remove("items")) {
(false, Some(items)) if items.is_object() || items.is_boolean() => items,
(false, _) => return None,
(true, _) => Value::Object(part),
};
let mut each: Map<String, Value> = all
.iter()
.filter(|(key, _)| NOT_CHECKS.contains(&key.as_str()))
.map(|(key, value)| (key.clone(), value.clone()))
.collect();
each.insert(EACH.to_owned(), part);
each.insert(
"allOf".to_owned(),
serde_json::json!([{ "$ref": format!("#/{EACH}") }]),
);
let compile = |schema: Map<String, Value>, moved| {
let schema = Value::Object(schema);
let validator = options.build(&schema).ok()?;
Some(Compiled {
validator,
schema,
moved,
})
};
Some(Split {
whole: compile(whole, None)?,
each: compile(each, Some(if members { "" } else { "/items" }))?,
})
}
#[cfg(test)]
fn message(error: &ValidationError<'_>) -> String {
message_at(error, None)
}
fn message_at(error: &ValidationError<'_>, node: Option<Nd<'_>>) -> String {
let short = node.map_or_else(|| fits(error.instance()), |node| fits_node(&node));
if short {
let message = error.to_string();
if message.len() <= MAX_MESSAGE {
return message;
}
}
error.masked().to_string()
}
fn fits_node(node: &Nd<'_>) -> bool {
struct Left(usize);
impl Left {
fn take(&mut self, n: usize) -> bool {
self.0.checked_sub(n).map(|rest| self.0 = rest).is_some()
}
fn string(&mut self, text: &str) -> bool {
self.take(2)
&& text.chars().all(|c| {
self.take(match c {
'"' | '\\' | '\u{8}' | '\u{c}' | '\n' | '\r' | '\t' => 2,
c if c < ' ' => 6,
c => c.len_utf8(),
})
})
}
fn node(&mut self, node: &Nd<'_>) -> bool {
match node.json_type() {
JsonType::Null => self.take(4),
JsonType::Boolean => self.take(if node.as_boolean() == Some(true) {
4
} else {
5
}),
JsonType::String => node.as_string().is_some_and(|s| self.string(&s)),
JsonType::Array => node.as_array().is_some_and(|array| {
self.take(2 + array.len().saturating_sub(1))
&& array.elements().all(|item| self.node(&item))
}),
JsonType::Object => node.as_object().is_some_and(|object| {
self.take(2 + object.len().saturating_sub(1))
&& object.members().all(|(key, value)| {
self.string(key) && self.take(1) && self.node(&value)
})
}),
_ => node
.as_number()
.is_some_and(|n| self.take(n.to_string().len())),
}
}
}
Left(MAX_MESSAGE).node(node)
}
fn fits(value: &Value) -> bool {
struct Budget(usize);
impl std::io::Write for Budget {
fn write(&mut self, bytes: &[u8]) -> std::io::Result<usize> {
self.0 = self
.0
.checked_sub(bytes.len())
.ok_or(std::io::ErrorKind::WriteZero)?;
Ok(bytes.len())
}
fn flush(&mut self) -> std::io::Result<()> {
Ok(())
}
}
serde_json::to_writer(Budget(MAX_MESSAGE), value).is_ok()
}
fn cut(mut message: String) -> String {
if message.len() > MAX_MESSAGE {
let mut end = MAX_MESSAGE;
while !message.is_char_boundary(end) {
end -= 1;
}
message.truncate(end);
message.push_str("...");
}
message
}
#[cfg(test)]
mod tests {
use super::limits::{Reach, registry};
use super::{Compiled, MAX_MESSAGE, Schema, cut, fits, fits_node, message, split};
use jsonvet::{Config, Dialect};
use proptest::prelude::*;
use serde_json::{Value, json};
use std::sync::OnceLock;
use super::fold::documents;
use super::fold::tests::any_json;
fn text_fits(text: &str) -> bool {
let (_, events) = jsonvet::parse(text, &Config::new(Dialect::Json));
let events = events.unwrap_or_default();
let document = documents(&events).next().expect("a document");
fits_node(&document.tree.root())
}
#[test]
fn a_string_is_counted_by_the_bytes_it_is_written_in() {
assert!(text_fits(&format!("\"{}\"", " ".repeat(MAX_MESSAGE - 2))));
assert!(!text_fits(&format!("\"{}\"", " ".repeat(MAX_MESSAGE - 1))));
let controls = |n: usize| format!("\"{}\"", "\\u0001".repeat(n));
assert!(text_fits(&controls((MAX_MESSAGE - 2) / 6)));
assert!(!text_fits(&controls((MAX_MESSAGE - 2) / 6 + 1)));
}
#[test]
fn every_kind_of_value_is_counted_at_the_bytes_it_is_written_in() {
let shapes: [fn(&str) -> String; 7] = [
|p| format!(r#"[true,false,null,"{p}"]"#),
|p| format!(r#"[[true],[false],[null],["{p}"]]"#),
|p| format!(r#"{{"a":true,"b":false,"c":null,"d":"{p}"}}"#),
|p| format!(r#"{{"a":[1,2],"b":{{"c":"{p}"}}}}"#),
|p| format!(r#"["{p}",true]"#),
|p| format!(r#"["{p}",-1.5,12]"#),
|p| format!(r#"{{"{p}":null}}"#),
];
for shape in shapes {
let base =
serde_json::to_string(&serde_json::from_str::<Value>(&shape("")).expect("json"))
.expect("json")
.len();
let pad = "x".repeat(MAX_MESSAGE - base);
assert!(text_fits(&shape(&pad)), "{}", shape(&pad));
assert!(!text_fits(&shape(&format!("{pad}x"))), "{}", shape(&pad));
}
}
#[test]
fn a_large_nested_value_is_named_not_quoted() {
let validator = jsonschema::validator_for(&json!({"type": "string"})).expect("a schema");
let long = "x".repeat(300);
for instance in [
json!([{"a": [long.clone()]}]),
json!({"a": {"b": long.clone()}}),
json!({ long.clone(): 1 }),
] {
let error = validator.iter_errors(&instance).next().expect("an error");
assert_eq!(message(&error), "value is not of type \"string\"");
}
let small = json!([{"a": [1]}]);
let error = validator.iter_errors(&small).next().expect("an error");
assert_eq!(message(&error), "[{\"a\":[1]}] is not of type \"string\"");
}
#[test]
fn a_value_fits_while_its_json_takes_at_most_the_budget() {
let x = |n| json!("x".repeat(n));
assert!(fits(&x(MAX_MESSAGE - 2)));
assert!(!fits(&x(MAX_MESSAGE - 1)));
}
#[test]
fn a_long_message_is_cut_at_a_character_boundary() {
let long = format!("x{}", "\u{e9}".repeat(200));
let message = cut(long.clone());
assert_eq!(message.len(), MAX_MESSAGE - 1 + "...".len());
assert!(message.ends_with("\u{e9}..."), "{message}");
assert_eq!(
cut(long[..MAX_MESSAGE - 1].to_owned()),
long[..MAX_MESSAGE - 1]
);
let full = "x".repeat(MAX_MESSAGE);
assert_eq!(cut(full.clone()), full);
}
fn split_schemas() -> [(Value, bool); 10] {
[
(
json!({"items": {"type": "string"}, "minItems": 2, "uniqueItems": true}),
true,
),
(
json!({
"items": {"$ref": "#/$defs/p"},
"contains": {"type": "null"},
"minContains": 2,
"$defs": {"p": {"properties": {"a": {"type": "integer"}}, "additionalProperties": false}},
}),
true,
),
(
json!({
"$schema": "http://json-schema.org/draft-07/schema#",
"$id": "https://example.com/r.json",
"items": {"$ref": "#/definitions/n"},
"definitions": {"n": {"type": ["array", "integer"], "items": {"$ref": "#/definitions/n"}}},
}),
true,
),
(
json!({"items": {"additionalProperties": false}, "maxItems": 3}),
true,
),
(json!({"items": false}), true),
(json!({"items": {"$ref": "#"}, "type": "array"}), false),
(
json!({"items": {"anyOf": [{"$ref": "#"}]}, "type": "array"}),
false,
),
(
json!({"items": {"type": "string"}, "allOf": [{"items": {"minLength": 1}}]}),
false,
),
(
json!({"$schema": "https://json-schema.org/draft/2019-09/schema", "items": [{"type": "string"}]}),
false,
),
(
json!({"items": {"type": "string"}, "$defs": {"a": {"$ref": "#/items"}}, "contains": {"$ref": "#/$defs/a"}}),
false,
),
]
}
type Errors = Vec<(usize, String, bool)>;
fn one_pass_and_split(schema: &Value, text: &str) -> (Errors, Option<Errors>) {
let options = jsonschema::options_for::<crate::schema::Own>();
let registry = registry(schema).expect("a registry");
let kept = Reach::new(schema).measure(®istry).is_ok_and(|kept| kept);
let checked = |items, members| {
let schema = Schema {
compiled: Compiled {
validator: options.build(schema).expect("a schema"),
schema: schema.clone(),
moved: None,
},
items: OnceLock::from(items),
members: OnceLock::from(members),
kept,
key_patterns: Vec::new(),
string_patterns: Vec::new(),
linear: true,
quiet: None,
};
schema.check(text, &Config::new(Dialect::Json)).1
};
let items = split(schema, kept, false, &options);
let members = split(schema, kept, true, &options);
let split = (items.is_some() || members.is_some()).then(|| checked(items, members));
(checked(None, None), split)
}
#[test]
fn a_split_schema_reports_what_one_pass_does_past_the_cap() {
let text = format!("[{}]", vec!["{\"a\": 1, \"b\": 1}"; 150].join(","));
for (schema, splits) in split_schemas() {
let (one_pass, split) = one_pass_and_split(&schema, &text);
assert_eq!(split.is_some(), splits, "{schema}");
if let Some(split) = split {
assert_eq!(split, one_pass, "{schema}");
}
}
}
fn member_schemas() -> [(Value, bool); 7] {
[
(
json!({"properties": {"a": {"type": "string"}, "b": {"const": 1}}, "required": ["c"], "maxProperties": 2}),
true,
),
(
json!({"patternProperties": {"^a": {"type": "integer"}}, "additionalProperties": false, "propertyNames": {"maxLength": 2}}),
true,
),
(
json!({"additionalProperties": false, "minProperties": 1}),
true,
),
(
json!({"additionalProperties": {"$ref": "#/$defs/n"}, "$defs": {"n": {"type": ["object", "null"], "additionalProperties": {"$ref": "#/$defs/n"}}}}),
true,
),
(
json!({"properties": {"a": true}, "unevaluatedProperties": false}),
false,
),
(
json!({"properties": {"a": {"type": "string"}}, "anyOf": [{"required": ["a"]}]}),
false,
),
(
json!({"additionalProperties": {"$ref": "#/properties/a"}, "properties": {"a": {"type": "null"}}}),
false,
),
]
}
#[test]
fn a_split_object_schema_reports_as_many_errors_past_the_cap() {
let members: Vec<String> = (0..150)
.map(|i| format!("\"a{i}\": {{\"b\": 1}}"))
.collect();
let text = format!("{{{}}}", members.join(","));
for (schema, splits) in member_schemas() {
let (one_pass, split) = one_pass_and_split(&schema, &text);
assert_eq!(split.is_some(), splits, "{schema}");
if let Some(split) = split {
assert_eq!(split.len(), one_pass.len(), "{schema}");
assert_eq!(split.last(), one_pass.last(), "{schema}");
}
}
}
#[test]
fn check_lines_places_schema_errors_across_lines() {
let schema_val = json!({
"properties": {"a": {"type": "integer"}},
"required": ["a"]
});
let options = jsonschema::options_for::<crate::schema::Own>();
let schema = Schema {
compiled: Compiled {
validator: options.build(&schema_val).expect("a schema"),
schema: schema_val,
moved: None,
},
items: OnceLock::new(),
members: OnceLock::new(),
kept: false,
key_patterns: Vec::new(),
string_patterns: Vec::new(),
linear: true,
quiet: None,
};
let text = "{\"a\": \"bad1\"}\n{\"a\": \"bad2\"}\n{\"a\": 3}\n{\"a\": \"bad4\"}\n";
let config = Config::new(Dialect::JsonLines);
let (_, errors) = schema.check_lines(text, 0..text.len(), &config);
assert_eq!(errors.len(), 3);
assert_eq!(errors[0].0, 6);
assert_eq!(errors[1].0, 20);
assert_eq!(errors[2].0, 43);
let (_, errors) = schema.check_lines(text, 14..text.len(), &config);
assert_eq!(errors.len(), 2);
assert_eq!(errors[0].0, 20);
assert_eq!(errors[1].0, 43);
}
proptest! {
#[test]
fn a_tree_fits_when_its_value_does(value in any_json()) {
let text = serde_json::to_string(&value).unwrap_or_default();
let (_, events) = jsonvet::parse(&text, &Config::new(Dialect::Json));
let events = events.unwrap_or_default();
let document = documents(&events).next().expect("a document");
prop_assert_eq!(fits_node(&document.tree.root()), fits(&value), "{}", text);
}
}
proptest! {
#[test]
fn a_split_object_schema_reports_what_one_pass_does(members in prop::collection::vec(("[ab]{1,2}", any_json()), 0..6)) {
let object: serde_json::Map<String, Value> = members.into_iter().collect();
let text = serde_json::to_string(&object).unwrap_or_default();
for (schema, _) in member_schemas() {
let (one_pass, split) = one_pass_and_split(&schema, &text);
if let Some(split) = split {
prop_assert_eq!(split, one_pass, "{}", schema);
}
}
}
#[test]
fn a_split_schema_reports_what_one_pass_does(items in prop::collection::vec(any_json(), 0..6)) {
let text = serde_json::to_string(&items).unwrap_or_default();
for (schema, _) in split_schemas() {
let (one_pass, split) = one_pass_and_split(&schema, &text);
if let Some(split) = split {
prop_assert_eq!(split, one_pass, "{}", schema);
}
}
}
}
}