lumin 0.1.16

A library for searching and displaying local files
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168

use anyhow::Result;
use lumin::tree::{Entry, TreeOptions, generate_tree};
use std::path::Path;

#[test]
fn test_tree_basic() -> Result<()> {
    let directory = Path::new("tests/fixtures");
    let options = TreeOptions::default();

    let results = generate_tree(directory, &options)?;

    // Should generate a tree structure
    assert!(!results.is_empty());

    // Root directory should be in the results
    let root_dir = results.iter().find(|d| d.dir.ends_with("fixtures"));
    assert!(root_dir.is_some());

    // Root directory should have entries
    if let Some(root) = root_dir {
        assert!(!root.entries.is_empty());

        // Should contain the "text_files" and "nested" directories
        let dir_names: Vec<_> = root
            .entries
            .iter()
            .filter_map(|e| {
                if let Entry::Directory { name } = e {
                    Some(name.as_str())
                } else {
                    None
                }
            })
            .collect();

        assert!(dir_names.contains(&"text_files"));
        assert!(dir_names.contains(&"nested"));
        assert!(dir_names.contains(&"binary_files"));

        // Should not contain ignored or hidden directories
        assert!(!dir_names.contains(&".hidden"));
    }

    // Should include nested directories
    let nested_dir = results.iter().find(|d| d.dir.contains("nested"));
    assert!(nested_dir.is_some());

    // Should include nested/level1 directory
    let level1_dir = results.iter().find(|d| d.dir.contains("nested/level1"));
    assert!(level1_dir.is_some());

    // Should include level2 directories with correct parent
    let level2_dir = results.iter().find(|d| d.dir.contains("level2"));
    if let Some(level2) = level2_dir {
        // The level2 directory should be under level1
        assert!(level2.dir.contains("level1/level2"));
    }

    Ok(())
}

#[test]
fn test_tree_without_gitignore_respect() -> Result<()> {
    let directory = Path::new("tests/fixtures");
    let options = TreeOptions {
        respect_gitignore: false,
        ..TreeOptions::default()
    };

    let results = generate_tree(directory, &options)?;

    // Should include .hidden directory when not respecting gitignore
    let contains_hidden_dir = results.iter().any(|d| d.dir.contains(".hidden"));
    assert!(
        contains_hidden_dir,
        ".hidden directory should be included when not respecting gitignore"
    );

    // Should include files from gitignored directories
    let hidden_dir = results.iter().find(|d| d.dir.contains(".hidden"));
    if let Some(dir) = hidden_dir {
        // Should have secret.txt as an entry
        let has_secret_file = dir.entries.iter().any(|e| {
            if let Entry::File { name } = e {
                name == "secret.txt"
            } else {
                false
            }
        });

        assert!(
            has_secret_file,
            "hidden/secret.txt should be included when not respecting gitignore"
        );
    }

    Ok(())
}

#[test]
fn test_tree_structure_integrity() -> Result<()> {
    let directory = Path::new("tests/fixtures");
    let options = TreeOptions::default();

    let results = generate_tree(directory, &options)?;

    // Verify the nested directory structure is preserved correctly

    // Should have all levels of nesting
    let has_level1 = results
        .iter()
        .any(|d| d.dir.contains("level1") && !d.dir.contains("level2"));
    let has_level2 = results.iter().any(|d| d.dir.contains("level2"));

    assert!(has_level1, "Should have level1 directory in results");
    assert!(has_level2, "Should have level2 directory in results");

    // Verify level1 directory contains level2 as a subdirectory
    let level1_dir = results
        .iter()
        .find(|d| d.dir.contains("level1") && !d.dir.contains("level2"));
    if let Some(level1) = level1_dir {
        let has_level2_entry = level1.entries.iter().any(|e| {
            if let Entry::Directory { name } = e {
                name == "level2"
            } else {
                false
            }
        });

        assert!(
            has_level2_entry,
            "level1 directory should contain level2 as a subdirectory"
        );
    }

    // Verify text_files directory contains the correct files
    let text_files_dir = results.iter().find(|d| d.dir.contains("text_files"));
    if let Some(dir) = text_files_dir {
        // Should contain sample.txt, markdown.md, and config.toml
        let file_names: Vec<_> = dir
            .entries
            .iter()
            .filter_map(|e| {
                if let Entry::File { name } = e {
                    Some(name.as_str())
                } else {
                    None
                }
            })
            .collect();

        assert!(
            file_names.contains(&"sample.txt"),
            "text_files directory should contain sample.txt"
        );
        assert!(
            file_names.contains(&"markdown.md"),
            "text_files directory should contain markdown.md"
        );
        assert!(
            file_names.contains(&"config.toml"),
            "text_files directory should contain config.toml"
        );
    }

    Ok(())
}