refactor: consolidate AnsiPrefixes at crate root; Coloring struct; ColoredTreeHorizontalSlice

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

Author: Copilot

Cargo.lock

@@ -84,3 +84,4 @@ maplit = "1.0.2"
 normalize-path = "0.2.1"
 pretty_assertions = "1.4.1"
 rand = "0.10.0"
+strip-ansi-escapes = "0.2.1"

Cargo.toml

@@ -0,0 +1,29 @@
+use lscolors::{Indicator, LsColors};
+
+/// ANSI prefix strings for each color variant, read from `LS_COLORS`.
+#[derive(Debug, Clone)]
+pub struct AnsiPrefixes {
+    pub(crate) directory: String,
+    pub(crate) normal: String,
+    pub(crate) executable: String,
+    pub(crate) symlink: String,
+}
+
+impl AnsiPrefixes {
+    /// Initialize by reading the current environment's `LS_COLORS`.
+    pub fn from_env() -> Self {
+        let ls_colors = LsColors::from_env().unwrap_or_default();
+        let prefix_for = |indicator: Indicator| {
+            ls_colors
+                .style_for_indicator(indicator)
+                .map(|s| s.to_nu_ansi_term_style().prefix().to_string())
+                .unwrap_or_default()
+        };
+        AnsiPrefixes {
+            directory: prefix_for(Indicator::Directory),
+            normal: prefix_for(Indicator::RegularFile),
+            executable: prefix_for(Indicator::ExecutableFile),
+            symlink: prefix_for(Indicator::SymbolicLink),
+        }
+    }
+}

src/ansi_prefixes.rs

@@ -12,6 +12,7 @@ use crate::{
     runtime_error::RuntimeError,
     size,
     visualizer::{BarAlignment, ColumnWidthDistribution, Direction, Visualizer},
+    AnsiPrefixes,
 };
 use clap::Parser;
 use hdd::any_path_is_in_hdd;
@@ -27,13 +28,16 @@ use crate::get_size::{GetBlockCount, GetBlockSize};
 pub struct App {
     /// The CLI arguments.
     args: Args,
+    /// ANSI prefix strings read from `LS_COLORS`.
+    ansi_prefixes: AnsiPrefixes,
 }
 
 impl App {
     /// Initialize the application from the environment.
     pub fn from_env() -> Self {
         App {
             args: Args::parse(),
+            ansi_prefixes: AnsiPrefixes::from_env(),
         }
     }
 
@@ -46,6 +50,8 @@ impl App {
         //
         // The other operations which are invoked frequently should not utilize dynamic dispatch.
 
+        // Extract `ansi_prefixes` by move before `match self.args` consumes the rest of `self`.
+        let ansi_prefixes = self.ansi_prefixes;
         let column_width_distribution = self.args.column_width_distribution();
 
         if self.args.json_input {
@@ -310,6 +316,7 @@ impl App {
                     min_ratio,
                     no_sort,
                     color,
+                    ansi_prefixes,
                 }
                 .run(),
             )*} };

src/app.rs

@@ -10,7 +10,8 @@ use crate::{
     runtime_error::RuntimeError,
     size,
     status_board::GLOBAL_STATUS_BOARD,
-    visualizer::{BarAlignment, Color, ColumnWidthDistribution, Direction, Visualizer},
+    visualizer::{BarAlignment, Color, Coloring, ColumnWidthDistribution, Direction, Visualizer},
+    AnsiPrefixes,
 };
 use pipe_trait::Pipe;
 use serde::Serialize;
@@ -56,6 +57,8 @@ where
     pub no_sort: bool,
     /// When to use colors in the output.
     pub color: ColorWhen,
+    /// ANSI prefix strings read from `LS_COLORS`.
+    pub ansi_prefixes: AnsiPrefixes,
 }
 
 impl<Size, SizeGetter, HardlinksHandler, Report> Sub<Size, SizeGetter, HardlinksHandler, Report>
@@ -82,6 +85,7 @@ where
             min_ratio,
             no_sort,
             color,
+            ansi_prefixes,
         } = self;
 
         let max_depth = max_depth.get();
@@ -106,6 +110,7 @@ where
                 files: vec![".".into()],
                 hardlinks_handler,
                 reporter,
+                ansi_prefixes,
                 ..self
             }
             .run();
@@ -201,10 +206,10 @@ where
             ColorWhen::Auto => stdout().is_terminal(),
         };
 
