Struct Jargon

pub struct Jargon(/* private fields */);

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.

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

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 duplicate of the value.

const 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) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

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

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for Jargon

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl PartialOrd 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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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

impl Eq for Jargon

impl StructuralPartialEq for Jargon