rd-ast 0.0.1

Canonical, producer-agnostic AST for R's Rd (documentation) format
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

use super::*;

#[test]
fn rejects_non_list_roots() {
    let root = fixture("rd_minimal_v2.rds");
    let non_list = root.attributes().get("class").expect("class attr");
    assert!(matches!(non_list.value(), RValue::Character(_)));
    let error = lower_r_object(non_list).unwrap_err();
    assert!(matches!(error, LowerError::RootMustBeList { .. }));
    assert!(error.location().path().segments().is_empty());
    assert_eq!(
        error.to_string(),
        "root Rd object must be a list at document root"
    );
}

#[test]
fn invalid_string_in_text_leaf_reports_node_character_location() {
    let node = RObject::from_parts(RValue::Character(vec![RStr::Na, invalid_string()]), Attributes::new(vec![attribute(
            "Rd_tag",
            RValue::Character(vec![RStr::Value {
                bytes: Arc::from(&b"TEXT"[..]),
                encoding: REncoding::Utf8,
                native_encoding: None,
            }]),
        )]));
    let error = lower_r_object(&bare(RValue::List(vec![node]))).unwrap_err();

    assert_eq!(
        error.location().path().segments(),
        &[
            RdPathSegment::TopLevel(0),
            RdPathSegment::CharacterElement(1),
        ]
    );
    assert_eq!(error.location().tag(), Some("TEXT"));
    assert_eq!(error.location().attribute(), None);
    assert_eq!(error.encoding(), Some(StringEncoding::Bytes));
    assert_eq!(
        error.to_string(),
        "invalid Bytes string encoding at top-level[0] / character[1] (TEXT)"
    );
}

#[test]
fn invalid_string_in_option_reports_option_context() {
    let node = RObject::from_parts(RValue::Null, Attributes::new(vec![
            attribute(
                "Rd_tag",
                RValue::Character(vec![RStr::Value {
                    bytes: Arc::from(&br"\arguments"[..]),
                    encoding: REncoding::Utf8,
                    native_encoding: None,
                }]),
            ),
            attribute("Rd_option", RValue::Character(vec![invalid_string()])),
        ]));
    let error = lower_r_object(&bare(RValue::List(vec![node]))).unwrap_err();

    assert_eq!(
        error.location().path().segments(),
        &[
            RdPathSegment::TopLevel(0),
            RdPathSegment::Option,
            RdPathSegment::CharacterElement(0),
        ]
    );
    assert_eq!(error.location().tag(), Some(r"\arguments"));
    assert_eq!(error.location().attribute(), Some("Rd_option"));
}

#[test]
fn invalid_string_in_raw_attribute_reports_attribute_context() {
    let node = RObject::from_parts(RValue::Null, Attributes::new(vec![
            attribute(
                "Rd_tag",
                RValue::Character(vec![RStr::Value {
                    bytes: Arc::from(&b"TEXT"[..]),
                    encoding: REncoding::Utf8,
                    native_encoding: None,
                }]),
            ),
            attribute("rootextra", RValue::Character(vec![invalid_string()])),
        ]));
    let error = lower_r_object(&bare(RValue::List(vec![node]))).unwrap_err();

    assert_eq!(
        error.location().path().segments(),
        &[
            RdPathSegment::TopLevel(0),
            RdPathSegment::Attribute("rootextra".to_string()),
            RdPathSegment::AttributeValue,
            RdPathSegment::CharacterElement(0),
        ]
    );
    assert_eq!(error.location().tag(), Some("TEXT"));
    assert_eq!(error.location().attribute(), Some("rootextra"));
}

#[test]
fn invalid_string_in_rd_tag_reports_tag_attribute_context() {
    let node = RObject::from_parts(RValue::Null, Attributes::new(vec![attribute(
            "Rd_tag",
            RValue::Character(vec![invalid_string()]),
        )]));
    let error = lower_r_object(&bare(RValue::List(vec![node]))).unwrap_err();

    assert_eq!(
        error.location().path().segments(),
        &[
            RdPathSegment::TopLevel(0),
            RdPathSegment::CharacterElement(0),
        ]
    );
    assert_eq!(error.location().tag(), None);
    assert_eq!(error.location().attribute(), Some("Rd_tag"));
}