feat: Validate with JSON pointer

crates/jsonschema/src/compiler.rs

@@ -12,7 +12,7 @@ use crate::{
     },
     node::{PendingSchemaNode, SchemaNode},
     options::{PatternEngineOptions, ValidationOptions},
-    paths::{Location, LocationSegment},
+    paths::{write_escaped_str, Location, LocationSegment},
     types::{JsonType, JsonTypeSet},
     validator::Validate,
     ValidationError, Validator,
@@ -729,7 +729,22 @@ pub(crate) fn build_validator(
     // Finally, compile the validator
     let root = compile(&ctx, resource_ref).map_err(ValidationError::to_owned)?;
     let draft = config.draft();
-    Ok(Validator { root, draft })
+
+    // Collect all subschemas with their JSON pointers
+    if config.collect_pointer_subschemas {
+        let subschemas = Some(collect_subschemas(&ctx, schema));
+        return Ok(Validator {
+            root,
+            draft,
+            subschemas,
+        });
+    }
+
+    Ok(Validator {
+        root,
+        draft,
+        subschemas: None,
+    })
 }
 
 #[cfg(feature = "resolve-async")]
@@ -801,7 +816,22 @@ pub(crate) async fn build_validator_async(
 
     let root = compile(&ctx, resource_ref).map_err(ValidationError::to_owned)?;
     let draft = config.draft();
-    Ok(Validator { root, draft })
+
+    // Collect all subschemas with their JSON pointers
+    if config.collect_pointer_subschemas {
+        let subschemas = Some(collect_subschemas(&ctx, schema));
+        return Ok(Validator {
+            root,
+            draft,
+            subschemas,
+        });
+    }
+
+    Ok(Validator {
+        root,
+        draft,
+        subschemas: None,
+    })
 }
 
 fn annotations_to_value(annotations: AHashMap<String, Value>) -> Arc<Value> {
@@ -824,6 +854,47 @@ fn collect_resource_pairs(
     )
 }
 
+/// Iteratively collect all subschemas from a schema document with their JSON pointers
+fn collect_subschemas(ctx: &Context, schema: &Value) -> AHashMap<String, SchemaNode> {
+    let mut subschemas = AHashMap::new();
+
+    // Stack to hold (schema, pointer) pairs to process
+    let mut stack = vec![(schema, "#".to_string())];
+
+    while let Some((current_schema, pointer)) = stack.pop() {
+        // Compile and store the current schema if it's not the root (empty pointer)
+        let resource_ref = ctx.as_resource_ref(current_schema);
+        let ctx_at_location = ctx.new_at_location(pointer.as_str());
+        if let Ok(node) = compile(&ctx_at_location, resource_ref) {
+            subschemas.insert(pointer.clone(), node);
+        } else {
+            // Skip schemas that fail to compile (e.g., invalid references)
+            // This allows the validator to still work with valid subschemas
+        }
+
+        // Process subschemas based on schema structure
+        match current_schema {
+            Value::Object(obj) => {
+                stack.extend(obj.iter().map(|(key, value)| {
+                    let mut buffer = String::new();
+                    write_escaped_str(&mut buffer, key);
+                    (value, format!("{pointer}/{buffer}"))
+                }));
+            }
+            Value::Array(arr) => {
+                stack.extend(
+                    arr.iter()
+                        .enumerate()
+                        .map(|(idx, item)| (item, format!("{pointer}/{idx}"))),
+                );
+            }
+            _ => {}
+        }
+    }
+
+    subschemas
+}
+
 fn validate_schema(draft: Draft, schema: &Value) -> Result<(), ValidationError<'static>> {
     // Boolean schemas are always valid per the spec, skip validation
     if schema.is_boolean() {

crates/jsonschema/src/options.rs

@@ -32,6 +32,7 @@ pub struct ValidationOptions<R = Arc<dyn Retrieve>> {
     formats: AHashMap<String, Arc<dyn Format>>,
     validate_formats: Option<bool>,
     pub(crate) validate_schema: bool,
+    pub(crate) collect_pointer_subschemas: bool,
     ignore_unknown_formats: bool,
     keywords: AHashMap<String, Arc<dyn KeywordFactory>>,
     pattern_options: PatternEngineOptions,
@@ -51,6 +52,7 @@ impl Default for ValidationOptions<Arc<dyn Retrieve>> {
             formats: AHashMap::default(),
             validate_formats: None,
             validate_schema: true,
+            collect_pointer_subschemas: false,
             ignore_unknown_formats: true,
             keywords: AHashMap::default(),
             pattern_options: PatternEngineOptions::default(),
@@ -73,6 +75,7 @@ impl Default for ValidationOptions<Arc<dyn referencing::AsyncRetrieve>> {
             formats: AHashMap::default(),
             validate_formats: None,
             validate_schema: true,
+            collect_pointer_subschemas: false,
             ignore_unknown_formats: true,
             keywords: AHashMap::default(),
             pattern_options: PatternEngineOptions::default(),
@@ -413,6 +416,12 @@ impl<R> ValidationOptions<R> {
         self.validate_schema = false;
         self
     }
+    /// Collect JSON pointer subschemas during compilation.
+    #[must_use]
+    pub fn collect_pointer_subschemas(mut self) -> Self {
+        self.collect_pointer_subschemas = true;
+        self
+    }
     /// Set whether to validate formats.
     ///
     /// Default behavior depends on the draft version. This method overrides
@@ -748,6 +757,7 @@ impl ValidationOptions<Arc<dyn referencing::AsyncRetrieve>> {
             formats: self.formats,
             validate_formats: self.validate_formats,
             validate_schema: self.validate_schema,
+            collect_pointer_subschemas: self.collect_pointer_subschemas,
             ignore_unknown_formats: self.ignore_unknown_formats,
             keywords: self.keywords,
             pattern_options: self.pattern_options,
@@ -783,6 +793,7 @@ impl ValidationOptions<Arc<dyn referencing::AsyncRetrieve>> {
             formats: self.formats,
             validate_formats: self.validate_formats,
             validate_schema: self.validate_schema,
+            collect_pointer_subschemas: self.collect_pointer_subschemas,
             ignore_unknown_formats: self.ignore_unknown_formats,
             keywords: self.keywords,
             pattern_options: self.pattern_options,