refactor(r7): rename AnsiPrefixes→LsColors, private fields, restructure coloring, move color logic to App::run

Copilot · KSXGitHub · Copilot · commit ab5cc0a723aa · 2026-03-07T14:20:29.000Z
Co-authored-by: KSXGitHub &lt;11488886+KSXGitHub@users.noreply.github.com&gt;
diff --git a/src/app.rs b/src/app.rs
@@ -3,21 +3,24 @@ pub mod sub;
 pub use sub::Sub;
 
 use crate::{
-    args::{Args, Quantity, Threads},
+    args::{Args, ColorWhen, Quantity, Threads},
     bytes_format::BytesFormat,
     get_size::{GetApparentSize, GetSize},
     hardlink,
     json_data::{JsonData, JsonDataBody, JsonShared, JsonTree},
+    ls_colors::LsColors,
     reporter::{ErrorOnlyReporter, ErrorReport, ProgressAndErrorReporter, ProgressReport},
     runtime_error::RuntimeError,
     size,
     visualizer::{BarAlignment, ColumnWidthDistribution, Direction, Visualizer},
-    AnsiPrefixes,
 };
 use clap::Parser;
 use hdd::any_path_is_in_hdd;
 use pipe_trait::Pipe;
-use std::{io::stdin, time::Duration};
+use std::{
+    io::{stdin, stdout, IsTerminal},
+    time::Duration,
+};
 use sub::JsonOutputParam;
 use sysinfo::Disks;
 
@@ -28,16 +31,13 @@ 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(),
         }
     }
 
@@ -50,8 +50,6 @@ 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 {
@@ -315,8 +313,11 @@ impl App {
                     max_depth,
                     min_ratio,
                     no_sort,
-                    color,
-                    ansi_prefixes,
+                    color: match color {
+                        ColorWhen::Always => Some(LsColors::from_env()),
+                        ColorWhen::Never => None,
+                        ColorWhen::Auto => stdout().is_terminal().then(LsColors::from_env),
+                    },
                 }
                 .run(),
             )*} };
diff --git a/src/app/sub.rs b/src/app/sub.rs
@@ -1,23 +1,23 @@
 use crate::{
-    args::{ColorWhen, Depth, Fraction},
+    args::{Depth, Fraction},
     data_tree::DataTree,
     fs_tree_builder::FsTreeBuilder,
     get_size::GetSize,
     hardlink::{DeduplicateSharedSize, HardlinkIgnorant, RecordHardlinks},
     json_data::{BinaryVersion, JsonData, JsonDataBody, JsonShared, JsonTree, SchemaVersion},
+    ls_colors::LsColors,
     os_string_display::OsStringDisplay,
     reporter::ParallelReporter,
     runtime_error::RuntimeError,
     size,
     status_board::GLOBAL_STATUS_BOARD,
     visualizer::{BarAlignment, Color, Coloring, ColumnWidthDistribution, Direction, Visualizer},
-    AnsiPrefixes,
 };
 use pipe_trait::Pipe;
 use serde::Serialize;
 use std::{
     collections::HashMap,
-    io::{stdout, IsTerminal},
+    io::stdout,
     iter::once,
     path::{Path, PathBuf},
 };
@@ -55,10 +55,8 @@ where
     pub min_ratio: Fraction,
     /// Preserve order of entries.
     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,
+    /// Whether to color the output.
+    pub color: Option<LsColors>,
 }
 
 impl<Size, SizeGetter, HardlinksHandler, Report> Sub<Size, SizeGetter, HardlinksHandler, Report>
@@ -85,7 +83,6 @@ where
             min_ratio,
             no_sort,
             color,
-            ansi_prefixes,
         } = self;
 
         let max_depth = max_depth.get();
@@ -110,7 +107,7 @@ where
                 files: vec![".".into()],
                 hardlinks_handler,
                 reporter,
-                ansi_prefixes,
+                color,
                 ..self
             }
             .run();
@@ -200,19 +197,11 @@ where
                 .or(deduplication_result);
         }
 
