benjamin-bergia/karbon - Change SCCMQCSX6BA6DQKARGW25PVWQPU3MZNZS4RNZ53FXYFCKMI24RGQC

Fix the add transformer. Now handles the '-' at the end of the json pointer like json patches do

Created by ITChap on February 15, 2022

SCCMQCSX6BA6DQKARGW25PVWQPU3MZNZS4RNZ53FXYFCKMI24RGQC

Dependencies

In channels

main

Change contents

Replacement in testApp/overlays/worker/karbon.yml at line 8 [3.4834]
B:BD[3.4949] → [4.127:153]
```
  - nameSuffix: '-worker'
```
[3.4949]
```
  - suffix:
      /metadata/name: '-worker'
```
Replacement in testApp/overlays/web/karbon.yml at line 10 [4.264]
B:BD[4.410] → [4.410:433]
```
  - nameSuffix: '-web'
```
[4.410]
[4.433]
```
  - suffix:
      /metadata/name: '-web'
```
Replacement in testApp/overlays/web/karbon.yml at line 14 [4.264]
B:BD[2.31] → [2.31:58]
```
      /metadata/name: test
```
[2.31]
[4.503]
```
      /metadata/name: test-web
```

Replacement in testApp/overlays/web/karbon.yml at line 16 [4.264]

B:BD[4.512] → [4.512:579]

      /spec/template/spec/containers/0/ports/-/containerPort: 8080

[4.512]

[2.59]

      /spec/template/spec/containers/0/ports/-:
        name: http
        containerPort: 8080

Replacement in testApp/environments/prod/karbon.yml at line 10 [3.4413]

B:BD[2.211] → [2.211:243]

      /metadata/namespace: prod

[2.211]

      /metadata/namespace: 'test-prod'
  - filter:
      /kind: Service
    add:
      /spec/ports/-:
        name: metrics
        port: 1111

Insertion in src/main.rs at line 6 [3.21]
[2.355]
[2.355]
```
mod json_pointer;
```
Replacement in src/karbonfile.rs at line 2 [2.1218]
B:BD[2.1243] → [2.1243:1283]
```
use serde_yaml::{self, Value, Mapping};
```
[2.1243]
[2.1283]
```
use serde_yaml::{self, Value, Mapping, Sequence};
```
Insertion in src/karbonfile.rs at line 6 [2.1218]
[2.1369]
[2.1369]
```
use crate::json_pointer;
```

Replacement in src/karbonfile.rs at line 127 [2.1218]

B:BD[2.4574] → [2.4574:4750]

                        // remove: Option<serde_yaml::Mapping>,
                        // name_prefix: Option<String>,
                        // name_suffix: Option<String>,

[2.4574]

[2.4750]

                        // prefix: Option<serde_yaml::Mapping>,
                        // suffix: Option<serde_yaml::Mapping>,

Replacement in src/karbonfile.rs at line 138 [2.1218]

