Struct LexError 

pub struct LexError<'a> { /* private fields */ }

Collect context for creating an error

Implementations

impl<'a> LexError<'a>

pub fn msg<M>(message: M) -> Self

where M: Display,

Create a new error object from a printable error message.

Examples found in repository

examples/hello-error.rs (line 26)

fn parse_args() -> Result<Args, String> {
    #![allow(clippy::enum_glob_use)]
    use lexarg_parser::Arg::*;

    let mut thing = None;
    let mut number = 1;
    let mut shout = false;
    let raw = std::env::args_os().collect::<Vec<_>>();
    let mut parser = lexarg_parser::Parser::new(&raw);
    let bin_name = parser
        .next_raw()
        .expect("nothing parsed yet so no attached lingering")
        .expect("always at least one");
    while let Some(arg) = parser.next_arg() {
        match arg {
            Short("n") | Long("number") => {
                let value = parser.next_flag_value().ok_or_else(|| {
                    LexError::msg("missing required value")
                        .within(arg)
                        .to_string()
                })?;
                number = value
                    .to_str()
                    .ok_or_else(|| {
                        LexError::msg("invalid number")
                            .unexpected(Value(value))
                            .within(arg)
                            .to_string()
                    })?
                    .parse()
                    .map_err(|e| {
                        LexError::msg(e)
                            .unexpected(Value(value))
                            .within(arg)
                            .to_string()
                    })?;
            }
            Long("shout") => {
                shout = true;
            }
            Value(val) if thing.is_none() => {
                thing =
                    Some(val.to_str().ok_or_else(|| {
                        LexError::msg("invalid string").unexpected(arg).to_string()
                    })?);
            }
            Short("h") | Long("help") => {
                println!("Usage: hello [-n|--number=NUM] [--shout] THING");
                std::process::exit(0);
            }
            _ => {
                return Err(LexError::msg("unexpected argument")
                    .unexpected(arg)
                    .to_string());
            }
        }
    }

    Ok(Args {
        thing: thing
            .ok_or_else(|| {
                LexError::msg("missing argument THING")
                    .within(Value(bin_name))
                    .to_string()
            })?
            .to_owned(),
        number,
        shout,
    })
}

pub fn within(self, within: Arg<'a>) -> Self

Arg the error occurred within

Examples found in repository

examples/hello-error.rs (line 27)

fn parse_args() -> Result<Args, String> {
    #![allow(clippy::enum_glob_use)]
    use lexarg_parser::Arg::*;

    let mut thing = None;
    let mut number = 1;
    let mut shout = false;
    let raw = std::env::args_os().collect::<Vec<_>>();
    let mut parser = lexarg_parser::Parser::new(&raw);
    let bin_name = parser
        .next_raw()
        .expect("nothing parsed yet so no attached lingering")
        .expect("always at least one");
    while let Some(arg) = parser.next_arg() {
        match arg {
            Short("n") | Long("number") => {
                let value = parser.next_flag_value().ok_or_else(|| {
                    LexError::msg("missing required value")
                        .within(arg)
                        .to_string()
                })?;
                number = value
                    .to_str()
                    .ok_or_else(|| {
                        LexError::msg("invalid number")
                            .unexpected(Value(value))
                            .within(arg)
                            .to_string()
                    })?
                    .parse()
                    .map_err(|e| {
                        LexError::msg(e)
                            .unexpected(Value(value))
                            .within(arg)
                            .to_string()
                    })?;
            }
            Long("shout") => {
                shout = true;
            }
            Value(val) if thing.is_none() => {
                thing =
                    Some(val.to_str().ok_or_else(|| {
                        LexError::msg("invalid string").unexpected(arg).to_string()
                    })?);
            }
            Short("h") | Long("help") => {
                println!("Usage: hello [-n|--number=NUM] [--shout] THING");
                std::process::exit(0);
            }
            _ => {
                return Err(LexError::msg("unexpected argument")
                    .unexpected(arg)
                    .to_string());
            }
        }
    }

    Ok(Args {
        thing: thing
            .ok_or_else(|| {
                LexError::msg("missing argument THING")
                    .within(Value(bin_name))
                    .to_string()
            })?
            .to_owned(),
        number,
        shout,
    })
}

pub fn unexpected(self, unexpected: Arg<'a>) -> Self

The failing Arg

Examples found in repository

examples/hello-error.rs (line 34)

fn parse_args() -> Result<Args, String> {
    #![allow(clippy::enum_glob_use)]
    use lexarg_parser::Arg::*;

    let mut thing = None;
    let mut number = 1;
    let mut shout = false;
    let raw = std::env::args_os().collect::<Vec<_>>();
    let mut parser = lexarg_parser::Parser::new(&raw);
    let bin_name = parser
        .next_raw()
        .expect("nothing parsed yet so no attached lingering")
        .expect("always at least one");
    while let Some(arg) = parser.next_arg() {
        match arg {
            Short("n") | Long("number") => {
                let value = parser.next_flag_value().ok_or_else(|| {
                    LexError::msg("missing required value")
                        .within(arg)
                        .to_string()
                })?;
                number = value
                    .to_str()
                    .ok_or_else(|| {
                        LexError::msg("invalid number")
                            .unexpected(Value(value))
                            .within(arg)
                            .to_string()
                    })?
                    .parse()
                    .map_err(|e| {
                        LexError::msg(e)
                            .unexpected(Value(value))
                            .within(arg)
                            .to_string()
                    })?;
            }
            Long("shout") => {
                shout = true;
            }
            Value(val) if thing.is_none() => {
                thing =
                    Some(val.to_str().ok_or_else(|| {
                        LexError::msg("invalid string").unexpected(arg).to_string()
                    })?);
            }
            Short("h") | Long("help") => {
                println!("Usage: hello [-n|--number=NUM] [--shout] THING");
                std::process::exit(0);
            }
            _ => {
                return Err(LexError::msg("unexpected argument")
                    .unexpected(arg)
                    .to_string());
            }
        }
    }

    Ok(Args {
        thing: thing
            .ok_or_else(|| {
                LexError::msg("missing argument THING")
                    .within(Value(bin_name))
                    .to_string()
            })?
            .to_owned(),
        number,
        shout,
    })
}

Trait Implementations

impl<'a> Debug for LexError<'a>

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

Formats the value using the given formatter.

impl Display for LexError<'_>

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

Formats the value using the given formatter.

impl<E> From<E> for LexError<'_>

where E: Error + Send + Sync + 'static,

fn from(error: E) -> Self

Converts to this type from the input type.