styx-tree 3.0.1

High-level syntax tree for the Styx configuration language
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

use super::*;
use facet_testhelpers::test;

#[test]
fn test_parse_simple() {
    let doc = Document::parse("name Alice\nage 30").unwrap();
    assert_eq!(doc.get("name").and_then(|v| v.as_str()), Some("Alice"));
    assert_eq!(doc.get("age").and_then(|v| v.as_str()), Some("30"));
}

#[test]
fn test_parse_empty() {
    let doc = Document::parse("").unwrap();
    assert!(doc.root.is_empty());
}

#[test]
fn test_convenience_parse() {
    let value = parse("greeting hello").unwrap();
    assert_eq!(
        value.get("greeting").and_then(|v| v.as_str()),
        Some("hello")
    );
}

#[test]
fn test_schema_tree_structure() {
    // Parse a schema-like document to understand the tree structure
    // Structure:
    //   schema {
    //     @ @object{         // @ is unit key, @object{...} is the value (tag with object payload)
    //       name @string
    //     }
    //   }
    let source = r#"schema {
  @ @object{
    name @string
  }
}"#;
    let value = parse(source).unwrap();

    // Root is an object with one entry: "schema"
    let obj = value.as_object().expect("root should be object");
    assert_eq!(obj.len(), 1);

    // "schema" value is an object
    let schema = obj.get("schema").expect("should have schema key");
    let schema_obj = schema.as_object().expect("schema should be object");

    // schema has one entry with a unit key
    assert_eq!(schema_obj.len(), 1);
    let entry = &schema_obj.entries[0];

    // Key is unit (@ as a key means unit key)
    assert!(
        entry.key.is_unit(),
        "key should be unit, got {:?}",
        entry.key
    );

    // Value is @object{...} - a tagged value with tag "object" and object payload
    assert_eq!(
        entry.value.tag_name(),
        Some("object"),
        "value should have tag 'object'"
    );

    // The payload of @object{...} is the inner object { name @string }
    let payload = entry
        .value
        .payload
        .as_ref()
        .expect("@object should have payload");
    let payload_obj = match payload {
        value::Payload::Object(obj) => obj,
        _ => panic!("payload should be object, got {:?}", payload),
    };
    assert_eq!(payload_obj.len(), 1);

    // "name" entry
    let name_entry = &payload_obj.entries[0];
    assert_eq!(name_entry.key.as_str(), Some("name"));

    // Value is tagged with "string", no payload
    assert_eq!(
        name_entry.value.tag_name(),
        Some("string"),
        "@string should have tag 'string'"
    );
    assert!(
        name_entry.value.payload.is_none(),
        "@string should have no payload"
    );
}