tier 0.1.17

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
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

use std::collections::BTreeSet;

use serde_json::Value;

use crate::path::{ExternalPathSegment, normalize_path};

pub(super) fn parse_patch_path(path: &str) -> Result<(Vec<String>, BTreeSet<usize>), String> {
    let mut explicit_array_segments = BTreeSet::new();
    let segments = crate::path::parse_external_path(path)?
        .into_iter()
        .enumerate()
        .map(|(index, segment)| {
            if matches!(&segment, ExternalPathSegment::Index(_)) {
                explicit_array_segments.insert(index);
            }
            segment.value().to_owned()
        })
        .collect();

    Ok((segments, explicit_array_segments))
}

pub(super) fn canonicalize_patch_path(
    root: &Value,
    segments: &[String],
    explicit_array_segments: &BTreeSet<usize>,
) -> (Vec<String>, BTreeSet<usize>) {
    enum PatchShape<'a> {
        Value(&'a Value),
        Object,
        Array,
    }

    let mut canonical = Vec::with_capacity(segments.len());
    let mut array_segments = BTreeSet::new();
    let mut current = PatchShape::Value(root);
    let mut index = 0;

    while index < segments.len() {
        let segment = &segments[index];
        let is_last = index + 1 == segments.len();
        let next_is_explicit_array = !is_last && explicit_array_segments.contains(&(index + 1));

        match current {
            PatchShape::Value(Value::Object(map)) => {
                canonical.push(segment.clone());
                current = if is_last {
                    PatchShape::Object
                } else if let Some(next) = map.get(segment) {
                    PatchShape::Value(next)
                } else if next_is_explicit_array {
                    PatchShape::Array
                } else {
                    PatchShape::Object
                };
            }
            PatchShape::Value(Value::Array(values)) => {
                let Ok(array_index) = segment.parse::<usize>() else {
                    canonical.extend(segments[index..].iter().cloned());
                    break;
                };
                canonical.push(array_index.to_string());
                array_segments.insert(index);
                current = if is_last {
                    PatchShape::Array
                } else if let Some(next) = values.get(array_index) {
                    PatchShape::Value(next)
                } else if next_is_explicit_array {
                    PatchShape::Array
                } else {
                    PatchShape::Object
                };
            }
            PatchShape::Value(_) => {
                canonical.extend(segments[index..].iter().cloned());
                break;
            }
            PatchShape::Object => {
                canonical.push(segment.clone());
                current = if is_last {
                    PatchShape::Object
                } else if next_is_explicit_array {
                    PatchShape::Array
                } else {
                    PatchShape::Object
                };
            }
            PatchShape::Array => {
                let Ok(array_index) = segment.parse::<usize>() else {
                    canonical.extend(segments[index..].iter().cloned());
                    break;
                };
                canonical.push(array_index.to_string());
                array_segments.insert(index);
                current = if is_last || next_is_explicit_array {
                    PatchShape::Array
                } else {
                    PatchShape::Object
                };
            }
        }

        index += 1;
    }

    (canonical, array_segments)
}

pub(super) fn patch_indexed_array_container_paths(
    segments: &[String],
    array_segments: &BTreeSet<usize>,
) -> BTreeSet<String> {
    array_segments
        .iter()
        .map(|index| normalize_path(&segments[..*index].join(".")))
        .collect()
}