From 6c7c238bb2276d4690c44f5582bd06103fc764cc Mon Sep 17 00:00:00 2001
From: Tavian Barnes <tavianator@tavianator.com>
Date: Thu, 16 Sep 2021 15:20:12 -0400
Subject: [PATCH] Don't color each path component separately

It can be expensive to color each path component separately, requiring a
stat() call on each component.  For deep hierarchies this can result in
quadratic overhead.  Instead, just color the path up to the basename as
a directory.

Fixes #720.
---
 src/output.rs | 56 ++++++++++++++++++++++++++++++++++-----------------
 1 file changed, 38 insertions(+), 18 deletions(-)

diff --git a/src/output.rs b/src/output.rs
index 471b8fb9d..2a97e8d92 100644
--- a/src/output.rs
+++ b/src/output.rs
@@ -1,10 +1,11 @@
+use std::borrow::Cow;
 use std::io::{self, StdoutLock, Write};
 use std::path::Path;
 use std::process;
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::Arc;
 
-use lscolors::{LsColors, Style};
+use lscolors::{Indicator, LsColors, Style};
 
 use crate::error::print_error;
 use crate::exit_codes::ExitCode;
@@ -53,32 +54,51 @@ fn print_entry_colorized(
     ls_colors: &LsColors,
     wants_to_quit: &Arc<AtomicBool>,
 ) -> io::Result<()> {
-    let default_style = ansi_term::Style::default();
-
-    // Traverse the path and colorize each component
-    for (component, style) in ls_colors.style_for_path_components(path) {
-        let style = style
-            .map(Style::to_ansi_term_style)
-            .unwrap_or(default_style);
+    // Split the path between the parent and the last component
+    let mut offset = 0;
+    let path_str = path.to_string_lossy();
+
+    if let Some(parent) = path.parent() {
+        offset = parent.to_string_lossy().len();
+        for c in path_str[offset..].chars() {
+            if std::path::is_separator(c) {
+                offset += c.len_utf8();
+            } else {
+                break;
+            }
+        }
+    }
 
-        let mut path_string = component.to_string_lossy();
+    if offset > 0 {
+        let mut parent_str = Cow::from(&path_str[..offset]);
         if let Some(ref separator) = config.path_separator {
-            *path_string.to_mut() = replace_path_separator(&path_string, separator);
+            *parent_str.to_mut() = replace_path_separator(&parent_str, separator);
         }
-        write!(stdout, "{}", style.paint(path_string))?;
 
-        // TODO: can we move this out of the if-statement? Why do we call it that often?
-        if wants_to_quit.load(Ordering::Relaxed) {
-            writeln!(stdout)?;
-            process::exit(ExitCode::KilledBySigint.into());
-        }
+        let style = ls_colors
+            .style_for_indicator(Indicator::Directory)
+            .map(Style::to_ansi_term_style)
+            .unwrap_or_default();
+        write!(stdout, "{}", style.paint(parent_str))?;
     }
 
+    let style = ls_colors
+        .style_for_path(path)
+        .map(Style::to_ansi_term_style)
+        .unwrap_or_default();
+    write!(stdout, "{}", style.paint(&path_str[offset..]))?;
+
     if config.null_separator {
-        write!(stdout, "\0")
+        write!(stdout, "\0")?;
     } else {
-        writeln!(stdout)
+        writeln!(stdout)?;
     }
+
+    if wants_to_quit.load(Ordering::Relaxed) {
+        process::exit(ExitCode::KilledBySigint.into());
+    }
+
+    Ok(())
 }
 
 // TODO: this function is performance critical and can probably be optimized