Struct jargon_args::Jargon

pub struct Jargon(_);

Jargon

This is the main struct in this crate. This is what is used to handle arguments, and get arguments’ values.

Example

use jargon_args::Jargon;
let mut jargon: Jargon = Jargon::from_env();

if jargon.contains(["-h", "--help"]) {
    println!("help text");
    std::process::exit(0);
}

// ...

Implementations

impl Jargon

pub fn from_env() -> Self

Extracts a program’s arguments from the environment.

Examples found in repository

examples/subcontinued.rs (line 4)

fn main() {
    let mut j: Jargon = Jargon::from_env();
    j.on_subcommand("go", go);
}

examples/subcommand.rs (line 4)

fn main() {
    let mut j: Jargon = Jargon::from_env();

    j.on_subcommand("list", list);
    j.on_subcommand("backwards", list_backwards);
}

examples/name.rs (line 4)

fn main() {
    let mut j: Jargon = Jargon::from_env();
    let name_key: Key = "--name".into();

    match j.option_arg::<String, Key>(name_key.clone()) {
        Some(n) => println!("Your name: {}", n),
        None => eprintln!("Missing argument: {}", name_key),
    }
}

examples/basename.rs (line 12)

fn main() {
    let mut j: Jargon = Jargon::from_env(); // Get an instance of Jargon using `std::env::args()`

    if j.contains(["-h", "--help"]) { // check for help argument
        print!("{}", HELP);
        return;
    }

    if j.contains(["-v", "--version"]) { // check for version argument
        println!(
            "basename example for Jargon crate {}",
            env!("CARGO_PKG_VERSION")
        );
        return;
    }

    let args = Args { // fill helper struct
        multiple: j.contains(["-a", "--multiple"]), // multiple
        suffix: j.option_arg(["-s", "--suffix"]), // suffix to remove
        zero: j.contains(["-z", "--zero"]), // terminate lines with null
        names: j.finish(), // get names
    };

    if args.names.is_empty() { // check if there are names
        println!("Missing NAMES");
        return;
    }

    let mut v: Vec<String> = vec![print(&args, &args.names[0])]; // initiate vector of names

    if args.multiple { // fill the rest if `-a` or `--multiple` was passed
        args.names.iter().skip(1).for_each(|name| v.append(&mut vec![print(&args, name)]));
    }

    if args.zero { // terminate with null if `-z` or `--zero` was passed
        v.iter().for_each(|name| print!("{}", name));
    } else { // terminate each name with space or new line
        v.iter().for_each(|name| println!("{} ", name));
    }
}

pub fn from_vec<T: ToString>(v: Vec<T>) -> Self

Places provided vector into Jargon. Please have the program’s name or subcommand’s name at index 0. 0 is always ignored.

Examples found in repository

examples/subcontinued.rs (line 10)

fn go(v: Vec<String>) {
    println!("go!");
    let mut j: Jargon = Jargon::from_vec(v);
    j.on_subcommand("goo", goo)
}

fn goo(v: Vec<String>) {
    println!("goo!");
    let mut j: Jargon = Jargon::from_vec(v);
    j.on_subcommand("gooo", gooo)
}

pub fn contains<K: Into<Key>>(&mut self, key: K) -> bool

Checks if provided key is given in arguments. Removes it.

Examples found in repository

examples/basename.rs (line 14)

fn main() {
    let mut j: Jargon = Jargon::from_env(); // Get an instance of Jargon using `std::env::args()`

    if j.contains(["-h", "--help"]) { // check for help argument
        print!("{}", HELP);
        return;
    }

    if j.contains(["-v", "--version"]) { // check for version argument
        println!(
            "basename example for Jargon crate {}",
            env!("CARGO_PKG_VERSION")
        );
        return;
    }

    let args = Args { // fill helper struct
        multiple: j.contains(["-a", "--multiple"]), // multiple
        suffix: j.option_arg(["-s", "--suffix"]), // suffix to remove
        zero: j.contains(["-z", "--zero"]), // terminate lines with null
        names: j.finish(), // get names
    };

    if args.names.is_empty() { // check if there are names
        println!("Missing NAMES");
        return;
    }

    let mut v: Vec<String> = vec![print(&args, &args.names[0])]; // initiate vector of names

    if args.multiple { // fill the rest if `-a` or `--multiple` was passed
        args.names.iter().skip(1).for_each(|name| v.append(&mut vec![print(&args, name)]));
    }

    if args.zero { // terminate with null if `-z` or `--zero` was passed
        v.iter().for_each(|name| print!("{}", name));
    } else { // terminate each name with space or new line
        v.iter().for_each(|name| println!("{} ", name));
    }
}

pub fn on_subcommand<K: Into<Key>, F: FnMut(Vec<String>)>( &mut self, key: K, f: F )

Runs function that does not return a value if specified key exists. Removes the program’s name from provided vector.

Examples found in repository

examples/subcontinued.rs (line 5)

fn main() {
    let mut j: Jargon = Jargon::from_env();
    j.on_subcommand("go", go);
}

fn go(v: Vec<String>) {
    println!("go!");
    let mut j: Jargon = Jargon::from_vec(v);
    j.on_subcommand("goo", goo)
}

fn goo(v: Vec<String>) {
    println!("goo!");
    let mut j: Jargon = Jargon::from_vec(v);
    j.on_subcommand("gooo", gooo)
}

