How to load binaries like cargo-web.exe in Clap?

hydroper · 2018-12-22 16:11:44 UTC

Is it possible to interrupt parsing after astro air, for example, once it ultrapasses 'air'?

extern crate clap;
use clap::{App, Arg, ArgGroup, SubCommand};

// mod config;
// mod storage;

fn main() {
    let app = App::new("Astro")
        .version("0.1.0")
        .subcommand(SubCommand::with_name("new")
            .group(ArgGroup::with_name("type")
                .required(true))
            .arg(Arg::from_usage("--bin [dev-type]").group("type"))
            .arg(Arg::from_usage("--lib [dev-type]").group("type"))
            .arg_from_usage("<name>"))
        .subcommand(SubCommand::with_name("air"));

    // Got to figure in how to add sym-link
    // commands w/ clap.
//  storage::devtools::commands(&app);

    let matches = app.get_matches();

    match matches.subcommand_name() {
        Some("new") => println!("Rant new"),
        Some("air") => println!("{}", std::env::args().nth(0).unwrap().as_str()),
        None => (),
        _ => println!("Missing impl")
    }
}

Not really working.

hydroper · 2018-12-22 18:58:03 UTC

So far I didn’t find anything related in Cargo’s source (this is where all the CLI goes). To clarify I want to know how cargo web works. How does cargo-web.exe runs as a subcommand in cargo if it’s not a built-in one?

It looks like my GitHub issue won’t be answered too and I’m not wanting to waste time again like my threwn away parsers.

daboross · 2018-12-22 22:05:04 UTC

If I’m reading the source correctly, cargo matches on clap errors and if it’s an unrecognized subcommand, it will try to execute an external binary cargo-<subcommandname>:

github.com

rust-lang/cargo/blob/41a7e150fcd6191afec6425cb024ccae60d71cd2/src/bin/cargo/cli.rs#L15


use cargo::{self, CliResult, Config};


use super::commands;
use super::list_commands;
use crate::command_prelude::*;


pub fn main(config: &mut Config) -> CliResult {
let args = match cli().get_matches_safe() {
    Ok(args) => args,
    Err(e) => {
        if e.kind == clap::ErrorKind::UnrecognizedSubcommand {
            // An unrecognized subcommand might be an external subcommand.
            let cmd = &e.info.as_ref().unwrap()[0].to_owned();
            return super::execute_external_subcommand(config, cmd, &[cmd, "--help"])
                .map_err(|_| e.into());
        } else {
            return Err(e)?;
        }
    }
};

and execute_external_subcommand:

github.com

rust-lang/cargo/blob/41a7e150fcd6191afec6425cb024ccae60d71cd2/src/bin/cargo/main.rs#L140-L177


fn execute_external_subcommand(config: &Config, cmd: &str, args: &[&str]) -> CliResult {
let command_exe = format!("cargo-{}{}", cmd, env::consts::EXE_SUFFIX);
let path = search_directories(config)
    .iter()
    .map(|dir| dir.join(&command_exe))
    .find(|file| is_executable(file));
let command = match path {
    Some(command) => command,
    None => {
        let err = match find_closest(config, cmd) {
            Some(closest) => format_err!(
                "no such subcommand: `{}`\n\n\tDid you mean `{}`?\n",
                cmd,
                closest
            ),
            None => format_err!("no such subcommand: `{}`", cmd),
        };
        return Err(CliError::new(err, 101));
    }
};

This file has been truncated. show original

There’s probably more to it than just this, but the rest can probably be found by digging around in cargo’s source searching for usages of execute_external_subcommand and the like?

hydroper · 2018-12-26 09:53:30 UTC

It’s not always ::UnrecognizedSubcommand, so…

if let Err(err) = result {
        match err.kind {
              ErrorKind::UnrecognizedSubcommand
            | ErrorKind::UnknownArgument => {
                let name = &err.info.unwrap()[0];
                println!("Probably air");
                return;
            },
            _ => {
                if err.use_stderr() {
                    err.exit();
                }
                return;
            }
        }
    }