tablo-core 0.8.0

The core toolkit types for Tablo, a server-rendered admin toolkit on Topcoat and Toasty.
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

use super::Options;
use crate::{
    FormScalar,
    extend::{Column as _, Filter as _},
    test_support::cx,
    values::FormValues,
};

/// One list shared by the form, the filter and the column.
#[derive(Debug, Clone, Copy, PartialEq, Eq, toasty::Embed, crate::Options)]
enum Status {
    Draft,
    #[option(label = "Live")]
    Published,
    #[option(value = "arch", label = "Archive")]
    Archived,
}

#[test]
fn an_options_enum_shares_one_value_label_list() {
    let options: Vec<_> = Status::options()
        .into_iter()
        .map(|(value, label)| (value, label.english()))
        .collect();
    assert_eq!(
        options,
        [
            ("draft".to_string(), "Draft".to_string()),
            ("published".to_string(), "Live".to_string()),
            ("arch".to_string(), "Archive".to_string()),
        ]
    );
    assert_eq!(
        Status::Draft.label(),
        crate::Text::option("status", "draft"),
        "an undeclared label is the message `option-{{enum}}.{{variant}}`"
    );
    assert_eq!(
        Status::Published.label(),
        crate::Text::from("Live"),
        "a declared label is plain"
    );
    assert_eq!(Status::Draft.value(), "draft");
    assert_eq!(Status::Published.label(), "Live");
    assert_eq!(Status::from_value("draft"), Some(Status::Draft));
    assert_eq!(Status::from_value("arch"), Some(Status::Archived));
    assert_eq!(Status::from_value("gone"), None);
    assert_eq!(Status::label_of("published"), "Live");
    assert_eq!(
        Status::label_of("renamed"),
        "renamed",
        "a value no option has reads as itself"
    );
}

#[test]
fn an_options_enum_posts_its_value_and_reads_as_its_label() {
    assert_eq!(Status::parse_form("arch"), Ok(Status::Archived));
    assert!(
        Status::parse_form("archived").is_err(),
        "the form spells a variant by its option value, not its name"
    );
    assert_eq!(Status::Archived.to_form(), "arch");
    assert_eq!(Status::Archived.to_label(), "Archive");
}

#[tokio::test]
async fn a_typed_field_takes_its_options_and_labels_from_its_type() {
    let schema = crate::Schema::new(
        crate::Field::choice(StatusField::fields().status()).options(Status::options()),
    );
    let mut valid = FormValues::new();
    valid.insert("status".to_string(), "arch".to_string());
    let cx = topcoat::context::CxTestBuilder::new().build();
    let errors = schema.checked(&cx, &valid).await;
    assert!(errors.is_empty(), "a listed option validates: {errors:?}");
    let mut bogus = FormValues::new();
    bogus.insert("status".to_string(), "gone".to_string());
    assert!(
        !schema.checked(&cx, &bogus).await.is_empty(),
        "an unlisted value fails"
    );
    let filter = crate::SelectFilter::of(StatusField::fields().status());
    assert_eq!(filter.options(), Status::options().as_slice());
    assert!(filter.to_expr(&cx, &"arch".into()).is_some());
    assert!(
        filter.to_expr(&cx, &"gone".into()).is_none(),
        "an unlisted value selects nothing"
    );
    let column = crate::TextColumn::new(crate::lens!(StatusField.status));
    let row = StatusField {
        id: uuid::Uuid::nil(),
        status: Status::Published,
        previous: None,
    };
    assert_eq!(column.text(&crate::test_support::cx(), &row), "Live");
}

#[test]
fn an_optional_options_enum_reads_empty_as_none() {
    assert_eq!(
        Option::<Status>::parse_form("arch"),
        Ok(Some(Status::Archived))
    );
    assert_eq!(Some(Status::Archived).to_label(), "Archive");
    assert_eq!(None::<Status>.to_form(), "");
    let filter = crate::SelectFilter::of(StatusField::fields().previous());
    assert_eq!(filter.options(), Status::options().as_slice());
    assert!(filter.to_expr(&cx(), &"arch".into()).is_some());
    assert!(filter.misdeclared().is_none());
}

#[test]
fn a_select_option_the_field_type_does_not_parse_is_misdeclared() {
    let filter = crate::SelectFilter::new(
        StatusField::fields().status(),
        vec![
            (String::new(), "All".to_string()),
            ("draft".to_string(), "Draft".to_string()),
            ("Archive".to_string(), "Archive".to_string()),
        ],
    );
    assert_eq!(
        filter.misdeclared(),
        Some(crate::DeclarationErrorKind::UnparsedFilterOption {
            filter: "status".to_string(),
            value: "Archive".to_string(),
        })
    );
}

#[derive(Debug, Clone, toasty::Model)]
struct StatusField {
    #[key]
    #[auto]
    id: uuid::Uuid,
    status: Status,
    previous: Option<Status>,
}