-        let use_color = match color {
-            ColorWhen::Always => true,
-            ColorWhen::Never => false,
-            ColorWhen::Auto => stdout().is_terminal(),
-        };
-
-        let coloring: Option<Coloring<OsStringDisplay>> = if use_color {
+        let coloring: Option<Coloring<OsStringDisplay>> = color.map(|ls_colors| {
             let mut map = HashMap::new();
             build_coloring_map(&data_tree, PathBuf::new(), &mut map);
-            Some(Coloring::new(ansi_prefixes, map))
-        } else {
-            None
-        };
+            Coloring::new(ls_colors, map)
+        });
 
         let visualizer = Visualizer {
             data_tree: &data_tree,
@@ -302,13 +291,13 @@ fn build_coloring_map(
     map: &mut HashMap<OsStringDisplay, Color>,
 ) {
     let node_path = path.join(node.name().as_os_str());
-    if node.children().is_empty() {
-        map.insert(node.name().clone(), file_color(&node_path));
-    } else {
+    if !node.children().is_empty() {
         for child in node.children() {
             build_coloring_map(child, node_path.clone(), map);
         }
+        return;
     }
+    map.insert(node.name().clone(), file_color(&node_path));
 }
 
 fn file_color(path: &Path) -> Color {
@@ -327,7 +316,7 @@ fn file_color(path: &Path) -> Color {
 fn is_executable(path: &Path) -> bool {
     use std::os::unix::fs::PermissionsExt;
     path.metadata()
-        .map(|m| m.permissions().mode() & 0o111 != 0)
+        .map(|stats| stats.permissions().mode() & 0o111 != 0)
         .unwrap_or(false)
 }
 
diff --git a/src/lib.rs b/src/lib.rs
@@ -36,21 +36,19 @@ 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;
 pub mod get_size;
 pub mod hardlink;
 pub mod inode;
 pub mod json_data;
+pub mod ls_colors;
 pub mod os_string_display;
 pub mod reporter;
 pub mod size;
 pub mod status_board;
 pub mod tree_builder;
 pub mod visualizer;
 
-pub use ansi_prefixes::AnsiPrefixes;
-
 pub use zero_copy_pads;
diff --git a/src/ls_colors.rs b/src/ls_colors.rs
@@ -0,0 +1,41 @@
+use crate::visualizer::coloring::Color;
+use lscolors::{Indicator, LsColors as LsColorsCrate};
+
+/// ANSI color prefix strings for terminal output, initialized from the `LS_COLORS` environment
+/// variable.
+#[derive(Debug, Clone)]
+pub struct LsColors {
+    directory: String,
+    normal: String,
+    executable: String,
+    symlink: String,
+}
+
+impl LsColors {
+    /// Initialize by reading the current environment's `LS_COLORS`.
+    pub fn from_env() -> Self {
+        let ls_colors = LsColorsCrate::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()
+        };
+        LsColors {
+            directory: prefix_for(Indicator::Directory),
+            normal: prefix_for(Indicator::RegularFile),
+            executable: prefix_for(Indicator::ExecutableFile),
+            symlink: prefix_for(Indicator::SymbolicLink),
+        }
+    }
+
+    /// Return the ANSI prefix string for the given [`Color`] variant.
+    pub(crate) fn prefix_str(&self, color: Color) -> &str {
+        match color {
+            Color::Directory => &self.directory,
+            Color::Normal => &self.normal,
+            Color::Executable => &self.executable,
+            Color::Symlink => &self.symlink,
+        }
+    }
+}
diff --git a/src/visualizer/coloring.rs b/src/visualizer/coloring.rs
@@ -1,5 +1,32 @@
-use crate::AnsiPrefixes;
+use super::{ChildPosition, TreeHorizontalSlice};
+use crate::ls_colors::LsColors;
+use derive_more::Display;
 use std::{collections::HashMap, fmt, hash::Hash};
+use zero_copy_pads::Width;
+
+/// Coloring configuration: ANSI prefix strings from the environment and a name-to-color map.
+#[derive(Debug)]
+pub struct Coloring<Name> {
+    ansi_prefixes: LsColors,
+    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: LsColors, map: HashMap<Name, Color>) -> Self {
+        Coloring { ansi_prefixes, map }
+    }
+
+    /// Return `(color, prefixes)` for a node, used to build a colored slice for rendering.
+    pub(crate) fn node_color(&self, name: &Name, has_children: bool) -> Option<(Color, &LsColors)> {
+        let color = if has_children {
+            Some(Color::Directory)
+        } else {
+            self.map.get(name).copied()
+        }?;
+        Some((color, &self.ansi_prefixes))
+    }
+}
 
 /// The coloring to apply to a node name.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -16,24 +43,14 @@ pub enum Color {
 
 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,
-        })
+    pub fn ansi_prefix(self, prefixes: &LsColors) -> AnsiPrefix<'_> {
+        AnsiPrefix(prefixes.prefix_str(self))
     }
 }
 
-/// 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)
-    }
-}
+/// ANSI prefix wrapper for a [`Color`] variant, implements [`Display`].
+#[derive(Display)]
+pub struct AnsiPrefix<'a>(&'a str);
 
 impl AnsiPrefix<'_> {
     /// Returns the reset suffix to emit after this prefix, or `""` if no prefix.
@@ -46,18 +63,35 @@ impl AnsiPrefix<'_> {
     }
 }
 
-/// 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>,
+/// A [`TreeHorizontalSlice`] with its color applied, used for rendering.
+pub(crate) struct ColoredTreeHorizontalSlice<'a> {
+    pub(crate) slice: TreeHorizontalSlice<String>,
+    pub(crate) color: Color,
+    pub(crate) ansi_prefixes: &'a LsColors,
 }
 
-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 }
+impl fmt::Display for ColoredTreeHorizontalSlice<'_> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let TreeHorizontalSlice {
+            ancestor_relative_positions,
+            skeletal_component,
+            name,
+        } = &self.slice;
+        for pos in ancestor_relative_positions {
+            let connector = match pos {
+                ChildPosition::Init => "│ ",
+                ChildPosition::Last => "  ",
+            };
+            write!(f, "{connector}")?;
+        }
+        let prefix = self.color.ansi_prefix(self.ansi_prefixes);
+        let suffix = prefix.suffix();
+        write!(f, "{skeletal_component}{prefix}{name}{suffix}")
+    }
+}
+
+impl Width for ColoredTreeHorizontalSlice<'_> {
+    fn width(&self) -> usize {
+        self.slice.width()
     }
 }
diff --git a/src/visualizer/methods.rs b/src/visualizer/methods.rs
diff --git a/tests/usual_cli.rs b/tests/usual_cli.rs
