jsonschema_rs 0.45.0 → 0.46.0

data/ext/jsonschema/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "jsonschema-rb-ext"
-version = "0.45.0"
+version = "0.46.0"
 edition = "2021"
 publish = false
 
@@ -10,10 +10,10 @@ name = "jsonschema_rb"
 path = "../../src/lib.rs"
 
 [dependencies]
-jsonschema = { version = "0.45.0", default-features = false, features = ["arbitrary-precision", "resolve-http", "resolve-file", "tls-ring"] }
+jsonschema = { version = "0.46.0", default-features = false, features = ["arbitrary-precision", "resolve-http", "resolve-file", "tls-ring"] }
 magnus = { version = "0.8", features = ["rb-sys"] }
 rb-sys = "0.9"
-referencing = "0.45.0"
+referencing = "0.46.0"
 serde = { version = "1", features = ["derive"] }
 serde_json = { version = "1", features = ["arbitrary_precision"] }
 

data/lib/jsonschema/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module JSONSchema
-  VERSION = "0.45.0"
+  VERSION = "0.46.0"
 end

data/sig/jsonschema.rbs

@@ -41,6 +41,22 @@ module JSONSchema
     ?http_options: HttpOptions?
   ) -> Validator
 
+  # Create a map of validators for all sub-schemas in a JSON Schema.
+  def self.validator_map_for: (
+    untyped schema,
+    ?validate_formats: bool?,
+    ?ignore_unknown_formats: bool?,
+    ?mask: ::String?,
+    ?base_uri: ::String?,
+    ?retriever: (^(::String) -> untyped)?,
+    ?registry: Registry?,
+    ?formats: ::Hash[::String, ^(::String) -> bool]?,
+    ?keywords: ::Hash[::String, untyped]?,
+    ?pattern_options: (RegexOptions | FancyRegexOptions)?,
+    ?email_options: EmailOptions?,
+    ?http_options: HttpOptions?
+  ) -> ValidatorMap
+
   # Bundle a JSON Schema into a Compound Schema Document.
   # All externally-referenced schemas reachable via $ref are embedded in a
   # draft-appropriate container (definitions for Draft 4/6/7, $defs for
@@ -54,6 +70,16 @@ module JSONSchema
     ?base_uri: String?
   ) -> Hash[String, untyped]
 
+  # Dereference a JSON Schema by recursively replacing all $ref values
+  # with the schemas they point to.
+  def self.dereference: (
+    untyped schema,
+    ?draft: draft?,
+    ?retriever: (^(String) -> untyped)?,
+    ?registry: Registry?,
+    ?base_uri: String?
+  ) -> untyped
+
   # Detect the JSON Schema draft for a schema and return the corresponding validator class.
   # Draft is detected automatically from the `$schema` field. Defaults to Draft202012Validator.
   def self.validator_cls_for: (untyped schema) -> (singleton(Draft4Validator) | singleton(Draft6Validator) | singleton(Draft7Validator) | singleton(Draft201909Validator) | singleton(Draft202012Validator))
@@ -165,6 +191,16 @@ module JSONSchema
   end
   public
 
+  # Map of validators for all sub-schemas in a JSON Schema, keyed by JSON Pointer.
+  class ValidatorMap
+    def []: (::String pointer) -> Validator?
+    def fetch: (::String pointer) -> Validator
+    def key?: (::String pointer) -> bool
+    def keys: () -> ::Array[::String]
+    def length: () -> ::Integer
+    def size: () -> ::Integer
+  end
+
   # JSON Schema Draft 4 validator.
   class Draft4Validator < Validator
   end
@@ -281,6 +317,20 @@ module JSONSchema
     def inspect: () -> String
   end
 
+  # Resolver for JSON Schema references.
+  class Resolver
+    def base_uri: () -> String
+    def dynamic_scope: () -> Array[String]
+    def lookup: (String reference) -> Resolved
+  end
+
+  # Resolved reference containing the dereferenced schema and its context.
+  class Resolved
+    def contents: () -> untyped
+    def resolver: () -> Resolver
+    def draft: () -> Integer
+  end
+
   # Schema registry for reference resolution.
   class Registry
     # Create a registry from URI/schema pairs.

data/src/lib.rs

@@ -12,6 +12,7 @@ mod registry;
 mod retriever;
 mod ser;
 mod static_id;
