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
121
122
123
124
125
126
127
128
129
130
131
132
133
|
//! Mingling
//!
//! # Intro
//! `Mingling` is a Rust command-line framework. Its name comes from the Chinese Pinyin for "命令", which means "Command".
//!
//! # Use
//!
//! ```rust
//! use mingling::macros::{dispatcher, gen_program, r_println, renderer};
//!
//! #[tokio::main]
//! async fn main() {
//! let mut program = ThisProgram::new();
//! program.with_dispatcher(HelloCommand);
//!
//! // Execute
//! program.exec().await;
//! }
//!
//! // Define command: "<bin> hello"
//! dispatcher!("hello", HelloCommand => HelloEntry);
//!
//! // Render HelloEntry
//! #[renderer]
//! fn render_hello_world(_prev: HelloEntry) {
//! r_println!("Hello, World!")
//! }
//!
//! // Fallbacks
//! #[renderer]
//! fn fallback_dispatcher_not_found(prev: DispatcherNotFound) {
//! r_println!("Dispatcher not found for command `{}`", prev.join(", "))
//! }
//!
//! #[renderer]
//! fn fallback_renderer_not_found(prev: RendererNotFound) {
//! r_println!("Renderer not found `{}`", *prev)
//! }
//!
//! // Collect renderers and chains to generate ThisProgram
//! gen_program!();
//! ```
//!
// Output:
//!
//! ```text
//! > mycmd hello
//! Hello, World!
//! > mycmd hallo
//! Dispatcher not found for command `hallo`
//! ```
//!
//! # Features
//! - `comp` enables command completion functionality, see [example](_mingling_examples/example_completion/index.html) for details
//! - `parser` enables the `mingling::parser` module, see [example](_mingling_examples/example_picker/index.html) for details
//! - `general_renderer` adds support for serialized output formats such as JSON and YAML, see [example](_mingling_examples/example_general_renderer/index.html) for details
//!
//! # Examples
//! `Mingling` provides detailed usage examples for your reference.
//! See [Examples](_mingling_examples/index.html)
mod example_docs;
// Re-export Core lib
pub use mingling::*;
pub use mingling_core as mingling;
/// `Mingling` argument parser
#[cfg(feature = "parser")]
pub mod parser;
/// Re-export from `mingling_macros`
#[allow(unused_imports)]
pub mod macros {
/// Used to generate a struct implementing the `Chain` trait via a method
pub use mingling_macros::chain;
/// Used to generate completion entry
#[cfg(feature = "comp")]
pub use mingling_macros::completion;
/// Used to create a dispatcher that routes to a `Chain`
pub use mingling_macros::dispatcher;
/// Used to create a dispatcher with clap argument parsing
#[cfg(feature = "clap")]
pub use mingling_macros::dispatcher_clap;
/// Used to collect data and create a command-line context
pub use mingling_macros::gen_program;
/// Used to generate a struct implementing the `HelpRequest` trait via a method
pub use mingling_macros::help;
/// Used to create a `Node` struct via a literal
pub use mingling_macros::node;
/// Used to create a wrapper type for use with `Chain` and `Renderer`
pub use mingling_macros::pack;
#[cfg(feature = "comp")]
/// Internal macro for 'gen_program' used to finally generate the completion structure
pub use mingling_macros::program_comp_gen;
/// Internal macro for 'gen_program' used to finally generate the fallback
pub use mingling_macros::program_fallback_gen;
/// Internal macro for 'gen_program' used to finally generate the program
pub use mingling_macros::program_final_gen;
// Used to generate program setup
pub use mingling_macros::program_setup;
/// Used to print content within a `Renderer` context
pub use mingling_macros::r_print;
/// Used to print content with a newline within a `Renderer` context
pub use mingling_macros::r_println;
/// Used to register a chain
pub use mingling_macros::register_chain;
/// Used to register a help
pub use mingling_macros::register_help;
/// Used to register a renderer
pub use mingling_macros::register_renderer;
/// Used to register a type into the context
pub use mingling_macros::register_type;
/// Used to generate a struct implementing the `Renderer` trait via a method
pub use mingling_macros::renderer;
#[cfg(feature = "comp")]
/// Used to generate suggestions
pub use mingling_macros::suggest;
#[cfg(feature = "comp")]
/// Used to generate enum suggestions
pub use mingling_macros::suggest_enum;
}
/// derive macro EnumTag
pub use mingling_macros::EnumTag;
/// derive macro Groupped
pub use mingling_macros::Groupped;
/// Example projects for `Mingling`, for learning how to use `Mingling`
pub mod _mingling_examples {
pub use crate::example_docs::*;
}
|
