use std::collections::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 super::Schema;
use super::limits::{PATTERN_BYTES, RUN_PATTERNS};
use crate::settings::{self, Settings};
use crate::{check, 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<(PathBuf, bool), Loaded>>,
patterns: AtomicUsize,
over: OnceLock<String>,
own: Mutex<HashMap<(PathBuf, String), Own>>,
}
type Own = Result<Option<Arc<Schema>>, String>;
impl Schemas {
pub(crate) fn get(
&self,
path: &Path,
quiet: bool,
load: impl FnOnce(&dyn Fn(usize) -> Result<(), String>) -> Result<Schema, String>,
) -> Loaded {
let key = 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 admit = |count: usize| {
self.over()?;
let patterns = self.patterns.load(Ordering::Relaxed) + count;
if patterns > RUN_PATTERNS {
let error = format!(
"the schema {} takes the schemas this run reads past \
{RUN_PATTERNS} regexes between them, each allowed {} MB once \
compiled",
path.display(),
PATTERN_BYTES >> 20
);
return Err(self.over.get_or_init(|| error).clone());
}
self.patterns.store(patterns, Ordering::Relaxed);
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
}
}
#[derive(Default)]
struct OwnSchema {
depth: Option<usize>,
value: bool,
done: bool,
found: Option<(usize, String)>,
}
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 {
text.match_indices("$schema").any(|(at, key)| {
let rest = text[at + key.len()..].trim_start_matches(['"', '\'']);
rest.trim_start()
.strip_prefix(':')
.is_none_or(|value| !is_url(value.trim_start().trim_start_matches(['"', '\''])))
})
}
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)))? {
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),
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_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),
] {
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}");
}
}
}