108 lines
2.6 KiB
Rust
108 lines
2.6 KiB
Rust
use std::collections::{HashMap, HashSet};
|
|
|
|
use crate::{compiler::CompileError, draft::*, loader::DefaultUrlLoader, root::Root, util::*};
|
|
|
|
use serde_json::Value;
|
|
use url::Url;
|
|
|
|
// --
|
|
|
|
pub(crate) struct Roots {
|
|
pub(crate) default_draft: &'static Draft,
|
|
map: HashMap<Url, Root>,
|
|
pub(crate) loader: DefaultUrlLoader,
|
|
}
|
|
|
|
impl Roots {
|
|
fn new() -> Self {
|
|
Self {
|
|
default_draft: latest(),
|
|
map: Default::default(),
|
|
loader: DefaultUrlLoader::new(),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Default for Roots {
|
|
fn default() -> Self {
|
|
Self::new()
|
|
}
|
|
}
|
|
|
|
impl Roots {
|
|
pub(crate) fn get(&self, url: &Url) -> Option<&Root> {
|
|
self.map.get(url)
|
|
}
|
|
|
|
pub(crate) fn resolve_fragment(&mut self, uf: UrlFrag) -> Result<UrlPtr, CompileError> {
|
|
self.or_load(uf.url.clone())?;
|
|
let Some(root) = self.map.get(&uf.url) else {
|
|
return Err(CompileError::Bug("or_load didn't add".into()));
|
|
};
|
|
root.resolve_fragment(&uf.frag)
|
|
}
|
|
|
|
pub(crate) fn ensure_subschema(&mut self, up: &UrlPtr) -> Result<(), CompileError> {
|
|
self.or_load(up.url.clone())?;
|
|
let Some(root) = self.map.get_mut(&up.url) else {
|
|
return Err(CompileError::Bug("or_load didn't add".into()));
|
|
};
|
|
if !root.draft.is_subschema(up.ptr.as_str()) {
|
|
let doc = self.loader.load(&root.url)?;
|
|
let v = up.ptr.lookup(doc, &up.url)?;
|
|
root.draft.validate(up, v)?;
|
|
root.add_subschema(doc, &up.ptr)?;
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
pub(crate) fn or_load(&mut self, url: Url) -> Result<(), CompileError> {
|
|
debug_assert!(url.fragment().is_none(), "trying to add root with fragment");
|
|
if self.map.contains_key(&url) {
|
|
return Ok(());
|
|
}
|
|
let doc = self.loader.load(&url)?;
|
|
let r = self.create_root(url.clone(), doc)?;
|
|
self.map.insert(url, r);
|
|
Ok(())
|
|
}
|
|
|
|
pub(crate) fn create_root(&self, url: Url, doc: &Value) -> Result<Root, CompileError> {
|
|
let draft = {
|
|
let up = UrlPtr {
|
|
url: url.clone(),
|
|
ptr: "".into(),
|
|
};
|
|
self.loader
|
|
.get_draft(&up, doc, self.default_draft, HashSet::new())?
|
|
};
|
|
let vocabs = self.loader.get_meta_vocabs(doc, draft)?;
|
|
let resources = {
|
|
let mut m = HashMap::default();
|
|
draft.collect_resources(doc, &url, "".into(), &url, &mut m)?;
|
|
m
|
|
};
|
|
|
|
if !matches!(url.host_str(), Some("json-schema.org")) {
|
|
draft.validate(
|
|
&UrlPtr {
|
|
url: url.clone(),
|
|
ptr: "".into(),
|
|
},
|
|
doc,
|
|
)?;
|
|
}
|
|
|
|
Ok(Root {
|
|
draft,
|
|
resources,
|
|
url: url.clone(),
|
|
meta_vocabs: vocabs,
|
|
})
|
|
}
|
|
|
|
pub(crate) fn insert(&mut self, roots: &mut HashMap<Url, Root>) {
|
|
self.map.extend(roots.drain());
|
|
}
|
|
}
|