Skip to content

A lightweight, agnostic CLI argument parsing library for Rust.

License

Notifications You must be signed in to change notification settings

Blobfolio/argyle

Repository files navigation

Argyle

docs.rs changelog
crates.io ci deps.rs
license contributions welcome

This crate provides a simple streaming CLI argument parser/iterator called Argue, offering a middle ground between the standard library's barebones std::env::args_os helper and full-service crates like clap.

Argue performs some basic normalization — it handles string conversion in a non-panicking way, recognizes shorthand value assignments like -kval, -k=val, --key=val, and handles end-of-command (--) arguments — and will help identify any special keys/values expected by your app.

The subsequent validation and handling, however, are left entirely up to you. Loop, match, and proceed however you see fit.

If that sounds terrible, just use clap instead. Haha.

Installation

Add argyle to your dependencies in Cargo.toml, like:

[dependencies]
argyle = "0.9.*"

Example

A general setup might look something like the following.

Refer to the documentation for Argue, KeyWord, and Argument for more information, caveats, etc.

use argyle::{Argument, KeyWord};
use std::path::PathBuf;

#[derive(Debug, Clone, Default)]
/// # Configuration.
struct Settings {
    threads: usize,
    verbose: bool,
    paths: Vec<PathBuf>,
}

let args = argyle::args()
    .with_keywords([
        KeyWord::key("-h").unwrap(),            // Boolean flag (short).
        KeyWord::key("--help").unwrap(),        // Boolean flag (long).
        KeyWord::key_with_value("-j").unwrap(), // Expects a value.
        KeyWord::key_with_value("--threads").unwrap(),
    ]);

// Loop and handle!
let mut settings = Settings::default();
for arg in args {
    match arg {
        // Help flag match.
        Argument::Key("-h" | "--help") => {
            println!("Help Screen Goes Here.");
            return;
        },

        // Thread option match.
        Argument::KeyWithValue("-j" | "--threads", value) => {
            settings.threads = value.parse()
                .expect("Maximum threads must be a number!");
        },

        // Something else.
        Argument::Other(v) => {
            settings.paths.push(PathBuf::from(v));
        },

        // Also something else, but not String-able. PathBuf doesn't care
        // about UTF-8, though, so it might be fine!
        Argument::InvalidUtf8(v) => {
            settings.paths.push(PathBuf::from(v));
        },

        // Nothing else is relevant here.
        _ => {},
    }
}

// Now that you're set up, do stuff…

License

See also: CREDITS.md

Copyright © 2024 Blobfolio, LLC <hello@blobfolio.com>

This work is free. You can redistribute it and/or modify it under the terms of the Do What The Fuck You Want To Public License, Version 2.

DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
Version 2, December 2004

Copyright (C) 2004 Sam Hocevar <sam@hocevar.net>

Everyone is permitted to copy and distribute verbatim or modified
copies of this license document, and changing it is allowed as long
as the name is changed.

DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION

0. You just DO WHAT THE FUCK YOU WANT TO.