melodium 0.10.0

Flow-oriented language & tool, focusing on treatments applied on data, allowing high scalability and massive parallelization safely
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
118
119
120
121
122
123
124

use melodium_common::descriptor::{Identifier, PackageRequirement, Version, VersionReq};
use std::collections::HashMap;

pub fn cicd_pattern(program_name: &str, version: &Version) -> HashMap<String, Vec<u8>> {
    let melodium_version = Version::parse(crate::VERSION).unwrap();

    let compo = melodium_loader::Compo {
        name: program_name.to_string(),
        version: version.clone(),
        requirements: vec![
            PackageRequirement {
                package: "std".into(),
                version_requirement: VersionReq::parse(&if melodium_version.pre.is_empty() {
                    melodium_version.to_string()
                } else {
                    format!("={melodium_version}")
                })
                .unwrap(),
            },
            PackageRequirement {
                package: "log".into(),
                version_requirement: VersionReq::parse(&if melodium_version.pre.is_empty() {
                    melodium_version.to_string()
                } else {
                    format!("={melodium_version}")
                })
                .unwrap(),
            },
            PackageRequirement {
                package: "fs".into(),
                version_requirement: VersionReq::parse(&if melodium_version.pre.is_empty() {
                    melodium_version.to_string()
                } else {
                    format!("={melodium_version}")
                })
                .unwrap(),
            },
            PackageRequirement {
                package: "process".into(),
                version_requirement: VersionReq::parse(&if melodium_version.pre.is_empty() {
                    melodium_version.to_string()
                } else {
                    format!("={melodium_version}")
                })
                .unwrap(),
            },
            PackageRequirement {
                package: "work".into(),
                version_requirement: VersionReq::parse(&if melodium_version.pre.is_empty() {
                    melodium_version.to_string()
                } else {
                    format!("={melodium_version}")
                })
                .unwrap(),
            },
            PackageRequirement {
                package: "distrib".into(),
                version_requirement: VersionReq::parse(&if melodium_version.pre.is_empty() {
                    melodium_version.to_string()
                } else {
                    format!("={melodium_version}")
                })
                .unwrap(),
            },
            PackageRequirement {
                package: "net".into(),
                version_requirement: VersionReq::parse(&if melodium_version.pre.is_empty() {
                    melodium_version.to_string()
                } else {
                    format!("={melodium_version}")
                })
                .unwrap(),
            },
            PackageRequirement {
                package: "http".into(),
                version_requirement: VersionReq::parse(&if melodium_version.pre.is_empty() {
                    melodium_version.to_string()
                } else {
                    format!("={melodium_version}")
                })
                .unwrap(),
            },
            PackageRequirement {
                package: "cicd".into(),
                version_requirement: VersionReq::parse(&if melodium_version.pre.is_empty() {
                    melodium_version.to_string()
                } else {
                    format!("={melodium_version}")
                })
                .unwrap(),
            },
        ],
        entrypoints: {
            let mut entrypoints = HashMap::new();
            entrypoints.insert(
                "main".to_string(),
                Identifier::new(vec![program_name.to_string()], "main"),
            );
            entrypoints.insert(
                "advanced".to_string(),
                Identifier::new(
                    vec![program_name.to_string(), "advanced".to_string()],
                    "main",
                ),
            );
            entrypoints
        },
    }
    .restitute();

    let mut files = HashMap::new();

    files.insert("Compo.toml".to_string(), compo.into());
    files.insert(
        "lib-root.mel".to_string(),
        include_str!("lib-root.mel").into(),
    );
    files.insert(
        "advanced.mel".to_string(),
        include_str!("advanced.mel").into(),
    );

    files
}