taba-cli 0.1.1

The Taba client command line.
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

use super::*;

fn text(map: &[(String, Node)], path: &[&str]) -> Option<String> {
    let mut current = map;
    for (n, key) in path.iter().enumerate() {
        let node = &current.iter().find(|(k, _)| k == key)?.1;
        match node {
            Node::Text(t) if n + 1 == path.len() => return Some(t.clone()),
            Node::Map(m) => current = m,
            Node::Text(_) => return None,
        }
    }
    None
}

/// UC: UC-CLI-028
#[test]
fn reads_the_documented_example() {
    let doc = "default: local\nprofiles:\n  local:\n    url: http://127.0.0.1:8080\n    token-file: C:\\taba\\secrets\\root-token\n  staging:\n    url: https://taba.stg.example.com\n    ca-file: /etc/ssl/taba-stg-ca.pem   # own CA\n    token-file: ~/.taba/stg-token\n";
    let map = parse(doc).unwrap();
    assert_eq!(text(&map, &["default"]).as_deref(), Some("local"));
    assert_eq!(
        text(&map, &["profiles", "local", "url"]).as_deref(),
        Some("http://127.0.0.1:8080")
    );
    assert_eq!(
        text(&map, &["profiles", "local", "token-file"]).as_deref(),
        Some("C:\\taba\\secrets\\root-token")
    );
    assert_eq!(
        text(&map, &["profiles", "staging", "ca-file"]).as_deref(),
        Some("/etc/ssl/taba-stg-ca.pem")
    );
}

/// UC: UC-CLI-028
#[test]
fn handles_comments_blank_lines_bom_and_empty_documents() {
    assert!(parse("").unwrap().is_empty());
    assert!(parse("# only a comment\n\n   \n").unwrap().is_empty());
    let map = parse("\u{feff}# top\na: b # end\n\nc:   d  \n").unwrap();
    assert_eq!(text(&map, &["a"]).as_deref(), Some("b"));
    assert_eq!(text(&map, &["c"]).as_deref(), Some("d"));
    let map = parse("profiles: {}\n").unwrap();
    assert_eq!(map, [("profiles".to_owned(), Node::Map(vec![]))]);
    let map = parse("profiles:\n").unwrap();
    assert_eq!(map, [("profiles".to_owned(), Node::Map(vec![]))]);
}

/// UC: UC-CLI-028
#[test]
fn reads_quoted_scalars_and_keeps_hash_inside_quotes() {
    let map = parse("a: \"x # y \\\"z\\\" \\\\ \\u00e9\\n\"\nb: 'it''s # ok'\nc: http://h:80/p#frag\n\"d e\": ~\n").unwrap();
    assert_eq!(text(&map, &["a"]).as_deref(), Some("x # y \"z\" \\ é\n"));
    assert_eq!(text(&map, &["b"]).as_deref(), Some("it's # ok"));
    assert_eq!(text(&map, &["c"]).as_deref(), Some("http://h:80/p#frag"));
    assert_eq!(text(&map, &["d e"]).as_deref(), Some(""));
}

/// UC: UC-CLI-028
#[test]
fn reports_the_line_of_invalid_yaml() {
    for (doc, line) in [
        ("a: b\n\tc: d\n", 2),
        ("a: b\n- x\n", 2),
        ("a: b\n  c: d\n", 2),
        ("a: b\na: c\n", 2),
        ("a: \"open\n", 1),
        ("a: [1, 2]\n", 1),
        ("no colon\n", 1),
        ("a:\n    b: 1\n  c: 2\n", 3),
        ("a: |\n  text\n", 1),
        ("a: &x 1\n", 1),
    ] {
        let e = parse(doc).unwrap_err();
        assert_eq!(e.line, line, "{doc:?}: {e}");
    }
}

/// UC: UC-CLI-028
#[test]
fn rendering_then_parsing_gives_the_same_values_for_awkward_text() {
    let values = [
        "http://127.0.0.1:8080",
        "C:\\taba\\secrets\\root-token",
        "",
        "has # hash",
        "dois: pontos",
        "  spaces  ",
        "true",
        "-starts",
        "quotes \" and ' together",
        "linha\nnova",
        "çã 中",
        "ends:",
    ];
    for v in values {
        let map = vec![("k".to_owned(), Node::Text(v.to_owned()))];
        let again = parse(&render(&map)).unwrap_or_else(|e| panic!("{v:?}: {e}\n{}", render(&map)));
        assert_eq!(again, map, "{v:?}");
    }
}

/// UC: UC-CLI-028
#[test]
fn renders_nested_maps_and_empty_maps() {
    let map = vec![
        ("default".to_owned(), Node::Text("a".to_owned())),
        (
            "profiles".to_owned(),
            Node::Map(vec![
                (
                    "a".to_owned(),
                    Node::Map(vec![("url".to_owned(), Node::Text("http://h".to_owned()))]),
                ),
                ("b".to_owned(), Node::Map(vec![])),
            ]),
        ),
    ];
    let text = render(&map);
    assert_eq!(
        text,
        "default: a\nprofiles:\n  a:\n    url: http://h\n  b: {}\n"
    );
    assert_eq!(parse(&text).unwrap(), map);
}