boon now included

validator/src/roots.rs

@@ -0,0 +1,107 @@
+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());
+    }
+}