Add path navigation to structured documents

Author: ynqa

promkit-widgets/src/structured/json/document.rs

@@ -2,9 +2,13 @@ use std::{cell::Cell, io::Read};
 
 use super::{
     deserializer,
-    jsonz::{self, Row, RowOperation},
+    jsonz::{self, ContainerNode, ContainerType, JsonNode, Row, RowOperation},
+};
+use crate::structured::{
+    ProjectionViewport,
+    path::{append_bracket, append_string_key},
+    projection_viewport,
 };
-use crate::structured::{ProjectionViewport, projection_viewport};
 
 /// Represents a navigable JSON document, allowing for efficient row navigation and folding.
 #[derive(Clone)]
@@ -130,6 +134,36 @@ impl Document {
         row_index_at_visible_position(&self.rows, self.position, visible_offset)
     }
 
+    /// Resolves a jq-style path to its underlying document row index.
+    ///
+    /// Paths use dot notation for identifier keys and bracket notation for array indices and
+    /// other string keys, for example `.items[0].name` and `["first name"]`.
+    pub fn row_index_for_path(&self, path: &str) -> Option<usize> {
+        locate_path(&self.rows, path).map(|located| located.row_index)
+    }
+
+    /// Moves the cursor to the value at a jq-style path.
+    ///
+    /// Folded ancestors are expanded while unrelated folding state is preserved.
+    pub fn move_to_path(&mut self, path: &str) -> bool {
+        let Some(located) = locate_path(&self.rows, path) else {
+            return false;
+        };
+        for open_index in located.ancestors {
+            if matches!(
+                self.rows[open_index].node,
+                JsonNode::Container(ContainerNode::Open {
+                    collapsed: true,
+                    ..
+                })
+            ) {
+                self.rows.toggle(open_index);
+            }
+        }
+        self.position = located.row_index;
+        true
+    }
+
     pub(super) fn row_index_at_viewport_position(&self, visible_position: usize) -> Option<usize> {
         let viewport = self.viewport.get();
         viewport
@@ -173,6 +207,62 @@ impl Document {
     }
 }
 
+struct PathFrame {
+    path: String,
+    typ: ContainerType,
+    next_index: usize,
+    open_index: usize,
+}
+
+struct LocatedRow {
+    row_index: usize,
+    ancestors: Vec<usize>,
+}
+
+fn locate_path(rows: &[Row], target: &str) -> Option<LocatedRow> {
+    let mut stack: Vec<PathFrame> = Vec::new();
+
+    for (row_index, row) in rows.iter().enumerate() {
+        if matches!(row.node, JsonNode::Container(ContainerNode::Close { .. })) {
+            stack.truncate(row.depth);
+            continue;
+        }
+        stack.truncate(row.depth);
+
+        let path = if row.depth == 0 {
+            ".".to_owned()
+        } else {
+            let parent = stack.get_mut(row.depth - 1)?;
+            match parent.typ {
+                ContainerType::Object => append_string_key(&parent.path, row.key.as_deref()?),
+                ContainerType::Array => {
+                    let path = append_bracket(&parent.path, &parent.next_index.to_string());
+                    parent.next_index += 1;
+                    path
+                }
+            }
+        };
+
+        if path == target {
+            return Some(LocatedRow {
+                row_index,
+                ancestors: stack.iter().map(|frame| frame.open_index).collect(),
+            });
+        }
+
+        if let JsonNode::Container(ContainerNode::Open { typ, .. }) = &row.node {
+            stack.push(PathFrame {
+                path,
+                typ: typ.clone(),
+                next_index: 0,
+                open_index: row_index,
+            });
+        }
+    }
+
+    None
+}
+
 fn visible_position(rows: &Vec<Row>, target: usize) -> usize {
     let mut position = rows.head();
     let mut visible = 0;
@@ -276,4 +366,44 @@ mod tests {
             assert!(Document::from_reader(Cursor::new(b"[1,")).is_err());
         }
     }
