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

/// Make an enum implementing [`Command`](`crate::Command`)
/// where its every variant have only one field implements [`Commnad`](`crate::Command`).
/// The enum will provide a parse function matching each variant's name directly.
///
/// Example:
/// ```rust
/// # use kal::{Command, command_group, CommandFragment, CommandParseError};
/// # #[derive(Debug, PartialEq)]
/// #[derive(Command)]
/// struct A;
///
/// # #[derive(Debug, PartialEq)]
/// #[derive(Command)]
/// struct B;
///
///
/// command_group! {
/// #   #[derive(Debug, PartialEq)]
///     enum Root {
///         A(A),
///         B(B)
///     }
/// }
///
/// assert_eq!(Ok(Root::A(A)), Root::parse(&[CommandFragment::Select("a".to_string()), CommandFragment::Execute(vec![])]));
/// assert_eq!(Ok(Root::B(B)), Root::parse(&[CommandFragment::Select("b".to_string()), CommandFragment::Execute(vec![])]));
/// assert_eq!(Err(CommandParseError::UnknownCommand(&"c".to_string())), Root::parse(&[CommandFragment::Select("c".to_string()), CommandFragment::Execute(vec![])]));
#[macro_export]
macro_rules! command_group {
    (
        $(#[$attrs:meta])*
        $vis:vis enum $name:ident {
            $(
                $variant:ident($path:path)
            ),*
        }
    ) => {
        $(#[$attrs])*
        $vis enum $name {
            $($variant($path)),*
        }

        impl $name {
            pub fn contains(name: &str) -> bool {
                ::std::matches!(name, $(<$path as ::kal::Command>::NAME)|*)
            }

            pub fn children_specs() -> ::std::vec::Vec<::kal::CommandSpec> {
                ::std::vec![$(<$path as ::kal::Command>::spec()),*]
            }
        }

        impl ::kal::Command for $name {
            const NAME: &'static str = "<root>";

            fn spec() -> ::kal::CommandSpec {
                ::kal::CommandSpec {
                    name: Self::NAME,
                    description: "",
                    options: ::std::vec::Vec::new(),
                    subcommands: ::std::vec![
                        $(
                            <$path as ::kal::Command>::spec(),
                        )*
                    ],
                }
            }

            fn parse(fragments: &[::kal::CommandFragment]) -> ::std::result::Result<Self, ::kal::CommandParseError> {
                match fragments {
                    [::kal::CommandFragment::Select(name), rest @ ..] => {
                        match name.as_str() {
                            $(
                                <$path as ::kal::Command>::NAME =>
                                    <$path as ::kal::Command>::parse(rest).map($name::$variant),
                            )*
                            _ => ::std::result::Result::Err(::kal::CommandParseError::UnknownCommand(name)),
                        }
                    },
                    [::kal::CommandFragment::Execute(_), ..] => ::std::result::Result::Err(::kal::CommandParseError::ExecuteTooEarly),
                    [] => ::std::result::Result::Err(::kal::CommandParseError::IncompleteCommand),
                }
            }
        }
    }
}