asto 0.1.0

Asto is a minimalist DSL for documenting CLI tools, built from the ground up in Rust.
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

use indexmap::IndexMap;
use serde::{Deserialize, Serialize};




#[derive(Debug, Serialize, Deserialize)]
#[serde(untagged)]
pub enum InputAlias {
    Text(String),
    List(Vec<String>),
    ListParam(Vec<ParamStruct>)
}



#[derive(Serialize, Deserialize, Debug)]
pub struct InputStruct {
    pub command: String,
    pub desc: String,

    pub prefix: String,
    pub func: String,
    pub version: String,
    
    #[serde(rename = "param_config")]
    pub params_config: Vec<ParamStruct>,

    // #[serde(rename = "output_logs")]
    // pub output_logs: Vec<String>,
    
    pub params: Vec<String>
    
}

impl InputStruct {
    pub fn new(prefix: String, func: String, command: String, desc: String, version: String, params: Vec<String>, params_config: Vec<ParamStruct>) -> Self {
        Self {
            command: command,
            desc: desc,
            prefix: prefix,
            func: func,
            version: version,
            params: params,
            params_config: params_config,
            // output_logs: output_logs
        }
    }
}


#[derive(Debug, Serialize, Deserialize)]
pub struct ParamStruct {
    pub name: String,
    pub typeval: String,
    pub desc: String
}


// FUNCTIONS 


pub fn get_version_string(version: &str) -> String {
    match version {
        "new" => String::from("🟡 New"),
        "depre" => String::from("🔴 Deprecated"),
        "expm" => String::from("🔵 Experimental"),
        "stable" => String::from("🟢 Stable"),
        _ => {
            String::from("No Implemented")
        }
    }
}




pub fn to_input(input: InputStruct) -> IndexMap<String, InputAlias> {
    let mut structure: IndexMap<String, InputAlias> = IndexMap::new();

    let node_name: InputAlias = InputAlias::Text("Input".to_string());

    structure.insert("node".to_string(), node_name);
    structure.insert("command".to_string(), InputAlias::Text(input.command));
    structure.insert("description".to_string(), InputAlias::Text(input.desc));
    structure.insert("prefix".to_string(), InputAlias::Text(input.prefix));
    structure.insert("function".to_string(), InputAlias::Text(input.func));
    structure.insert("version".to_string(), InputAlias::Text(input.version));
    structure.insert("params".to_string(), InputAlias::List(input.params));
    structure.insert("params_config".to_string(), InputAlias::ListParam(input.params_config));
    // structure.insert("output_logs".to_string(), InputAlias::List(input.output_logs));

    structure
}