B:BD[2.5198] → [2.5198:5412]

                            for (k, v) in add.iter() {
                                let updated = pointer_mut(&mut result, k.as_str().unwrap()).unwrap();
                                *updated = v.to_owned();

[2.5198]

[2.5412]

                            for (ptr, v) in add.iter() {
                                let mut p = ptr
                                            .as_str()
                                            .unwrap();
                                if p.ends_with('-') {
                                    // When the pointer ends with '-' append the value to the end
                                    // of the sequence. If the sequence doesn't exist, create it.
                                    p = p.trim_end_matches("/-");
                                    let updated = json_pointer::insert(&mut result, p).unwrap();
                                    if let Some(s) = updated.as_sequence_mut() {
                                        s.push(v.to_owned());
                                    } else  {
                                        let mut value = Sequence::new();
                                        value.push(v.to_owned());
                                        *updated = serde_yaml::Value::Sequence(value);
                                    }
                                } else {
                                    let updated = json_pointer::insert(&mut result, p).unwrap();
                                    *updated = v.to_owned();
                                }

Insertion in src/karbonfile.rs at line 166 [2.1218]

[2.5528]

                            for (ptr, v) in replace.iter() {
                                let updated = json_pointer::update(&mut result, ptr.as_str().unwrap()).unwrap();
                                *updated = v.to_owned();
                            }

Replacement in src/karbonfile.rs at line 172 [2.1218]

B:BD[2.5555] → [2.5555:5638]

                        if let Some(remove) = t.remove {
                        }

[2.5555]

[2.5638]

                        if let Some(prefix) = t.prefix {
                            for (ptr, value) in prefix.iter() {
                                let p: &str = ptr.as_str().unwrap();
                                let v: &str = value.as_str().unwrap();

Replacement in src/karbonfile.rs at line 177 [2.1218]

B:BD[2.5639] → [2.5639:5951]

                        if let Some(prefix) = t.name_prefix {
                            if let Value::String(current) = &result["metadata"]["name"] {
                                let new = format!("{prefix}{current}");
                                result["metadata"]["name"] = Value::String(new.into());

[2.5639]

[2.5951]

                                if let Some(Value::String(current)) = json_pointer::get(&result, &p) {
                                    let new = format!("{v}{current}");
                                    *json_pointer::update(&mut result, &p).unwrap() = Value::String(new.into());
                                }

Replacement in src/karbonfile.rs at line 184 [2.1218]

B:BD[2.6008] → [2.6008:6320]

                        if let Some(suffix) = t.name_suffix {
                            if let Value::String(current) = &result["metadata"]["name"] {
                                let new = format!("{current}{suffix}");
                                result["metadata"]["name"] = Value::String(new.into());

[2.6008]

[2.6320]

                        if let Some(suffix) = t.suffix {
                            for (ptr, value) in suffix.iter() {
                                let p: &str = ptr.as_str().unwrap();
                                let v: &str = value.as_str().unwrap();
                                if let Some(Value::String(current)) = json_pointer::get(&result, &p) {
                                    let new = format!("{current}{v}");
                                    *json_pointer::update(&mut result, &p).unwrap() = Value::String(new.into());
                                }

Replacement in src/karbonfile.rs at line 208 [2.1218]

B:BD[2.6640] → [2.6640:6691]

            if pointer(doc, f).unwrap() != value {

[2.6640]

[2.6691]

            if json_pointer::get(doc, f).unwrap() != value {

Deletion in src/karbonfile.rs at line 217 [2.1218]

B:BD[2.6764] → [2.6764:7531]

fn pointer<'a>(doc: &'a Value, pointer: &'a str) -> Option<&'a Value> {
    // Taken from serde JSON
    if pointer.is_empty() {
        return Some(doc);
    }
    if !pointer.starts_with('/') {
        return None;
    }
    pointer
        .split('/')
        .skip(1)
        .map(|x| x.replace("~1", "/").replace("~0", "~"))
        .try_fold(doc, |target, token| {
            match target {
                Value::Mapping(map) => {
                    let t: Value = serde_yaml::from_str(&token).unwrap();
                    map.get(&t)
                }
                Value::Sequence(seq) => {
                    let t: usize = token.parse().unwrap();
                    seq.get(t)
                }
                _ => None,
            }
        })
}

Deletion in src/karbonfile.rs at line 218 [2.1218]

B:BD[2.7532] → [2.7532:8319]

fn pointer_mut<'a>(doc: &'a mut Value, pointer: &'a str) -> Option<&'a mut Value> {
    // Taken from serde JSON
    if pointer.is_empty() {
        return Some(doc);
    }
    if !pointer.starts_with('/') {
        return None;
    }
    pointer
        .split('/')
        .skip(1)
        .map(|x| x.replace("~1", "/").replace("~0", "~"))
        .try_fold(doc, |target, token| {
            match target {
                Value::Mapping(map) => {
                    let t: Value = serde_yaml::from_str(&token).unwrap();
                    map.get_mut(&t)
                }
                Value::Sequence(seq) => {
                    let t: usize = token.parse().unwrap();
                    seq.get_mut(t)
                }
                _ => None,
            }
        })
}

Deletion in src/karbonfile.rs at line 258 [2.1218]
B:BD[2.9238] → [2.9238:9273]
```
#[serde(rename_all = "camelCase")]
```
Replacement in src/karbonfile.rs at line 270 [2.1218]
B:BD[2.9592] → [2.9592:9625]
```
    name_prefix: Option<String>,
```
[2.9592]
[2.9625]
```
    prefix: Option<Mapping>,
```
Replacement in src/karbonfile.rs at line 272 [2.1218]
B:BD[2.9647] → [2.9647:9680]
```
    name_suffix: Option<String>,
```
[2.9647]
[2.9680]
```
    suffix: Option<Mapping>,
```

File addition: json_pointer.rs (----------)

[3.4]

use serde_yaml::{self, Value, Mapping};
pub fn get<'a>(doc: &'a Value, pointer: &'a str) -> Option<&'a Value> {
    // Taken from serde JSON
    if pointer.is_empty() {
        return Some(doc);
    }
    if !pointer.starts_with('/') {
        return None;
    }
    pointer
        .split('/')
        .skip(1)
        .map(|x| x.replace("~1", "/").replace("~0", "~"))
        .try_fold(doc, |target, token| {
            match target {
                Value::Mapping(map) => {
                    let t: Value = serde_yaml::from_str(&token).unwrap();
                    map.get(&t)
                }
                Value::Sequence(seq) => {
                    let t: usize = token.parse().unwrap();
                    seq.get(t)
                }
                _ => None,
            }
        })
}
pub fn insert<'a>(doc: &'a mut Value, pointer: &'a str) -> Option<&'a mut Value> {
    // Taken from serde JSON
    if pointer.is_empty() {
        return Some(doc);
    }
    if !pointer.starts_with('/') {
        return None;
    }
    pointer
        .split('/')
        .skip(1)
        .map(|x| x.replace("~1", "/").replace("~0", "~"))
        .try_fold(doc, |target, token| {
            match target {
                Value::Mapping(map) => {
                    let t: Value = serde_yaml::from_str(&token).unwrap();
                    if !map.contains_key(&t) {
                        let next = Mapping::new();
                        map.insert(t.to_owned(), Value::Mapping(next));
                    }
                    map.get_mut(&t)
                }
                Value::Sequence(seq) => {
                    let t = token.parse::<usize>().unwrap();
                    seq.get_mut(t)
                }
                _ => None,
            }
        })
}
pub fn update<'a>(doc: &'a mut Value, pointer: &'a str) -> Option<&'a mut Value> {
    // Taken from serde JSON
    if pointer.is_empty() {
        return Some(doc);
    }
    if !pointer.starts_with('/') {
        return None;
    }
    pointer
        .split('/')
        .skip(1)
        .map(|x| x.replace("~1", "/").replace("~0", "~"))
        .try_fold(doc, |target, token| {
            match target {
                Value::Mapping(map) => {
                    let t: Value = serde_yaml::from_str(&token).unwrap();
                    map.get_mut(&t)
                }
                Value::Sequence(seq) => {
                    let t: usize = token.parse().unwrap();
                    seq.get_mut(t)
                }
                _ => None,
            }
        })
}
pub fn upsert<'a>(doc: &'a mut Value, pointer: &'a str) -> Option<&'a mut Value> {
    // Taken from serde JSON
    if pointer.is_empty() {
        return Some(doc);
    }
    if !pointer.starts_with('/') {
        return None;
    }
    pointer
        .split('/')
        .skip(1)
        .map(|x| x.replace("~1", "/").replace("~0", "~"))
        .try_fold(doc, |target, token| {
            match target {
                Value::Mapping(map) => {
                    let t: Value = serde_yaml::from_str(&token).unwrap();
                    if !map.contains_key(&t) {
                            let next = Mapping::new();
                            map.insert(t.to_owned(), Value::Mapping(next));
                    }
                    map.get_mut(&t)
                }
                Value::Sequence(seq) => {
                    let t: usize = token.parse().unwrap();
                    seq.get_mut(t)
                }
                _ => None,
            }
        })
}

Fix the add transformer. Now handles the '-' at the end of the json pointer like json patches do

Dependencies

In channels

Change contents

Replacement in testApp/overlays/worker/karbon.yml at line 8 [3.4834]

Replacement in testApp/overlays/web/karbon.yml at line 10 [4.264]

Replacement in testApp/overlays/web/karbon.yml at line 14 [4.264]

Replacement in testApp/overlays/web/karbon.yml at line 16 [4.264]

Replacement in testApp/environments/prod/karbon.yml at line 10 [3.4413]

Insertion in src/main.rs at line 6 [3.21]

Replacement in src/karbonfile.rs at line 2 [2.1218]

Insertion in src/karbonfile.rs at line 6 [2.1218]