tablo-core 0.3.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

use super::Rules;

/// The messages `errors` carries, in the order the rules reported them.
fn messages(errors: &[crate::form::FieldError]) -> Vec<&str> {
    errors.iter().map(|error| error.message.as_str()).collect()
}

/// The typed rule words one message for a value the type cannot parse and
/// for one it parses into a value it does not accept.
fn rejected(input: &str) -> String {
    format!("`{input}` is not a valid number")
}

/// `f32`/`f64` `FromStr` accepts `NaN`, `inf` and `-inf`. They are refused like
/// any other unparseable submission.
#[test]
fn a_float_refuses_a_non_finite_parse() {
    for input in ["NaN", "nan", "inf", "-inf", "infinity", "1e400"] {
        let f64_errs = Rules::new()
            .scalar::<f64>()
            .validate("amount", "Amount", true, input);
        let f32_errs = Rules::new()
            .scalar::<f32>()
            .validate("amount", "Amount", true, input);
        assert_eq!(
            messages(&f64_errs),
            [rejected(input)],
            "f64 accepted {input}"
        );
        assert_eq!(
            messages(&f32_errs),
            [rejected(input)],
            "f32 accepted {input}"
        );
    }
}

/// The same field keeps accepting a finite number, and normalises it
/// through `f64`'s `Display` as any typed rule does.
#[test]
fn a_float_accepts_and_normalises_a_finite_number() {
    let rules = Rules::new().scalar::<f64>();
    assert!(rules.validate("amount", "Amount", true, "-0.25").is_empty());
    assert!(rules.validate("amount", "Amount", true, "1e3").is_empty());
    assert_eq!(
        rules.normalize(" 12.50 ").expect("12.50 parses"),
        "12.5",
        "a finite value stores its own spelling"
    );
}