clik 0.2.1

A simple-to-use interactive CLI framework
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

#![doc = include_str!("../README.md")]
#![cfg_attr(nightly, feature(doc_cfg))]

use std::{collections::HashMap, error::Error};

#[cfg_attr(nightly, doc(cfg(feature = "async")))]
#[cfg(feature = "async")]
use std::{future::Future, pin::Pin};

mod cli;
mod command;
pub mod error;
mod prelude;

pub use clik_codegen::*;

// NOTE: Taken from shellfish
/// A shorthand for a synchronous function pointer
pub type Fn<T> = fn(&mut T, Vec<String>) -> Result<(), Box<dyn Error>>;

// NOTE: Taken from shellfish
/// A shorthand for an asynchronous function pointer
#[cfg_attr(nightly, doc(cfg(feature = "async")))]
#[cfg(feature = "async")]
pub type AsyncFn<T> = fn(
    &mut T,
    Vec<String>,
) -> Pin<Box<dyn Future<Output = Result<(), Box<dyn Error>>> + Send + '_>>;

// NOTE: Partially taken from shellfish
/// A function or callback can be either synchronous or asynchronous
pub enum FnType<T> {
    Sync(Fn<T>),
    #[cfg_attr(nightly, doc(cfg(feature = "async")))]
    #[cfg(feature = "async")]
    Async(AsyncFn<T>),
}

/// The `CLI` struct is the main handle for a CLI interface that holds all the commands
pub struct CLI<'a, T: Send> {
    /// The state that gets represented to callbacks
    state: T,
    /// All the available commands
    commands: HashMap<&'a str, Command<'a, T>>,
}

impl<'a, T: Send> CLI<'_, T> {
    /// Create a new CLI with an internal state
    /// # Arguments
    /// * `state` - The state to provide to the callbacks
    pub fn new(state: T) -> Self {
        Self {
            state,
            commands: HashMap::new(),
        }
    }
}

/// A command that can have some subcommands
pub struct Command<'a, T> {
    name: &'a str,
    help: &'a str,
    callback: FnType<T>,
    subcommands: HashMap<&'a str, Command<'a, T>>,
}

impl<'a, T: Send> Command<'a, T> {
    /// Create a new command with a name and help string
    /// # Arguments
    /// * `name` - The name of the command, as typed into the CLI
    /// * `help` - The help string to describe this command
    /// * `callback` - The funcion to call when there is a match for this command
    pub fn new(name: &'a str, help: &'a str, callback: Fn<T>) -> Self {
        Self {
            name,
            help,
            callback: FnType::Sync(callback),
            subcommands: HashMap::new(),
        }
    }

    /// Create a new command with a name and help string
    /// # Arguments
    /// * `name` - The name of the command, as typed into the CLI
    /// * `help` - The help string to describe this command
    /// * `callback` - The async funcion to call when there is a match for this command
    #[cfg_attr(nightly, doc(cfg(feature = "async")))]
    #[cfg(feature = "async")]
    pub fn new_async(name: &'a str, help: &'a str, callback: AsyncFn<T>) -> Self {
        Self {
            name,
            help,
            callback: FnType::Async(callback),
            subcommands: HashMap::new(),
        }
    }
}