holochain_scaffolding_cli 0.4000.4

CLI to easily generate and modify holochain apps
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

use holochain_types::prelude::{
    DnaManifest, DnaManifestCurrentBuilder, ZomeDependency, ZomeManifest,
};

use crate::{
    error::{ScaffoldError, ScaffoldResult},
    file_tree::insert_file,
};

use super::{manifest::check_zome_doesnt_exist, zome_wasm_location, DnaFileTree};

pub fn add_coordinator_zome_to_manifest(
    mut dna_file_tree: DnaFileTree,
    zome_manifest: ZomeManifest,
) -> ScaffoldResult<DnaFileTree> {
    check_zome_doesnt_exist(&dna_file_tree.dna_manifest, &zome_manifest)?;

    let (integrity_manifest, mut coordinator_manifest) = match dna_file_tree.dna_manifest.clone() {
        DnaManifest::V1(m) => (m.integrity, m.coordinator),
    };
    if let Some(dependencies) = zome_manifest.dependencies.clone() {
        for d in dependencies {
            if !integrity_manifest
                .zomes
                .iter()
                .any(|z| z.name.0.to_string().eq(&d.name.0.to_string()))
            {
                return Err(ScaffoldError::IntegrityZomeNotFound(
                    d.name.0.to_string(),
                    dna_file_tree.dna_manifest.name(),
                ));
            }
        }
    }
    coordinator_manifest.zomes.push(zome_manifest);

    let new_manifest: DnaManifest = DnaManifestCurrentBuilder::default()
        .coordinator(coordinator_manifest)
        .integrity(integrity_manifest)
        .name(dna_file_tree.dna_manifest.name())
        .lineage(vec![])
        .build()
        .unwrap()
        .into();

    insert_file(
        &mut dna_file_tree.file_tree,
        &dna_file_tree.dna_manifest_path,
        &serde_yaml::to_string(&new_manifest)?,
    )?;

    Ok(dna_file_tree)
}

pub fn new_coordinator_zome_manifest(
    dna_file_tree: &DnaFileTree,
    name: &str,
    maybe_dependencies: Option<&Vec<String>>,
) -> ScaffoldResult<ZomeManifest> {
    let location = zome_wasm_location(dna_file_tree, name);
    let zome_manifest = ZomeManifest {
        name: name.into(),
        hash: None,
        location,
        dependencies: maybe_dependencies.map(|dz| {
            dz.iter()
                .map(|d| ZomeDependency {
                    name: d.to_owned().into(),
                })
                .collect()
        }),
        dylib: None,
    };

    Ok(zome_manifest)
}