Skip to main content

scon/
lib.rs

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/// Construct a [`Value`] from a SCON-like literal.
82///
83/// ```
84/// # let port = 8080u64;
85/// let value = scon::scon!({
86///     name: "demo",
87///     "read.only": true,
88///     port: port,
89///     paths: ["/bin", "/usr/bin"],
90///     tls: null,
91/// });
92/// # assert!(matches!(value, scon::Value::Object(_)));
93/// ```
94///
95/// Identifier object keys are stringified, string literal keys are accepted
96/// directly, and parenthesized keys are serialized dynamically. Interpolated
97/// Rust expressions must implement [`serde::Serialize`]. Serialization failures
98/// panic, matching the behavior of `serde_json::json!`.
99#[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}