Merge 654df00 into 7d8d39b

Author: Copilot

src/app/sub.rs

@@ -200,7 +200,12 @@ where
 
         let coloring: Option<Coloring> = color.map(|ls_colors| {
             let mut map = HashMap::new();
-            build_coloring_map(&data_tree, &mut Vec::new(), &mut map);
+            // In the multi-arg case the root is the virtual "(total)" node, which does not
+            // correspond to a real filesystem path.  Pass `fs_path_skip = 1` so that
+            // `file_color` receives the actual relative path (e.g. "dir-a/file.txt") rather
+            // than the fake one ("(total)/dir-a/file.txt").
+            let fs_path_skip = usize::from(!only_one_arg);
+            build_coloring_map(&data_tree, &mut Vec::new(), fs_path_skip, &mut map);
             Coloring::new(ls_colors, map)
         });
 
@@ -288,18 +293,25 @@ where
 /// 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.
+///
+/// `fs_path_skip` controls how many leading components of `path_stack` to skip when building
+/// the filesystem path passed to [`file_color`].  This is set to `1` in the multi-argument case
+/// so that the virtual `(total)` root component is excluded from the path used for filesystem
+/// queries, while still being included in the map key (which must match what
+/// [`maybe_colored_slice`](crate::visualizer::coloring::maybe_colored_slice) constructs).
 fn build_coloring_map<'a>(
     node: &'a DataTree<OsStringDisplay, impl size::Size>,
     path_stack: &mut Vec<&'a OsStr>,
+    fs_path_skip: usize,
     map: &mut HashMap<Vec<&'a OsStr>, Color>,
 ) {
     path_stack.push(node.name().as_os_str());
     if node.children().is_empty() {
-        let color = file_color(&path_stack.iter().collect::<PathBuf>());
+        let color = file_color(&path_stack[fs_path_skip..].iter().collect::<PathBuf>());
         map.insert(path_stack.clone(), color);
     } else {
         for child in node.children() {
-            build_coloring_map(child, path_stack, map);
+            build_coloring_map(child, path_stack, fs_path_skip, map);
         }
     }
     path_stack.pop();

tests/usual_cli.rs

@@ -880,6 +880,81 @@ fn color_always() {
     assert_eq!(actual, expected);
 }
 
+#[cfg(unix)]
+#[test]
+fn color_always_multiple_args() {
+    let workspace = SampleWorkspace::simple_tree_with_diverse_kinds();
+
+    let actual = Command::new(PDU)
+        .with_current_dir(&workspace)
+        .with_arg("--color=always")
+        .with_arg("--quantity=apparent-size")
+        .with_arg("--total-width=100")
+        .with_arg("--min-ratio=0")
+        .with_arg("dir-a")
+        .with_arg("link-dir")
+        .with_env("LS_COLORS", LS_COLORS)
+        .pipe(stdio)
+        .output()
+        .expect("spawn command with --color=always and multiple args")
+        .pipe(stdout_text);
+    eprintln!("ACTUAL:\n{actual}\n");
+
+    let data_tree = ["dir-a", "link-dir"]
+        .iter()
+        .map(|name| {
+            let builder = FsTreeBuilder {
+                root: workspace.to_path_buf().join(name),
+                size_getter: GetApparentSize,
+                hardlinks_recorder: &HardlinkIgnorant,
+                reporter: &ErrorOnlyReporter::new(ErrorReport::SILENT),
+                max_depth: 10,
+            };
+            let mut data_tree: DataTree<OsStringDisplay, _> = builder.into();
+            *data_tree.name_mut() = OsStringDisplay::os_string_from(name);
+            data_tree
+        })
+        .pipe(|children| {
+            DataTree::dir(
+                OsStringDisplay::os_string_from("(total)"),
+                0u64.into(),
+                children.collect(),
+            )
+        })
+        .into_par_sorted(|left, right| left.size().cmp(&right.size()).reverse());
+
+    let ls_colors = LsColors::from_str(LS_COLORS);
+    let leaf_colors = [
+        ("(total)/dir-a/file-a1.txt", Color::Normal),
+        ("(total)/dir-a/file-a2.txt", Color::Normal),
+        ("(total)/dir-a/subdir-a/file-a3.txt", Color::Normal),
+        ("(total)/link-dir", Color::Symlink),
+    ];
+    let leaf_colors = HashMap::from(leaf_colors.map(|(path, color)| {
+        (
+            path.split('/')
+                .map(AsRef::<OsStr>::as_ref)
+                .collect::<Vec<_>>(),
+            color,
+        )
+    }));
+    let coloring = Coloring::new(ls_colors, leaf_colors);
+
+    let visualizer = Visualizer::<OsStringDisplay, _> {
+        data_tree: &data_tree,
+        bytes_format: BytesFormat::MetricUnits,
+        direction: Direction::BottomUp,
+        bar_alignment: BarAlignment::Left,
+        column_width_distribution: ColumnWidthDistribution::total(100),
+        coloring: Some(&coloring),
+    };
+    let expected = format!("{visualizer}");
+    let expected = expected.trim_end();
+    eprintln!("EXPECTED:\n{expected}\n");
+
+    assert_eq!(actual, expected);
+}
+
 #[test]
 fn colorful_equals_colorless() {
     let workspace = SampleWorkspace::default();