tomlini 0.1.0

SAX TOML/INI parser and editor. Zero-dependency, no footguns.
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
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238

//! Validation tests for tomlini.

use tomlini::{ValidationErrorKind, ValidationMode};

// ---------------------------------------------------------------------------
// duplicate key detection
// ---------------------------------------------------------------------------

#[test]
fn test_duplicate_key_rejected() {
    let mut doc = tomlini::parse("[a]\nb=1\n[a]\nc=2\n").unwrap();
    let errors = doc.validate(ValidationMode::Relaxed);
    assert!(!errors.is_empty(), "expected duplicate key error");
    assert!(
        errors
            .iter()
            .any(|e| matches!(e.kind, ValidationErrorKind::DuplicateKey)),
        "expected DuplicateKey error, got: {:?}",
        errors.iter().map(|e| e.kind).collect::<Vec<_>>(),
    );
}

#[test]
fn test_duplicate_key_within_table() {
    let mut doc = tomlini::parse("[table]\nkey = 1\nkey = 2\n").unwrap();
    let errors = doc.validate(ValidationMode::Relaxed);
    assert!(
        errors
            .iter()
            .any(|e| matches!(e.kind, ValidationErrorKind::DuplicateKey)),
        "expected DuplicateKey error"
    );
}

#[test]
fn test_no_duplicate_distinct_tables() {
    let mut doc = tomlini::parse("[a]\nkey = 1\n[b]\nkey = 2\n").unwrap();
    let errors = doc.validate(ValidationMode::Relaxed);
    // Same key name in different tables is fine
    assert!(
        !errors
            .iter()
            .any(|e| matches!(e.kind, ValidationErrorKind::DuplicateKey)),
        "should not report duplicate for same key in different tables"
    );
}

// ---------------------------------------------------------------------------
// table conflict detection
// ---------------------------------------------------------------------------

#[test]
fn test_table_conflict() {
    let mut doc = tomlini::parse("a = 1\n[a.b]\nc = 2\n").unwrap();
    let errors = doc.validate(ValidationMode::Relaxed);
    assert!(
        errors
            .iter()
            .any(|e| matches!(e.kind, ValidationErrorKind::TableConflict)),
        "expected TableConflict error, got: {:?}",
        errors.iter().map(|e| e.kind).collect::<Vec<_>>(),
    );
}

#[test]
fn test_no_table_conflict_valid_nesting() {
    let mut doc = tomlini::parse("[a]\nb = 1\n[a.c]\nd = 2\n").unwrap();
    let errors = doc.validate(ValidationMode::Relaxed);
    assert!(
        !errors
            .iter()
            .any(|e| matches!(e.kind, ValidationErrorKind::TableConflict)),
        "should not report conflict for valid table nesting"
    );
}

#[test]
fn test_table_conflict_dotted_key() {
    // a.b = 1 means 'a' is implicitly a table containing 'b'. Then [a] redefines it.
    let mut doc = tomlini::parse("a.b = 1\n[a]\nc = 2\n").unwrap();
    let errors = doc.validate(ValidationMode::Relaxed);
    // The implicit table 'a' from dotted key vs explicit [a] table — this is a conflict
    assert!(
        errors
            .iter()
            .any(|e| matches!(e.kind, ValidationErrorKind::TableConflict)),
        "expected TableConflict error for dotted key + table conflict"
    );
}

// ---------------------------------------------------------------------------
// AOT ordering
// ---------------------------------------------------------------------------

#[test]
fn test_aot_ordering_non_consecutive() {
    let mut doc = tomlini::parse("[[a]]\nx = 1\n[[b]]\ny = 2\n[[a]]\nz = 3\n").unwrap();
    let errors = doc.validate(ValidationMode::Relaxed);
    assert!(
        errors
            .iter()
            .any(|e| matches!(e.kind, ValidationErrorKind::AotOrdering)),
        "expected AotOrdering error"
    );
}

#[test]
fn test_aot_ordering_consecutive_ok() {
    let mut doc = tomlini::parse("[[a]]\nx = 1\n[[a]]\ny = 2\n").unwrap();
    let errors = doc.validate(ValidationMode::Relaxed);
    assert!(
        !errors
            .iter()
            .any(|e| matches!(e.kind, ValidationErrorKind::AotOrdering)),
        "consecutive AOT entries should be valid"
    );
}

