Skip to main content

ls_tree/
lib.rs

1//! Recursively render a directory hierarchy using the classic `tree` drawing
2//! characters (`├──`, `└──`, `│   `) or output machine-readable JSON.
3//! Supports colours, file sizes, `.gitignore` awareness, sorting, pruning, and
4//! file-type icons. The render target is a generic [`std::io::Write`] so the
5//! library can be tested without a terminal or the filesystem.
6
7use std::fs;
8use std::io::{self, Write};
9use std::path::Path;
10
11use ignore::gitignore::{Gitignore, GitignoreBuilder};
12use serde::Serialize;
13
14/// Controls how the tree is gathered and rendered.
15#[derive(Debug, Clone)]
16pub struct Options {
17    pub show_hidden: bool,
18    pub max_depth: Option<usize>,
19    /// Deprecated: use [`format`](Self::format) instead. When `true` it forces
20    /// [`Format::Json`] regardless of `format`.
21    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    /// Return the effective output format, respecting the legacy `json` flag.
36    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/// Controls which output format is used to render the tree.
76///
77/// The default is [`Tree`](Format::Tree). Use [`Flat`](Format::Flat) for a
78/// find-style listing or [`Json`](Format::Json) for machine-readable output.
79#[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
106/// Convenience entry point that selects the built-in formatter based on
107/// [`Options::effective_format`] and delegates to [`generate_with_formatter`].
108pub 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
116/// Build the tree and hand it off to a custom [`OutputFormatter`].
117///
118/// This is the primitive that [`generate`] calls internally. Use it directly
119/// when you want to supply your own formatter implementation.
120pub 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
347// ---------------------------------------------------------------------------
348// Output formatter trait + built-in implementations
349// ---------------------------------------------------------------------------
350
351/// Renders a complete [`TreeNode`] tree into the supplied writer.
352///
353/// Each implementation produces a different output format (tree, flat, JSON).
354/// Library consumers can implement this trait to supply custom formats.
355pub trait OutputFormatter {
356    /// Render a complete tree into `out`.
357    ///
358    /// Implementations receive the root [`TreeNode`] (already fully built), the
359    /// display name of the root path, the active options, and the output writer.
360    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
369/// Classic `├──` / `└──` / `│   ` tree output.
370pub struct TreeFormatter;
371
372/// Find-style flat listing (one path per line).
373pub struct FlatFormatter;
374
375/// Machine-readable JSON output.
376pub 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
428/// Recursively print child entries as flat relative paths.
429fn 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}