instruct 0.1.0

A language to write general purpose 'makefile like' tasks which are powerful and reuseable
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

use std::collections::HashMap;

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Namespace {
    pub name: String,
    pub namespace_type: NamespaceType,
    pub children: HashMap<String, NamespaceOrExecuteable>,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum NamespaceType {
    Module,
    Collection,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum NamespaceOrExecuteable {
    Namespace(Namespace),
    Executeable(Executeable),
}

impl NamespaceOrExecuteable {
    pub fn get_name(&self) -> &str {
        match self {
            NamespaceOrExecuteable::Executeable(executeable) => &executeable.name,
            NamespaceOrExecuteable::Namespace(namespace) => &namespace.name,
        }
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct Executeable {
    pub output_variables: Option<VariableBindings>,
    pub name: String,
    pub options: Option<VariableBindings>,
    pub executeable_type: ExecuteableType,
}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum VariableBinding {
    Single(String),
    Dual(String, String),
}

impl From<&str> for VariableBinding {
    fn from(val: &str) -> Self {
        Self::Single(val.into())
    }
}

impl From<(&str, &str)> for VariableBinding {
    fn from(val: (&str, &str)) -> Self {
        Self::Dual(val.0.into(), val.1.into())
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct VariableBindings {
    pub bindings: Vec<VariableBinding>,
}

impl VariableBindings {
    pub fn find(&self, name: &str) -> Option<&str> {
        for binding in &self.bindings {
            match binding {
                VariableBinding::Single(binding_name) if binding_name == name => {
                    return Some(binding_name)
                }
                VariableBinding::Dual(binding_name, value) if binding_name == name => {
                    return Some(value)
                }
                _ => (),
            }
        }
        None
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum ExecuteableType {
    Command { cmd: String },
    Call { target: String },
    Block { executeables: Vec<Executeable> },
    Task { executeables: Vec<Executeable> },
}