1use std::fs;
8use std::io::{self, Write};
9use std::path::Path;
10
11use ignore::gitignore::{Gitignore, GitignoreBuilder};
12use serde::Serialize;
13
14#[derive(Debug, Clone)]
16pub struct Options {
17 pub show_hidden: bool,
18 pub max_depth: Option<usize>,
19 pub json: bool,
22 pub format: Format,
23 pub show_size: bool,
24 pub human_readable: bool,
25 pub color: bool,
26 pub git_ignore: bool,
27 pub dirs_only: bool,
28 pub sort_by: SortField,
29 pub prune: bool,
30 pub show_icons: bool,
31 pub show_total_size: bool,
32}
33
34impl Options {
35 pub fn effective_format(&self) -> Format {
37 if self.json {
38 Format::Json
39 } else {
40 self.format
41 }
42 }
43}
44
45impl Default for Options {
46 fn default() -> Self {
47 let color = std::io::IsTerminal::is_terminal(&std::io::stdout())
48 && std::env::var("NO_COLOR").is_err();
49 Self {
50 show_hidden: false,
51 max_depth: None,
52 json: false,
53 format: Format::default(),
54 show_size: false,
55 human_readable: false,
56 color,
57 git_ignore: false,
58 dirs_only: false,
59 sort_by: SortField::Name,
60 prune: false,
61 show_icons: false,
62 show_total_size: false,
63 }
64 }
65}
66
67#[derive(Debug, Default, Clone, Copy, PartialEq, Eq)]
68pub enum SortField {
69 #[default]
70 Name,
71 Size,
72 Time,
73}
74
75#[derive(Debug, Default, Clone, Copy, PartialEq, Eq)]
80pub enum Format {
81 #[default]
82 Tree,
83 Flat,
84 Json,
85}
86
87#[derive(Debug, Default, Clone, Copy, PartialEq, Eq)]
88pub struct TreeStats {
89 pub directories: u64,
90 pub files: u64,
91}
92
93#[derive(Debug, Serialize)]
94pub struct TreeNode {
95 name: String,
96 #[serde(skip_serializing_if = "Option::is_none")]
97 size: Option<u64>,
98 #[serde(rename = "type")]
99 entry_type: String,
100 #[serde(skip_serializing_if = "Option::is_none")]
101 target: Option<String>,
102 #[serde(skip_serializing_if = "Vec::is_empty")]
103 children: Vec<TreeNode>,
104}
105
106pub fn generate(root: &Path, out: &mut impl Write, opts: &Options) -> io::Result<TreeStats> {
109 match opts.effective_format() {
110 Format::Tree => generate_with_formatter(root, out, opts, &TreeFormatter),
111 Format::Flat => generate_with_formatter(root, out, opts, &FlatFormatter),
112 Format::Json => generate_with_formatter(root, out, opts, &JsonFormatter),
113 }
114}
115
116pub fn generate_with_formatter(
121 root: &Path,
122 out: &mut impl Write,
123 opts: &Options,
124 formatter: &dyn OutputFormatter,
125) -> io::Result<TreeStats> {
126 let canonical_root = root.canonicalize().unwrap_or_else(|_| root.to_path_buf());
127
128 let name = root_display_name(root)?;
129
130 match fs::metadata(root) {
131 Ok(meta) if meta.is_dir() => {
132 let gi = if opts.git_ignore {
133 build_gitignore(&canonical_root)
134 } else {
135 None
136 };
137
138 let root_node = match build_tree(root, &canonical_root, opts, 0, &gi) {
139 Ok(node) => node,
140 Err(e) if e.kind() == io::ErrorKind::PermissionDenied => {
141 writeln!(out, "{}", name)?;
142 writeln!(out, "└── [Access Denied]")?;
143 return Ok(TreeStats {
144 directories: 1,
145 files: 0,
146 });
147 }
148 Err(e) => return Err(e),
149 };
150
151 formatter.write_tree(&root_node, &name, opts, out)
152 }
153 Ok(_) => Err(io::Error::new(
154 io::ErrorKind::InvalidInput,
155 "not a directory",
156 )),
157 Err(ref e) if e.kind() == io::ErrorKind::PermissionDenied => {
158 writeln!(out, "{}", name)?;
159 writeln!(out, "└── [Access Denied]")?;
160 Ok(TreeStats {
161 directories: 1,
162 files: 0,
163 })
164 }
165 Err(e) => Err(e),
166 }
167}
168
169fn root_display_name(root: &Path) -> io::Result<String> {
170 let empty = root.as_os_str().is_empty() || root.as_os_str() == ".";
171 if empty {
172 let cwd = std::env::current_dir()?;
173 Ok(cwd
174 .file_name()
175 .and_then(|n| n.to_str())
176 .unwrap_or(".")
177 .to_string())
178 } else {
179 Ok(match root.file_name().and_then(|n| n.to_str()) {
180 Some(s) => s.to_string(),
181 None => root.to_string_lossy().into_owned(),
182 })
183 }
184}
185
186fn build_tree(
187 dir: &Path,
188 root: &Path,
189 opts: &Options,
190 depth: usize,
191 gitignore: &Option<Gitignore>,
192) -> io::Result<TreeNode> {
193 let dir_name = dir
194 .file_name()
195 .and_then(|n| n.to_str())
196 .map(|s| s.to_string())
197 .unwrap_or_else(|| dir.to_string_lossy().into_owned());
198
199 let read_dir = match fs::read_dir(dir) {
200 Ok(rd) => rd,
201 Err(e) if e.kind() == io::ErrorKind::PermissionDenied && depth > 0 => {
202 return Ok(TreeNode {
203 name: dir_name,
204 size: None,
205 entry_type: "directory".to_string(),
206 target: None,
207 children: vec![TreeNode {
208 name: "[Access Denied]".to_string(),
209 size: None,
210 entry_type: "file".to_string(),
211 target: None,
212 children: vec![],
213 }],
214 });
215 }
216 Err(e) => return Err(e),
217 };
218 let mut raw: Vec<fs::DirEntry> = read_dir.filter_map(|r| r.ok()).collect();
219
220 if !opts.show_hidden {
221 raw.retain(|e| !e.file_name().to_string_lossy().starts_with('.'));
222 }
223
224 if let Some(ref gi) = *gitignore {
225 raw.retain(|e| {
226 let path = e.path();
227 let is_dir = e.file_type().map(|t| t.is_dir()).unwrap_or(false);
228 !is_ignored(&path, is_dir, root, gi)
229 });
230 }
231
232 if opts.dirs_only {
233 raw.retain(|e| e.file_type().map(|t| t.is_dir()).unwrap_or(false));
234 }
235
236 sort_entries(&mut raw, opts.sort_by);
237
238 let mut children: Vec<TreeNode> = Vec::new();
239
240 for entry in &raw {
241 let ft = match entry.file_type() {
242 Ok(t) => t,
243 Err(_) => continue,
244 };
245 let meta = match entry.metadata() {
246 Ok(m) => m,
247 Err(_) => continue,
248 };
249 let name = entry.file_name().to_string_lossy().into_owned();
250
251 if ft.is_symlink() {
252 let target = fs::read_link(entry.path())
253 .map(|t| t.to_string_lossy().into_owned())
254 .unwrap_or_else(|_| "<unknown>".to_string());
255 children.push(TreeNode {
256 name: format!("{} -> {}", name, target),
257 size: if opts.show_size {
258 Some(meta.len())
259 } else {
260 None
261 },
262 entry_type: "symlink".to_string(),
263 target: Some(target),
264 children: vec![],
265 });
266 } else if ft.is_dir() {
267 let descend = opts.max_depth.is_none_or(|max| depth + 1 < max);
268 if descend {
269 let child = build_tree(&entry.path(), root, opts, depth + 1, gitignore)?;
270 if opts.prune && child.children.is_empty() {
271 continue;
272 }
273 let child_size = child.size.unwrap_or(0);
274 children.push(TreeNode {
275 name,
276 size: if opts.show_size || opts.show_total_size {
277 Some(child_size)
278 } else {
279 None
280 },
281 entry_type: "directory".to_string(),
282 target: None,
283 children: child.children,
284 });
285 } else {
286 children.push(TreeNode {
287 name,
288 size: if opts.show_size {
289 Some(meta.len())
290 } else {
291 None
292 },
293 entry_type: "directory".to_string(),
294 target: None,
295 children: vec![],
296 });
297 }
298 } else {
299 children.push(TreeNode {
300 name,
301 size: if opts.show_size {
302 Some(meta.len())
303 } else {
304 None
305 },
306 entry_type: "file".to_string(),
307 target: None,
308 children: vec![],
309 });
310 }
311 }
312
313 let total_size: u64 = children.iter().filter_map(|c| c.size).sum();
314
315 Ok(TreeNode {
316 name: dir_name,
317 size: if opts.show_total_size || (opts.show_size && !children.is_empty()) {
318 Some(total_size)
319 } else {
320 None
321 },
322 entry_type: "directory".to_string(),
323 target: None,
324 children,
325 })
326}
327
328fn count_nodes(node: &TreeNode) -> TreeStats {
329 let mut dirs = 0u64;
330 let mut files = 0u64;
331 if node.entry_type == "directory" {
332 dirs += 1;
333 } else {
334 files += 1;
335 }
336 for child in &node.children {
337 let s = count_nodes(child);
338 dirs += s.directories;
339 files += s.files;
340 }
341 TreeStats {
342 directories: dirs,
343 files,
344 }
345}
346
347pub trait OutputFormatter {
356 fn write_tree(
361 &self,
362 root: &TreeNode,
363 root_name: &str,
364 opts: &Options,
365 out: &mut dyn Write,
366 ) -> io::Result<TreeStats>;
367}
368
369pub struct TreeFormatter;
371
372pub struct FlatFormatter;
374
375pub struct JsonFormatter;
377
378impl OutputFormatter for TreeFormatter {
379 fn write_tree(
380 &self,
381 root: &TreeNode,
382 root_name: &str,
383 opts: &Options,
384 out: &mut dyn Write,
385 ) -> io::Result<TreeStats> {
386 writeln!(out, "{}", root_name)?;
387 let mut stats = TreeStats {
388 directories: 1,
389 files: 0,
390 };
391 render_children(&root.children, "", opts, out, &mut stats)?;
392 Ok(stats)
393 }
394}
395
396impl OutputFormatter for JsonFormatter {
397 fn write_tree(
398 &self,
399 root: &TreeNode,
400 _root_name: &str,
401 _opts: &Options,
402 out: &mut dyn Write,
403 ) -> io::Result<TreeStats> {
404 serde_json::to_writer_pretty(&mut *out, root)?;
405 writeln!(out)?;
406 Ok(count_nodes(root))
407 }
408}
409
410impl OutputFormatter for FlatFormatter {
411 fn write_tree(
412 &self,
413 root: &TreeNode,
414 root_name: &str,
415 opts: &Options,
416 out: &mut dyn Write,
417 ) -> io::Result<TreeStats> {
418 writeln!(out, "{}", root_name)?;
419 let mut stats = TreeStats {
420 directories: 1,
421 files: 0,
422 };
423 flatten_children(root, "", opts, out, &mut stats)?;
424 Ok(stats)
425 }
426}
427
428fn flatten_children(
430 node: &TreeNode,
431 prefix: &str,
432 _opts: &Options,
433 out: &mut dyn Write,
434 stats: &mut TreeStats,
435) -> io::Result<()> {
436 for child in &node.children {
437 let path = if prefix.is_empty() {
438 child.name.clone()
439 } else {
440 format!("{}/{}", prefix, child.name)
441 };
442
443 match child.entry_type.as_str() {
444 "directory" => {
445 writeln!(out, "{}/", path)?;
446 stats.directories += 1;
447 flatten_children(child, &path, _opts, out, stats)?;
448 }
449 _ => {
450 writeln!(out, "{}", path)?;
451 stats.files += 1;
452 }
453 }
454 }
455 Ok(())
456}
457
458fn render_children(
459 children: &[TreeNode],
460 prefix: &str,
461 opts: &Options,
462 out: &mut dyn Write,
463 stats: &mut TreeStats,
464) -> io::Result<()> {
465 let last = children.len().saturating_sub(1);
466 for (i, child) in children.iter().enumerate() {
467 let is_last = i == last;
468 let connector = if is_last { "└── " } else { "├── " };
469 let child_prefix = format!("{}{}", prefix, if is_last { " " } else { "│ " });
470
471 let display = format_entry(child, opts);
472
473 match child.entry_type.as_str() {
474 "directory" => {
475 writeln!(out, "{}{}{}/", prefix, connector, display)?;
476 stats.directories += 1;
477 render_children(&child.children, &child_prefix, opts, out, &mut *stats)?;
478 }
479 "symlink" => {
480 writeln!(out, "{}{}{}", prefix, connector, display)?;
481 stats.files += 1;
482 }
483 _ => {
484 writeln!(out, "{}{}{}", prefix, connector, display)?;
485 stats.files += 1;
486 }
487 }
488 }
489 Ok(())
490}
491
492fn format_entry(node: &TreeNode, opts: &Options) -> String {
493 let icon = if opts.show_icons {
494 file_icon(&node.name, &node.entry_type, false)
495 } else {
496 ""
497 };
498
499 let display_name = if node.entry_type == "symlink" {
500 if let Some(ref target) = node.target {
501 let bare = node.name.trim_end_matches(&format!(" -> {}", target));
502 let coloured = colorize(bare, "symlink", opts.color);
503 format!("{} -> {}", coloured, target)
504 } else {
505 colorize(&node.name, "symlink", opts.color)
506 }
507 } else {
508 colorize(&node.name, &node.entry_type, opts.color)
509 };
510
511 let suffix = if opts.human_readable {
512 if let Some(sz) = node.size {
513 format!(" [{}]", format_size_human(sz))
514 } else {
515 String::new()
516 }
517 } else if opts.show_size {
518 if let Some(sz) = node.size {
519 format!(" [{}]", sz)
520 } else {
521 String::new()
522 }
523 } else {
524 String::new()
525 };
526
527 format!("{}{}{}", icon, display_name, suffix)
528}
529
530fn format_size_human(size: u64) -> String {
531 const UNITS: &[&str] = &["B", "K", "M", "G", "T"];
532 let mut s = size as f64;
533 let mut idx = 0;
534 while s >= 1024.0 && idx < UNITS.len() - 1 {
535 s /= 1024.0;
536 idx += 1;
537 }
538 if idx == 0 {
539 format!("{}", size)
540 } else if s < 10.0 {
541 format!("{:.1}{}", s, UNITS[idx])
542 } else {
543 format!("{:.0}{}", s, UNITS[idx])
544 }
545}
546
547mod colour {
548 pub const RESET: &str = "\x1b[0m";
549 pub const DIR: &str = "\x1b[1;34m";
550 pub const EXE: &str = "\x1b[32m";
551 pub const SYMLINK: &str = "\x1b[36m";
552}
553
554fn colorize(name: &str, entry_type: &str, enabled: bool) -> String {
555 if !enabled {
556 return name.to_string();
557 }
558 let code = match entry_type {
559 "directory" => colour::DIR,
560 "symlink" => colour::SYMLINK,
561 _ => colour::EXE,
562 };
563 format!("{}{}{}", code, name, colour::RESET)
564}
565
566fn file_icon(name: &str, entry_type: &str, _is_exe: bool) -> &'static str {
567 match entry_type {
568 "directory" => "\u{1f4c1} ",
569 "symlink" => "\u{1f517} ",
570 _ => {
571 if name.ends_with(".rs") {
572 "\u{1f980} "
573 } else if name.ends_with(".md") {
574 "\u{1f4dd} "
575 } else if name.ends_with(".toml") || name.ends_with(".json") || name.ends_with(".yml") {
576 "\u{2699}\u{fe0f} "
577 } else if name.ends_with(".png")
578 || name.ends_with(".jpg")
579 || name.ends_with(".svg")
580 || name.ends_with(".ico")
581 {
582 "\u{1f5bc}\u{fe0f} "
583 } else {
584 "\u{1f4c4} "
585 }
586 }
587 }
588}
589
590fn sort_entries(entries: &mut [fs::DirEntry], field: SortField) {
591 match field {
592 SortField::Name => {
593 entries.sort_by_key(|a| a.file_name());
594 }
595 SortField::Size => {
596 entries.sort_by(|a, b| {
597 let sa = a.metadata().ok().map(|m| m.len()).unwrap_or(0);
598 let sb = b.metadata().ok().map(|m| m.len()).unwrap_or(0);
599 sa.cmp(&sb)
600 });
601 }
602 SortField::Time => {
603 entries.sort_by(|a, b| {
604 let ta = a
605 .metadata()
606 .ok()
607 .and_then(|m| m.modified().ok())
608 .unwrap_or(std::time::UNIX_EPOCH);
609 let tb = b
610 .metadata()
611 .ok()
612 .and_then(|m| m.modified().ok())
613 .unwrap_or(std::time::UNIX_EPOCH);
614 ta.cmp(&tb)
615 });
616 }
617 }
618}
619
620fn build_gitignore(root: &Path) -> Option<Gitignore> {
621 let gitignore_path = root.join(".gitignore");
622 if !gitignore_path.exists() || !gitignore_path.is_file() {
623 return None;
624 }
625 let mut builder = GitignoreBuilder::new(root);
626 builder.add(gitignore_path);
627 builder.build().ok()
628}
629
630fn is_ignored(path: &Path, is_dir: bool, root: &Path, gi: &Gitignore) -> bool {
631 let rel = path.strip_prefix(root).unwrap_or(path);
632 gi.matched(rel, is_dir).is_ignore()
633}
634
635#[cfg(test)]
636mod tests {
637 use super::*;
638 use std::fs;
639 use std::path::PathBuf;
640
641 struct Tmp(PathBuf);
642 impl Tmp {
643 fn path(&self) -> &Path {
644 &self.0
645 }
646 }
647 impl Drop for Tmp {
648 fn drop(&mut self) {
649 let _ = fs::remove_dir_all(&self.0);
650 }
651 }
652
653 fn make_tmp() -> Tmp {
654 use std::sync::atomic::{AtomicU64, Ordering};
655 static COUNTER: AtomicU64 = AtomicU64::new(0);
656 let n = COUNTER.fetch_add(1, Ordering::SeqCst);
657 let mut p = std::env::temp_dir();
658 p.push(format!("ls-tree-test-{}-{}", std::process::id(), n));
659 fs::create_dir_all(&p).expect("create temp dir");
660 Tmp(p)
661 }
662
663 fn render(dir: &Path, opts: &Options) -> (String, TreeStats) {
664 let mut buf = Vec::new();
665 let stats = generate(dir, &mut buf, opts).expect("generate should succeed");
666 (String::from_utf8(buf).unwrap(), stats)
667 }
668
669 fn scaffold() -> Tmp {
670 let tmp = make_tmp();
671 fs::create_dir(tmp.path().join("a")).unwrap();
672 fs::write(tmp.path().join("a").join("a1.txt"), b"hello").unwrap();
673 fs::write(tmp.path().join("a").join("a2.txt"), b"world").unwrap();
674 fs::create_dir(tmp.path().join("a").join("sub")).unwrap();
675 fs::write(tmp.path().join("a").join("sub").join("deep.txt"), b"deep").unwrap();
676 fs::write(tmp.path().join("b.txt"), b"root").unwrap();
677 fs::write(tmp.path().join(".hidden_file"), b"").unwrap();
678 fs::create_dir(tmp.path().join(".hidden_dir")).unwrap();
679 fs::write(tmp.path().join(".hidden_dir").join("x.txt"), b"").unwrap();
680 tmp
681 }
682
683 #[test]
684 fn renders_recursive_hierarchy() {
685 let tmp = scaffold();
686 let (out, stats) = render(tmp.path(), &Options::default());
687 assert!(out.contains("a/"));
688 assert!(out.contains("a1.txt"));
689 assert!(out.contains("a2.txt"));
690 assert!(out.contains("sub/"));
691 assert!(out.contains("deep.txt"));
692 assert!(out.contains("b.txt"));
693 assert!(!out.contains(".hidden_file"));
694 assert!(!out.contains(".hidden_dir"));
695 assert_eq!(
696 stats,
697 TreeStats {
698 directories: 3,
699 files: 4
700 }
701 );
702 }
703
704 #[test]
705 fn shows_hidden_with_flag() {
706 let tmp = scaffold();
707 let opts = Options {
708 show_hidden: true,
709 ..Default::default()
710 };
711 let (out, stats) = render(tmp.path(), &opts);
712 assert!(out.contains(".hidden_file"));
713 assert!(out.contains(".hidden_dir/"));
714 assert_eq!(
715 stats,
716 TreeStats {
717 directories: 4,
718 files: 6
719 }
720 );
721 }
722
723 #[test]
724 fn symlink_does_not_cause_cycle() {
725 let tmp = scaffold();
726 #[cfg(unix)]
727 std::os::unix::fs::symlink(tmp.path(), tmp.path().join("loop")).unwrap();
728 #[cfg(windows)]
729 std::os::windows::fs::symlink_dir(tmp.path(), tmp.path().join("loop")).unwrap();
730
731 let (out, _) = render(tmp.path(), &Options::default());
732 assert!(out.contains("loop"));
733 assert!(out.contains("->"));
734 }
735
736 #[test]
737 fn handles_permission_denied_gracefully() {
738 let tmp = scaffold();
739 let locked = tmp.path().join("locked");
740 fs::create_dir(&locked).unwrap();
741 fs::write(locked.join("secret.txt"), b"").unwrap();
742 #[cfg(unix)]
743 {
744 use std::os::unix::fs::PermissionsExt;
745 fs::set_permissions(&locked, fs::Permissions::from_mode(0o000)).unwrap();
746 }
747 if fs::read_dir(&locked).is_ok() {
748 return;
749 }
750
751 let (out, _) = render(tmp.path(), &Options::default());
752 assert!(out.contains("[Access Denied]"));
753
754 #[cfg(unix)]
755 {
756 use std::os::unix::fs::PermissionsExt;
757 fs::set_permissions(&locked, fs::Permissions::from_mode(0o700)).unwrap();
758 }
759 }
760
761 #[test]
762 fn root_permission_denied_is_minimal() {
763 let tmp = make_tmp();
764 let locked = tmp.path().join("locked");
765 fs::create_dir(&locked).unwrap();
766 #[cfg(unix)]
767 {
768 use std::os::unix::fs::PermissionsExt;
769 fs::set_permissions(&locked, fs::Permissions::from_mode(0o000)).unwrap();
770 }
771 if fs::read_dir(&locked).is_ok() {
772 return;
773 }
774
775 let mut buf = Vec::new();
776 let stats = generate(&locked, &mut buf, &Options::default()).unwrap();
777 let out = String::from_utf8(buf).unwrap();
778 assert!(out.contains("[Access Denied]"));
779 assert_eq!(
780 stats,
781 TreeStats {
782 directories: 1,
783 files: 0
784 }
785 );
786
787 #[cfg(unix)]
788 {
789 use std::os::unix::fs::PermissionsExt;
790 fs::set_permissions(&locked, fs::Permissions::from_mode(0o700)).unwrap();
791 }
792 }
793
794 #[test]
795 fn json_output_is_valid() {
796 let tmp = scaffold();
797 let opts = Options {
798 json: true,
799 ..Default::default()
800 };
801 let (out, stats) = render(tmp.path(), &opts);
802 let parsed: serde_json::Value = serde_json::from_str(&out).expect("valid JSON");
803 assert!(parsed.get("name").is_some());
804 assert_eq!(parsed["type"], "directory");
805 assert!(stats.directories >= 1);
806 assert!(parsed["children"].is_array());
807 }
808
809 #[test]
810 fn json_output_serializes_symlinks() {
811 let tmp = make_tmp();
812 fs::write(tmp.path().join("target.txt"), b"hi").unwrap();
813 #[cfg(unix)]
814 std::os::unix::fs::symlink("target.txt", tmp.path().join("link")).unwrap();
815 #[cfg(windows)]
816 std::os::windows::fs::symlink_file("target.txt", tmp.path().join("link")).unwrap();
817
818 let opts = Options {
819 json: true,
820 ..Default::default()
821 };
822 let (out, _) = render(tmp.path(), &opts);
823 let parsed: serde_json::Value = serde_json::from_str(&out).unwrap();
824 let children = parsed["children"].as_array().unwrap();
825 if children.len() == 2 {
826 let has_symlink = children.iter().any(|c| c["type"] == "symlink");
827 assert!(has_symlink, "output should contain a symlink: {}", out);
828 }
829 }
830
831 #[test]
832 fn size_flag_adds_size_info() {
833 let tmp = scaffold();
834 let opts = Options {
835 show_size: true,
836 ..Default::default()
837 };
838 let (out, _) = render(tmp.path(), &opts);
839 assert!(out.contains('['));
840 }
841
842 #[test]
843 fn dirs_only_shows_only_directories() {
844 let tmp = scaffold();
845 let opts = Options {
846 dirs_only: true,
847 ..Default::default()
848 };
849 let (out, stats) = render(tmp.path(), &opts);
850 assert!(out.contains("a/"));
851 assert!(out.contains("sub/"));
852 assert!(!out.contains("a1.txt"));
853 assert_eq!(stats.files, 0);
854 assert!(stats.directories >= 2);
855 }
856
857 #[test]
858 fn prune_removes_empty_dirs() {
859 let tmp = make_tmp();
860 fs::create_dir(tmp.path().join("full")).unwrap();
861 fs::write(tmp.path().join("full").join("f.txt"), b"").unwrap();
862 fs::create_dir(tmp.path().join("empty")).unwrap();
863
864 let opts = Options {
865 prune: true,
866 ..Default::default()
867 };
868 let (out, _) = render(tmp.path(), &opts);
869 assert!(out.contains("full/"));
870 assert!(!out.contains("empty/"));
871 }
872
873 #[test]
874 fn max_depth_limits_recursion() {
875 let tmp = scaffold();
876 let opts = Options {
877 max_depth: Some(1),
878 ..Default::default()
879 };
880 let (out, _) = render(tmp.path(), &opts);
881 assert!(out.contains("a/"));
882 assert!(out.contains("b.txt"));
883 assert!(!out.contains("deep.txt"));
884 }
885
886 #[test]
887 fn icons_are_rendered() {
888 let tmp = scaffold();
889 let opts = Options {
890 show_icons: true,
891 ..Default::default()
892 };
893 let (out, _) = render(tmp.path(), &opts);
894 assert!(out.contains('\u{1f4c1}'));
895 }
896}