1use crate::{
2 CliCommandsAlg, CliContextAlg, CliNamedSources, CliNestAlg, CliOperationAlg, CliProgramAlg, CliSources,
3 Conventions, Fallible, NamedSource, PositionalSource, ProductSource, SumSource, Total,
4};
5use alux_ext::OperationAlg;
6
7pub trait CompileCliProgram<Compiler> {
9 type Commands;
11
12 fn compile_cli_program(self, compiler: &Compiler) -> Self::Commands;
14}
15
16#[derive(Debug, Default)]
18pub struct Empty;
19
20#[derive(Debug)]
22pub struct Merge<Left, Right> {
23 left: Left,
24 right: Right,
25}
26
27#[derive(Debug)]
29pub struct Named<Program>(Program);
30
31#[derive(Debug)]
33pub struct Nest<Program> {
34 name: &'static str,
35 program: Program,
36}
37
38#[derive(Debug)]
43pub struct Within<Handler, Inputs, Mode, Program> {
44 handler: Handler,
45 inputs: Inputs,
46 mode: Mode,
47 program: Program,
48}
49
50#[derive(Debug)]
52pub struct Command<Handler, Inputs, Mode = Total> {
53 name: &'static str,
54 handler: Handler,
55 inputs: Inputs,
56 mode: Mode,
57 conventions: Conventions,
58}
59
60#[derive(Debug)]
63pub struct Operation<Handler, Inputs = (), Mode = Total> {
64 handler: Handler,
65 inputs: Inputs,
66 mode: Mode,
67 conventions: Conventions,
68}
69
70#[derive(Debug)]
72pub struct CliProgram<Program>(Program);
73
74#[derive(Debug, Default)]
76pub struct CliProgramBuilder;
77
78impl CliProgramBuilder {
79 pub fn commands(&self) -> CliProgram<Empty> {
81 CliProgram(Empty)
82 }
83
84 pub fn op<Handler>(&self, handler: Handler) -> Operation<Handler> {
86 Operation { handler, inputs: (), mode: Total, conventions: Conventions::default() }
87 }
88
89 pub fn program<Program>(&self, program: Program) -> CliProgram<Named<Program>> {
91 CliProgram(Named(program))
92 }
93
94 pub fn positional(&self, doc: &'static str) -> PositionalSource {
96 PositionalSource::new(doc)
97 }
98
99 pub fn product(&self) -> ProductSource<()> {
101 ProductSource::new()
102 }
103
104 pub fn sum(&self) -> SumSource<()> {
106 SumSource::new()
107 }
108
109 pub fn named(&self, doc: &'static str) -> NamedSource {
111 NamedSource::new(doc)
112 }
113}
114
115impl<Handler, Inputs, Mode> Operation<Handler, Inputs, Mode> {
116 pub fn arg<Source>(self, name: &'static str, source: Source) -> Operation<Handler, (Inputs, Source), Mode> {
122 let _: &'static str = name;
123 Operation {
124 handler: self.handler,
125 inputs: (self.inputs, source),
126 mode: self.mode,
127 conventions: self.conventions,
128 }
129 }
130
131 pub fn declare(self, name: &'static str) -> Command<Handler, Inputs, Mode> {
137 Command { name, handler: self.handler, inputs: self.inputs, mode: self.mode, conventions: self.conventions }
138 }
139}
140
141impl<Handler, Inputs, Mode> Operation<Handler, Inputs, Mode> {
142 #[must_use]
144 pub fn options_first(mut self) -> Self {
145 self.conventions.options_first = true;
146 self
147 }
148
149 #[must_use]
151 pub fn unknown_options_as_operands(mut self) -> Self {
152 self.conventions.unknown_options_are_operands = true;
153 self
154 }
155
156 #[must_use]
158 pub fn no_end_of_options(mut self) -> Self {
159 self.conventions.double_dash_ends_options = false;
160 self
161 }
162
163 #[must_use]
166 pub fn numeric_option(mut self, long: &'static str) -> Self {
167 self.conventions.numeric_option = Some(long);
168 self
169 }
170
171 #[must_use]
174 pub fn verbatim(mut self) -> Self {
175 self.conventions.verbatim = true;
176 self
177 }
178
179 pub fn within<Program>(self, program: CliProgram<Program>) -> Within<Handler, Inputs, Mode, Program> {
182 Within { handler: self.handler, inputs: self.inputs, mode: self.mode, program: program.0 }
183 }
184}
185
186impl<Handler, Inputs> Operation<Handler, Inputs, Total> {
187 pub fn fallible(self) -> Operation<Handler, Inputs, Fallible> {
189 Operation { handler: self.handler, inputs: self.inputs, mode: Fallible, conventions: self.conventions }
190 }
191}
192
193impl<Program> CliProgram<Program> {
194 pub fn merge<Other>(self, other: CliProgram<Other>) -> CliProgram<Merge<Program, Other>> {
196 CliProgram(Merge { left: self.0, right: other.0 })
197 }
198
199 pub fn cmd<Handler, Inputs, Mode>(
201 self,
202 name: &'static str,
203 operation: Operation<Handler, Inputs, Mode>,
204 ) -> CliProgram<Merge<Program, Command<Handler, Inputs, Mode>>> {
205 self.merge(CliProgram(operation.declare(name)))
206 }
207
208 pub fn cmd_root<Handler, Inputs, Mode>(
212 self,
213 operation: Operation<Handler, Inputs, Mode>,
214 ) -> CliProgram<Merge<Program, Command<Handler, Inputs, Mode>>> {
215 self.merge(CliProgram(operation.declare("")))
216 }
217
218 pub fn nest<Other>(self, name: &'static str, other: CliProgram<Other>) -> CliProgram<Merge<Program, Nest<Other>>> {
220 self.merge(CliProgram(other.under(name)))
221 }
222
223 pub fn within<Handler, Inputs, Mode, Other>(
225 self,
226 operation: Operation<Handler, Inputs, Mode>,
227 other: CliProgram<Other>,
228 ) -> CliProgram<Merge<Program, Within<Handler, Inputs, Mode, Other>>> {
229 self.merge(CliProgram(operation.within(other)))
230 }
231
232 pub fn under(self, name: &'static str) -> Nest<Program> {
234 Nest { name, program: self.0 }
235 }
236
237 pub fn into_program(self) -> Program {
239 self.0
240 }
241}
242
243impl<Compiler> CompileCliProgram<Compiler> for Empty
244where
245 Compiler: CliCommandsAlg,
246{
247 type Commands = Compiler::Commands;
248
249 fn compile_cli_program(self, compiler: &Compiler) -> Self::Commands {
250 compiler.cli_empty()
251 }
252}
253
254impl<Compiler, Left, Right, Commands> CompileCliProgram<Compiler> for Merge<Left, Right>
255where
256 Compiler: CliCommandsAlg<Commands = Commands>,
257 Left: CompileCliProgram<Compiler, Commands = Commands>,
258 Right: CompileCliProgram<Compiler, Commands = Commands>,
259{
260 type Commands = Commands;
261
262 fn compile_cli_program(self, compiler: &Compiler) -> Self::Commands {
263 compiler.cli_merge(self.left.compile_cli_program(compiler), self.right.compile_cli_program(compiler))
264 }
265}
266
267impl<Compiler, Program> CompileCliProgram<Compiler> for Named<Program>
268where
269 Program: CliProgramAlg<Compiler>,
270{
271 type Commands = Program::Commands;
272
273 fn compile_cli_program(self, compiler: &Compiler) -> Self::Commands {
274 self.0.compile_cli(compiler)
275 }
276}
277
278impl<Compiler, Program, Commands> CompileCliProgram<Compiler> for Nest<Program>
279where
280 Compiler: CliNestAlg<Commands = Commands>,
281 Program: CompileCliProgram<Compiler, Commands = Commands>,
282{
283 type Commands = Commands;
284
285 fn compile_cli_program(self, compiler: &Compiler) -> Self::Commands {
286 let program = self.program;
287 compiler.cli_nest_with(self.name, |compiler| program.compile_cli_program(compiler))
288 }
289}
290
291impl<Compiler, Handler, Inputs, Mode> CompileCliProgram<Compiler> for Command<Handler, Inputs, Mode>
292where
293 Compiler: CliOperationAlg<Handler, Inputs, Mode>,
294 Handler: OperationAlg,
295 Inputs: CliSources<Handler::Args>,
296{
297 type Commands = Compiler::Commands;
298
299 fn compile_cli_program(self, compiler: &Compiler) -> Self::Commands {
300 compiler.cli_operation(self.name, self.handler, self.inputs, self.mode, self.conventions)
301 }
302}
303
304impl<Compiler, Handler, Inputs, Mode, Program, Inner, InnerCommands> CompileCliProgram<Compiler>
305 for Within<Handler, Inputs, Mode, Program>
306where
307 Compiler: CliContextAlg<Handler, Inputs, Mode, Inner = Inner, InnerCommands = InnerCommands>,
308 Handler: OperationAlg,
309 Inputs: CliSources<Handler::Args> + CliNamedSources,
310 Program: CompileCliProgram<Inner, Commands = InnerCommands>,
311{
312 type Commands = Compiler::Commands;
313
314 fn compile_cli_program(self, compiler: &Compiler) -> Self::Commands {
315 let inner = self.program.compile_cli_program(&compiler.cli_inner());
316 compiler.cli_within(self.handler, self.inputs, self.mode, inner)
317 }
318}