lexarg-error 0.0.2

Argument error type for use with lexarg
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98

//! Error type for use with lexarg
//!
//! Inspired by [lexopt](https://crates.io/crates/lexopt), `lexarg` simplifies the formula down
//! further so it can be used for CLI plugin systems.
//!
//! ## Example
//!
//! ```no_run
#![doc = include_str!("../examples/hello-error.rs")]
//! ```

#![cfg_attr(docsrs, feature(doc_auto_cfg))]
#![warn(missing_debug_implementations)]
#![warn(missing_docs)]
#![warn(clippy::print_stderr)]
#![warn(clippy::print_stdout)]

/// Collect context for creating an error
#[derive(Debug)]
pub struct LexError<'a> {
    msg: String,
    within: Option<lexarg_parser::Arg<'a>>,
    unexpected: Option<lexarg_parser::Arg<'a>>,
}

impl<'a> LexError<'a> {
    /// Create a new error object from a printable error message.
    #[cold]
    pub fn msg<M>(message: M) -> Self
    where
        M: std::fmt::Display,
    {
        Self {
            msg: message.to_string(),
            within: None,
            unexpected: None,
        }
    }

    /// [`Arg`][lexarg_parser::Arg] the error occurred within
    #[cold]
    pub fn within(mut self, within: lexarg_parser::Arg<'a>) -> Self {
        self.within = Some(within);
        self
    }

    /// The failing [`Arg`][lexarg_parser::Arg]
    #[cold]
    pub fn unexpected(mut self, unexpected: lexarg_parser::Arg<'a>) -> Self {
        self.unexpected = Some(unexpected);
        self
    }
}

impl<E> From<E> for LexError<'_>
where
    E: std::error::Error + Send + Sync + 'static,
{
    #[cold]
    fn from(error: E) -> Self {
        Self::msg(error)
    }
}

impl std::fmt::Display for LexError<'_> {
    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        self.msg.fmt(formatter)?;
        if let Some(unexpected) = &self.unexpected {
            write!(formatter, ", found `")?;
            match unexpected {
                lexarg_parser::Arg::Short(short) => write!(formatter, "-{short}")?,
                lexarg_parser::Arg::Long(long) => write!(formatter, "--{long}")?,
                lexarg_parser::Arg::Escape(value) => write!(formatter, "{value}")?,
                lexarg_parser::Arg::Value(value) | lexarg_parser::Arg::Unexpected(value) => {
                    write!(formatter, "{}", value.to_string_lossy())?;
                }
            }
            write!(formatter, "`")?;
        }
        if let Some(within) = &self.within {
            write!(formatter, " when parsing `")?;
            match within {
                lexarg_parser::Arg::Short(short) => write!(formatter, "-{short}")?,
                lexarg_parser::Arg::Long(long) => write!(formatter, "--{long}")?,
                lexarg_parser::Arg::Escape(value) => write!(formatter, "{value}")?,
                lexarg_parser::Arg::Value(value) | lexarg_parser::Arg::Unexpected(value) => {
                    write!(formatter, "{}", value.to_string_lossy())?;
                }
            }
            write!(formatter, "`")?;
        }
        Ok(())
    }
}

#[doc = include_str!("../README.md")]
#[cfg(doctest)]
pub struct ReadmeDoctests;