refactor: use Vec<OsString> as coloring map keys instead of PathBuf

Co-authored-by: KSXGitHub <11488886+KSXGitHub@users.noreply.github.com>

Author: Copilot

src/app/sub.rs

@@ -17,6 +17,7 @@ use pipe_trait::Pipe;
 use serde::Serialize;
 use std::{
     collections::HashMap,
+    ffi::OsString,
     io::stdout,
     iter::once,
     path::{Path, PathBuf},
@@ -199,7 +200,7 @@ where
 
         let coloring: Option<Coloring> = color.map(|ls_colors| {
             let mut map = HashMap::new();
-            build_coloring_map(&data_tree, PathBuf::new(), &mut map);
+            build_coloring_map(&data_tree, &mut Vec::new(), &mut map);
             Coloring::new(ls_colors, map)
         });
 
@@ -279,26 +280,29 @@ where
     }
 }
 
-/// Recursively walk a pruned [`DataTree`] and build a map of full paths to [`Color`] values.
+/// Recursively walk a pruned [`DataTree`] and build a map of path-component vectors to [`Color`] values.
 ///
-/// The `path` argument should be the current path prefix for reconstructing full filesystem paths.
+/// The `path_stack` argument is a reusable buffer of path components representing the current
+/// ancestor chain. Each recursive call pushes the node's name and pops it on return, so no
+/// cloning occurs during traversal — only at leaf insertions.
 /// Leaf nodes (files or childless directories after pruning) are added to the map.
 /// Nodes with children are skipped because the [`Visualizer`] uses the children count to
 /// determine their color at render time.
 fn build_coloring_map(
     node: &DataTree<OsStringDisplay, impl size::Size>,
-    path: PathBuf,
-    map: &mut HashMap<PathBuf, Color>,
+    path_stack: &mut Vec<OsString>,
+    map: &mut HashMap<Vec<OsString>, Color>,
 ) {
-    let node_path = path.join(node.name().as_os_str());
-    if !node.children().is_empty() {
+    path_stack.push(node.name().as_os_str().to_os_string());
+    if node.children().is_empty() {
+        let color = file_color(&path_stack.iter().collect::<PathBuf>());
+        map.insert(path_stack.clone(), color);
+    } else {
         for child in node.children() {
-            build_coloring_map(child, node_path.clone(), map);
+            build_coloring_map(child, path_stack, map);
         }
-        return;
     }
-    let color = file_color(&node_path);
-    map.insert(node_path, color);
+    path_stack.pop();
 }
 
 fn file_color(path: &Path) -> Color {

src/visualizer/coloring.rs

@@ -3,30 +3,34 @@ use crate::ls_colors::LsColors;
 use derive_more::Display;
 use std::{
     collections::HashMap,
+    ffi::OsString,
     fmt,
-    path::{Path, PathBuf},
 };
 use zero_copy_pads::Width;
 
 /// Coloring configuration: ANSI prefix strings from the environment and a full-path-to-color map.
 #[derive(Debug)]
 pub struct Coloring {
     ls_colors: LsColors,
-    map: HashMap<PathBuf, Color>,
+    map: HashMap<Vec<OsString>, Color>,
 }
 
 impl Coloring {
-    /// Create a new [`Coloring`] from LS_COLORS prefixes and a full-path-to-color map.
-    pub fn new(ls_colors: LsColors, map: HashMap<PathBuf, Color>) -> Self {
+    /// Create a new [`Coloring`] from LS_COLORS prefixes and a path-components-to-color map.
+    pub fn new(ls_colors: LsColors, map: HashMap<Vec<OsString>, Color>) -> Self {
         Coloring { ls_colors, map }
     }
 
     /// Return `(color, ls_colors)` for a node, used to build a colored slice for rendering.
-    pub(super) fn node_color(&self, path: &Path, has_children: bool) -> Option<(Color, &LsColors)> {
+    pub(super) fn node_color(
+        &self,
+        path_components: &[OsString],
+        has_children: bool,
+    ) -> Option<(Color, &LsColors)> {
         let color = if has_children {
             Some(Color::Directory)
         } else {
-            self.map.get(path).copied()
+            self.map.get(path_components).copied()
         }?;
         Some((color, &self.ls_colors))
     }

src/visualizer/methods.rs

@@ -14,7 +14,7 @@ use tree_table::*;
 
 use super::{coloring::ColoredTreeHorizontalSlice, ColumnWidthDistribution, Visualizer};
 use crate::size;
-use std::{cmp::min, ffi::OsStr, fmt::Display, path::PathBuf};
+use std::{cmp::min, ffi::{OsStr, OsString}, fmt::Display};
 use zero_copy_pads::{align_left, align_right};
 
 impl<'a, Name, Size> Visualizer<'a, Name, Size>
@@ -92,15 +92,15 @@ where
                 } = tree_row;
 
                 let colored = self.coloring.and_then(|coloring| {
-                    let path: PathBuf = initial_row
+                    let path_components: Vec<OsString> = initial_row
                         .ancestors
                         .iter()
-                        .map(|a| a.name.as_ref() as &OsStr)
+                        .map(|a| a.name.as_ref().to_os_string())
                         .chain(std::iter::once(
-                            initial_row.node_info.name.as_ref() as &OsStr
+                            initial_row.node_info.name.as_ref().to_os_string(),
                         ))
                         .collect();
-                    coloring.node_color(&path, initial_row.node_info.children_count > 0)
+                    coloring.node_color(&path_components, initial_row.node_info.children_count > 0)
                 });
 
                 let aligned_colored_slice;

tests/usual_cli.rs

@@ -27,7 +27,7 @@ use parallel_disk_usage::{
     visualizer::{Color, Coloring},
 };
 #[cfg(unix)]
-use std::{collections::HashMap, path::PathBuf};
+use std::{collections::HashMap, ffi::OsString};
 
 #[cfg(unix)]
 use parallel_disk_usage::get_size::{GetBlockCount, GetBlockSize};
@@ -932,15 +932,59 @@ fn color_always() {
 
     let ls_colors = LsColors::from_ls_colors_string(LS_COLORS);
     let map = HashMap::from([
-        (PathBuf::from("./dir-a/file-a1.txt"), Color::Normal),
-        (PathBuf::from("./dir-a/file-a2.txt"), Color::Normal),
-        (PathBuf::from("./dir-a/subdir-a/file-a3.txt"), Color::Normal),
-        (PathBuf::from("./dir-b/file-b1.txt"), Color::Normal),
-        (PathBuf::from("./file-root.txt"), Color::Normal),
-        (PathBuf::from("./link-dir"), Color::Symlink),
-        (PathBuf::from("./link-file.txt"), Color::Symlink),
-        (PathBuf::from("./empty-dir-1"), Color::Directory),
-        (PathBuf::from("./empty-dir-2"), Color::Directory),
+        (
+            vec![
+                OsString::from("."),
+                OsString::from("dir-a"),
+                OsString::from("file-a1.txt"),
+            ],
+            Color::Normal,
+        ),
+        (
+            vec![
+                OsString::from("."),
+                OsString::from("dir-a"),
+                OsString::from("file-a2.txt"),
+            ],
+            Color::Normal,
+        ),
+        (
+            vec![
+                OsString::from("."),
+                OsString::from("dir-a"),
+                OsString::from("subdir-a"),
+                OsString::from("file-a3.txt"),
+            ],
+            Color::Normal,
+        ),
+        (
+            vec![
+                OsString::from("."),
+                OsString::from("dir-b"),
+                OsString::from("file-b1.txt"),
+            ],
+            Color::Normal,
+        ),
+        (
+            vec![OsString::from("."), OsString::from("file-root.txt")],
+            Color::Normal,
+        ),
+        (
+            vec![OsString::from("."), OsString::from("link-dir")],
+            Color::Symlink,
+        ),
+        (
+            vec![OsString::from("."), OsString::from("link-file.txt")],
+            Color::Symlink,
+        ),
+        (
+            vec![OsString::from("."), OsString::from("empty-dir-1")],
+            Color::Directory,
+        ),
+        (
+            vec![OsString::from("."), OsString::from("empty-dir-2")],
+            Color::Directory,
+        ),
     ]);
     let coloring = Coloring::new(ls_colors, map);