trail-config 0.4.0

A Rust library for reading config files with path-based access, typed deserialization, environment overlays, deep merging, env variable interpolation, and hot reload support.
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

use super::Config;

#[test]
fn escaped_separator_in_key() {
    let yaml = "
database:
  host/port: localhost:5432
  server: db.example.com
";
    let config = Config::load_yaml(yaml, "/").unwrap();

    let value = config.get("database/host\\/port");
    assert!(value.is_some());
    assert_eq!(config.str("database/host\\/port"), "localhost:5432");
}

#[test]
fn escaped_backslash_in_key() {
    let yaml = "
paths:
  'file\\path': C:\\Users\\data
  'normal': value
";
    let config = Config::load_yaml(yaml, "/").unwrap();

    let value = config.get("paths/file\\\\path");
    assert!(value.is_some());
}

#[test]
fn mixed_escaped_and_normal_separators() {
    let yaml = "
config:
  app/version: 1.0
  'db/host:port': localhost:5432
";
    let config = Config::load_yaml(yaml, "/").unwrap();

    let value1 = config.get("config/app\\/version");
    assert!(value1.is_some());
    assert_eq!(config.str("config/app\\/version"), "1.0");

    let value2 = config.get("config/db\\/host:port");
    assert!(value2.is_some());
}

#[test]
fn escape_sequences_in_strict_methods() {
    let yaml = "
database:
  'user/pass': myuser/mypass
";
    let config = Config::load_yaml(yaml, "/").unwrap();

    let result = config.get_strict("database/user\\/pass");
    assert!(result.is_ok());

    let result = config.str_strict("database/user\\/pass");
    assert!(result.is_ok());
    assert_eq!(result.unwrap(), "myuser/mypass");
}

#[test]
fn multibyte_separator_does_not_panic() {
    // '→' is a 3-byte UTF-8 character (E2 86 92).
    // parse_path uses &separator[1..] which is a byte slice —
    // slicing at byte 1 lands inside the multi-byte character and panics.
    let yaml = "
database:
  port: 1234
";
    let config = Config::load_yaml(yaml, "→").unwrap();
    assert_eq!(config.str("database→port"), "1234");
}

#[test]
fn parse_path_basic() {
    let parts = Config::parse_path("a/b/c", "/");
    assert_eq!(parts, vec!["a", "b", "c"]);
}

#[test]
fn parse_path_with_escaped_separator() {
    let parts = Config::parse_path("a/b\\/c/d", "/");
    assert_eq!(parts, vec!["a", "b/c", "d"]);
}

#[test]
fn parse_path_with_escaped_backslash() {
    let parts = Config::parse_path("a/b\\\\c/d", "/");
    assert_eq!(parts, vec!["a", "b\\c", "d"]);
}

#[test]
fn parse_path_multiple_escapes() {
    let parts = Config::parse_path("a\\/b\\/c/d", "/");
    assert_eq!(parts, vec!["a/b/c", "d"]);
}

#[test]
fn parse_path_with_custom_separator() {
    let parts = Config::parse_path("a::b\\::c::d", "::");
    assert_eq!(parts, vec!["a", "b::c", "d"]);
}

#[test]
fn parse_path_escape_requires_full_separator() {
    let parts = Config::parse_path(r"a::b\:c::d", "::");
    assert_eq!(parts, vec!["a", r"b\:c", "d"]);
}