+
+    mod row_index_for_path {
+        use super::*;
+
+        #[test]
+        fn resolves_nested_values_arrays_and_quoted_keys() {
+            let document = Document::from_str(
+                r#"{"items":[null,{"first name":true}],"true":false,"a\"b\n":0}"#,
+            )
+            .unwrap();
+
+            assert_eq!(document.row_index_for_path("."), Some(0));
+            assert_eq!(document.row_index_for_path(".items"), Some(1));
+            assert_eq!(document.row_index_for_path(".items[1]"), Some(3));
+            assert_eq!(
+                document.row_index_for_path(r#".items[1]["first name"]"#),
+                Some(4)
+            );
+            assert_eq!(document.row_index_for_path(r#"["true"]"#), Some(7));
+            assert_eq!(document.row_index_for_path(r#"["a\"b\n"]"#), Some(8));
+            assert_eq!(document.row_index_for_path(".missing"), None);
+        }
+    }
+
+    mod move_to_path {
+        use super::*;
+
+        #[test]
+        fn expands_ancestors_and_selects_the_target() {
+            let mut document =
+                Document::from_str(r#"{"items":[{"nested":true}],"other":{"value":1}}"#).unwrap();
+            document.toggle_at(1);
+            document.toggle_at(6);
+
+            assert!(document.move_to_path(".items[0].nested"));
+            assert_eq!(document.visible_position(), 3);
+            assert_eq!(document.visible_rows().len(), 8);
+            assert!(!document.move_to_path(".missing"));
+        }
+    }
 }

promkit-widgets/src/structured/json/jsonz.rs

@@ -1,5 +1,7 @@
 use rayon::prelude::*;
 
+use crate::structured::path::{append_bracket, append_string_key};
+
 pub use crate::structured::{ContainerNode, ContainerType, PrettyRender, RowOperation};
 
 #[derive(Clone, Debug, PartialEq)]
@@ -63,22 +65,18 @@ impl PrettyRender for [Row] {
                 },
             }
 
-            if i + 1 < self.len() {
-                if matches!(
+            if i + 1 < self.len()
+                && !matches!(
                     &self[i + 1].node,
                     JsonNode::Container(ContainerNode::Close { .. })
-                ) {
-                } else if matches!(&row.node, JsonNode::Container(ContainerNode::Open { .. })) {
-                } else {
-                    result.push(',');
-                }
+                )
+                && !matches!(&row.node, JsonNode::Container(ContainerNode::Open { .. }))
+            {
+                result.push(',');
             }
 
-            if matches!(&row.node, JsonNode::Container(ContainerNode::Open { .. })) {
-                first_in_container = true;
-            } else {
-                first_in_container = false;
-            }
+            first_in_container =
+                matches!(&row.node, JsonNode::Container(ContainerNode::Open { .. }));
         }
 
         result
@@ -263,31 +261,31 @@ fn process_value(
         serde_json::Value::Null => {
             rows.push(Row {
                 depth,
-                key: key,
+                key,
                 node: JsonNode::Null,
             });
             rows.len() - 1
         }
         serde_json::Value::Bool(b) => {
             rows.push(Row {
                 depth,
-                key: key,
+                key,
                 node: JsonNode::Boolean(*b),
             });
             rows.len() - 1
         }
         serde_json::Value::Number(n) => {
             rows.push(Row {
                 depth,
-                key: key,
+                key,
                 node: JsonNode::Number(n.clone()),
             });
             rows.len() - 1
         }
         serde_json::Value::String(s) => {
             rows.push(Row {
                 depth,
-                key: key,
+                key,
                 node: JsonNode::String(s.clone()),
             });
             rows.len() - 1
@@ -296,7 +294,7 @@ fn process_value(
             if arr.is_empty() {
                 rows.push(Row {
                     depth,
-                    key: key,
+                    key,
                     node: JsonNode::Container(ContainerNode::Empty {
                         typ: ContainerType::Array,
                     }),
@@ -308,7 +306,7 @@ fn process_value(
 
             rows.push(Row {
                 depth,
-                key: key,
+                key,
                 node: JsonNode::Container(ContainerNode::Open {
                     typ: ContainerType::Array,
                     collapsed: false,
@@ -343,7 +341,7 @@ fn process_value(
             if obj.is_empty() {
                 rows.push(Row {
                     depth,
-                    key: key,
+                    key,
                     node: JsonNode::Container(ContainerNode::Empty {
                         typ: ContainerType::Object,
                     }),
@@ -355,7 +353,7 @@ fn process_value(
 
             rows.push(Row {
                 depth,
-                key: key,
+                key,
                 node: JsonNode::Container(ContainerNode::Open {
                     typ: ContainerType::Object,
                     collapsed: false,
@@ -402,16 +400,6 @@ pub struct PathIterator<'a> {
     stack: Vec<(String, &'a serde_json::Value)>,
 }
 
-impl PathIterator<'_> {
-    fn escape_json_path_key(key: &str) -> String {
-        if key.contains('.') || key.contains('-') || key.contains('@') {
-            format!("\"{}\"", key)
-        } else {
-            key.to_string()
-        }
-    }
-}
-
 impl Iterator for PathIterator<'_> {
     type Item = String;
 
@@ -420,18 +408,13 @@ impl Iterator for PathIterator<'_> {
             match value {
                 serde_json::Value::Object(obj) => {
                     for (key, val) in obj.iter() {
-                        let escaped = Self::escape_json_path_key(key);
-                        let new_path = if current_path == "." {
-                            format!(".{}", escaped)
-                        } else {
-                            format!("{}.{}", current_path, escaped)
-                        };
+                        let new_path = append_string_key(&current_path, key);
                         self.stack.push((new_path, val));
                     }
                 }
                 serde_json::Value::Array(arr) => {
                     for (i, val) in arr.iter().enumerate() {
-                        let new_path = format!("{}[{}]", current_path, i);
+                        let new_path = append_bracket(&current_path, &i.to_string());
                         self.stack.push((new_path, val));
                     }
                 }

promkit-widgets/src/structured/mod.rs

@@ -10,6 +10,8 @@ pub mod yaml;
 #[cfg_attr(docsrs, doc(cfg(feature = "tree")))]
 pub mod tree;
 
+mod path;
+
 use std::cell::Cell;
 
 use promkit_core::grapheme::StyledGraphemes;