oak-toml 0.0.11

High-performance incremental TOML parser for the oak ecosystem with flexible configuration, optimized for configuration files and data serialization.
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
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141

mod lexer;
mod serde;

use oak_core::{Lexer, SourceText};
use oak_toml::{TomlLanguage, TomlLexer, TomlParser, TomlSyntaxKind};

#[test]
fn test_lexer_basic() {
    let language = TomlLanguage::new();
    let lexer = TomlLexer::new(&language);
    let source = SourceText::new(r#"key = "value""#);
    let mut cache = oak_core::ParseSession::<TomlLanguage>::default();

    let result = lexer.lex(&source, &[], &mut cache);
    assert!(result.result.is_ok());

    let tokens = result.result.unwrap();
    assert!(!tokens.is_empty());
    println!("Lexed {} tokens", tokens.len())
}

#[test]
fn test_parser_basic() {
    let language = TomlLanguage::new();
    let parser = TomlParser::new(&language);
    let lexer = TomlLexer::new(&language);
    let source = SourceText::new(r#"key = "value""#);
    let mut cache = oak_core::ParseSession::<TomlLanguage>::default();

    let result = oak_core::parser::parse(&parser, &lexer, &source, &[], &mut cache);
    assert!(result.result.is_ok());

    let tree = result.result.unwrap();
    assert!(!tree.children.is_empty());
    println!("Parsed tree with {} children", tree.children.len())
}

#[test]
fn test_lexer_string() {
    let language = TomlLanguage::new();
    let lexer = TomlLexer::new(&language);
    let source = SourceText::new(r#""hello world""#);
    let mut cache = oak_core::ParseSession::<TomlLanguage>::default();

    let result = lexer.lex(&source, &[], &mut cache);
    assert!(result.result.is_ok());

    let tokens = result.result.unwrap();
    assert!(!tokens.is_empty());

    // Check if string kind exists.
    let has_string = tokens.iter().any(|t| matches!(t.kind, TomlSyntaxKind::BasicString));
    assert!(has_string, "Should contain a string token")
}

#[test]
fn test_lexer_number() {
    let language = TomlLanguage::new();
    let lexer = TomlLexer::new(&language);
    let source = SourceText::new("123");
    let mut cache = oak_core::ParseSession::<TomlLanguage>::default();

    let result = lexer.lex(&source, &[], &mut cache);
    assert!(result.result.is_ok());

    let tokens = result.result.unwrap();
    assert!(!tokens.is_empty());

    // Check if number token exists.
    let has_number = tokens.iter().any(|t| matches!(t.kind, TomlSyntaxKind::Integer | TomlSyntaxKind::Float));
    assert!(has_number, "Should contain a number token")
}

#[test]
fn test_lexer_boolean() {
    let language = TomlLanguage::new();
    let lexer = TomlLexer::new(&language);
    let source = SourceText::new("true");
    let mut cache = oak_core::ParseSession::<TomlLanguage>::default();

    let result = lexer.lex(&source, &[], &mut cache);
    assert!(result.result.is_ok());

    let tokens = result.result.unwrap();
    assert!(!tokens.is_empty());

    // Check if boolean token exists.
    let has_boolean = tokens.iter().any(|t| matches!(t.kind, TomlSyntaxKind::Boolean));
    assert!(has_boolean, "Should contain a boolean token")
}

#[test]
fn test_parser_key_value() {
    let language = TomlLanguage::new();
    let parser = TomlParser::new(&language);
    let lexer = TomlLexer::new(&language);
    let source = SourceText::new(r#"name = "John""#);
    let mut cache = oak_core::ParseSession::<TomlLanguage>::default();

    let result = oak_core::parser::parse(&parser, &lexer, &source, &[], &mut cache);
    assert!(result.result.is_ok());

    let tree = result.result.unwrap();
    assert!(!tree.children.is_empty(), "Parsed tree should have children")
}

#[test]
fn test_parser_table() {
    let language = TomlLanguage::new();
    let parser = TomlParser::new(&language);
    let lexer = TomlLexer::new(&language);
    let source = SourceText::new(
        r#"[section]
name = "value"
"#,
    );
    let mut cache = oak_core::ParseSession::<TomlLanguage>::default();

    let result = oak_core::parser::parse(&parser, &lexer, &source, &[], &mut cache);
    assert!(result.result.is_ok());

    let tree = result.result.unwrap();
    assert!(!tree.children.is_empty(), "Parsed tree should have children")
}

#[test]
fn test_empty_input() {
    let language = TomlLanguage::new();
    let lexer = TomlLexer::new(&language);
    let parser = TomlParser::new(&language);
    let source = SourceText::new("");
    let mut cache = oak_core::ParseSession::<TomlLanguage>::default();

    // Test lexing of empty input
    let lex_result = lexer.lex(&source, &[], &mut cache);
    assert!(lex_result.result.is_ok());

    // Test parsing of empty input
    let parse_result = oak_core::parser::parse(&parser, &lexer, &source, &[], &mut cache);
    assert!(parse_result.result.is_ok())
}