Experiment B: refactor shared tree building helpers

src/javascript.rs

@@ -1,4 +1,9 @@
-use crate::{model::Language, model::Node, util::truncate_preview};
+use crate::{
+    model::Language,
+    model::Node,
+    tree::{build_tree, FlatItem},
+    util::truncate_preview,
+};
 use tree_sitter::{Node as AstNode, Parser};
 
 pub(crate) fn analyze_javascript(
@@ -20,41 +25,22 @@ pub(crate) fn analyze_javascript(
         return Vec::new();
     };
 
-    let mut items = Vec::<JavaScriptItem>::new();
+    let mut items = Vec::<FlatItem>::new();
     collect_javascript_items(tree.root_node(), source, preview_len, None, &mut items);
-    build_javascript_tree(&items, None)
-}
-
-#[derive(Debug, Clone)]
-struct JavaScriptItem {
-    parent: Option<usize>,
-    node: Node,
-}
-
-fn build_javascript_tree(items: &[JavaScriptItem], parent: Option<usize>) -> Vec<Node> {
-    items
-        .iter()
-        .enumerate()
-        .filter(|(_, item)| item.parent == parent)
-        .map(|(index, item)| {
-            let mut node = item.node.clone();
-            node.children = build_javascript_tree(items, Some(index));
-            node
-        })
-        .collect()
+    build_tree(&items, None)
 }
 
 fn collect_javascript_items(
     ast_node: AstNode,
     source: &str,
     preview_len: usize,
     parent: Option<usize>,
-    items: &mut Vec<JavaScriptItem>,
+    items: &mut Vec<FlatItem>,
 ) {
     let current_parent = if let Some(node) = javascript_node_from_ast(ast_node, source, preview_len)
     {
         let index = items.len();
-        items.push(JavaScriptItem { parent, node });
+        items.push(FlatItem { parent, node });
         Some(index)
     } else {
         parent

src/lib.rs

@@ -4,6 +4,7 @@ mod markdown;
 mod model;
 mod render;
 mod rust;
+mod tree;
 mod util;
 
 pub use analyzer::{analyze_file, analyze_source, detect_language};

src/markdown.rs

@@ -1,4 +1,8 @@
-use crate::{model::Node, util::truncate_preview};
+use crate::{
+    model::Node,
+    tree::{build_tree, FlatItem},
+    util::truncate_preview,
+};
 
 pub(crate) fn analyze_markdown(source: &str, preview_len: usize) -> Vec<Node> {
     let lines = source.lines().collect::<Vec<_>>();
@@ -124,7 +128,14 @@ pub(crate) fn analyze_markdown(source: &str, preview_len: usize) -> Vec<Node> {
         }
     }
 
-    build_markdown_tree(&items, None)
+    let flat: Vec<FlatItem> = items
+        .into_iter()
+        .map(|item| FlatItem {
+            parent: item.parent,
+            node: item.node,
+        })
+        .collect();
+    build_tree(&flat, None)
 }
 
 #[derive(Debug, Clone)]
@@ -134,19 +145,6 @@ struct MarkdownItem {
     node: Node,
 }
 
-fn build_markdown_tree(items: &[MarkdownItem], parent: Option<usize>) -> Vec<Node> {
-    items
-        .iter()
-        .enumerate()
-        .filter(|(_, item)| item.parent == parent)
-        .map(|(index, item)| {
-            let mut node = item.node.clone();
-            node.children = build_markdown_tree(items, Some(index));
-            node
-        })
-        .collect()
-}
-
 fn parse_heading(line: &str) -> Option<(usize, String)> {
     let trimmed = line.trim_start();
     let level = trimmed

src/rust.rs

@@ -1,4 +1,8 @@
-use crate::{model::Node, util::truncate_preview};
+use crate::{
+    model::Node,
+    tree::{build_tree, FlatItem},
+    util::truncate_preview,
+};
 use tree_sitter::{Node as AstNode, Parser};
 
 pub(crate) fn analyze_rust(source: &str, preview_len: usize) -> Vec<Node> {
@@ -10,7 +14,7 @@ pub(crate) fn analyze_rust(source: &str, preview_len: usize) -> Vec<Node> {
         return Vec::new();
     };
 
-    let mut items = Vec::<RustItem>::new();
+    let mut items = Vec::<FlatItem>::new();
     collect_rust_items(
         tree.root_node(),
         source,
@@ -19,26 +23,7 @@ pub(crate) fn analyze_rust(source: &str, preview_len: usize) -> Vec<Node> {
         false,
         &mut items,
     );
-    build_rust_tree(&items, None)
-}
-
-#[derive(Debug, Clone)]
-struct RustItem {
-    parent: Option<usize>,
-    node: Node,
-}
-
-fn build_rust_tree(items: &[RustItem], parent: Option<usize>) -> Vec<Node> {
-    items
-        .iter()
-        .enumerate()
-        .filter(|(_, item)| item.parent == parent)
-        .map(|(index, item)| {
-            let mut node = item.node.clone();
-            node.children = build_rust_tree(items, Some(index));
-            node
-        })
-        .collect()
+    build_tree(&items, None)
 }
 
 fn collect_rust_items(
@@ -47,12 +32,12 @@ fn collect_rust_items(
     preview_len: usize,
     parent: Option<usize>,
     has_test_attribute: bool,
-    items: &mut Vec<RustItem>,
+    items: &mut Vec<FlatItem>,
 ) {
     let current_parent =
         if let Some(node) = rust_node_from_ast(ast_node, source, preview_len, has_test_attribute) {
             let index = items.len();
-            items.push(RustItem { parent, node });
+            items.push(FlatItem { parent, node });
             Some(index)
         } else {
             parent

src/tree.rs

@@ -0,0 +1,29 @@
+use crate::model::Node;
+
+/// A flattened tree entry produced during AST or text collection.
+///
+/// `parent` stores the index into the flat `Vec` of the enclosing item
+/// (or `None` for a top-level item).  After collection, [`build_tree`]
+/// reconstructs the hierarchical `Vec<Node>` from the flat list.
+#[derive(Debug, Clone)]
+pub(crate) struct FlatItem {
+    pub parent: Option<usize>,
+    pub node: Node,
+}
+
+/// Reconstruct a hierarchical node tree from a flat list of [`FlatItem`]s.
+///
+/// Items whose `parent` matches the supplied index become children of the
+/// corresponding parent.  Called with `None` to obtain the top-level nodes.
+pub(crate) fn build_tree(items: &[FlatItem], parent: Option<usize>) -> Vec<Node> {
+    items
+        .iter()
+        .enumerate()
+        .filter(|(_, item)| item.parent == parent)
+        .map(|(index, item)| {
+            let mut node = item.node.clone();
+            node.children = build_tree(items, Some(index));
+            node
+        })
+        .collect()
+}