chore: Naive path tracking

Signed-off-by: Dmitry Dygalo <dmitry@dygalo.dev>

Author: Stranger6667

src/error.rs

@@ -19,20 +19,40 @@ impl error::Error for SchemaError {}
 #[derive(Debug)]
 pub struct ValidationError {
     message: String,
+    location: Vec<String>,
 }
 
 impl ValidationError {
     /// Create new validation error.
-    pub fn new(message: impl Into<String>) -> Self {
+    pub fn new(
+        message: impl Into<String>,
+        location: impl Iterator<Item = impl Into<String>>,
+    ) -> Self {
         Self {
             message: message.into(),
+            location: location.map(Into::into).collect(),
         }
     }
+    /// JSON Pointer to the location of the error.
+    pub fn location_pointer(&self) -> String {
+        let mut pointer = String::new();
+        for segment in &self.location {
+            pointer.push('/');
+            pointer.push_str(segment);
+        }
+        pointer
+    }
 }
 
 impl fmt::Display for ValidationError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.write_str(&self.message)
+        f.write_str(&self.message)?;
+        f.write_str(" at ")?;
+        for segment in self.location.iter() {
+            f.write_str("/")?;
+            f.write_str(segment)?;
+        }
+        Ok(())
     }
 }
 

src/keywords/mod.rs

@@ -9,5 +9,5 @@ pub(crate) use properties::Properties;
 pub(crate) use type_::Type;
 
 pub(crate) trait Node {
-    fn validate(&self, instance: &Value) -> Result<(), ValidationError>;
+    fn validate(&self, instance: &Value, path: Vec<&str>) -> Result<(), ValidationError>;
 }

src/keywords/properties.rs

@@ -20,11 +20,13 @@ impl Properties {
 }
 
 impl Node for Properties {
-    fn validate(&self, instance: &Value) -> Result<(), ValidationError> {
+    fn validate(&self, instance: &Value, path: Vec<&str>) -> Result<(), ValidationError> {
         if let Value::Object(object) = instance {
             for (key, value) in &self.properties {
-                if let Some(instance) = object.get(key) {
-                    value.validate(instance)?;
+                if let Some((key, instance)) = object.get_key_value(key) {
+                    let mut path = path.clone();
+                    path.push(key);
+                    value.validate(instance, path)?;
                 }
             }
         }

src/keywords/type_.rs

@@ -25,7 +25,7 @@ impl Type {
 }
 
 impl Node for Type {
-    fn validate(&self, instance: &Value) -> Result<(), ValidationError> {
+    fn validate(&self, instance: &Value, path: Vec<&str>) -> Result<(), ValidationError> {
         match (self, instance) {
             (Type::Array, Value::Array(_))
             | (Type::Null, Value::Null)
@@ -34,9 +34,10 @@ impl Node for Type {
             | (Type::Object, Value::Object(_))
             | (Type::String, Value::String(_)) => Ok(()),
             (Type::Integer, Value::Number(n)) if n.is_i64() || n.is_u64() => Ok(()),
-            _ => Err(ValidationError::new(format!(
-                "{instance} is not of type '{self}'"
-            ))),
+            _ => Err(ValidationError::new(
+                format!("{instance} is not of type '{self}'"),
+                path.into_iter(),
+            )),
         }
     }
 }

src/lib.rs

@@ -116,7 +116,7 @@ impl Validator {
     ///
     /// Returns `ValidationError` if the input instance is not valid under the given validator.
     pub fn validate(&self, instance: &Value) -> Result<(), ValidationError> {
-        self.node.validate(instance)
+        self.node.validate(instance, vec![])
     }
 }
 
@@ -154,6 +154,10 @@ mod tests {
           }
         });
         let error = validate(&instance, &json!({})).expect_err("Should fail");
-        assert_eq!(error.to_string(), "1 is not of type 'string'");
+        assert_eq!(
+            error.to_string(),
+            "1 is not of type 'string' at /inner/inner/inner/inner/another"
+        );
+        assert_eq!(instance.pointer(&error.location_pointer()), Some(&json!(1)));
     }
 }