tier 0.1.14

Rust configuration library for layered TOML, env, and CLI settings
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

use super::*;

/// Prefixes child metadata paths with a parent field name.
#[must_use]
pub fn prefixed_metadata(
    prefix: &str,
    prefix_aliases: Vec<String>,
    metadata: ConfigMetadata,
) -> ConfigMetadata {
    let prefix = if prefix.is_empty() {
        String::new()
    } else {
        try_normalize_metadata_path(prefix)
            .ok()
            .filter(|normalized| !normalized.is_empty())
            .unwrap_or_else(|| prefix.to_owned())
    };
    if prefix.is_empty() {
        return metadata;
    }
    let prefix_aliases = prefix_aliases
        .into_iter()
        .map(|alias| {
            if alias.is_empty() {
                alias
            } else {
                try_normalize_metadata_path(&alias)
                    .ok()
                    .filter(|normalized| !normalized.is_empty())
                    .unwrap_or(alias)
            }
        })
        .collect::<Vec<_>>();

    let mut prefixed = ConfigMetadata::from_fields(metadata.fields.into_iter().map(|field| {
        let canonical_suffix = field.path.clone();
        let alias_suffixes = if field.aliases.is_empty() {
            vec![canonical_suffix.clone()]
        } else {
            let mut suffixes = vec![canonical_suffix.clone()];
            suffixes.extend(field.aliases.iter().cloned());
            suffixes
        };

        let path = if canonical_suffix.is_empty() {
            prefix.clone()
        } else {
            format!("{prefix}.{}", canonical_suffix)
        };

        let mut aliases = field
            .aliases
            .into_iter()
            .map(|alias| {
                if alias.is_empty() {
                    prefix.clone()
                } else {
                    format!("{prefix}.{}", alias)
                }
            })
            .collect::<Vec<_>>();

        for prefix_alias in &prefix_aliases {
            if canonical_suffix.is_empty() {
                aliases.push(prefix_alias.clone());
                continue;
            }
            for suffix in &alias_suffixes {
                if prefix_alias.is_empty() {
                    aliases.push(suffix.clone());
                } else {
                    aliases.push(format!("{prefix_alias}.{suffix}"));
                }
            }
        }

        FieldMetadata {
            path,
            aliases,
            ..field
        }
    }));
    prefixed.extend_checks(
        metadata
            .checks
            .into_iter()
            .filter_map(|check| check.prefixed(&prefix)),
    );
    prefixed
}