CLIA

pronouced KLEE-uh

Rust command-line argument parser with no extra dependencies.

this is a crate with tools for parsing command-line arguments.

Features

• Generating help messages based on available options,
• Support for all the types of arguments specified later

Usage

supported types of arguments

As far as this crate is concerned, there are 4 types of arguments, in 2 main groups

Options: - flags (ei. -r) - flags w/ lists (ei -f [comma separated list] ) - flags w/ data (ei --format <NUMERIC>)

and Parameters: - (ei a file path, a string, etc.)

This crate makes the following assumptions about your command line program: - all options / flags start with a - - lists entered in the command line are comma separated - options and their associated bits of data, are typed before any parameter arguments (programs usage follows this pattern: foo.exe [OPTIONS]... [PARAMETERS]) - any and all "Parameters" are required, and must be included in the arguments for your program to work properly (optional arguments should be tied to flags anyway)

installing

see on crates.io

add clia=0.1.3 to the [dependencies] of your projects cargo.toml like so:

cargo.toml: rust [dependencies] clia="0.1.3"

Example

Here is an example showcasing all the basic features of CLIO. ```rust use std::env;

use clia::{optionargs::{ClOption,ClOptionInfo},parameterargs::ClParameter,Parser};

/// this is just an example of using this crate fn main() { /* step 1: define options and parameters */ let mut validoptions: Vec = Vec::new(); let mut expectedparameters: Vec = Vec::new();

// define options
//  this is an example of making an option with a list
valid_options.push( ClOption::new_flag_list( 
    &ClOptionInfo::new(
        "-f", 
        "--filter", 
        "Comma separated list of extensions, will only count lines of files with these extensions"
    ).unwrap(),
    "EXTENSIONS"
));
//  this is an example of making an option with some data
valid_options.push( ClOption::new_flag_data( 
    &ClOptionInfo::new(
        "-F", 
        "--format", 
        "Format the output in a list, valid formats are: DEFAULT, BULLET, MARKDOWN, and NUMERIC"
    ).unwrap(),
    "FORMAT"
));
//  this is an example of making a simple option
valid_options.push( ClOption::new_flag( 
    &ClOptionInfo::new(
        "-r", 
        "--recursive", 
        "Search through subdirectories"
    ).unwrap()
));
//  this is an example of making a simple option
valid_options.push( ClOption::new_flag( 
    &ClOptionInfo::new(
        "-h", 
        "--help", 
        "Prints help information"
    ).unwrap()
));

// define parameters
expected_parameters.push( ClParameter::new(
    "PATH",
    "Path to file/folder to search"
));
expected_parameters.push( ClParameter::new(
    "QUERY",
    "String to search for, all the stuff after the path wrap in \"'s if it contains spaces"
));



/* step 2: collect CLI Arguments and call the parser */
let args: Vec<String> = env::args().collect(); //read the argument values from env, and collect them into a string vector

//call parser
let arg_parser;
match Parser::new(&args, &valid_options, &expected_parameters) {
    Ok(arg_par) => arg_parser = arg_par,
    Err(e) => {println!("{}", Parser::help("foo.exe", "by Anthony Rubick", "Just here as an example of things you can do", &valid_options, &expected_parameters)); panic!("{}", e);}, //print any errors that occur
}



/* step 3: access the "found" fields of the parser */
//store data from the parser
let found_options = arg_parser.get_option_arguments_found();
let found_parameters = arg_parser.get_parameter_arguments_found();



/* process the arguments */
//user passed the -h flag
if found_options.iter().any(|opt| opt.get_info().get_short_flag().eq("-h")) {
    println!("{}", Parser::help("foo.exe", "by Anthony Rubick", "Just here as an example of things you can do", &valid_options, &expected_parameters));
}

// ...

} output of -h foo.exe by Anthony Rubick

Just here as an example of things you can do

USAGE: foo.exe [OPTIONS]... [PATH] [QUERY]

OPTIONS: -f, --filter ... Comma separated list of extensions, will only count lines of files with these extensions -F, --format Format the output in a list, valid formats are: DEFAULT, BULLET, MARKDOWN, and NUMERIC -r, --recursive Search through subdirectories -h, --help Prints help information

PARAMETER ARGUMENTS: PATH: Path to file/folder to search QUERY: String to search for, all the stuff after the path wrap in "'s if it contains spaces ```