jsonschema_rs 0.45.0 → 0.46.0

data/src/registry.rs

@@ -1,3 +1,5 @@
+use std::sync::Arc;
+
 use magnus::{
     function,
     gc::{register_address, unregister_address},
@@ -8,7 +10,11 @@ use magnus::{
     DataTypeFunctions, Error, RArray, RModule, Ruby, TryConvert, Value,
 };
 
-use crate::{options::parse_draft_symbol, retriever::make_retriever, ser::to_value};
+use crate::{
+    options::parse_draft_symbol,
+    retriever::make_retriever,
+    ser::{to_value, value_to_ruby},
+};
 
 struct RetrieverBuildRootGuard {
     // Keep roots in a heap allocation so addresses passed to Ruby GC are stable
@@ -40,7 +46,7 @@ impl Drop for RetrieverBuildRootGuard {
 #[derive(magnus::TypedData)]
 #[magnus(class = "JSONSchema::Registry", free_immediately, size, mark)]
 pub struct Registry {
-    pub inner: jsonschema::Registry,
+    pub inner: Arc<jsonschema::Registry<'static>>,
     retriever_root: Option<Opaque<Value>>,
 }
 
@@ -56,12 +62,63 @@ impl TryConvert for Registry {
     fn try_convert(val: Value) -> Result<Self, Error> {
         let typed: &Registry = TryConvert::try_convert(val)?;
         Ok(Registry {
-            inner: typed.inner.clone(),
+            inner: Arc::clone(&typed.inner),
             retriever_root: typed.retriever_root,
         })
     }
 }
 
+struct ResolverData {
+    registry: Arc<jsonschema::Registry<'static>>,
+    retriever_root: Option<Opaque<Value>>,
+    base_uri: jsonschema::Uri<String>,
+    dynamic_scope: Vec<jsonschema::Uri<String>>,
+}
+
+#[derive(magnus::TypedData)]
+#[magnus(class = "JSONSchema::Resolver", free_immediately, size, mark)]
+pub struct Resolver(ResolverData);
+
+impl DataTypeFunctions for Resolver {
+    fn mark(&self, marker: &magnus::gc::Marker) {
+        if let Some(root) = self.0.retriever_root {
+            marker.mark(root);
+        }
+    }
+}
+
+#[derive(magnus::TypedData)]
+#[magnus(class = "JSONSchema::Resolved", free_immediately, size, mark)]
+pub struct Resolved {
+    contents: Opaque<Value>,
+    resolver: ResolverData,
+    draft: u8,
+}
+
+impl DataTypeFunctions for Resolved {
+    fn mark(&self, marker: &magnus::gc::Marker) {
+        marker.mark(self.contents);
+        if let Some(root) = self.resolver.retriever_root {
+            marker.mark(root);
+        }
+    }
+}
+
+fn parse_uri(ruby: &Ruby, uri: &str) -> Result<jsonschema::Uri<String>, Error> {
+    jsonschema::uri::from_str(uri)
+        .map_err(|e| Error::new(ruby.exception_arg_error(), format!("{e}")))
+}
+
+fn draft_to_u8(draft: jsonschema::Draft) -> u8 {
+    match draft {
+        jsonschema::Draft::Draft4 => 4,
+        jsonschema::Draft::Draft6 => 6,
+        jsonschema::Draft::Draft7 => 7,
+        jsonschema::Draft::Draft201909 => 19,
+        _ => 20,
+    }
+}
+
 impl Registry {
     fn new_impl(ruby: &Ruby, args: &[Value]) -> Result<Self, Error> {
         let parsed_args = scan_args::<(RArray,), (), (), (), _, ()>(args)?;
@@ -72,7 +129,7 @@ impl Registry {
         let draft_val = kw.optional.0.flatten();
         let retriever_val = kw.optional.1;
 
-        let mut builder = jsonschema::Registry::options();
+        let mut builder = jsonschema::Registry::new();
         let mut retriever_root = None;
         let mut retriever_build_root = None;
 
@@ -89,33 +146,30 @@ impl Registry {
             }
         }
 
-        let pairs: Vec<(String, jsonschema::Resource)> = resources
-            .into_iter()
-            .map(|item| {
-                let pair: RArray = TryConvert::try_convert(item)?;
-                if pair.len() != 2 {
-                    return Err(Error::new(
-                        ruby.exception_arg_error(),
-                        "Each resource must be a [uri, schema] pair",
-                    ));
-                }
-                let uri: String = pair.entry(0)?;
-                let schema_val: Value = pair.entry(1)?;
-                let schema = to_value(ruby, schema_val)?;
-                let resource = jsonschema::Resource::from_contents(schema);
-                Ok((uri, resource))
-            })
-            .collect::<Result<Vec<_>, Error>>()?;
-
         // Keep the retriever proc GC-rooted for the entire build, because `build`
         // may call into retriever callbacks while traversing referenced resources.
         let _retriever_build_guard = RetrieverBuildRootGuard::new(retriever_build_root);
+        for item in resources {
+            let pair: RArray = TryConvert::try_convert(item)?;
+            if pair.len() != 2 {
+                return Err(Error::new(
+                    ruby.exception_arg_error(),
+                    "Each resource must be a [uri, schema] pair",
+                ));
+            }
+            let uri: String = pair.entry(0)?;
+            let schema_val: Value = pair.entry(1)?;
+            let schema = to_value(ruby, schema_val)?;
+            builder = builder
+                .add(uri, schema)
+                .map_err(|e| Error::new(ruby.exception_arg_error(), format!("{e}")))?;
+        }
         let registry = builder
-            .build(pairs)
-            .map_err(|e| Error::new(ruby.exception_arg_error(), e.to_string()))?;
+            .prepare()
+            .map_err(|e| Error::new(ruby.exception_arg_error(), format!("{e}")))?;
 
         Ok(Registry {
-            inner: registry,
+            inner: Arc::new(registry),
             retriever_root,
         })
     }
@@ -127,12 +181,117 @@ impl Registry {
     pub(crate) fn retriever_value(&self, ruby: &Ruby) -> Option<Value> {
         self.retriever_root.map(|root| ruby.get_inner(root))
     }
+
+    #[allow(clippy::needless_pass_by_value)]
+    fn resolver(ruby: &Ruby, rb_self: &Registry, base_uri: String) -> Result<Resolver, Error> {
+        Ok(Resolver(ResolverData {
+            registry: Arc::clone(&rb_self.inner),
+            retriever_root: rb_self.retriever_root,
+            base_uri: parse_uri(ruby, &base_uri)?,
+            dynamic_scope: Vec::new(),
+        }))
+    }
+}
+
+impl Resolver {
+    fn base_uri(&self) -> String {
+        self.0.base_uri.as_str().to_string()
+    }
+
+    fn dynamic_scope(ruby: &Ruby, rb_self: &Resolver) -> Result<Value, Error> {
+        let arr = ruby.ary_new_capa(rb_self.0.dynamic_scope.len());
+        for scope in &rb_self.0.dynamic_scope {
+            arr.push(ruby.into_value(scope.as_str()))?;
+        }
+        Ok(arr.as_value())
+    }
+
+    #[allow(clippy::needless_pass_by_value)]
+    fn lookup(ruby: &Ruby, rb_self: &Resolver, reference: String) -> Result<Resolved, Error> {
+        let resolver = if rb_self.0.dynamic_scope.is_empty() {
+            rb_self
+                .0
+                .registry
+                .as_ref()
+                .resolver(rb_self.0.base_uri.clone())
+        } else {
+            let oldest_uri = rb_self
+                .0
+                .dynamic_scope
+                .last()
+                .expect("dynamic_scope is not empty")
+                .clone();
+            let mut resolver = rb_self.0.registry.as_ref().resolver(oldest_uri);
+            for next_uri in rb_self
+                .0
+                .dynamic_scope
+                .iter()
+                .rev()
+                .skip(1)
+                .chain(std::iter::once(&rb_self.0.base_uri))
+            {
+                let next_resolved = resolver
+                    .lookup(next_uri.as_str())
+                    .map_err(|e| crate::referencing_error(ruby, e.to_string()))?;
+                resolver = next_resolved.into_inner().1;
+            }
+            resolver
+        };
+
+        let resolved = resolver
+            .lookup(&reference)
+            .map_err(|e| crate::referencing_error(ruby, e.to_string()))?;
+        let (contents, resolver, draft) = resolved.into_inner();
+
+        let contents_val = value_to_ruby(ruby, contents)?;
+
+        Ok(Resolved {
+            contents: Opaque::from(contents_val),
+            resolver: ResolverData {
+                registry: Arc::clone(&rb_self.0.registry),
+                retriever_root: rb_self.0.retriever_root,
+                base_uri: resolver.base_uri().as_ref().clone(),
+                dynamic_scope: resolver.dynamic_scope().iter().cloned().collect(),
+            },
+            draft: draft_to_u8(draft),
+        })
+    }
+}
+
+impl Resolved {
+    fn contents(ruby: &Ruby, rb_self: &Resolved) -> Value {
+        ruby.get_inner(rb_self.contents)
+    }
+
+    fn resolver(_ruby: &Ruby, rb_self: &Resolved) -> Resolver {
+        Resolver(ResolverData {
+            registry: Arc::clone(&rb_self.resolver.registry),
+            retriever_root: rb_self.resolver.retriever_root,
+            base_uri: rb_self.resolver.base_uri.clone(),
+            dynamic_scope: rb_self.resolver.dynamic_scope.clone(),
+        })
+    }
+
+    fn draft(&self) -> u8 {
+        self.draft
+    }
 }
 
 pub fn define_class(ruby: &Ruby, module: &RModule) -> Result<(), Error> {
     let class = module.define_class("Registry", ruby.class_object())?;
     class.define_singleton_method("new", function!(Registry::new_impl, -1))?;
     class.define_method("inspect", method!(Registry::inspect, 0))?;
+    class.define_method("resolver", method!(Registry::resolver, 1))?;
+
+    let resolver_class = module.define_class("Resolver", ruby.class_object())?;
+    resolver_class.define_method("base_uri", method!(Resolver::base_uri, 0))?;
+    resolver_class.define_method("dynamic_scope", method!(Resolver::dynamic_scope, 0))?;
+    resolver_class.define_method("lookup", method!(Resolver::lookup, 1))?;
+
+    let resolved_class = module.define_class("Resolved", ruby.class_object())?;
+    resolved_class.define_method("contents", method!(Resolved::contents, 0))?;
+    resolved_class.define_method("resolver", method!(Resolved::resolver, 0))?;
+    resolved_class.define_method("draft", method!(Resolved::draft, 0))?;
 
     Ok(())
 }

data/src/validator_map.rs

@@ -0,0 +1,92 @@
+//! ValidatorMap binding for Ruby.
+use magnus::{gc::Marker, method, prelude::*, DataTypeFunctions, Error, RModule, Ruby, TypedData};
+
+use crate::{
+    options::{CallbackRoots, CompilationRootsRef},
+    Validator,
+};
+
+/// Ruby wrapper around `jsonschema::ValidatorMap`.
+#[derive(TypedData)]
+#[magnus(class = "JSONSchema::ValidatorMap", free_immediately, size, mark)]
+pub struct ValidatorMap {
+    pub(crate) inner: jsonschema::ValidatorMap,
+    pub(crate) has_ruby_callbacks: bool,
+    pub(crate) callback_roots: CallbackRoots,
+    pub(crate) compilation_roots: CompilationRootsRef,
+    pub(crate) mask: Option<String>,
+}
+
+impl DataTypeFunctions for ValidatorMap {
+    fn mark(&self, marker: &Marker) {
+        // Avoid panicking in Ruby GC mark paths; preserving existing roots is safer than aborting.
+        let roots = match self.callback_roots.lock() {
+            Ok(roots) => roots,
+            Err(poisoned) => poisoned.into_inner(),
+        };
+        for root in roots.iter().copied() {
+            marker.mark(root);
+        }
+    }
+}
+
+impl ValidatorMap {
+    /// `map["#/$defs/User"]` → Validator | nil
+    #[allow(clippy::needless_pass_by_value)]
+    fn get(&self, pointer: String) -> Option<Validator> {
+        self.inner.get(&pointer).map(|v| {
+            Validator::from_jsonschema_with_roots(
+                v.clone(),
+                self.mask.clone(),
+                self.has_ruby_callbacks,
+                self.callback_roots.clone(),
+                self.compilation_roots.clone(),
+            )
+        })
+    }
+
+    /// `map.fetch("#/$defs/User")` → Validator (raises KeyError if missing)
+    #[allow(clippy::needless_pass_by_value)]
+    fn fetch(ruby: &Ruby, rb_self: &Self, pointer: String) -> Result<Validator, Error> {
+        match rb_self.inner.get(&pointer) {
+            Some(v) => Ok(Validator::from_jsonschema_with_roots(
+                v.clone(),
+                rb_self.mask.clone(),
+                rb_self.has_ruby_callbacks,
+                rb_self.callback_roots.clone(),
+                rb_self.compilation_roots.clone(),
+            )),
+            None => Err(Error::new(
+                ruby.exception_key_error(),
+                format!("key not found: {pointer}"),
+            )),
+        }
+    }
+
+    /// `map.key?("#/$defs/User")` → bool
+    #[allow(clippy::needless_pass_by_value)]
+    fn key_p(&self, pointer: String) -> bool {
+        self.inner.contains_key(&pointer)
+    }
+
+    /// `map.keys` → Array[String]
+    fn keys(&self) -> Vec<String> {
+        self.inner.keys().map(str::to_owned).collect()
+    }
+
+    /// `map.length` → Integer
+    fn length(&self) -> usize {
+        self.inner.len()
+    }
+}
+
+pub fn define_class(ruby: &Ruby, module: &RModule) -> Result<(), Error> {
+    let class = module.define_class("ValidatorMap", ruby.class_object())?;
+    class.define_method("[]", method!(ValidatorMap::get, 1))?;
+    class.define_method("fetch", method!(ValidatorMap::fetch, 1))?;
+    class.define_method("key?", method!(ValidatorMap::key_p, 1))?;
+    class.define_method("keys", method!(ValidatorMap::keys, 0))?;
+    class.define_method("length", method!(ValidatorMap::length, 0))?;
+    class.define_alias("size", "length")?;
+    Ok(())
+}

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jsonschema_rs
 version: !ruby/object:Gem::Version
-  version: 0.45.0
+  version: 0.46.0
 platform: ruby
 authors:
 - Dmitry Dygalo
@@ -71,6 +71,7 @@ files:
 - src/retriever.rs
 - src/ser.rs
 - src/static_id.rs
+- src/validator_map.rs
 homepage: https://github.com/Stranger6667/jsonschema/tree/master/crates/jsonschema-rb
 licenses:
 - MIT