+mod validator_map;
 
 use jsonschema::{paths::LocationSegment, ValidationOptions};
 use magnus::{
@@ -22,8 +23,8 @@ use magnus::{
     prelude::*,
     scan_args::scan_args,
     value::{Lazy, ReprValue},
-    DataTypeFunctions, Error, Exception, ExceptionClass, RClass, RHash, RModule, RObject, Ruby,
-    Value,
+    DataTypeFunctions, Error, Exception, ExceptionClass, RClass, RHash, RModule, RObject, RString,
+    Ruby, Value,
 };
 use referencing::unescape_segment;
 use std::{
@@ -84,16 +85,21 @@ struct BuiltValidator {
 fn build_validator(
     ruby: &Ruby,
     options: ValidationOptions,
+    registry: Option<&jsonschema::Registry<'_>>,
     retriever: Option<RubyRetriever>,
     callback_roots: CallbackRoots,
     compilation_roots: Arc<CompilationRoots>,
     schema: &serde_json::Value,
 ) -> Result<BuiltValidator, Error> {
-    let validator = match retriever {
-        Some(ret) => options.with_retriever(ret).build(schema),
-        None => options.build(schema),
+    let mut options = match retriever {
+        Some(ret) => options.with_retriever(ret),
+        None => options,
+    };
+    if let Some(registry) = registry {
+        options = options.with_registry(registry);
     }
-    .map_err(|error| {
+
+    let validator = options.build(schema).map_err(|error| {
         if let jsonschema::error::ValidationErrorKind::Referencing(err) = error.kind() {
             if let Some(message) = retriever_error_message(err) {
                 Error::new(ruby.exception_arg_error(), message)
@@ -157,7 +163,7 @@ fn build_parsed_options(
     ruby: &Ruby,
     kw: ExtractedKwargs,
     draft_override: Option<jsonschema::Draft>,
-) -> Result<ParsedOptions, Error> {
+) -> Result<ParsedOptions<'_>, Error> {
     let (
         draft_val,
         validate_formats,
@@ -446,7 +452,7 @@ fn to_ruby_error_value(
     into_ruby_error(ruby, error, root_instance, &message, mask)
 }
 
-fn referencing_error(ruby: &Ruby, message: String) -> Error {
+pub(crate) fn referencing_error(ruby: &Ruby, message: String) -> Error {
     let exc_class = ruby.get_inner(&REFERENCING_ERROR_CLASS);
     Error::new(exc_class, message)
 }
@@ -598,6 +604,22 @@ impl DataTypeFunctions for Validator {
 }
 
 impl Validator {
+    pub(crate) fn from_jsonschema_with_roots(
+        validator: jsonschema::Validator,
+        mask: Option<String>,
+        has_ruby_callbacks: bool,
+        callback_roots: CallbackRoots,
+        compilation_roots: CompilationRootsRef,
+    ) -> Self {
+        Self {
+            validator,
+            mask,
+            has_ruby_callbacks,
+            callback_roots,
+            _compilation_roots: compilation_roots,
+        }
+    }
+
     fn mark_callback_roots(&self, marker: &magnus::gc::Marker) {
         // Avoid panicking in Ruby GC mark paths; preserving existing roots is safer than aborting.
         let roots = match self.callback_roots.lock() {
@@ -802,6 +824,24 @@ fn validator_cls_for(ruby: &Ruby, schema: Value) -> Result<RClass, Error> {
         } else {
             jsonschema::Draft::default()
         }
+    } else if let Some(rstring) = RString::from_value(schema) {
+        #[allow(unsafe_code)]
+        let bytes = unsafe { rstring.as_slice() };
+        let value: serde_json::Value = serde_json::from_slice(bytes).map_err(|e| {
+            Error::new(
+                ruby.exception_arg_error(),
+                format!("Invalid JSON string: {e}"),
+            )
+        })?;
+        if let serde_json::Value::Object(map) = &value {
+            if let Some(serde_json::Value::String(s)) = map.get("$schema") {
+                jsonschema::Draft::from_schema_uri(s)
+            } else {
+                jsonschema::Draft::default()
+            }
+        } else {
+            jsonschema::Draft::default()
+        }
     } else {
         jsonschema::Draft::default()
     };
@@ -832,6 +872,7 @@ fn validator_for(ruby: &Ruby, args: &[Value]) -> Result<Validator, Error> {
     } = build_validator(
         ruby,
         parsed.options,
+        parsed.registry,
         parsed.retriever,
         parsed.callback_roots,
         parsed.compilation_roots,
@@ -846,6 +887,49 @@ fn validator_for(ruby: &Ruby, args: &[Value]) -> Result<Validator, Error> {
     })
 }
 
+fn validator_map_for(ruby: &Ruby, args: &[Value]) -> Result<validator_map::ValidatorMap, Error> {
+    let parsed_args = scan_args::<(Value,), (), (), (), _, ()>(args)?;
+    let (schema,) = parsed_args.required;
+    let kw = extract_kwargs_no_draft(ruby, parsed_args.keywords)?;
+
+    let json_schema = to_schema_value(ruby, schema)?;
+    let parsed = build_parsed_options(ruby, kw, None)?;
+    let has_ruby_callbacks = parsed.has_ruby_callbacks;
+    let callback_roots = parsed.callback_roots;
+    let compilation_roots = parsed.compilation_roots;
+    let mask = parsed.mask;
+
+    let mut options = match parsed.retriever {
+        Some(ret) => parsed.options.with_retriever(ret),
+        None => parsed.options,
+    };
+    if let Some(registry) = parsed.registry {
+        options = options.with_registry(registry);
+    }
+
+    match options.build_map(&json_schema) {
+        Ok(inner) => Ok(validator_map::ValidatorMap {
+            inner,
+            has_ruby_callbacks,
+            callback_roots,
+            compilation_roots,
+            mask,
+        }),
+        // Error handling mirrors build_validator: retriever_error_message → referencing_error → ArgumentError
+        Err(error) => {
+            if let jsonschema::error::ValidationErrorKind::Referencing(err) = error.kind() {
+                if let Some(message) = retriever_error_message(err) {
+                    Err(Error::new(ruby.exception_arg_error(), message))
+                } else {
+                    Err(referencing_error(ruby, err.to_string()))
+                }
+            } else {
+                Err(Error::new(ruby.exception_arg_error(), error.to_string()))
+            }
+        }
+    }
+}
+
 fn bundle(ruby: &Ruby, args: &[Value]) -> Result<Value, Error> {
     let parsed_args = scan_args::<(Value,), (), (), (), _, ()>(args)?;
     let (schema,) = parsed_args.required;
@@ -853,7 +937,11 @@ fn bundle(ruby: &Ruby, args: &[Value]) -> Result<Value, Error> {
 
     let json_schema = to_schema_value(ruby, schema)?;
     let parsed = build_parsed_options(ruby, kw, None)?;
-    match parsed.options.bundle(&json_schema) {
+    let mut options = parsed.options;
+    if let Some(registry) = parsed.registry {
+        options = options.with_registry(registry);
+    }
+    match options.bundle(&json_schema) {
         Ok(bundled) => ser::value_to_ruby(ruby, &bundled),
         Err(e @ jsonschema::ReferencingError::Unretrievable { .. }) => {
             Err(referencing_error(ruby, e.to_string()))
@@ -862,6 +950,29 @@ fn bundle(ruby: &Ruby, args: &[Value]) -> Result<Value, Error> {
     }
 }
 
+fn dereference(ruby: &Ruby, args: &[Value]) -> Result<Value, Error> {
+    let parsed_args = scan_args::<(Value,), (), (), (), _, ()>(args)?;
+    let (schema,) = parsed_args.required;
+    let kw = extract_kwargs(ruby, parsed_args.keywords)?;
+
+    let json_schema = to_schema_value(ruby, schema)?;
+    let parsed = build_parsed_options(ruby, kw, None)?;
+    let mut options = match parsed.retriever {
+        Some(ret) => parsed.options.with_retriever(ret),
+        None => parsed.options,
+    };
+    if let Some(registry) = parsed.registry {
+        options = options.with_registry(registry);
+    }
+    match options.dereference(&json_schema) {
+        Ok(result) => ser::value_to_ruby(ruby, &result),
+        Err(e @ jsonschema::ReferencingError::Unretrievable { .. }) => {
+            Err(referencing_error(ruby, e.to_string()))
+        }
+        Err(e) => Err(Error::new(ruby.exception_runtime_error(), e.to_string())),
+    }
+}
+
 /// to_string(object) -> String
 ///
 /// Serialize a Ruby value to canonical JSON.
@@ -888,6 +999,7 @@ fn is_valid(ruby: &Ruby, args: &[Value]) -> Result<bool, Error> {
     } = build_validator(
         ruby,
         parsed.options,
+        parsed.registry,
         parsed.retriever,
         parsed.callback_roots,
         parsed.compilation_roots,
@@ -927,6 +1039,7 @@ fn validate(ruby: &Ruby, args: &[Value]) -> Result<(), Error> {
     } = build_validator(
         ruby,
         parsed.options,
+        parsed.registry,
         parsed.retriever,
         parsed.callback_roots,
         parsed.compilation_roots,
@@ -978,6 +1091,7 @@ fn each_error(ruby: &Ruby, args: &[Value]) -> Result<Value, Error> {
     } = build_validator(
         ruby,
         parsed.options,
+        parsed.registry,
         parsed.retriever,
         parsed.callback_roots,
         parsed.compilation_roots,
@@ -1073,6 +1187,7 @@ fn evaluate(ruby: &Ruby, args: &[Value]) -> Result<Evaluation, Error> {
     } = build_validator(
         ruby,
         parsed.options,
+        parsed.registry,
         parsed.retriever,
         parsed.callback_roots,
         parsed.compilation_roots,
@@ -1126,6 +1241,7 @@ macro_rules! define_draft_validator {
                 } = build_validator(
                     ruby,
                     parsed.options,
+                    parsed.registry,
                     parsed.retriever,
                     parsed.callback_roots,
                     parsed.compilation_roots,
@@ -1201,9 +1317,9 @@ fn meta_is_valid(ruby: &Ruby, args: &[Value]) -> Result<bool, Error> {
 
     let json_schema = to_schema_value(ruby, schema)?;
 
-    let result = if let Some(reg) = registry {
+    let result = if let Some(registry) = registry {
         jsonschema::meta::options()
-            .with_registry(reg.inner.clone())
+            .with_registry(registry.inner.as_ref())
             .validate(&json_schema)
     } else {
         jsonschema::meta::validate(&json_schema)
@@ -1230,9 +1346,9 @@ fn meta_validate(ruby: &Ruby, args: &[Value]) -> Result<(), Error> {
 
     let json_schema = to_schema_value(ruby, schema)?;
 
-    let result = if let Some(reg) = registry {
+    let result = if let Some(registry) = registry {
         jsonschema::meta::options()
-            .with_registry(reg.inner.clone())
+            .with_registry(registry.inner.as_ref())
             .validate(&json_schema)
     } else {
         jsonschema::meta::validate(&json_schema)
@@ -1356,7 +1472,9 @@ fn init(ruby: &Ruby) -> Result<(), Error> {
     // Module-level functions
     module.define_singleton_method("validator_cls_for", function!(validator_cls_for, 1))?;
     module.define_singleton_method("validator_for", function!(validator_for, -1))?;
+    module.define_singleton_method("validator_map_for", function!(validator_map_for, -1))?;
     module.define_singleton_method("bundle", function!(bundle, -1))?;
+    module.define_singleton_method("dereference", function!(dereference, -1))?;
     module.define_singleton_method("valid?", function!(is_valid, -1))?;
     module.define_singleton_method("validate!", function!(validate, -1))?;
     module.define_singleton_method("each_error", function!(each_error, -1))?;
@@ -1427,10 +1545,17 @@ fn init(ruby: &Ruby) -> Result<(), Error> {
     // Internal implementation detail for shared validator behavior.
     let _: Value = module.funcall("private_constant", ("Validator",))?;
 
+    module.const_set("Draft4", 4u8)?;
+    module.const_set("Draft6", 6u8)?;
+    module.const_set("Draft7", 7u8)?;
+    module.const_set("Draft201909", 19u8)?;
+    module.const_set("Draft202012", 20u8)?;
+
     evaluation::define_class(ruby, &module)?;
     registry::define_class(ruby, &module)?;
     error_kind::define_class(ruby, &module)?;
     options::define_classes(ruby, &module)?;
+    validator_map::define_class(ruby, &module)?;
 
     let meta_module = module.define_module("Meta")?;
     meta_module.define_singleton_method("valid?", function!(meta_is_valid, -1))?;

data/src/options.rs

@@ -56,9 +56,10 @@ define_rb_intern!(static SYM_CALL: "call");
 define_rb_intern!(static SYM_NEW: "new");
 define_rb_intern!(static SYM_VALIDATE: "validate");
 
-pub struct ParsedOptions {
+pub struct ParsedOptions<'i> {
     pub mask: Option<String>,
-    pub options: jsonschema::ValidationOptions,
+    pub options: jsonschema::ValidationOptions<'i>,
+    pub registry: Option<&'i jsonschema::Registry<'static>>,
     pub retriever: Option<RubyRetriever>,
     // Runtime callbacks invoked during `validator.*` calls (formats / custom keywords).
     // Retriever callbacks are used at build time and do not affect GVL behavior at runtime.
@@ -420,8 +421,9 @@ pub fn make_options_from_kwargs(
     pattern_options_val: Option<Value>,
     email_options_val: Option<Value>,
     http_options_val: Option<Value>,
-) -> Result<ParsedOptions, Error> {
+) -> Result<ParsedOptions<'_>, Error> {
     let mut opts = jsonschema::options();
+    let mut registry = None;
     let mut retriever = None;
     let retriever_was_provided = retriever_val.is_some();
     let mut has_ruby_callbacks = false;
@@ -473,7 +475,7 @@ pub fn make_options_from_kwargs(
                     "registry must be a JSONSchema::Registry instance",
                 )
             })?;
-            opts = opts.with_registry(reg.inner.clone());
+            registry = Some(reg.inner.as_ref());
 
             if !retriever_was_provided && retriever.is_none() {
                 if let Some(registry_retriever_value) = reg.retriever_value(ruby) {
@@ -763,6 +765,7 @@ pub fn make_options_from_kwargs(
     Ok(ParsedOptions {
         mask,
         options: opts,
+        registry,
         retriever,
         has_ruby_callbacks,
         callback_roots,