mod fold;
mod limits;
mod place;
pub(crate) mod select;
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::{PatternOptions, ReferencingError, ValidationError, ValidationOptions, Validator};
use jsonvet::{Config, Dialect, Event, Report, Rule, Severity};
use serde_json::{Map, Value};
use crate::settings::Settings;
use fold::{Fold, documents};
use limits::{MAX_SCHEMA_DEPTH, PATTERN_BYTES, Reach, registry};
use place::{Place, 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: Option<Split>,
members: Option<Split>,
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,
events: &[Event<'_>],
report: &jsonvet::Report<'_>,
) -> Quiet {
let mut targets = Vec::new();
quoted(schema, &mut Vec::new(), None, &mut targets);
let places = place(events, targets.clone())
.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>) -> String {
use ValidationErrorKind as K;
match error.kind() {
K::PropertyNames { error } => return self.message(error, moved),
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(error),
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 { .. } => "a 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)) => {
format!("value fails \"{keyword}\" (the schema {name}:{line}:{column})")
}
None => format!("value fails \"{keyword}\" (the schema {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,
schema: Value,
moved: Option<&'static str>,
}
impl Compiled {
fn errors<'i>(&'i self, value: &'i Value) -> 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(
|| "a pattern".to_owned(),
|r| format!("the pattern \"{r}\""),
);
format!(
"this {what} could not be checked against {pattern}: matching it takes more than \
{BACKTRACK_LIMIT} backtracking steps"
)
}
fn build(
schema: &Value,
) -> (
ValidationOptions<'static>,
Result<Validator, ValidationError<'_>>,
bool,
) {
let linear = jsonschema::options().offline().with_pattern_options(
PatternOptions::regex()
.size_limit(PATTERN_BYTES)
.dfa_size_limit(PATTERN_BYTES),
);
if let Ok(validator) = linear.build(schema) {
return (linear, Ok(validator), true);
}
let fancy = fancy();
let built = fancy.build(schema);
(fancy, built, false)
}
fn fancy() -> ValidationOptions<'static> {
jsonschema::options().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().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: &Value,
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: &Value, 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 object = value.pointer(error.instance_path().as_str())?;
let members = object.as_object()?;
(object != error.instance().as_ref()).then(|| members.keys().cloned().collect())
}
_ => None,
}
}
#[cold]
#[inline(never)]
fn open<'e>(
slot: &mut Option<Place<'e>>,
found: &[Found],
spots: &mut Vec<Vec<(usize, String)>>,
event: &Event<'e>,
) {
spots.extend(slot.take().map(Place::finish));
let place = slot.insert(Place::new(place::found_targets(found)));
place.event(event);
}
struct Checking<'s, 'e> {
schema: &'s Schema,
fold: Fold<'e>,
documents: Vec<Checked>,
}
enum Checked {
Unchecked(usize, &'static str),
Found(Range<usize>, usize, Errors),
}
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.documents.push(Checked::Unchecked(offset, reason));
return;
}
let found = self.schema.collect(&document.value);
if !found.kept.is_empty() {
self.documents
.push(Checked::Found(document.events, document.offset, found));
}
}
fn errors(
self,
walk: impl FnOnce(&[(Range<usize>, usize)], &mut dyn FnMut(usize, &Event<'e>)),
) -> Vec<(usize, String, bool)> {
let pending: Vec<(Range<usize>, &[Found])> = self
.documents
.iter()
.filter_map(|checked| match checked {
Checked::Found(events, _, found) => Some((events.clone(), &found.kept[..])),
Checked::Unchecked(..) => None,
})
.collect();
let failing: Vec<(Range<usize>, usize)> = self
.documents
.iter()
.filter_map(|checked| match checked {
Checked::Found(events, offset, _) => Some((events.clone(), *offset)),
Checked::Unchecked(..) => None,
})
.collect();
let mut spots = Vec::with_capacity(pending.len());
let mut place: Option<Place<'e>> = None;
if !pending.is_empty() {
let mut next = 0;
walk(&failing, &mut |i, event| {
while pending.get(next).is_some_and(|(events, _)| events.end <= i) {
next += 1;
}
if let Some((events, found)) = pending.get(next)
&& events.contains(&i)
{
if i == events.start {
open(&mut place, found, &mut spots, event);
} else if let Some(place) = &mut place {
place.event(event);
}
}
});
}
spots.extend(place.map(Place::finish));
debug_assert_eq!(spots.len(), pending.len());
let mut spots = spots.into_iter();
let mut errors = Vec::new();
for checked in self.documents {
let (offset, found) = match checked {
Checked::Unchecked(offset, reason) => {
errors.push((
offset,
format!("{reason}, so this document is not checked against the schema"),
false,
));
continue;
}
Checked::Found(_, offset, found) => (offset, found),
};
let spots = spots.next().unwrap_or_default();
let spots = place::found_spots(&found.kept, spots);
let mut placed: Vec<(usize, String, bool)> = found
.kept
.into_iter()
.zip(spots)
.map(|(found, (offset, at))| {
(offset, cut(format!("{} (at {at})", found.message)), false)
})
.collect();
placed.sort_by_key(|(offset, ..)| *offset);
errors.append(&mut placed);
if found.more {
errors.push((
offset,
"... and more schema errors in this document".to_owned(),
true,
));
}
}
errors
}
}
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| format!("cannot read the schema {name}: {e}"))?;
let mut config = settings.config_for(&name);
if config.dialect() == Dialect::JsonLines
&& Dialect::for_path(path) != Some(Dialect::JsonLines)
{
config = settings.config(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);
if quiet {
return format!("the schema {name}:{}:{} cannot be used", at.line, at.column);
}
format!("the schema {name}:{}:{}: {problem}", at.line, at.column)
};
if let Some(problem) = report
.problems()
.iter()
.find(|p| p.severity() == Severity::Error)
{
return Err(at(problem.offset(), problem));
}
let events = events.unwrap_or_default();
let mut documents: Vec<_> = documents(&events).collect();
if documents.len() != 1 {
return Err(format!("the schema {name} must hold one value"));
}
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 outside = |error: &ReferencingError| match error {
ReferencingError::Unretrievable { .. } if quiet => Some(format!(
"the schema {name} has a `$ref` outside the file; jsonvet fetches no schemas"
)),
ReferencingError::Unretrievable { uri, .. } => Some(format!(
"the schema {name} has a `$ref` to {uri}, outside the file; jsonvet fetches no \
schemas"
)),
_ => None,
};
let registry = registry(schema)
.map_err(|error| outside(&error).unwrap_or_else(|| at(events[0].offset, &error)))?;
let refuse = |over: limits::Over| {
let (offset, _) = place(events, vec![(over.path.clone(), vec![over.key.clone()])])[0];
at(offset, &over.message())
};
let kept = Reach::new(schema).measure(®istry).map_err(refuse)?;
admit(limits::patterns(schema).map_err(refuse)?)?;
let (options, 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: split(schema, kept, false, &options),
members: split(schema, kept, true, &options),
key_patterns,
string_patterns,
linear,
quiet: quiet.then(|| Quiet::new(&name, schema, events, &report)),
});
}
Err(error) => error,
};
if let ValidationErrorKind::Referencing(error) = error.kind()
&& let Some(message) = outside(error)
{
return Err(message);
}
let (offset, _) = place_found(events, &found(None, schema, &error, String::new))[0];
if matches!(error.kind(), ValidationErrorKind::Format { format } if format == "regex") {
let mb = PATTERN_BYTES >> 20;
return Err(at(
offset,
&format!("{error}, or it takes more than {mb} MB compiled"),
));
}
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),
|_, sink| {
let mut i = 0;
jsonvet::parse_with(text, &config, &mut |event| {
sink(i, &event);
i += 1;
});
},
)
}
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,
|failing, sink| {
let mut documents = failing.iter().peekable();
while let Some((events, offset)) = documents.next() {
let mut last = (events.end, *offset);
while let Some((next, offset)) =
documents.next_if(|(next, _)| next.start == last.0)
{
last = (next.end, *offset);
}
let start = text[..*offset].rfind('\n').map_or(0, |at| at + 1);
let end = text[last.1..]
.find('\n')
.map_or(text.len(), |at| last.1 + at + 1);
let mut i = events.start;
jsonvet::parse_lines(
text,
start..end,
&config,
Some(&mut |event| {
sink(i, &event);
i += 1;
}),
);
}
},
)
}
fn check_with<'t, R>(
&self,
read: impl FnOnce(&mut dyn FnMut(Event<'t>)) -> R,
syntax_error: impl FnOnce(&R) -> bool,
again: impl FnOnce(&[(Range<usize>, usize)], &mut dyn FnMut(usize, &Event<'t>)),
) -> (R, Vec<(usize, String, bool)>) {
let mut checking = self.checking();
let first = read(&mut |event| checking.event(&event));
if syntax_error(&first) {
return (first, Vec::new());
}
(first, checking.errors(again))
}
fn checking<'e>(&self) -> Checking<'_, 'e> {
Checking {
schema: self,
fold: Fold::default(),
documents: Vec::new(),
}
}
fn collect(&self, value: &Value) -> Errors {
let mut errors = Errors::default();
if self.linear && self.compiled.validator.is_valid(value) {
return errors;
}
match (value, &self.items, &self.members) {
(Value::Array(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.iter().enumerate() {
for error in each.errors(item) {
if !errors.add(self.found(each, Some(i), item, &error)) {
return errors;
}
}
}
errors.add(after);
}
(Value::Object(members), _, Some(Split { whole, each })) => {
for error in whole.errors(value) {
if !errors.add(self.found(whole, None, value, &error)) {
return errors;
}
}
for (key, member) in members {
let one = Value::Object(Map::from_iter([(key.clone(), member.clone())]));
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 found(
&self,
compiled: &Compiled,
index: Option<usize>,
value: &Value,
error: &ValidationError<'_>,
) -> Vec<Found> {
if !backtracked(error) {
return found(index, value, error, || match &self.quiet {
Some(quiet) => quiet.message(error, compiled.moved),
None => message(error),
});
}
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) -> 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" }))?,
})
}
fn message(error: &ValidationError<'_>) -> String {
if fits(error.instance()) {
let message = error.to_string();
if message.len() <= MAX_MESSAGE {
return message;
}
}
error.masked().to_string()
}
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, message, split};
use jsonvet::{Config, Dialect};
use proptest::prelude::*;
use serde_json::{Value, json};
use super::fold::tests::any_json;
#[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();
let checked = |items, members| {
let schema = Schema {
compiled: Compiled {
validator: options.build(schema).expect("a schema"),
schema: schema.clone(),
moved: None,
},
items,
members,
key_patterns: Vec::new(),
string_patterns: Vec::new(),
linear: true,
quiet: None,
};
schema.check(text, &Config::new(Dialect::Json)).1
};
let registry = registry(schema).expect("a registry");
let kept = Reach::new(schema).measure(®istry).is_ok_and(|kept| kept);
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}");
}
}
}
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);
}
}
}
}
}