-        let coloring: Option<HashMap<OsStringDisplay, Color>> = if use_color {
+        let coloring: Option<Coloring<OsStringDisplay>> = if use_color {
             let mut map = HashMap::new();
             build_coloring_map(&data_tree, PathBuf::new(), &mut map);
-            Some(map)
+            Some(Coloring::new(ansi_prefixes, map))
         } else {
             None
         };

src/app/sub.rs

@@ -36,6 +36,7 @@ pub use clap_complete;
 #[cfg(feature = "cli")]
 pub use clap_utilities;
 
+pub mod ansi_prefixes;
 pub mod bytes_format;
 pub mod data_tree;
 pub mod fs_tree_builder;
@@ -50,4 +51,6 @@ pub mod status_board;
 pub mod tree_builder;
 pub mod visualizer;
 
+pub use ansi_prefixes::AnsiPrefixes;
+
 pub use zero_copy_pads;

src/lib.rs

@@ -9,15 +9,15 @@ pub mod tree;
 
 pub use bar_alignment::BarAlignment;
 pub use child_position::ChildPosition;
-pub use coloring::Color;
+pub use coloring::{AnsiPrefix, Color, Coloring};
 pub use column_width_distribution::ColumnWidthDistribution;
 pub use direction::Direction;
 pub use parenthood::Parenthood;
 pub use proportion_bar::{ProportionBar, ProportionBarBlock};
 pub use tree::{TreeHorizontalSlice, TreeSkeletalComponent};
 
 use super::{data_tree::DataTree, size};
-use std::{collections::HashMap, fmt::Display};
+use std::fmt::Display;
 
 /// Visualize a [`DataTree`].
 ///
@@ -62,7 +62,7 @@ where
     /// Distribution and total number of characters/blocks can be placed in a line.
     pub column_width_distribution: ColumnWidthDistribution,
     /// Mapping of names to colors for colorful output.
-    pub coloring: Option<&'a HashMap<Name, Color>>,
+    pub coloring: Option<&'a Coloring<Name>>,
 }
 
 mod copy;

src/visualizer.rs

@@ -1,3 +1,6 @@
+use crate::AnsiPrefixes;
+use std::{collections::HashMap, fmt, hash::Hash};
+
 /// The coloring to apply to a node name.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum Color {
@@ -10,3 +13,51 @@ pub enum Color {
     /// Color as a symbolic link.
     Symlink,
 }
+
+impl Color {
+    /// Get the ANSI prefix for this color from the given prefix table.
+    pub fn ansi_prefix(self, prefixes: &AnsiPrefixes) -> AnsiPrefix<'_> {
+        AnsiPrefix(match self {
+            Color::Directory => &prefixes.directory,
+            Color::Normal => &prefixes.normal,
+            Color::Executable => &prefixes.executable,
+            Color::Symlink => &prefixes.symlink,
+        })
+    }
+}
+
+/// ANSI prefix wrapper for a [`Color`] variant, implements [`fmt::Display`].
+pub struct AnsiPrefix<'a>(pub(crate) &'a str);
+
+impl fmt::Display for AnsiPrefix<'_> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str(self.0)
+    }
+}
+
+impl AnsiPrefix<'_> {
+    /// Returns the reset suffix to emit after this prefix, or `""` if no prefix.
+    pub fn suffix(&self) -> &'static str {
+        if self.0.is_empty() {
+            ""
+        } else {
+            "\x1b[0m"
+        }
+    }
+}
+
+/// Coloring configuration: ANSI prefix strings from the environment and a name-to-color map.
+#[derive(Debug)]
+pub struct Coloring<Name> {
+    /// ANSI prefix strings read from `LS_COLORS`.
+    pub(crate) ansi_prefixes: AnsiPrefixes,
+    /// Map from node name to color.
+    pub(crate) map: HashMap<Name, Color>,
+}
+
+impl<Name: Hash + Eq> Coloring<Name> {
+    /// Create a new [`Coloring`] from ANSI prefixes and a name-to-color map.
+    pub fn new(ansi_prefixes: AnsiPrefixes, map: HashMap<Name, Color>) -> Self {
+        Coloring { ansi_prefixes, map }
+    }
+}

src/visualizer/coloring.rs

@@ -13,74 +13,41 @@ use table::*;
 use tree_table::*;
 
 use super::{ChildPosition, Color, ColumnWidthDistribution, TreeHorizontalSlice, Visualizer};
