vize_l0 0.631.0

L0 - the Davinci foundation level: ids, side tables, keys, dumps, diagnostics, passes and facts
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

use super::{AttributeHyphenationConfig, AttributeHyphenationOptions, HyphenationStyle};
use crate::config::ConfigLintRuleOptions;
use serde_json::json;

fn config(value: serde_json::Value) -> ConfigLintRuleOptions {
    serde_json::from_value(json!({"vue/attribute-hyphenation": value})).unwrap()
}

#[test]
fn style_strings_keep_the_original_accessor_and_serialized_shape() {
    for (text, style) in [
        ("always", HyphenationStyle::Always),
        ("never", HyphenationStyle::Never),
    ] {
        let value = config(json!(text));
        assert_eq!(value.attribute_hyphenation(), Some(style));
        assert_eq!(value.attribute_hyphenation_ignore(), None);
        assert_eq!(
            serde_json::to_value(value).unwrap()["vue/attribute-hyphenation"],
            json!(text)
        );
    }
}

#[test]
fn objects_default_to_always_and_preserve_literal_order_case_and_boundaries() {
    let value = config(json!({"ignore": ["active", "/foo/", "FOO", "\u{85}", "\u{200b}"]}));
    assert_eq!(
        value.attribute_hyphenation(),
        Some(HyphenationStyle::Always)
    );
    let actual: Vec<_> = value
        .attribute_hyphenation_ignore()
        .unwrap()
        .iter()
        .map(|s| s.as_str())
        .collect();
    assert_eq!(actual, vec!["active", "/foo/", "FOO", "\u{85}", "\u{200b}"]);
    let empty = config(json!({}));
    assert_eq!(
        empty.attribute_hyphenation(),
        Some(HyphenationStyle::Always)
    );
    assert_eq!(
        empty.attribute_hyphenation_ignore(),
        Some(&[] as &[crate::String])
    );
}

#[test]
fn full_policy_overlay_replaces_the_custom_list_and_a_string_resets_it() {
    let mut value = config(json!({"style":"never","ignore":["active"]}));
    value.merge_from(&serde_json::from_value(json!({})).unwrap());
    assert_eq!(value.attribute_hyphenation_ignore().unwrap().len(), 1);
    value.merge_from(&config(json!({"ignore":["foo"]})));
    assert_eq!(
        value.attribute_hyphenation(),
        Some(HyphenationStyle::Always)
    );
    assert_eq!(
        value.attribute_hyphenation_ignore().unwrap()[0].as_str(),
        "foo"
    );
    value.merge_from(&config(json!("never")));
    assert_eq!(value.attribute_hyphenation(), Some(HyphenationStyle::Never));
    assert_eq!(value.attribute_hyphenation_ignore(), None);
}

#[test]
fn malformed_lists_and_unknown_options_are_refused_instead_of_widening_exemptions() {
    for value in [
        json!({"style":null}),
        json!({"style":"sometimes"}),
        json!({"ignore":null}),
        json!({"ignore":[1]}),
        json!({"ignore":[""]}),
        json!({"ignore":[" "]}),
        json!({"ignore":["\u{feff}"]}),
        json!({"ignore":["name:exit"]}),
        json!({"ignore":["active","active"]}),
    ] {
        assert!(serde_json::from_value::<AttributeHyphenationConfig>(value).is_err());
    }
    let direct = AttributeHyphenationOptions {
        ignore: vec!["".into()],
        ..Default::default()
    };
    assert!(direct.validate().is_err());
}

#[test]
fn formerly_unknown_tag_field_admits_only_literal_unique_policies() {
    // This exact former unknown-field input now belongs to the literal-tag feature.
    let value: AttributeHyphenationConfig =
        serde_json::from_value(json!({"ignoreTags":["MyWidget"]})).unwrap();
    assert_eq!(value.style(), HyphenationStyle::Always);
    assert_eq!(value.ignore_tags().unwrap()[0].as_str(), "MyWidget");
    for tags in [vec![], vec!["", " ", ":exit", "//", "/name", "/x/\n"]] {
        let value: AttributeHyphenationConfig =
            serde_json::from_value(json!({"ignoreTags":tags})).unwrap();
        assert_eq!(value.ignore_tags().unwrap().len(), tags.len());
    }
    for tags in [
        json!(["/^My/"]),
        json!(["/MyWidget/i"]),
        json!(["/x/y"]),
        json!(["MyWidget", "MyWidget"]),
        json!([1]),
        json!(null),
    ] {
        assert!(
            serde_json::from_value::<AttributeHyphenationConfig>(json!({"ignoreTags":tags}))
                .is_err()
        );
    }
    let value: AttributeHyphenationConfig = serde_json::from_value(json!({})).unwrap();
    assert_eq!(
        serde_json::to_value(value).unwrap(),
        json!({"style":"always", "ignore":[]})
    );
}