devstart 0.7.0

Make me: make me run dev tasks without thinking
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

//! Extend `argh` to be better integrated with the `cargo` ecosystem
//!
//! For now, this only adds a --version/-V option which causes early-exit.
use argh::{FromArgs, TopLevelCommand};

struct ArgsOrVersion<T: FromArgs>(T);
impl<T> argh::TopLevelCommand for ArgsOrVersion<T> where T: FromArgs {}
impl<T> FromArgs for ArgsOrVersion<T>
where
    T: FromArgs,
{
    fn from_args(command_name: &[&str], args: &[&str]) -> Result<Self, argh::EarlyExit> {
        /// Also use argh for catching `--version`-only invocations
        #[derive(FromArgs)]
        struct Version {
            /// print version information and exit
            #[argh(switch, short = 'V')]
            pub version: bool,
        }
        match Version::from_args(command_name, args) {
            Ok(v) => {
                if v.version {
                    Err(argh::EarlyExit {
                        output: format!(
                            "{} {}",
                            command_name.first().unwrap_or(&""),
                            env!("CARGO_PKG_VERSION")
                        ),
                        status: Ok(()),
                    })
                } else {
                    // seems args are empty
                    T::from_args(command_name, args).map(Self)
                }
            }
            Err(exit) => match exit.status {
                Ok(()) => {
                    // must have been --help
                    let help = match T::from_args(command_name, &["--help"]) {
                        Ok(_) => unreachable!(),
                        Err(exit) => exit.output,
                    };
                    Err(argh::EarlyExit {
                        output: format!(
                            "{help}  -V, --version     print version information and exit"
                        ),
                        status: Ok(()),
                    })
                }
                Err(()) => T::from_args(command_name, args).map(Self),
            },
        }
    }
}
/// Create a `FromArgs` type from the current process’s `env::args`.
///
/// This function will exit early from the current process if argument parsing was unsuccessful or if information like `--help` was requested.
/// Error messages will be printed to stderr, and `--help` output to stdout.
pub fn from_env<T>() -> T
where
    T: TopLevelCommand,
{
    argh::from_env::<ArgsOrVersion<T>>().0
}