chore: Row based implementations for tree-widgets

Author: ynqa

examples/tree/src/tree.rs

@@ -1,11 +1,12 @@
 use std::path::Path;
 
-use promkit::{preset::tree::Tree, widgets::tree::node::Node, Prompt};
+use promkit::{preset::tree::Tree, widgets::tree::Document, Prompt};
 
 #[tokio::main]
 async fn main() -> anyhow::Result<()> {
     let root = Path::new(env!("CARGO_MANIFEST_DIR")).join("../../promkit/src");
-    let ret = Tree::new(Node::try_from(&root)?)
+    let document = Document::from_path(&root)?;
+    let ret = Tree::new(document)
         .title("Select a directory or file")
         .tree_lines(10)
         .run()

promkit-widgets/src/tree.rs

@@ -1,12 +1,11 @@
 use promkit_core::{Widget, grapheme::StyledGraphemes};
 
-pub mod node;
-use node::Kind;
-#[path = "tree/tree.rs"]
-mod inner;
-pub use inner::Tree;
+mod document;
+pub use document::Document;
 pub mod config;
 pub use config::Config;
+pub mod treez;
+pub use treez::Row;
 
 /// Represents the state of a tree structure within the application.
 ///
@@ -17,31 +16,18 @@ pub use config::Config;
 /// for child items in the tree.
 #[derive(Clone)]
 pub struct State {
-    pub tree: Tree,
+    pub document: Document,
     /// Configuration for rendering and behavior.
     pub config: Config,
 }
 
 impl Widget for State {
     fn create_graphemes(&self, _width: u16, height: u16) -> StyledGraphemes {
-        let symbol = |kind: &Kind| -> &str {
-            match kind {
-                Kind::Folded { .. } => &self.config.folded_symbol,
-                Kind::Unfolded { .. } => &self.config.unfolded_symbol,
-            }
-        };
-
-        let indent = |kind: &Kind| -> usize {
-            match kind {
-                Kind::Folded { path, .. } | Kind::Unfolded { path, .. } => {
-                    path.len() * self.config.indent
-                }
-            }
-        };
-
-        let id = |kind: &Kind| -> String {
-            match kind {
-                Kind::Folded { id, .. } | Kind::Unfolded { id, .. } => id.clone(),
+        let symbol = |row: &Row| -> &str {
+            if row.has_children && !row.collapsed {
+                &self.config.unfolded_symbol
+            } else {
+                &self.config.folded_symbol
             }
         };
 
@@ -50,29 +36,30 @@ impl Widget for State {
             None => height as usize,
         };
 
-        let kinds = self.tree.kinds();
-        let lines = kinds
-            .iter()
-            .enumerate()
-            .filter(|(i, _)| *i >= self.tree.position() && *i < self.tree.position() + height)
-            .map(|(i, kind)| {
-                if i == self.tree.position() {
-                    StyledGraphemes::from_str(
-                        format!("{}{}{}", symbol(kind), " ".repeat(indent(kind)), id(kind),),
-                        self.config.active_item_style,
-                    )
-                } else {
-                    StyledGraphemes::from_str(
-                        format!(
-                            "{}{}{}",
-                            " ".repeat(StyledGraphemes::from(symbol(kind)).widths()),
-                            " ".repeat(indent(kind)),
-                            id(kind),
-                        ),
-                        self.config.inactive_item_style,
-                    )
-                }
-            });
+        let rows = self.document.extract_rows_from_current(height);
+        let lines = rows.iter().enumerate().map(|(offset, row)| {
+            if offset == 0 {
+                StyledGraphemes::from_str(
+                    format!(
+                        "{}{}{}",
+                        symbol(row),
+                        " ".repeat(row.depth * self.config.indent),
+                        row.id,
+                    ),
+                    self.config.active_item_style,
+                )
+            } else {
+                StyledGraphemes::from_str(
+                    format!(
+                        "{}{}{}",
+                        " ".repeat(StyledGraphemes::from(symbol(row)).widths()),
+                        " ".repeat(row.depth * self.config.indent),
+                        row.id,
+                    ),
+                    self.config.inactive_item_style,
+                )
+            }
+        });
 
         StyledGraphemes::from_lines(lines)
     }

promkit-widgets/src/tree/document.rs

@@ -0,0 +1,78 @@
+use super::{Row, treez::RowOperation};
+
+/// Represents a navigable tree document, allowing for efficient row navigation and folding.
+#[derive(Clone)]
+pub struct Document {
+    rows: Vec<Row>,
+    position: usize,
+}
+
+impl Document {
+    pub fn new(rows: Vec<Row>) -> Self {
+        Self { rows, position: 0 }
+    }
+
+    pub fn from_path(path: &std::path::Path) -> anyhow::Result<Self> {
+        Ok(Self::new(super::treez::create_rows_from_path(path)?))
+    }
+}
+
+impl Document {
+    /// Returns a reference to the underlying vector of rows.
+    pub fn rows(&self) -> &[Row] {
+        &self.rows
+    }
+
+    /// Returns the selected tree path represented by visible row labels.
+    pub fn get(&self) -> Vec<String> {
+        self.rows
+            .get(self.position)
+            .map(|row| row.path.clone())
+            .unwrap_or_default()
+    }
+
+    /// Extract rows from the current cursor position.
+    pub fn extract_rows_from_current(&self, n: usize) -> Vec<Row> {
+        self.rows.extract(self.position, n)
+    }
+
+    /// Toggles the visibility of a node at the cursor's current position.
+    pub fn toggle(&mut self) {
+        let index = self.rows.toggle(self.position);
+        self.position = index;
+    }
+
+    /// Sets the visibility of all rows.
+    pub fn set_nodes_visibility(&mut self, collapsed: bool) {
+        self.rows.set_rows_visibility(collapsed);
+        self.position = self.rows.head();
+    }
+
+    /// Moves the cursor backward through rows.
+    pub fn up(&mut self) -> bool {
+        let index = self.rows.up(self.position);
+        let ret = index != self.position;
+        self.position = index;
+        ret
+    }
+
+    /// Moves the cursor to the head position.
+    pub fn head(&mut self) -> bool {
+        self.position = self.rows.head();
+        true
+    }
+
+    /// Moves the cursor forward through rows.
+    pub fn down(&mut self) -> bool {
+        let index = self.rows.down(self.position);
+        let ret = index != self.position;
+        self.position = index;
+        ret
+    }
+
+    /// Moves the cursor to the last position.
+    pub fn tail(&mut self) -> bool {
+        self.position = self.rows.tail();
+        true
+    }
+}