1#![doc = include_str!("../README.md")]
2#![allow(clippy::result_large_err)]
3
4mod analysis;
5mod ast;
6mod de;
7mod error;
8mod eval;
9mod format;
10mod limits;
11mod loader;
12mod parser;
13mod ser;
14mod source;
15mod value;
16
17use std::path::Path;
18
19pub use analysis::{
20 AnalyzedDocument, Comment, CommentKind, Definition, DefinitionKind, Diagnostic,
21 DiagnosticRelatedInformation, DiagnosticSeverity, FileSourceStore, FormatOptions,
22 IncludeReference, ParseOptions, ParsedDocument, Reference, ReferenceKind, SourcePosition,
23 SourceRange, SourceStore, Symbol, Utf16Position, analyze_file, analyze_file_with_store,
24 analyze_source, diagnostic_from_error, format_source, get_path, parse_source, resolve_file,
25 resolve_source,
26};
27pub use error::{Error, ErrorCode, Result};
28pub use limits::{Limits, LoadOptions};
29pub use source::{LineIndex, Token, TokenKind};
30pub use value::{Number, Value};
31
32pub const VERSION: &str = env!("CARGO_PKG_VERSION");
33
34#[doc(hidden)]
35pub mod __private {
36 use indexmap::IndexMap;
37 use serde::Serialize;
38
39 use crate::Value;
40
41 pub fn new_object() -> IndexMap<String, Value> {
42 IndexMap::new()
43 }
44
45 pub fn insert_object(object: &mut IndexMap<String, Value>, key: String, value: Value) {
46 object.insert(key, value);
47 }
48
49 pub fn key_to_string<T>(key: &T) -> String
50 where
51 T: Serialize,
52 {
53 match to_value(key) {
54 Value::String(value) => value,
55 other => panic!(
56 "scon! object keys must serialize as strings, found {}",
57 type_name(&other)
58 ),
59 }
60 }
61
62 pub fn to_value<T>(value: &T) -> Value
63 where
64 T: Serialize,
65 {
66 crate::to_value(value).expect("scon! failed to serialize interpolated value")
67 }
68
69 fn type_name(value: &Value) -> &'static str {
70 match value {
71 Value::Null => "null",
72 Value::Bool(_) => "boolean",
73 Value::Number(_) => "number",
74 Value::String(_) => "string",
75 Value::Array(_) => "array",
76 Value::Object(_) => "object",
77 }
78 }
79}
80
81#[macro_export]
100macro_rules! scon {
101 (@array [$($elems:expr,)*]) => {
102 vec![$($elems,)*]
103 };
104
105 (@array [$($elems:expr),*]) => {
106 vec![$($elems),*]
107 };
108
109 (@array [$($elems:expr,)*] null $($rest:tt)*) => {
110 $crate::scon!(@array [$($elems,)* $crate::scon!(@value null)] $($rest)*)
111 };
112
113 (@array [$($elems:expr,)*] true $($rest:tt)*) => {
114 $crate::scon!(@array [$($elems,)* $crate::scon!(@value true)] $($rest)*)
115 };
116
117 (@array [$($elems:expr,)*] false $($rest:tt)*) => {
118 $crate::scon!(@array [$($elems,)* $crate::scon!(@value false)] $($rest)*)
119 };
120
121 (@array [$($elems:expr,)*] [$($array:tt)*] $($rest:tt)*) => {
122 $crate::scon!(@array [$($elems,)* $crate::scon!(@value [$($array)*])] $($rest)*)
123 };
124
125 (@array [$($elems:expr,)*] {$($object:tt)*} $($rest:tt)*) => {
126 $crate::scon!(@array [$($elems,)* $crate::scon!(@value {$($object)*})] $($rest)*)
127 };
128
129 (@array [$($elems:expr,)*] $next:expr, $($rest:tt)*) => {
130 $crate::scon!(@array [$($elems,)* $crate::scon!(@value $next),] $($rest)*)
131 };
132
133 (@array [$($elems:expr,)*] $last:expr) => {
134 $crate::scon!(@array [$($elems,)* $crate::scon!(@value $last)])
135 };
136
137 (@array [$($elems:expr),*] , $($rest:tt)*) => {
138 $crate::scon!(@array [$($elems,)*] $($rest)*)
139 };
140
141 (@object $object:ident () () ()) => {};
142
143 (@object $object:ident [$($key:tt)+] ($value:expr) , $($rest:tt)*) => {
144 $crate::__private::insert_object(
145 &mut $object,
146 $crate::scon!(@key $($key)+),
147 $value,
148 );
149 $crate::scon!(@object $object () ($($rest)*) ($($rest)*));
150 };
151
152 (@object $object:ident [$($key:tt)+] ($value:expr) $unexpected:tt $($rest:tt)*) => {
153 compile_error!(concat!("unexpected token in scon! object: ", stringify!($unexpected)));
154 };
155
156 (@object $object:ident [$($key:tt)+] ($value:expr)) => {
157 $crate::__private::insert_object(
158 &mut $object,
159 $crate::scon!(@key $($key)+),
160 $value,
161 );
162 };
163
164 (@object $object:ident ($($key:tt)+) (: null $($rest:tt)*) $copy:tt) => {
165 $crate::scon!(@object $object [$($key)+] ($crate::scon!(@value null)) $($rest)*);
166 };
167
168 (@object $object:ident ($($key:tt)+) (: true $($rest:tt)*) $copy:tt) => {
169 $crate::scon!(@object $object [$($key)+] ($crate::scon!(@value true)) $($rest)*);
170 };
171
172 (@object $object:ident ($($key:tt)+) (: false $($rest:tt)*) $copy:tt) => {
173 $crate::scon!(@object $object [$($key)+] ($crate::scon!(@value false)) $($rest)*);
174 };
175
176 (@object $object:ident ($($key:tt)+) (: [$($array:tt)*] $($rest:tt)*) $copy:tt) => {
177 $crate::scon!(@object $object [$($key)+] ($crate::scon!(@value [$($array)*])) $($rest)*);
178 };
179
180 (@object $object:ident ($($key:tt)+) (: {$($map:tt)*} $($rest:tt)*) $copy:tt) => {
181 $crate::scon!(@object $object [$($key)+] ($crate::scon!(@value {$($map)*})) $($rest)*);
182 };
183
184 (@object $object:ident ($($key:tt)+) (: $value:expr , $($rest:tt)*) $copy:tt) => {
185 $crate::scon!(@object $object [$($key)+] ($crate::scon!(@value $value)) , $($rest)*);
186 };
187
188 (@object $object:ident ($($key:tt)+) (: $value:expr) $copy:tt) => {
189 $crate::scon!(@object $object [$($key)+] ($crate::scon!(@value $value)));
190 };
191
192 (@object $object:ident ($($key:tt)+) (:) $copy:tt) => {
193 compile_error!("missing value in scon! object");
194 };
195
196 (@object $object:ident ($($key:tt)+) () $copy:tt) => {
197 compile_error!("missing colon and value in scon! object");
198 };
199
200 (@object $object:ident () (: $($rest:tt)*) ($colon:tt $($copy:tt)*)) => {
201 compile_error!("unexpected colon in scon! object");
202 };
203
204 (@object $object:ident ($($key:tt)*) (, $($rest:tt)*) ($comma:tt $($copy:tt)*)) => {
205 compile_error!("unexpected comma in scon! object key");
206 };
207
208 (@object $object:ident () (($key:expr) : $($rest:tt)*) $copy:tt) => {
209 $crate::scon!(@object $object (($key)) (: $($rest)*) (: $($rest)*));
210 };
211
212 (@object $object:ident ($($key:tt)*) (: $($unexpected:tt)+) $copy:tt) => {
213 compile_error!("invalid expression in scon! object value");
214 };
215
216 (@object $object:ident ($($key:tt)*) ($tt:tt $($rest:tt)*) $copy:tt) => {
217 $crate::scon!(@object $object ($($key)* $tt) ($($rest)*) ($($rest)*));
218 };
219
220 (@key $key:ident) => {
221 stringify!($key).to_string()
222 };
223
224 (@key ($key:expr)) => {
225 $crate::__private::key_to_string(&$key)
226 };
227
228 (@key $key:literal) => {
229 $crate::__private::key_to_string(&$key)
230 };
231
232 (@value null) => {
233 $crate::Value::Null
234 };
235
236 (@value true) => {
237 $crate::Value::Bool(true)
238 };
239
240 (@value false) => {
241 $crate::Value::Bool(false)
242 };
243
244 (@value []) => {
245 $crate::Value::Array(vec![])
246 };
247
248 (@value [ $($tt:tt)+ ]) => {
249 $crate::Value::Array($crate::scon!(@array [] $($tt)+))
250 };
251
252 (@value {}) => {
253 $crate::Value::Object($crate::__private::new_object())
254 };
255
256 (@value { $($tt:tt)+ }) => {
257 $crate::Value::Object({
258 let mut object = $crate::__private::new_object();
259 $crate::scon!(@object object () ($($tt)+) ($($tt)+));
260 object
261 })
262 };
263
264 (@value $other:expr) => {
265 $crate::__private::to_value(&$other)
266 };
267
268 ($($scon:tt)+) => {
269 $crate::scon!(@value $($scon)+)
270 };
271}
272
273pub fn from_str<T>(source: &str) -> Result<T>
274where
275 T: serde::de::DeserializeOwned,
276{
277 let doc = parser::parse_str(source, None)?;
278 let resolved = eval::eval_resolved_document(doc, &mut loader::NoopLoader)?;
279 de::from_resolved(&resolved)
280}
281
282pub fn from_file<T>(path: impl AsRef<Path>) -> Result<T>
283where
284 T: serde::de::DeserializeOwned,
285{
286 from_file_with_options(path, LoadOptions::default())
287}
288
289pub fn to_string<T>(value: &T) -> Result<String>
290where
291 T: serde::Serialize,
292{
293 let value = to_value(value)?;
294 format::to_string(&value)
295}
296
297pub fn to_string_value(value: &Value) -> Result<String> {
298 format::to_string(value)
299}
300
301pub fn to_string_fragment(value: &Value) -> String {
302 format::to_fragment_string(value)
303}
304
305pub fn parse_str(source: &str) -> Result<Value> {
306 let doc = parser::parse_str(source, None)?;
307 eval::eval_document(doc, &mut loader::NoopLoader)
308}
309
310pub fn parse_file(path: impl AsRef<Path>) -> Result<Value> {
311 parse_file_with_options(path, LoadOptions::default())
312}
313
314pub fn parse_file_with_options(path: impl AsRef<Path>, options: LoadOptions) -> Result<Value> {
315 let mut loader = loader::FileLoader::new(path.as_ref(), options)?;
316 let doc = loader.load_entry()?;
317 eval::eval_document(doc, &mut loader)
318}
319
320pub fn from_file_with_options<T>(path: impl AsRef<Path>, options: LoadOptions) -> Result<T>
321where
322 T: serde::de::DeserializeOwned,
323{
324 let mut loader = loader::FileLoader::new(path.as_ref(), options)?;
325 let doc = loader.load_entry()?;
326 let resolved = eval::eval_resolved_document(doc, &mut loader)?;
327 de::from_resolved(&resolved)
328}
329
330pub fn to_value<T>(value: &T) -> Result<Value>
331where
332 T: serde::Serialize,
333{
334 value.serialize(ser::Serializer)
335}
336
337pub fn from_value<T>(value: Value) -> Result<T>
338where
339 T: serde::de::DeserializeOwned,
340{
341 T::deserialize(de::Deserializer::new(value))
342}
343
344#[cfg(test)]
345mod tests {
346 use super::*;
347 use indexmap::IndexMap;
348 use serde::{Deserialize, Serialize};
349 use std::collections::HashMap;
350 use std::fs;
351 use std::path::{Path, PathBuf};
352
353 #[derive(Debug, Deserialize, PartialEq, Serialize)]
354 struct Server {
355 host: String,
356 port: u16,
357 tls: Option<bool>,
358 }
359
360 #[derive(Debug, Deserialize, PartialEq, Serialize)]
361 struct App {
362 name: String,
363 server: Server,
364 paths: Vec<String>,
365 }
366
367 #[test]
368 fn deserializes_structs_from_resolved_scon() {
369 let app: App = from_str(
370 r#"
371 defaults {
372 host = "127.0.0.1"
373 port = 8080
374 }
375
376 name = "demo"
377 server {
378 ...${defaults}
379 port = 9090
380 tls = true
381 }
382 base_paths = ["/bin", "/usr/bin"]
383 paths = [...${base_paths}, "/opt/bin"]
384 "#,
385 )
386 .unwrap();
387
388 assert_eq!(
389 app,
390 App {
391 name: "demo".to_string(),
392 server: Server {
393 host: "127.0.0.1".to_string(),
394 port: 9090,
395 tls: Some(true),
396 },
397 paths: vec![
398 "/bin".to_string(),
399 "/usr/bin".to_string(),
400 "/opt/bin".to_string()
401 ],
402 }
403 );
404 }
405
406 #[test]
407 fn serializes_and_round_trips_structs() {
408 let app = App {
409 name: "demo".to_string(),
410 server: Server {
411 host: "127.0.0.1".to_string(),
412 port: 8080,
413 tls: None,
414 },
415 paths: vec!["/bin".to_string()],
416 };
417
418 let text = to_string(&app).unwrap();
419 assert!(text.contains("name = \"demo\""));
420 assert!(text.ends_with('\n'));
421
422 let round_trip: App = from_str(&text).unwrap();
423 assert_eq!(round_trip, app);
424 }
425
426 #[test]
427 fn parse_str_returns_value() {
428 let value = parse_str(r#"a.b = 1"#).unwrap();
429 let mut b = IndexMap::new();
430 b.insert("b".to_string(), Value::Number(Number::from_u64(1)));
431 let mut a = IndexMap::new();
432 a.insert("a".to_string(), Value::Object(b));
433 assert_eq!(value, Value::Object(a));
434 }
435
436 #[test]
437 fn parses_numbers_into_explicit_number_variants() {
438 let value = parse_str(
439 r#"
440 zero = 0
441 max = 18446744073709551615
442 negative = -9223372036854775808
443 decimal = 1.25
444 exponent = 1e2
445 "#,
446 )
447 .unwrap();
448 let Value::Object(root) = value else {
449 panic!("expected object root");
450 };
451
452 assert_eq!(root["zero"], Value::Number(Number::from_u64(0)));
453 assert_eq!(root["max"], Value::Number(Number::from_u64(u64::MAX)));
454 assert_eq!(root["negative"], Value::Number(Number::from_i64(i64::MIN)));
455 assert_eq!(root["decimal"], Value::Number(Number::F64(1.25)));
456 assert_eq!(root["exponent"], Value::Number(Number::F64(100.0)));
457 }
458
459 #[test]
460 fn rejects_numbers_outside_the_supported_model() {
461 let err = parse_str("too_large = 18446744073709551616").unwrap_err();
462 assert_eq!(err.code, ErrorCode::InvalidNumber);
463
464 let err = parse_str("too_small = -9223372036854775809").unwrap_err();
465 assert_eq!(err.code, ErrorCode::InvalidNumber);
466
467 let err = parse_str("too_large_float = 1e9999").unwrap_err();
468 assert_eq!(err.code, ErrorCode::InvalidNumber);
469 }
470
471 #[test]
472 fn deserializes_numbers_with_checked_integer_conversions() {
473 #[derive(Debug, Deserialize, PartialEq)]
474 struct Ports {
475 small: u8,
476 signed: i16,
477 ratio: f32,
478 }
479
480 let ports: Ports = from_str(
481 r#"
482 small = 255
483 signed = -128
484 ratio = 1.5
485 "#,
486 )
487 .unwrap();
488 assert_eq!(
489 ports,
490 Ports {
491 small: 255,
492 signed: -128,
493 ratio: 1.5,
494 }
495 );
496
497 assert_eq!(
498 from_str::<Ports>("small = 256\nsigned = 0\nratio = 1.0")
499 .unwrap_err()
500 .code,
501 ErrorCode::Serde
502 );
503 assert_eq!(
504 from_str::<Ports>("small = -1\nsigned = 0\nratio = 1.0")
505 .unwrap_err()
506 .code,
507 ErrorCode::Serde
508 );
509 }
510
511 #[test]
512 fn serializes_numbers_into_explicit_number_variants() {
513 assert_eq!(
514 to_value(&-1i64).unwrap(),
515 Value::Number(Number::from_i64(-1))
516 );
517 assert_eq!(to_value(&1u64).unwrap(), Value::Number(Number::from_u64(1)));
518 assert_eq!(
519 to_value(&1.25f64).unwrap(),
520 Value::Number(Number::F64(1.25))
521 );
522 assert_eq!(
523 to_string_fragment(&Value::Number(Number::F64(1.0))),
524 "1.0\n"
525 );
526 }
527
528 #[test]
529 fn rejects_forward_references() {
530 let err = parse_str(
531 r#"
532 url = "http://${host}"
533 host = "127.0.0.1"
534 "#,
535 )
536 .unwrap_err();
537 assert_eq!(err.code, ErrorCode::MissingReference);
538 }
539
540 #[test]
541 fn rejects_space_separated_object_members() {
542 let err = parse_str(
543 r#"
544 a = 1 b = 2
545 "#,
546 )
547 .unwrap_err();
548 assert_eq!(err.code, ErrorCode::UnexpectedToken);
549 }
550
551 #[test]
552 fn accepts_crlf_and_rejects_standalone_cr() {
553 let value = parse_str("a = 1\r\nb = 2\r\n").unwrap();
554 let Value::Object(root) = value else {
555 panic!("expected object root");
556 };
557 assert_eq!(root["a"], Value::Number(Number::from_u64(1)));
558 assert_eq!(root["b"], Value::Number(Number::from_u64(2)));
559
560 let err = parse_str("a = 1\rb = 2").unwrap_err();
561 assert_eq!(err.code, ErrorCode::InvalidCharacter);
562
563 let err = parse_str("a = \r\n1").unwrap_err();
564 assert_eq!(err.code, ErrorCode::UnexpectedToken);
565 }
566
567 #[test]
568 fn format_source_preserves_comments_and_composition() {
569 let formatted = format_source(
570 r#"
571# leading
572defaults { // inline
573host="127.0.0.1"
574}
575server {
576...${defaults}
577url="http://${defaults.host}"
578}
579"#,
580 FormatOptions::default(),
581 )
582 .unwrap();
583
584 assert!(formatted.contains("# leading"));
585 assert!(formatted.contains("// inline"));
586 assert!(formatted.contains("...${defaults}"));
587 assert!(formatted.contains("url = \"http://${defaults.host}\""));
588 }
589
590 #[test]
591 fn format_source_uses_ast_trivia_golden_output() {
592 let formatted = format_source(
593 r#"
594# leading
595include "./base.scon"
596defaults { // inline
597host="127.0.0.1"
598}
599server {
600...${defaults}
601paths=[...${base_paths},"/opt/bin"]
602url="http://${defaults.host}" // url
603}
604"#,
605 FormatOptions::default(),
606 )
607 .unwrap();
608
609 assert_eq!(
610 formatted,
611 r#"# leading
612include "./base.scon"
613defaults { // inline
614 host = "127.0.0.1"
615}
616server {
617 ...${defaults}
618 paths = [
619 ...${base_paths},
620 "/opt/bin"
621 ]
622 url = "http://${defaults.host}" // url
623}
624"#
625 );
626 }
627
628 #[test]
629 fn format_source_round_trips_resolved_value() {
630 let source = r#"
631defaults {
632host = "127.0.0.1"
633}
634base_paths = ["/bin", "/usr/bin"]
635server {
636...${defaults}
637paths = [...${base_paths}, "/opt/bin"]
638url = "http://${defaults.host}"
639}
640"#;
641
642 let formatted = format_source(source, FormatOptions::default()).unwrap();
643 parse_source(&formatted, ParseOptions::default()).unwrap();
644 assert_eq!(parse_str(source).unwrap(), parse_str(&formatted).unwrap());
645 }
646
647 #[test]
648 fn format_source_escapes_interpolation_in_quoted_keys() {
649 let formatted = format_source(r#""\${literal}" = true"#, FormatOptions::default()).unwrap();
650
651 parse_source(&formatted, ParseOptions::default()).unwrap();
652 assert_eq!(
653 parse_str(r#""\${literal}" = true"#).unwrap(),
654 parse_str(&formatted).unwrap()
655 );
656 }
657
658 #[test]
659 fn line_index_maps_utf8_and_utf16_positions() {
660 let source = "name = \"\u{1F980}\"\nnext = 1\n";
661 let index = LineIndex::new(source);
662 let crab = '\u{1F980}';
663 let crab_byte = source.find(crab).unwrap();
664
665 let source_position = index.source_position(source, crab_byte);
666 assert_eq!(source_position.line, 0);
667 assert_eq!(source_position.character, 8);
668 assert_eq!(index.byte_for_line_character(source, 0, 8), Some(crab_byte));
669
670 let after_crab = crab_byte + crab.len_utf8();
671 let utf16 = index.utf16_position(source, after_crab);
672 assert_eq!(utf16.line, 0);
673 assert_eq!(utf16.character, 10);
674 assert_eq!(
675 index.byte_for_utf16_position(source, 0, 10),
676 Some(after_crab)
677 );
678 assert_eq!(index.byte_for_utf16_position(source, 0, 9), None);
679 }
680
681 #[test]
682 fn parse_source_exposes_parser_backed_comments_tokens_and_symbols() {
683 let parsed = parse_source(
684 r#"
685# leading
686server {
687 host = "127.0.0.1" // inline
688}
689"#,
690 ParseOptions::default(),
691 )
692 .unwrap();
693
694 assert_eq!(parsed.comments.len(), 2);
695 assert!(
696 parsed
697 .tokens
698 .iter()
699 .any(|token| matches!(token.kind, TokenKind::Comment(_)))
700 );
701 assert!(
702 parsed
703 .symbols
704 .iter()
705 .any(|symbol| symbol.path == vec!["server"])
706 );
707 assert!(
708 parsed
709 .symbols
710 .iter()
711 .any(|symbol| symbol.path == vec!["server", "host"])
712 );
713 }
714
715 #[test]
716 fn analyze_source_exposes_definitions_references_and_targets() {
717 let analysis = analyze_source(
718 r#"
719defaults {
720 host = "127.0.0.1"
721}
722base_paths = ["/bin"]
723server {
724 ...${defaults}
725 paths = [...${base_paths}]
726 host_copy = ${defaults.host}
727 url = "http://${defaults.host}"
728}
729"#,
730 ParseOptions::default(),
731 );
732
733 assert!(analysis.diagnostics.is_empty());
734 assert!(analysis.value.is_some());
735 assert!(
736 analysis
737 .definitions
738 .iter()
739 .any(|definition| definition.path == vec!["defaults", "host"])
740 );
741 assert!(analysis.references.iter().any(|reference| {
742 reference.kind == ReferenceKind::ObjectSpread
743 && reference.path == vec!["defaults"]
744 && reference.target.is_some()
745 }));
746 assert!(analysis.references.iter().any(|reference| {
747 reference.kind == ReferenceKind::ArraySpread
748 && reference.path == vec!["base_paths"]
749 && reference.target.is_some()
750 }));
751 assert!(analysis.references.iter().any(|reference| {
752 reference.kind == ReferenceKind::Interpolation
753 && reference.path == vec!["defaults", "host"]
754 && reference.target.is_some()
755 }));
756 }
757
758 #[test]
759 fn analyze_file_can_use_source_store_for_unsaved_includes() {
760 struct MemoryStore {
761 sources: HashMap<PathBuf, String>,
762 }
763
764 impl SourceStore for MemoryStore {
765 fn read_source(&self, path: &Path) -> std::io::Result<Option<String>> {
766 Ok(self.sources.get(path).cloned())
767 }
768 }
769
770 let root = tempfile::tempdir().unwrap();
771 let root_path = root.path().canonicalize().unwrap();
772 let app = root_path.join("app.scon");
773 let base = root_path.join("base.scon");
774 let mut sources = HashMap::new();
775 sources.insert(
776 app.clone(),
777 r#"
778defaults {
779 host = "0.0.0.0"
780}
781include "./base.scon"
782"#
783 .to_string(),
784 );
785 sources.insert(
786 base.clone(),
787 r#"
788server {
789 host = ${defaults.host}
790}
791"#
792 .to_string(),
793 );
794
795 let store = MemoryStore { sources };
796 let analysis = analyze_file_with_store(&app, LoadOptions::default(), &store);
797
798 assert!(analysis.diagnostics.is_empty());
799 assert!(analysis.value.is_some());
800 assert_eq!(analysis.includes.len(), 1);
801 assert_eq!(analysis.includes[0].resolved_path, Some(base));
802 }
803
804 #[test]
805 fn analyze_source_reports_reference_diagnostic_at_reference_span() {
806 let analysis = analyze_source("a = ${missing}\n", ParseOptions::default());
807 let diagnostic = analysis.diagnostics.first().unwrap();
808 assert_eq!(diagnostic.code, ErrorCode::MissingReference);
809 let range = diagnostic.range.as_ref().unwrap();
810 assert_eq!(range.start.character, 6);
811 assert_eq!(range.end.character, 13);
812 }
813
814 #[test]
815 fn to_string_requires_object_root() {
816 let err = format::to_string(&Value::Array(vec![])).unwrap_err();
817 assert_eq!(err.code, ErrorCode::InvalidRootType);
818 }
819
820 #[test]
821 fn parse_file_evaluates_includes_in_source_order() {
822 let dir = tempfile::tempdir().unwrap();
823 fs::write(
824 dir.path().join("base.scon"),
825 r#"
826 server {
827 host = ${defaults.host}
828 port = 8080
829 }
830 "#,
831 )
832 .unwrap();
833 fs::write(
834 dir.path().join("app.scon"),
835 r#"
836 defaults {
837 host = "0.0.0.0"
838 }
839 include "./base.scon"
840 "#,
841 )
842 .unwrap();
843
844 let value = parse_file(dir.path().join("app.scon")).unwrap();
845 let Value::Object(root) = value else {
846 panic!("expected object root");
847 };
848 let Value::Object(server) = &root["server"] else {
849 panic!("expected server object");
850 };
851 assert_eq!(server["host"], Value::String("0.0.0.0".to_string()));
852 }
853
854 #[test]
855 fn serialization_rejects_non_string_map_keys_and_non_finite_floats() {
856 use std::collections::BTreeMap;
857
858 let mut map = BTreeMap::new();
859 map.insert(1u8, "bad");
860 assert_eq!(to_value(&map).unwrap_err().code, ErrorCode::Serde);
861
862 let value = f64::NAN;
863 assert_eq!(to_value(&value).unwrap_err().code, ErrorCode::Serde);
864 }
865
866 #[test]
867 fn quoted_keys_and_interpolation_escapes_round_trip() {
868 let mut root = IndexMap::new();
869 root.insert(
870 "read.only".to_string(),
871 Value::String("${literal}".to_string()),
872 );
873 let text = format::to_string(&Value::Object(root)).unwrap();
874 assert!(text.contains("\"read.only\""));
875 assert!(text.contains("\"\\${literal}\""));
876
877 let parsed = parse_str(&text).unwrap();
878 let Value::Object(root) = parsed else {
879 panic!("expected object root");
880 };
881 assert_eq!(root["read.only"], Value::String("${literal}".to_string()));
882 }
883
884 #[test]
885 fn scon_macro_builds_nested_values() {
886 let port = 8080u64;
887 let dynamic_key = String::from("read.only");
888
889 let value = scon!({
890 name: "demo",
891 "enabled": true,
892 (dynamic_key): false,
893 port: port,
894 paths: ["/bin", "/usr/bin",],
895 server: {
896 host: "127.0.0.1",
897 tls: null,
898 },
899 });
900
901 let Value::Object(root) = value else {
902 panic!("expected object root");
903 };
904 assert_eq!(root["name"], Value::String("demo".to_string()));
905 assert_eq!(root["enabled"], Value::Bool(true));
906 assert_eq!(root["read.only"], Value::Bool(false));
907 assert_eq!(root["port"], Value::Number(Number::from_u64(8080)));
908 assert_eq!(
909 root["paths"],
910 Value::Array(vec![
911 Value::String("/bin".to_string()),
912 Value::String("/usr/bin".to_string()),
913 ])
914 );
915
916 let Value::Object(server) = &root["server"] else {
917 panic!("expected server object");
918 };
919 assert_eq!(server["host"], Value::String("127.0.0.1".to_string()));
920 assert_eq!(server["tls"], Value::Null);
921 }
922
923 #[test]
924 fn scon_macro_builds_empty_arrays_and_objects() {
925 assert_eq!(scon!([]), Value::Array(vec![]));
926 assert_eq!(scon!({}), Value::Object(IndexMap::new()));
927 }
928
929 #[test]
930 fn scon_macro_formats_fragment() {
931 let value = scon!({
932 list: [1u64, 2u64],
933 });
934
935 assert_eq!(
936 to_string_fragment(&value),
937 "{\n list = [\n 1,\n 2,\n ]\n}\n"
938 );
939 }
940
941 #[test]
942 fn scon_macro_uses_rust_numeric_semantics() {
943 assert_eq!(scon!(1), Value::Number(Number::from_i64(1)));
944 assert_eq!(scon!(1u64), Value::Number(Number::from_u64(1)));
945 assert_eq!(scon!(-1i64), Value::Number(Number::from_i64(-1)));
946 assert_eq!(
947 scon!(1.25f64),
948 Value::Number(Number::from_f64(1.25).unwrap())
949 );
950 }
951
952 #[test]
953 #[should_panic(expected = "scon! object keys must serialize as strings")]
954 fn scon_macro_rejects_non_string_dynamic_keys() {
955 let _ = scon!({
956 (1u64): "bad",
957 });
958 }
959
960 #[test]
961 #[should_panic(expected = "scon! failed to serialize interpolated value")]
962 fn scon_macro_rejects_non_finite_float_values() {
963 let _ = scon!(f64::NAN);
964 }
965}