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
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
|
# Changelogs
### Release 0.1.7
#### Fixes:
1. Fixed a build failure on **Windows** caused by `mingling_core/src/program.rs`
#### Features:
1. **\[macros\]** Completed the `clap` feature: **Mingling** now supports parsing input using `clap::Parser`
```rust
#[derive(Groupped, clap::Parser)]
#[dispatcher_clap("your_cmd", YourClapCommand)]
// #[dispatcher_clap("...", ..., error = YourCommandParseError)] // Dispatch when parse failed
// #[dispatcher_clap("...", ..., help = true)] // Enable clap help
struct YourCommandEntry {
#[arg(long, short)]
str_param: String,
#[arg(long, short)]
path_param: PathBuf,
}
```
2. **\[clap\]** Added the `stdout_setting.clap_help_print_behaviour` configuration item to `Program`, used to control the behavior of Clap Help
3. **\[core\]** Added function `new_with_args` to `Program`
4. **\[core\]** Added function `dispatch_args_dynamic` to `Program`
5. **\[core\]** Impl `std::io::Write` trait for `RenderResult`
6. **\[core\]** Added Help system, which allows binding an event for `--help` to an `Entry` via the `help!` macro
```rust
#[help]
fn your_command_help(_prev: YourEntry) {
r_println!("Your help docs");
}
```
7. **\[macros\]** Added the `route!` macro, which allows quick error routing within the `chain!` function. Usage is as follows:
```rust
// Before
#[chain]
fn parse(prev: PickEntry) -> mingling::ChainProcess<ThisProgram> {
let picker = Picker::new(prev.inner);
let pick_result = picker
.pick_or_route((), NoNameProvided::default().to_render())
.unpack();
match pick_result {
Ok(name) => {
// use name here
}
Err(e) => {
// handle error route here
e
}
}
}
// After
#[chain]
fn parse(prev: PickEntry) -> mingling::ChainProcess<ThisProgram> {
let picker = Picker::new(prev.inner);
let name: String = route! {
picker
.pick_or_route((), NoNameProvided::default().to_render())
.unpack()
};
// use name here
}
```
8. Added a resource system to `Program` for managing global resources [Details](docs/res/changlog_examples/feat_program_res.rs)
```rust
// Define global resource
#[derive(Debug, Default, Clone)]
struct Global {
name: String,
age: i32,
}
// Add global resource
program.with_resource(Global::default());
// Read the global resource
let global = this::<ThisProgram>().res_or_default::<Global>();
// Modify the global resource
this::<ThisProgram>().modify_res(|r: &mut Global| {
r.name = name;
r.age = age
});
```
#### **BREAKING CHANGES**:
1. **\[macros\]** Removed macro `dispatcher_render!` from `mingling_macros`
2. **\[core\]** The `<..., Group>` in `Program<Collect, Group>` no longer requires `std::fmt::Display`
3. **\[core\]** Changed `Program<Collect, Group>` to `Program<Collect>` (merged the Group and Collect types)
4. **\[picker\]** When performing `unpack` or `unpack_directly` on the result of the first `pick` of `Picker`, it no longer returns a tuple
```rust
// Before
#[chain]
fn parse_sth(prev: SomeEntry) -> NextProcess {
let str: String = Picker::<()>::new(prev.inner)
.pick_or((), "None")
.unpack_directly().0;
let parsed = Something::new(ok);
parsed
}
// Now
#[chain]
fn parse_sth(prev: SomeEntry) -> NextProcess {
let str: String = Picker::<()>::new(prev.inner)
.pick_or((), "None")
.unpack_directly(); // Directly return the type instead of a tuple
let parsed = Something::new(ok);
parsed
}
```
5. **\[core\]** Removed `mingling::marker::NextProcess` and moved its creation process to `gen_program!()`
```rust
use mingling::marker::NextProcess; // Remove this
// NextProcess generated here
gen_program!();
```
---
### Release 0.1.6 **\[YANKED\]**
`Mingling` 0.1.6 primarily focuses on optimizing the writing experience and code completion.
> [!CAUTION]
>
> This version cannot be built correctly on **Windows**, please do not use this version.
> [!warning]
>
> To align with the `mingling` version, `mingling_core` and `mingling_macros` will skip version `0.1.5` and be released directly as `0.1.6`.
#### Fixes:
1. **\[core\]** Fixed an issue where the `Powershell` completion script could not be used.
#### Features:
1. **\[core\]** Added support for completion descriptions in `Powershell`.
2. **\[core\]** Added more context-based completion functions, such as `filling_argument` and `typing_argument`. For details, see [Docs.rs](https://docs.rs/mingling/0.1.6/mingling/)
#### **BREAKING CHANGES**:
1. **\[macros\]** The `chain!` macro no longer requires explicit type conversion when routing a type to `Chain`.
```rust
// Before
#[chain]
fn proc(_prev: SomeType) -> NextProcess {
let result = SomeResult::new(());
result.to_chain()
}
// Now
#[chain]
fn proc(_prev: SomeType) -> NextProcess {
let result = SomeResult::new(());
result // No need for `to_chain()`
}
```
2. **\[macros\]** Moved type registration from the `chain!` and `renderer!` macros forward to the `pack!` and `derive Groupped` macros
3. **\[core\]** **\[macros\]** Added an `async` feature, which is disabled by default. `Mingling` no longer forces a dependency on an Async Runtime.
4. **\[picker\]** Changed the signature of `pick_or` from `(..., or: TNext)` to `(..., or: impl Into<TNext>)`
|
