mingling 0.1.7

A Rust CLI framework for many subcmds & complex workflows, reduces boilerplate via proc macros, focus on biz logic
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
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

//! Mingling
//!
//! # Intro
//! A Rust CLI framework for many subcmds & complex workflows, reduces boilerplate via proc macros, focus on biz logic
//!
//! # 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
//! - `async` enables async runtime support for command execution, see [example](_mingling_examples/example_async/index.html) for details
//! - `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;
    /// Used to generate a route that either returns a successful result or early returns an error.
    pub use mingling_macros::route;
    #[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::*;
}