-use crate::size;
-use lscolors::{Indicator, LsColors};
+use crate::{size, AnsiPrefixes};
 use std::{
     cmp::min,
     fmt::{self, Display},
     hash::Hash,
-    sync::LazyLock,
 };
 use zero_copy_pads::{align_left, align_right, Width};
 
-struct AnsiPrefixes {
-    directory: String,
-    normal: String,
-    executable: String,
-    symlink: String,
-}
-
-static ANSI_PREFIXES: LazyLock<AnsiPrefixes> = LazyLock::new(|| {
-    let ls_colors = LsColors::from_env().unwrap_or_default();
-    let compute = |indicator: Indicator| {
-        ls_colors
-            .style_for_indicator(indicator)
-            .map(|s| s.to_nu_ansi_term_style().prefix().to_string())
-            .unwrap_or_default()
-    };
-    AnsiPrefixes {
-        directory: compute(Indicator::Directory),
-        normal: compute(Indicator::RegularFile),
-        executable: compute(Indicator::ExecutableFile),
-        symlink: compute(Indicator::SymbolicLink),
-    }
-});
-
-fn color_ansi_prefix(color: Color) -> &'static str {
-    match color {
-        Color::Directory => &ANSI_PREFIXES.directory,
-        Color::Normal => &ANSI_PREFIXES.normal,
-        Color::Executable => &ANSI_PREFIXES.executable,
-        Color::Symlink => &ANSI_PREFIXES.symlink,
-    }
-}
-
-struct ColoredSlice<'a> {
-    slice: &'a TreeHorizontalSlice<String>,
+struct ColoredTreeHorizontalSlice<'a> {
+    slice: TreeHorizontalSlice<String>,
     color: Color,
+    ansi_prefixes: &'a AnsiPrefixes,
 }
 
-impl fmt::Display for ColoredSlice<'_> {
+impl fmt::Display for ColoredTreeHorizontalSlice<'_> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let TreeHorizontalSlice {
             ancestor_relative_positions,
             skeletal_component,
             name,
-        } = self.slice;
+        } = &self.slice;
         for pos in ancestor_relative_positions {
             let connector = match pos {
                 ChildPosition::Init => "│ ",
                 ChildPosition::Last => "  ",
             };
             write!(f, "{connector}")?;
         }
-        let prefix = color_ansi_prefix(self.color);
-        let suffix = if prefix.is_empty() { "" } else { "\x1b[0m" };
+        let prefix = self.color.ansi_prefix(self.ansi_prefixes);
+        let suffix = prefix.suffix();
         write!(f, "{skeletal_component}{prefix}{name}{suffix}")
     }
 }
 
-impl Width for ColoredSlice<'_> {
+impl Width for ColoredTreeHorizontalSlice<'_> {
     fn width(&self) -> usize {
         self.slice.width()
     }
@@ -151,25 +118,38 @@ where
         bar_table
             .into_iter()
             .map(|row| {
-                let BarRow { tree_row, proportion_bar } = row;
-                let TreeRow { initial_row, tree_horizontal_slice: slice } = tree_row;
-
-                let node_color = self.coloring.and_then(|coloring| {
-                    if initial_row.node_info.children_count > 0 {
+                let BarRow {
+                    tree_row,
+                    proportion_bar,
+                } = row;
+                let TreeRow {
+                    initial_row,
+                    tree_horizontal_slice,
+                } = tree_row;
+
+                let colored = self.coloring.and_then(|coloring| {
+                    let color = if initial_row.node_info.children_count > 0 {
                         Some(Color::Directory)
                     } else {
-                        coloring.get(initial_row.node_info.name).copied()
-                    }
+                        coloring.map.get(initial_row.node_info.name).copied()
+                    }?;
+                    Some((color, &coloring.ansi_prefixes))
                 });
 
                 let aligned_colored_slice;
                 let aligned_plain_slice;
-                let tree = if let Some(color) = node_color {
-                    aligned_colored_slice =
-                        align_left(ColoredSlice { slice: &slice, color }, tree_width);
+                let tree = if let Some((color, ansi_prefixes)) = colored {
+                    aligned_colored_slice = align_left(
+                        ColoredTreeHorizontalSlice {
+                            slice: tree_horizontal_slice,
+                            color,
+                            ansi_prefixes,
+                        },
+                        tree_width,
+                    );
                     format_args!("{aligned_colored_slice}")
                 } else {
-                    aligned_plain_slice = align_left(&slice, tree_width);
+                    aligned_plain_slice = align_left(&tree_horizontal_slice, tree_width);
                     format_args!("{aligned_plain_slice}")
                 };