add matches function

Author: drmorr0

Cargo.lock

@@ -8,8 +8,8 @@ license = "MIT"
 readme = "README.md"
 
 [dependencies]
-json-patch = "3"
-jsonptr = "0.6.3"
+json-patch = "4"
+jsonptr = "0.7.1"
 serde_json = "1"
 thiserror = "1"
 

Cargo.toml

@@ -1,4 +1,4 @@
-use jsonptr::assign::AssignError;
+use jsonptr::assign;
 use jsonptr::index::ParseIndexError;
 use jsonptr::resolve::ResolveError;
 pub use thiserror::Error;
@@ -21,7 +21,7 @@ pub enum PatchError {
     ResolveError(#[from] ResolveError),
 
     #[error("json path assign error: {0}")]
-    AssignError(#[from] AssignError),
+    AssignError(#[from] assign::Error),
 
     #[error("index parse error: {0}")]
     ParseIndexError(#[from] ParseIndexError),

src/errors.rs

@@ -118,6 +118,47 @@ pub fn escape(input: &str) -> String {
     Token::new(input).encoded().into()
 }
 
+pub fn matches(path: &Pointer, value: &Value) -> Vec<PointerBuf> {
+    let Some(idx) = path.as_str().find("/*") else {
+        // Base case -- no stars;
+        // If we can't resolve, there's no match to be found
+        if path.resolve(value).is_ok() {
+            return vec![path.to_buf()];
+        } else {
+            return vec![];
+        }
+    };
+
+    // we checked the index above so unwrap is safe here
+    let (head, cons) = path.split_at(idx).unwrap();
+    let mut res = vec![];
+
+    // If we can't resolve the head, or it's not an array, no match found
+    let Ok(head_val) = head.resolve(value) else {
+        return vec![];
+    };
+    let Some(next_array_val) = head_val.as_array() else {
+        return vec![];
+    };
+
+    for (i, v) in next_array_val.iter().enumerate() {
+        // /1 is a valid pointer so the unsafe block below is fine
+        let idx_str = format!("/{i}");
+        let idx_path = unsafe { PointerBuf::new_unchecked(idx_str) };
+
+        // The cons pointer either looks like /* or /*/something, so we need to split_front
+        // to get the array marker out, and either return the current path if there's nothing
+        // else, or recurse and concatenate the subpath(s) to the head
+        if let Some((_, c)) = cons.split_front() {
+            let subpaths = matches(c, v);
+            res.extend(subpaths.iter().map(|p| head.concat(&idx_path.concat(p))));
+        } else {
+            res.push(head.concat(&idx_path));
+        }
+    }
+    res
+}
+
 pub fn patch_ext(obj: &mut Value, p: PatchOperation) -> Result<(), PatchError> {
     match p {
         PatchOperation::Add(op) => add_or_replace(obj, &op.path, &op.value, false)?,
@@ -217,9 +258,16 @@ fn patch_ext_helper<'a>(
             PatchMode::Skip => return Ok(vec![]),
         }
     }
+
+    // Head now points at what we believe is an array; if not, it's an error.
     let next_array_val =
         head.resolve_mut(value)?.as_array_mut().ok_or(PatchError::UnexpectedType(head.as_str().into()))?;
+
+    // Iterate over all the array values and recurse, returning all found values
     for v in next_array_val {
+        // The cons pointer either looks like /* or /*/something, so we need to split_front
+        // to get the array marker out, and either return the current value if there's nothing
+        // else, or recurse and return all the found values
         if let Some((_, c)) = cons.split_front() {
             res.extend(patch_ext_helper(c, v, mode)?);
         } else {
@@ -248,6 +296,46 @@ mod tests {
         })
     }
 
+    #[rstest]
+    fn test_matches_1(data: Value) {
+        let path = format_ptr!("/foo");
+        let m = matches(&path, &data);
+        assert_eq!(m, vec![format_ptr!("/foo")]);
+    }
+
+    #[rstest]
+    fn test_matches_2(data: Value) {
+        let path = format_ptr!("/foo/*/baz");
+        let m = matches(&path, &data);
+        assert_eq!(m, vec![format_ptr!("/foo/0/baz"), format_ptr!("/foo/1/baz"), format_ptr!("/foo/2/baz")]);
+    }
+
+    #[rstest]
+    fn test_matches_3(data: Value) {
+        let path = format_ptr!("/foo/*");
+        let m = matches(&path, &data);
+        assert_eq!(m, vec![format_ptr!("/foo/0"), format_ptr!("/foo/1"), format_ptr!("/foo/2")]);
+    }
+
+    #[rstest]
+    #[case(format_ptr!("/foo/*/baz/fixx"))]
+    #[case(format_ptr!("/foo/2/baz/fixx"))]
+    fn test_matches_4(#[case] path: PointerBuf, data: Value) {
+        let m = matches(&path, &data);
+        assert_eq!(m, vec![format_ptr!("/foo/2/baz/fixx")]);
+    }
+
+    #[rstest]
+    #[case(format_ptr!("/*"))]
+    #[case(format_ptr!("/food"))]
+    #[case(format_ptr!("/foo/3/baz"))]
+    #[case(format_ptr!("/foo/bar/baz"))]
+    #[case(format_ptr!("/foo/0/baz/fixx"))]
+    fn test_no_match(#[case] path: PointerBuf, data: Value) {
+        let m = matches(&path, &data);
+        assert_is_empty!(m);
+    }
+
     #[rstest]
     fn test_patch_ext_add(mut data: Value) {
         let path = format_ptr!("/foo/*/baz/buzz");