s3m VS clap-rs

I've been working on a project (s3m - https://github.com/s3m/s3m/) to address the challenge of storing Mariabackup backups in S3 buckets, particularly on systems with limited resources. The project aims to handle data streams efficiently. For instance, creating a database backup stream can impact system performance, leading to potential cluster locks. The effort required for stream creation is proportional to the database size, with larger databases demanding more time and system resources. The goal is to optimize this process, ensuring data integrity without overwhelming system resources.

I would like mycli.rs to be only like the switch/dispatcher based on an option/subcommand so that I could test each option apart, for example wondering from another project (clap 3): https://github.com/s3m/s3m/blob/main/src/bin/s3m.rs, but would like to know ( maybe "idiomatic") way of doing it

So far working fine, I have tidied the docs (https://s3m.stream/) and code (https://github.com/s3m/s3m) but still have a long journey to make proper tests and some optimizations, I am using this space to ask for some reviews and ideas in order to improve, and optimize better the projects, here please find the project: https://github.com/s3m/, create: https://crates.io/crates/s3m/

We will be using the library for Clap - A simple-to-use, efficient, and full-featured library for parsing command line arguments and subcommands.

I recently came across this question (and associated answer) on the clap repository. The answer given is a good one. But I wanted to expand with my own findings and practices, which spurred the motivation for this post.

We can also use tuple-like struct syntax and named-field struct syntax for enum variants within our enum; this is because unlike in other OOP languages, Rust enums are actually sum types. You can read more about how powerful Rust enums are in another article we wrote here. You can have optional arguments by simply wrapping the types in Option, but if you want to add a flag to a command you can use bool, since clap recognises that flags are either there or not there. Let's have a look at what this might look like:

I began by developing a wrapper for the CurseForge API, which turned out to be a lengthy and challenging process but constituted the bulk of the work. Next, I coded the CLI, which was relatively straightforward. Instead of using the clap crate, a Rust tool for generating CLIs, I opted for the following line of code:

By this time I had already gotten tired of parsing arguments by myself and had looked for something to help with that. I found a really dang good argument parsing library called clap. What makes it so cool is it's largely declarative for common uses. You simply mark up a struct with attributes, and the parser automatically generates the usage and all the argument parsing code.

How CLI arguments are handled (using clap).

Is this just referring to wrapping based on the terminal width? That is supported with the wrap_help feature though I have been considering making it a default feature.

CLI, use Clap. If you want to get fancy, use Tui.

As our CLI is getting more complex, we'll use the clap crate to parse the command line arguments.