iced-swdir-tree 0.7.0

iced widget for file tree powered by swdir, supporting selection, lazy loading and filtering.
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

//! Unit tests for the [`super::IconTheme`] trait and stock themes.

use super::*;

#[test]
fn unicode_theme_produces_expected_glyphs() {
    let t = UnicodeTheme;
    assert_eq!(t.glyph(IconRole::FolderClosed).glyph.as_ref(), "\u{1F4C1}");
    assert_eq!(t.glyph(IconRole::FolderOpen).glyph.as_ref(), "\u{1F4C2}");
    assert_eq!(t.glyph(IconRole::File).glyph.as_ref(), "\u{1F4C4}");
    assert_eq!(t.glyph(IconRole::Error).glyph.as_ref(), "\u{26A0}");
    assert_eq!(t.glyph(IconRole::CaretRight).glyph.as_ref(), "\u{25B8}");
    assert_eq!(t.glyph(IconRole::CaretDown).glyph.as_ref(), "\u{25BE}");
}

#[test]
fn unicode_theme_does_not_set_font() {
    // The whole point of UnicodeTheme is that it uses glyphs in the
    // default system font — setting a specific font would defeat
    // that.
    let t = UnicodeTheme;
    assert!(t.glyph(IconRole::FolderClosed).font.is_none());
    assert!(t.glyph(IconRole::File).font.is_none());
}

#[test]
fn unicode_theme_does_not_set_size() {
    // Theme defers sizing to the widget so row heights stay
    // consistent across configurations.
    let t = UnicodeTheme;
    assert!(t.glyph(IconRole::FolderClosed).size.is_none());
}

#[cfg(feature = "icons")]
#[test]
fn lucide_theme_sets_the_lucide_font() {
    let t = LucideTheme;
    let spec = t.glyph(IconRole::FolderClosed);
    assert!(
        spec.font.is_some(),
        "LucideTheme must set a font so the glyph codepoints render"
    );
}

#[cfg(feature = "icons")]
#[test]
fn lucide_theme_glyph_length_is_single_char() {
    // Lucide codepoints live in the Private Use Area (single chars).
    let t = LucideTheme;
    for role in [
        IconRole::FolderClosed,
        IconRole::FolderOpen,
        IconRole::File,
        IconRole::Error,
        IconRole::CaretRight,
        IconRole::CaretDown,
    ] {
        let spec = t.glyph(role);
        let s = spec.glyph.as_ref();
        assert_eq!(s.chars().count(), 1, "role {role:?} produced {s:?}");
    }
}

#[test]
fn iconspec_builder_sets_font_and_size() {
    let spec = IconSpec::new("x")
        .with_font(iced::Font::DEFAULT)
        .with_size(22.0);
    assert_eq!(spec.glyph.as_ref(), "x");
    assert_eq!(spec.font, Some(iced::Font::DEFAULT));
    assert_eq!(spec.size, Some(22.0));
}

#[test]
fn iconspec_new_accepts_static_str_and_string() {
    // `Cow<'static, str>` over `Into<Cow<_, _>>` accepts both
    // without forcing callers to choose.
    let from_static: IconSpec = IconSpec::new("static");
    let from_owned: IconSpec = IconSpec::new(String::from("owned"));
    assert_eq!(from_static.glyph.as_ref(), "static");
    assert_eq!(from_owned.glyph.as_ref(), "owned");
}

#[test]
fn custom_theme_is_consulted_per_role() {
    // A tiny fake theme demonstrates that the trait contract is
    // enough for a downstream implementor to plug in.
    #[derive(Debug)]
    struct FakeTheme;

    impl IconTheme for FakeTheme {
        fn glyph(&self, role: IconRole) -> IconSpec {
            // In-crate so exhaustive; external themes need `_ =>`.
            let s: &'static str = match role {
                IconRole::FolderClosed => "C",
                IconRole::FolderOpen => "O",
                IconRole::File => "F",
                IconRole::Error => "E",
                IconRole::CaretRight => ">",
                IconRole::CaretDown => "v",
            };
            IconSpec::new(s)
        }
    }

    let t = FakeTheme;
    assert_eq!(t.glyph(IconRole::FolderClosed).glyph.as_ref(), "C");
    assert_eq!(t.glyph(IconRole::FolderOpen).glyph.as_ref(), "O");
    assert_eq!(t.glyph(IconRole::File).glyph.as_ref(), "F");
    assert_eq!(t.glyph(IconRole::Error).glyph.as_ref(), "E");
    assert_eq!(t.glyph(IconRole::CaretRight).glyph.as_ref(), ">");
    assert_eq!(t.glyph(IconRole::CaretDown).glyph.as_ref(), "v");
}

#[test]
fn icon_theme_is_object_safe() {
    // If this compiles, `IconTheme` is object-safe — which it must
    // be, because the widget holds it in `Arc<dyn IconTheme>`.
    let _boxed: Box<dyn IconTheme> = Box::new(UnicodeTheme);
    let _arc: std::sync::Arc<dyn IconTheme> = std::sync::Arc::new(UnicodeTheme);
}

#[test]
fn default_theme_produces_reasonable_folder_glyph() {
    // Regardless of feature flag, the default theme must produce a
    // non-empty glyph for every role — the widget depends on this
    // for layout stability.
    let t = default_theme();
    for role in [
        IconRole::FolderClosed,
        IconRole::FolderOpen,
        IconRole::File,
        IconRole::Error,
        IconRole::CaretRight,
        IconRole::CaretDown,
    ] {
        let spec = t.glyph(role);
        assert!(
            !spec.glyph.as_ref().is_empty(),
            "default theme returned empty glyph for {role:?}"
        );
    }
}