examples/subcommand.rs (line 6)

fn main() {
    let mut j: Jargon = Jargon::from_env();

    j.on_subcommand("list", list);
    j.on_subcommand("backwards", list_backwards);
}

pub fn opt_on_subcommand<K: Into<Key>, F: FnMut(Vec<String>) -> Option<T>, T>( &mut self, key: K, f: F ) -> Option<T>

Runs function that returns Option if specified key exists. Removes the program’s name from provided vector.

pub fn res_on_subcommand<K: Into<Key>, F: FnMut(Vec<String>) -> Result<T, Error>, T>( &mut self, key: K, f: F ) -> Result<T, Error>

Runs function that returns Result<T, jargon_args::Error> if specified key exists. Removes the program’s name from provided vector.

pub fn subcommand<K: Into<Key>>(&mut self, key: K) -> Option<Vec<String>>

Checks if key exists, removes it, and returns it and all remaining arguments in Some(Vec). None if key isn’t in arguments.

pub fn option_arg<T: FromStr, K: Into<Key>>(&mut self, key: K) -> Option<T>

Checks for provided key in arguments, removes it, returns Some(String) with the value after it if there is one. None is there is no value.

Examples found in repository

examples/name.rs (line 7)

fn main() {
    let mut j: Jargon = Jargon::from_env();
    let name_key: Key = "--name".into();

    match j.option_arg::<String, Key>(name_key.clone()) {
        Some(n) => println!("Your name: {}", n),
        None => eprintln!("Missing argument: {}", name_key),
    }
}

examples/basename.rs (line 29)

fn main() {
    let mut j: Jargon = Jargon::from_env(); // Get an instance of Jargon using `std::env::args()`

    if j.contains(["-h", "--help"]) { // check for help argument
        print!("{}", HELP);
        return;
    }

    if j.contains(["-v", "--version"]) { // check for version argument
        println!(
            "basename example for Jargon crate {}",
            env!("CARGO_PKG_VERSION")
        );
        return;
    }

    let args = Args { // fill helper struct
        multiple: j.contains(["-a", "--multiple"]), // multiple
        suffix: j.option_arg(["-s", "--suffix"]), // suffix to remove
        zero: j.contains(["-z", "--zero"]), // terminate lines with null
        names: j.finish(), // get names
    };

    if args.names.is_empty() { // check if there are names
        println!("Missing NAMES");
        return;
    }

    let mut v: Vec<String> = vec![print(&args, &args.names[0])]; // initiate vector of names

    if args.multiple { // fill the rest if `-a` or `--multiple` was passed
        args.names.iter().skip(1).for_each(|name| v.append(&mut vec![print(&args, name)]));
    }

    if args.zero { // terminate with null if `-z` or `--zero` was passed
        v.iter().for_each(|name| print!("{}", name));
    } else { // terminate each name with space or new line
        v.iter().for_each(|name| println!("{} ", name));
    }
}

pub fn result_arg<T: FromStr, K: Into<Key>>( &mut self, key: K ) -> Result<T, Error>

Checks for provided key in arguments, removes it, returns Ok(String) with the value after it if there is one. Err(jargon_args::Error) is there is no value.

pub fn opt_next<T: FromStr>(&mut self) -> Option<T>

Returns the next argument as Some(T) or ‘None’ if there is no more arguments or another argument key.

pub fn finish(self) -> Vec<String>

Returns the next argument as Ok(T) or ‘Err()’ if there is no more arguments or another argument key. Drops your jargon instance and returns all remaining arguments.

Examples found in repository

examples/basename.rs (line 31)

fn main() {
    let mut j: Jargon = Jargon::from_env(); // Get an instance of Jargon using `std::env::args()`

    if j.contains(["-h", "--help"]) { // check for help argument
        print!("{}", HELP);
        return;
    }

    if j.contains(["-v", "--version"]) { // check for version argument
        println!(
            "basename example for Jargon crate {}",
            env!("CARGO_PKG_VERSION")
        );
        return;
    }

    let args = Args { // fill helper struct
        multiple: j.contains(["-a", "--multiple"]), // multiple
        suffix: j.option_arg(["-s", "--suffix"]), // suffix to remove
        zero: j.contains(["-z", "--zero"]), // terminate lines with null
        names: j.finish(), // get names
    };

    if args.names.is_empty() { // check if there are names
        println!("Missing NAMES");
        return;
    }

    let mut v: Vec<String> = vec![print(&args, &args.names[0])]; // initiate vector of names

    if args.multiple { // fill the rest if `-a` or `--multiple` was passed
        args.names.iter().skip(1).for_each(|name| v.append(&mut vec![print(&args, name)]));
    }

    if args.zero { // terminate with null if `-z` or `--zero` was passed
        v.iter().for_each(|name| print!("{}", name));
    } else { // terminate each name with space or new line
        v.iter().for_each(|name| println!("{} ", name));
    }
}

Trait Implementations

impl Clone for Jargon

fn clone(&self) -> Jargon

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Jargon

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Ord for Jargon

fn cmp(&self, other: &Jargon) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Selfwhere Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Selfwhere Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval.

impl PartialEq<Jargon> for Jargon

fn eq(&self, other: &Jargon) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd<Jargon> for Jargon

fn partial_cmp(&self, other: &Jargon) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Eq for Jargon

impl StructuralEq for Jargon

impl StructuralPartialEq for Jargon