feat: generic identifier (#27)

src/flatten.rs

@@ -1,15 +1,14 @@
-use crate::identifier::{TreeIdentifier, TreeIdentifierVec};
 use crate::TreeItem;
 
 /// A flattened item of all visible [`TreeItem`s](TreeItem).
 ///
 /// Generated via [`flatten`].
-pub struct Flattened<'a> {
-    pub identifier: Vec<usize>,
-    pub item: &'a TreeItem<'a>,
+pub struct Flattened<'a, Identifier> {
+    pub identifier: Vec<Identifier>,
+    pub item: &'a TreeItem<'a, Identifier>,
 }
 
-impl<'a> Flattened<'a> {
+impl<'a, Identifier> Flattened<'a, Identifier> {
     #[must_use]
     pub fn depth(&self) -> usize {
         self.identifier.len() - 1
@@ -18,21 +17,30 @@ impl<'a> Flattened<'a> {
 
 /// Get a flat list of all visible [`TreeItem`s](TreeItem).
 #[must_use]
-pub fn flatten<'a>(opened: &[TreeIdentifierVec], items: &'a [TreeItem<'a>]) -> Vec<Flattened<'a>> {
+pub fn flatten<'a, Identifier>(
+    opened: &[Vec<Identifier>],
+    items: &'a [TreeItem<'a, Identifier>],
+) -> Vec<Flattened<'a, Identifier>>
+where
+    Identifier: Clone + PartialEq,
+{
     internal(opened, items, &[])
 }
 
 #[must_use]
-fn internal<'a>(
-    opened: &[TreeIdentifierVec],
-    items: &'a [TreeItem<'a>],
-    current: TreeIdentifier,
-) -> Vec<Flattened<'a>> {
+fn internal<'a, Identifier>(
+    opened: &[Vec<Identifier>],
+    items: &'a [TreeItem<'a, Identifier>],
+    current: &[Identifier],
+) -> Vec<Flattened<'a, Identifier>>
+where
+    Identifier: Clone + PartialEq,
+{
     let mut result = Vec::new();
 
-    for (index, item) in items.iter().enumerate() {
+    for item in items {
         let mut child_identifier = current.to_vec();
-        child_identifier.push(index);
+        child_identifier.push(item.identifier.clone());
 
         result.push(Flattened {
             item,
@@ -49,30 +57,28 @@ fn internal<'a>(
 }
 
 #[cfg(test)]
-fn get_naive_string_from_text(text: &ratatui::text::Text<'_>) -> String {
-    text.lines
-        .first()
-        .unwrap()
-        .spans
-        .first()
-        .unwrap()
-        .content
-        .to_string()
-}
-
-#[cfg(test)]
-fn get_example_tree_items() -> Vec<TreeItem<'static>> {
+fn get_example_tree_items() -> Vec<TreeItem<'static, &'static str>> {
     vec![
-        TreeItem::new_leaf("a"),
+        TreeItem::new_leaf("a", "Alfa"),
         TreeItem::new(
             "b",
+            "Bravo",
             vec![
-                TreeItem::new_leaf("c"),
-                TreeItem::new("d", vec![TreeItem::new_leaf("e"), TreeItem::new_leaf("f")]),
-                TreeItem::new_leaf("g"),
+                TreeItem::new_leaf("c", "Charlie"),
+                TreeItem::new(
+                    "d",
+                    "Delta",
+                    vec![
+                        TreeItem::new_leaf("e", "Echo"),
+                        TreeItem::new_leaf("f", "Foxtrot"),
+                    ],
+                )
+                .expect("all item identifiers are unique"),
+                TreeItem::new_leaf("g", "Golf"),
             ],
-        ),
-        TreeItem::new_leaf("h"),
+        )
+        .expect("all item identifiers are unique"),
+        TreeItem::new_leaf("h", "Hotel"),
     ]
 }
 
@@ -80,45 +86,33 @@ fn get_example_tree_items() -> Vec<TreeItem<'static>> {
 fn get_opened_nothing_opened_is_top_level() {
     let items = get_example_tree_items();
     let result = flatten(&[], &items);
-    let result_text = result
-        .iter()
-        .map(|o| get_naive_string_from_text(&o.item.text))
-        .collect::<Vec<_>>();
+    let result_text = result.iter().map(|o| o.item.identifier).collect::<Vec<_>>();
     assert_eq!(result_text, ["a", "b", "h"]);
 }
 
 #[test]
 fn get_opened_wrong_opened_is_only_top_level() {
     let items = get_example_tree_items();
-    let opened = [vec![0], vec![1, 1]];
+    let opened = [vec!["a"], vec!["b", "d"]];
     let result = flatten(&opened, &items);
-    let result_text = result
-        .iter()
-        .map(|o| get_naive_string_from_text(&o.item.text))
-        .collect::<Vec<_>>();
+    let result_text = result.iter().map(|o| o.item.identifier).collect::<Vec<_>>();
     assert_eq!(result_text, ["a", "b", "h"]);
 }
 
 #[test]
 fn get_opened_one_is_opened() {
     let items = get_example_tree_items();
-    let opened = [vec![1]];
+    let opened = [vec!["b"]];
     let result = flatten(&opened, &items);
-    let result_text = result
-        .iter()
-        .map(|o| get_naive_string_from_text(&o.item.text))
-        .collect::<Vec<_>>();
+    let result_text = result.iter().map(|o| o.item.identifier).collect::<Vec<_>>();
     assert_eq!(result_text, ["a", "b", "c", "d", "g", "h"]);
 }
 
 #[test]
 fn get_opened_all_opened() {
     let items = get_example_tree_items();
-    let opened = [vec![1], vec![1, 1]];
+    let opened = [vec!["b"], vec!["b", "d"]];
     let result = flatten(&opened, &items);
-    let result_text = result
-        .iter()
-        .map(|o| get_naive_string_from_text(&o.item.text))
-        .collect::<Vec<_>>();
+    let result_text = result.iter().map(|o| o.item.identifier).collect::<Vec<_>>();
     assert_eq!(result_text, ["a", "b", "c", "d", "e", "f", "g", "h"]);
 }