// ---------------------------------------------------------------------------
// INI semicolon comment support
// ---------------------------------------------------------------------------

#[test]
fn test_ini_comment_accepted() {
    // Semicolons are always treated as comments now
    let doc = tomlini::parse("; this is a comment\nkey = 1\n").unwrap();
    // Verify the comment span is there
    let comment_spans: Vec<_> = doc
        .spans
        .iter()
        .filter(|s| s.kind == tomlini::SpanKind::Comment)
        .collect();
    assert!(!comment_spans.is_empty(), "expected a comment span for `;`");
    // Verify the key is correctly parsed
    assert!(doc.spans.iter().any(|s| {
        s.kind == tomlini::SpanKind::BareKey
            && &doc.source[s.start as usize..s.end as usize] == "key"
    }));
}

#[test]
fn test_semicolon_comment_mid_line() {
    // Not valid as an inline comment — ; is only a comment at line start (after whitespace).
    // But the parser treats bare `;` as a comment regardless of position in the main loop.
    // For now, verify parse doesn't crash.
    let result = tomlini::parse("key = 1 ; trailing\n");
    // May or may not parse depending on how `;` interacts with the value context.
    // The key point is it shouldn't panic.
    let _ = result;
}

#[test]
fn test_hash_comment_still_works() {
    let doc = tomlini::parse("# this is a comment\nkey = 1\n").unwrap();
    let comment_spans: Vec<_> = doc
        .spans
        .iter()
        .filter(|s| s.kind == tomlini::SpanKind::Comment)
        .collect();
    assert!(!comment_spans.is_empty(), "expected a comment span for `#`");
}

// ---------------------------------------------------------------------------
// strict mode checks
#[test]
fn test_strict_rejects_control_chars() {
    // Parse a document with a raw control character (form feed 0x0C).
    // The parser treats unknown bytes as BareKey, so \x0C becomes a 1-byte "bare key".
    // The validator checks all source bytes for control chars.
    let input = "key = 1\n\x0C\n";
    let mut doc = tomlini::parse(input).unwrap();
    let errors = doc.validate(ValidationMode::Strict);

    let has_control = errors
        .iter()
        .any(|e| matches!(e.kind, ValidationErrorKind::ControlCharacter));
    assert!(
        has_control,
        "expected ControlCharacter error for form feed (0x0C)"
    );
}

#[test]
fn test_strict_bare_key_validation() {
    // A bare key with an invalid character like `!` is accepted by the parser
    // (emitted as BareKey) but invalid in strict TOML.
    let mut doc = tomlini::parse("key! = 1\n").unwrap();
    let errors = doc.validate(ValidationMode::Strict);
    assert!(
        errors
            .iter()
            .any(|e| matches!(e.kind, ValidationErrorKind::InvalidKey)),
        "expected InvalidKey error for bare key with invalid char `!`, got: {:?}",
        errors.iter().map(|e| (e.kind, &e.msg)).collect::<Vec<_>>(),
    );
}

#[test]
fn test_strict_valid_bare_key() {
    let mut doc = tomlini::parse("my_key = 1\n").unwrap();
    let errors = doc.validate(ValidationMode::Strict);
    assert!(
        !errors
            .iter()
            .any(|e| matches!(e.kind, ValidationErrorKind::InvalidKey)),
        "valid bare key should not produce InvalidKey error"
    );
}

// ---------------------------------------------------------------------------
// mode behavior
// ---------------------------------------------------------------------------

#[test]
fn test_lenient_accepts_everything() {
    // Lenient mode still catches duplicate keys/tables (always checked)
    let mut doc = tomlini::parse("[ok]\nkey=1\n[other]\nval=2\n").unwrap();
    let errors = doc.validate(ValidationMode::Lenient);
    assert!(
        errors.is_empty(),
        "lenient mode should produce no errors for valid doc"
    );
}

#[test]
fn test_relaxed_accepts_loose_keys() {
    // Relaxed mode allows loose key syntax (like INI-style shenanigans)
    // but still checks structural rules
    let mut doc = tomlini::parse("[ok]\nkey = 1\n").unwrap();
    let errors = doc.validate(ValidationMode::Relaxed);
    // No structural errors expected
    assert!(
        !errors
            .iter()
            .any(|e| matches!(e.kind, ValidationErrorKind::InvalidKey)),
        "relaxed mode should not check key syntax"
    );
}