ito-core 0.1.27

Core functionality and business logic for Ito
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

//! Structured parsing for per-change `.ito.yaml` metadata.

use crate::errors::CoreError;
use ito_common::fs::FileSystem;
use ito_domain::changes::ChangeOrchestrateMetadata;
use serde::Deserialize;
use std::collections::BTreeMap;
use std::path::Path;

#[derive(Debug, Clone, Default, Deserialize)]
struct ChangeOrchestrateYaml {
    #[serde(default)]
    depends_on: Vec<String>,
    #[serde(default)]
    preferred_gates: Vec<String>,
    #[serde(flatten, default)]
    _extra: BTreeMap<String, serde_yaml::Value>,
}

#[derive(Debug, Clone, Default, Deserialize)]
struct ChangeMetaYaml {
    #[serde(default)]
    schema: Option<String>,
    #[serde(default)]
    orchestrate: Option<ChangeOrchestrateYaml>,
    #[serde(flatten, default)]
    _extra: BTreeMap<String, serde_yaml::Value>,
}

#[derive(Debug, Clone, Default)]
pub(crate) struct ChangeMeta {
    pub(crate) schema: Option<String>,
    pub(crate) orchestrate: ChangeOrchestrateMetadata,
}

pub(crate) fn parse_change_meta(contents: &str) -> Result<ChangeMeta, CoreError> {
    let contents = contents.trim();
    if contents.is_empty() {
        return Ok(ChangeMeta::default());
    }

    let yaml: ChangeMetaYaml = serde_yaml::from_str(contents)
        .map_err(|e| CoreError::Parse(format!("invalid .ito.yaml metadata: {e}")))?;

    Ok(ChangeMeta {
        schema: yaml.schema,
        orchestrate: parse_orchestrate_metadata(yaml.orchestrate),
    })
}

pub(crate) fn parse_change_meta_best_effort(contents: &str) -> ChangeMeta {
    parse_change_meta(contents).unwrap_or_default()
}

pub(crate) fn read_change_meta_from_dir<F: FileSystem>(fs: &F, change_dir: &Path) -> ChangeMeta {
    let path = change_dir.join(".ito.yaml");
    if !fs.is_file(&path) {
        return ChangeMeta::default();
    }

    let Ok(contents) = fs.read_to_string(&path) else {
        return ChangeMeta::default();
    };

    parse_change_meta_best_effort(&contents)
}

fn parse_orchestrate_metadata(
    orchestrate: Option<ChangeOrchestrateYaml>,
) -> ChangeOrchestrateMetadata {
    let Some(ChangeOrchestrateYaml {
        depends_on,
        preferred_gates,
        _extra: _,
    }) = orchestrate
    else {
        return ChangeOrchestrateMetadata::default();
    };

    ChangeOrchestrateMetadata {
        depends_on,
        preferred_gates,
    }
}