use std::cell::Cell;
use std::collections::{BTreeSet, HashMap};
use std::ffi::{OsStr, OsString};
use std::path::{Path, PathBuf};
use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::{Arc, Mutex, OnceLock};
use jsonvet::{Dialect, Event, EventKind, Report, Rule};
use memchr::memmem;
use super::Schema;
use super::limits::{PATTERN_BYTES, RUN_PATTERNS};
use crate::settings::{self, Settings};
use crate::{check, messages, output};
pub(crate) fn with_schema(((settings, schema), _): &Job, name: &OsStr, text: &str) -> bool {
schema.is_some()
|| may_name_a_path(text)
&& settings.config_for(&name.to_string_lossy()).dialect() != Dialect::JsonLines
}
pub(crate) type Job = ((Arc<Settings>, Option<Arc<Schema>>), OsString);
pub(crate) fn jobs(
files: Vec<OsString>,
shown: &impl Fn(&OsStr) -> OsString,
settings_for: &impl Fn(&Path) -> Result<Arc<Settings>, String>,
given: Option<&Path>,
load: &impl Fn(&Path, bool) -> Loaded,
) -> Result<Vec<Job>, String> {
let given = given
.map(|path| load(path, false))
.transpose()
.map_err(|e| output::printable(&e))?;
let mut walked = std::collections::HashSet::new();
files
.into_iter()
.map(|file| {
let name = shown(&file);
let settings = settings_for(Path::new(&name))?;
if given.is_none() && walked.insert(Arc::as_ptr(&settings)) {
for entry in &settings.schemas {
load(&entry.schema, entry.confined).map_err(|e| output::printable(&e))?;
}
}
let schema = match &given {
Some(schema) => Some(Arc::clone(schema)),
None => settings
.schema_for(&name.to_string_lossy())
.map(|entry| load(&entry.schema, entry.confined))
.transpose()
.map_err(|e| output::printable(&e))?,
};
Ok(((settings, schema), file))
})
.collect()
}
pub(crate) type Loaded = Result<Arc<Schema>, String>;
#[derive(Default)]
pub(crate) struct Schemas {
loaded: Mutex<HashMap<(SchemaKey, bool), Loaded>>,
patterns: AtomicUsize,
over: OnceLock<String>,
own: Mutex<HashMap<(PathBuf, String), Own>>,
missing: Mutex<BTreeSet<PathBuf>>,
}
type Own = Result<Option<Arc<Schema>>, String>;
#[derive(Eq, Hash, PartialEq)]
enum SchemaKey {
Local(PathBuf),
Catalog(String),
}
impl Schemas {
pub(crate) fn get(
&self,
path: &Path,
quiet: bool,
load: impl FnOnce(&dyn Fn(usize) -> Result<(), String>) -> Result<Schema, String>,
) -> Loaded {
self.get_named(path, quiet, false, load)
}
pub(crate) fn get_catalog(
&self,
url: &str,
load: impl FnOnce(&dyn Fn(usize) -> Result<(), String>) -> Result<Schema, String>,
) -> Loaded {
self.get_named(Path::new(url), false, true, load)
}
fn get_named(
&self,
path: &Path,
quiet: bool,
catalog: bool,
load: impl FnOnce(&dyn Fn(usize) -> Result<(), String>) -> Result<Schema, String>,
) -> Loaded {
let key = if catalog {
SchemaKey::Catalog(path.to_string_lossy().into_owned())
} else {
SchemaKey::Local(
std::fs::canonicalize(path)
.or_else(|_| std::path::absolute(path))
.unwrap_or_else(|_| path.to_owned()),
)
};
let mut loaded = self
.loaded
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner);
loaded
.entry((key, quiet))
.or_insert_with(|| {
let counted = Cell::new(0);
let admit = |count: usize| {
self.over()?;
let patterns = self.patterns.load(Ordering::Relaxed) - counted.get() + count;
if patterns > RUN_PATTERNS {
let error = messages::fill(
"schema.run-patterns",
&[
("path", &path.display()),
("limit", &RUN_PATTERNS),
("mb", &(PATTERN_BYTES >> 20)),
],
);
return Err(self.over.get_or_init(|| error).clone());
}
self.patterns.store(patterns, Ordering::Relaxed);
counted.set(count);
Ok(())
};
load(&admit).map(Arc::new)
})
.clone()
}
pub(crate) fn over(&self) -> Result<(), String> {
self.over.get().map_or(Ok(()), |error| Err(error.clone()))
}
fn own(&self, folder: &Path, path: &str, find: impl FnOnce() -> Own) -> Own {
let key = (folder.to_owned(), path.to_owned());
let known = self
.own
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner);
if let Some(own) = known.get(&key) {
return own.clone();
}
drop(known);
let own = find();
self.own
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner)
.insert(key, own.clone());
own
}
pub(crate) fn observe_missing(&self, observe: &impl Fn(&Path)) {
let missing = self
.missing
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner);
for path in missing.iter() {
observe(path);
}
}
pub(crate) fn missing_notes(&self) -> Vec<String> {
let missing = self
.missing
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner);
missing
.iter()
.map(|path| messages::fill("schema.missing", &[("path", &path.to_string_lossy())]))
.collect()
}
}
#[derive(Default)]
struct OwnSchema {
depth: Option<usize>,
value: bool,
done: bool,
found: Option<(usize, String)>,
}
pub(crate) fn names_local_schema(name: &str, text: &str, settings: &Settings) -> bool {
let config = settings.config_for(name);
if config.dialect() == Dialect::JsonLines || !may_name_a_path(text) {
return false;
}
let mut own = OwnSchema::default();
jsonvet::parse_with(text, &config, &mut |event| own.event(&event));
own.found.is_some()
}
impl OwnSchema {
fn event(&mut self, event: &Event<'_>) {
if self.done {
return;
}
if self.value {
self.done = true;
if let EventKind::String(path) = &event.kind {
let path = path.split_once('#').map_or(&**path, |(path, _)| path);
self.found =
(!path.is_empty() && !is_url(path)).then(|| (event.offset, path.to_owned()));
}
return;
}
let Some(depth) = &mut self.depth else {
self.depth = Some(0);
self.done = event.kind != EventKind::ObjectStart;
return;
};
match &event.kind {
EventKind::ObjectStart | EventKind::ArrayStart => *depth += 1,
EventKind::End if *depth == 0 => self.done = true,
EventKind::End => *depth -= 1,
EventKind::Key(key) if *depth == 0 && **key == *b"$schema" => self.value = true,
_ => {}
}
}
}
fn may_name_a_path(text: &str) -> bool {
let bytes = text.as_bytes();
memmem::find_iter(bytes, b"$schema").any(|at| {
let rest = text[at + "$schema".len()..].trim_start_matches(['"', '\'']);
rest.trim_start()
.strip_prefix(':')
.is_none_or(|value| !is_url(value.trim_start().trim_start_matches(['"', '\''])))
}) || memchr::memchr_iter(b'\\', bytes).any(|at| {
let next = &bytes[at + 1..];
next.starts_with(b"u")
|| next.starts_with(b"x")
|| next.starts_with(b"\n")
|| next.starts_with(b"\r")
|| next.starts_with("\u{2028}".as_bytes())
|| next.starts_with("\u{2029}".as_bytes())
})
}
fn is_url(text: &str) -> bool {
text.split_once(':').is_some_and(|(scheme, _)| {
scheme.len() > 1
&& scheme.starts_with(|c: char| c.is_ascii_alphabetic())
&& scheme
.chars()
.all(|c| c.is_ascii_alphanumeric() || matches!(c, '+' | '-' | '.'))
})
}
pub(crate) fn check_own_schema<'t>(
name: &str,
text: &'t str,
settings: &Settings,
schemas: &Schemas,
root: &impl Fn(&Path) -> PathBuf,
load: &impl Fn(&Path, bool) -> Loaded,
parts: usize,
) -> (Report<'t>, Vec<(usize, String, bool)>) {
let config = settings.config_for(name);
let mut own = OwnSchema::default();
let report = jsonvet::parse_with(text, &config, &mut |event| own.event(&event));
let syntax_error = report.problems().iter().any(|p| p.rule() == Rule::Syntax);
let Some((offset, path)) = own.found.filter(|_| !syntax_error) else {
return (report, Vec::new());
};
let folder = Path::new(name).parent().unwrap_or(Path::new(""));
let own = schemas.own(folder, &path, || {
if !settings::confined(&path, folder, &root(Path::new(name)))? {
schemas
.missing
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner)
.insert(settings::lexical(&folder.join(&path)));
return Ok(None);
}
load(&folder.join(&path), true).map(Some)
});
match own {
Ok(None) => (report, Vec::new()),
Ok(Some(schema)) => check(name, text, settings, Some(&schema), parts, None),
Err(error) => (report, vec![(offset, output::printable(&error), false)]),
}
}
#[cfg(test)]
mod tests {
use std::sync::atomic::{AtomicUsize, Ordering};
use super::{Schema, Schemas, Settings};
#[test]
fn every_spelling_of_a_schema_path_reads_it_once() {
let dir = std::env::temp_dir().join(format!("jsonvet-spellings-{}", std::process::id()));
std::fs::create_dir_all(dir.join("x")).expect("a temporary directory");
std::fs::write(dir.join("s.json"), "{}").expect("written");
let schemas = Schemas::default();
let reads = AtomicUsize::new(0);
let read = |admit: &dyn Fn(usize) -> Result<(), String>| {
reads.fetch_add(1, Ordering::Relaxed);
Schema::load(&dir.join("s.json"), &Settings::default(), false, admit)
};
for path in ["s.json", "x/../s.json", "x/../x/../s.json", "./s.json"] {
assert!(schemas.get(&dir.join(path), true, read).is_ok(), "{path}");
}
assert_eq!(reads.load(Ordering::Relaxed), 1);
assert!(schemas.get(&dir.join("s.json"), false, read).is_ok());
assert_eq!(reads.load(Ordering::Relaxed), 2);
let _ = std::fs::remove_dir_all(&dir);
}
#[test]
fn only_the_last_attempt_of_one_load_counts_its_patterns() {
let schemas = Schemas::default();
let loaded = schemas.get_catalog("https://json.schemastore.org/x.json", |admit| {
admit(600)?;
admit(600)?;
Schema::load_text(
std::path::Path::new("x.json"),
"{}",
&Settings::default(),
false,
admit,
)
});
assert_eq!(loaded.err(), None);
assert!(schemas.over().is_ok());
assert!(
schemas
.get_catalog("https://json.schemastore.org/y.json", |admit| {
admit(super::RUN_PATTERNS)?;
Schema::load_text(
std::path::Path::new("y.json"),
"{}",
&Settings::default(),
false,
admit,
)
})
.is_ok()
);
}
#[test]
fn only_a_dollar_schema_that_may_hold_a_path_is_worth_parsing() {
for (text, path) in [
("{}", false),
(r#"{"$schema": "https://x/s.json", "a": 1}"#, false),
("{$schema: 'https://x/s.json'}", false),
(
r#"{"a": {"$schema":"http://x"}, "$schema" : "urn:x"}"#,
false,
),
(r#"{"$schema": "s.json"}"#, true),
(r#"{"$schema": "C:\\s.json"}"#, true),
(r#"{"$schema": /* https://x */ "s.json"}"#, true),
(r#"{"$schema" /* c */: "https://x"}"#, true),
(r#"{"$schema": 1}"#, true),
(r#"{"a": "https://x", "$schema": "s.json"}"#, true),
("{\"$schema", true),
(r#"{"\u0024schema": "https://x"}"#, true),
(r#"{"\x24schema": "https://x"}"#, true),
("{\"$sch\\\nema\": \"https://x\"}", true),
("{\"$sch\\\u{2028}ema\": \"https://x\"}", true),
(r#"{"a\tb": "c:\\d", "$schema": "https://x"}"#, false),
] {
assert_eq!(super::may_name_a_path(text), path, "{text}");
}
}
#[test]
fn is_url_tells_a_scheme_from_a_windows_drive() {
for (text, url) in [
("https://x", true),
("ab:x", true),
("C:\\a.json", false),
("./a.json", false),
("a.json", false),
("1a:x", false),
] {
assert_eq!(super::is_url(text), url, "{text}");
}
}
#[test]
fn check_own_schema_runs_on_duplicate_key_without_syntax_error() {
let dir = std::env::temp_dir().join(format!("jsonvet-own-schema-{}", std::process::id()));
std::fs::create_dir_all(&dir).expect("a temporary directory");
std::fs::write(
dir.join("s.json"),
r#"{"properties": {"b": {"type": "integer"}}, "required": ["b"]}"#,
)
.expect("write schema");
let settings = Settings::default();
let schemas = Schemas::default();
let root = |_path: &std::path::Path| dir.clone();
let load = |path: &std::path::Path, quiet: bool| {
Schema::load(path, &settings, quiet, |_| Ok(())).map(std::sync::Arc::new)
};
let file = dir.join("test.json");
let text = r#"{"$schema": "s.json", "k": 1, "k": 2, "b": "bad"}"#;
let (report, errors) = super::check_own_schema(
&file.to_string_lossy(),
text,
&settings,
&schemas,
&root,
&load,
1,
);
assert_eq!(report.problems().len(), 1);
assert_eq!(report.problems()[0].rule(), jsonvet::Rule::DuplicateKey);
assert!(!errors.is_empty(), "own schema should be validated");
let _ = std::fs::remove_dir_all(&dir);
}
}