kal 0.5.0

Command Abstraction Layer
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

use crate::{CommaSeparated, SpaceSeparated};

/// The specification of coomand
#[derive(Debug, PartialEq)]
pub struct CommandSpec {
    /// The name of command
    pub name: &'static str,

    /// The description of command
    pub description: &'static str,

    /// The options command can take
    pub options: Vec<CommandOption>,

    /// The subcommands command have
    pub subcommands: Vec<CommandSpec>,
}

/// The option command cane take
#[derive(Debug, PartialEq)]
pub struct CommandOption {
    /// The name of option when it is treated as named argument
    pub name: &'static str,

    /// The position of option when it is treated as positional argument
    pub position: usize,

    /// The description of option
    pub description: &'static str,

    /// The kind of value option can take
    pub value: CommandOptionValueKind,
}

/// The kind of value option can take
#[derive(Clone, Debug, PartialEq)]
pub enum CommandOptionValueKind {
    /// A kind of value that can appear or not
    Optional(Box<CommandOptionValueKind>),

    /// A kind of value that can appear or not
    Multiple(Box<CommandOptionValueKind>),

    /// String value
    String,

    /// Integer value
    Integer,

    /// Double precision floating point value
    Double,
}

impl CommandOptionValueKind {
    /// Whether the option value can be optional
    pub fn is_optional(&self) -> bool {
        matches!(self, CommandOptionValueKind::Optional(_))
    }

    /// Make the option value kind as primitive as possible
    pub fn as_primitive(&self) -> CommandOptionValueKind {
        match self {
            CommandOptionValueKind::Optional(t) | CommandOptionValueKind::Multiple(t) => {
                t.as_primitive()
            }
            _ => self.clone(),
        }
    }
}

/// Associate Rust type with [`CommandOptionValueKind`] and provide Rust side default value.
pub trait CommandOptionValueTy: Sized {
    /// Associated value kind
    fn spec_kind() -> CommandOptionValueKind;

    /// The default value for Rust side
    fn default() -> Option<Self> {
        None
    }
}

impl<T: CommandOptionValueTy> CommandOptionValueTy for Option<T> {
    fn spec_kind() -> CommandOptionValueKind {
        CommandOptionValueKind::Optional(Box::new(T::spec_kind()))
    }

    fn default() -> Option<Self> {
        Some(None)
    }
}

impl CommandOptionValueTy for String {
    fn spec_kind() -> CommandOptionValueKind {
        CommandOptionValueKind::String
    }
}

impl CommandOptionValueTy for i64 {
    fn spec_kind() -> CommandOptionValueKind {
        CommandOptionValueKind::Integer
    }
}

impl CommandOptionValueTy for f64 {
    fn spec_kind() -> CommandOptionValueKind {
        CommandOptionValueKind::Double
    }
}

impl<T: CommandOptionValueTy> CommandOptionValueTy for SpaceSeparated<T> {
    fn spec_kind() -> CommandOptionValueKind {
        CommandOptionValueKind::Multiple(Box::new(T::spec_kind()))
    }
}

impl<T: CommandOptionValueTy> CommandOptionValueTy for CommaSeparated<T> {
    fn spec_kind() -> CommandOptionValueKind {
        CommandOptionValueKind::Multiple(Box::new(T::spec_kind()))
    }
}