14676016024

Committed 26 Apr 2025 12:56AM UTC coverage: 91.583%. First build

Build # 14676016024

Build Type

push

github

Committed by

Ortham

Commit Message

Deny a lot of extra lints and fix their errors

Run Details

330 of 349 new or added lines in 7 files covered. (94.56%)

4907 of 5358 relevant lines covered (91.58%)

15.83 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

58.16

/src/error.rs

use std::error;
use std::fmt;
use std::io;
use std::num::NonZeroUsize;
use std::num::ParseIntError;
use std::path::PathBuf;

use nom::error::ErrorKind;
use nom::Err;

#[expect(clippy::error_impl_error)]
#[derive(Debug)]
#[non_exhaustive]
pub enum Error {
    ParsingIncomplete(MoreDataNeeded),
    // The string is the input that was not parsed.
    UnconsumedInput(String),
    /// The string is the input at which the error was encountered.
    ParsingError(String, ParsingErrorKind),
    PeParsingError(PathBuf, Box<dyn error::Error + Send + Sync + 'static>),
    IoError(PathBuf, io::Error),
}

fn escape<I: fmt::Display>(input: I) -> String {
    input.to_string().replace('"', "\\\"")
}

impl<I: fmt::Debug + fmt::Display> From<Err<ParsingError<I>>> for Error {
    fn from(error: Err<ParsingError<I>>) -> Self {
        match error {
            Err::Incomplete(nom::Needed::Unknown) => {
                Error::ParsingIncomplete(MoreDataNeeded::UnknownSize)
            }
            Err::Incomplete(nom::Needed::Size(size)) => {
                Error::ParsingIncomplete(MoreDataNeeded::Size(size))
            }
            Err::Error(e) | Err::Failure(e) => Error::ParsingError(escape(e.input), e.kind),
        }
    }
}

impl fmt::Display for Error {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            Error::ParsingIncomplete(MoreDataNeeded::UnknownSize) => write!(
                f,
                "An unknown number of bytes of additional input was expected by the parser"
            ),
            Error::ParsingIncomplete(MoreDataNeeded::Size(size)) => write!(
                f,
                "{size} bytes of additional input was expected by the parser"
            ),
            Error::UnconsumedInput(i) => {
                write!(f, "The parser did not consume the following input: \"{i}\"")
            }
            Error::ParsingError(i, e) => write!(
                f,
                "An error was encountered while parsing the expression \"{i}\": {e}"
            ),
            Error::PeParsingError(p, e) => write!(
                f,
                "An error was encountered while reading the version fields of \"{}\": {}",
                p.display(),
                e
            ),
            Error::IoError(p, e) => write!(
                f,
                "An error was encountered while accessing the path \"{}\": {}",
                p.display(),
                e
            ),
        }
    }
}

impl error::Error for Error {
    fn source(&self) -> Option<&(dyn error::Error + 'static)> {
        match self {
            Error::ParsingError(_, e) => Some(e),
            Error::PeParsingError(_, e) => Some(e.as_ref()),
            Error::IoError(_, e) => Some(e),
            _ => None,
        }
    }
}

#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub enum MoreDataNeeded {
    /// It's not known how much more data are needed
    UnknownSize,
    /// Contains the number of bytes of data that are needed
    Size(NonZeroUsize),
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub struct ParsingError<I: fmt::Debug + fmt::Display> {
    input: I,
    kind: ParsingErrorKind,
}

impl<I: fmt::Debug + fmt::Display> From<(I, ErrorKind)> for ParsingError<I> {
    fn from((input, kind): (I, ErrorKind)) -> Self {
        use nom::error::ParseError;
        ParsingError::from_error_kind(input, kind)
    }
}

impl<I: fmt::Debug + fmt::Display> From<nom::error::Error<I>> for ParsingError<I> {
    fn from(error: nom::error::Error<I>) -> Self {
        use nom::error::ParseError;
        ParsingError::from_error_kind(error.input, error.code)
    }
}

impl<I: fmt::Debug + fmt::Display> fmt::Display for ParsingError<I> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(
            f,
            "An error was encountered while parsing the expression \"{}\": {}",
            self.input, self.kind
        )
    }
}

impl<I: fmt::Debug + fmt::Display> error::Error for ParsingError<I> {
    fn source(&self) -> Option<&(dyn error::Error + 'static)> {
        self.kind.source()
    }
}

impl<I: fmt::Debug + fmt::Display> nom::error::ParseError<I> for ParsingError<I> {
    fn from_error_kind(input: I, kind: ErrorKind) -> Self {
        ParsingError {
            input,
            kind: ParsingErrorKind::GenericParserError(kind.description().to_owned()),
        }
    }

    fn append(_: I, _: ErrorKind, other: Self) -> Self {
        other
    }
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub enum ParsingErrorKind {
    InvalidRegexSyntax(String),
    InvalidRegexUnknown,
    InvalidCrc(ParseIntError),
    PathEndsInADirectorySeparator(PathBuf),
    PathIsNotInGameDirectory(PathBuf),
    GenericParserError(String),
}

impl ParsingErrorKind {
    pub fn at<I: fmt::Debug + fmt::Display>(self, input: I) -> ParsingError<I> {
        ParsingError { input, kind: self }
    }
}

impl From<regex::Error> for ParsingErrorKind {
    fn from(error: regex::Error) -> Self {
        match error {
            regex::Error::Syntax(s) => ParsingErrorKind::InvalidRegexSyntax(s),
            _ => ParsingErrorKind::InvalidRegexUnknown,
        }
    }
}

impl From<ParseIntError> for ParsingErrorKind {
    fn from(error: ParseIntError) -> Self {
        ParsingErrorKind::InvalidCrc(error)
    }
}

impl error::Error for ParsingErrorKind {
    fn source(&self) -> Option<&(dyn error::Error + 'static)> {
        match self {
            ParsingErrorKind::InvalidCrc(e) => Some(e),
            _ => None,
        }
    }
}

impl fmt::Display for ParsingErrorKind {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            ParsingErrorKind::InvalidRegexSyntax(s) => write!(f, "{s}"),
            ParsingErrorKind::InvalidRegexUnknown => write!(f, "Unknown regex parsing error"),
            ParsingErrorKind::InvalidCrc(e) => e.fmt(f),
            ParsingErrorKind::PathEndsInADirectorySeparator(p) => {
                write!(f, "\"{}\" ends in a directory separator", p.display())
            }
            ParsingErrorKind::PathIsNotInGameDirectory(p) => {
                write!(f, "\"{}\" is not in the game directory", p.display())
            }
            ParsingErrorKind::GenericParserError(e) => write!(f, "Error in parser: {e}"),
        }
    }
}

1	use std::error;
2	use std::fmt;
3	use std::io;
4	use std::num::NonZeroUsize;
5	use std::num::ParseIntError;
6	use std::path::PathBuf;
7
8	use nom::error::ErrorKind;
9	use nom::Err;
10
11	#[expect(clippy::error_impl_error)]
12	#[derive(Debug)]
13	#[non_exhaustive]
14	pub enum Error {
15	ParsingIncomplete(MoreDataNeeded),
16	// The string is the input that was not parsed.
17	UnconsumedInput(String),
18	/// The string is the input at which the error was encountered.
19	ParsingError(String, ParsingErrorKind),
20	PeParsingError(PathBuf, Box<dyn error::Error + Send + Sync + 'static>),
21	IoError(PathBuf, io::Error),
22	}
23
24	fn escape<I: fmt::Display>(input: I) -> String {	4✔
25	input.to_string().replace('"', "\\\"")	4✔
26	}	4✔
27
28	impl<I: fmt::Debug + fmt::Display> From<Err<ParsingError<I>>> for Error {
29	fn from(error: Err<ParsingError<I>>) -> Self {	4✔
30	match error {	×
31	Err::Incomplete(nom::Needed::Unknown) => {
32	Error::ParsingIncomplete(MoreDataNeeded::UnknownSize)	×
33	}
34	Err::Incomplete(nom::Needed::Size(size)) => {	×
35	Error::ParsingIncomplete(MoreDataNeeded::Size(size))	×
36	}
37	Err::Error(e) \| Err::Failure(e) => Error::ParsingError(escape(e.input), e.kind),	4✔
38	}
39	}	4✔
40	}
41
42	impl fmt::Display for Error {
43	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {	10✔
44	match self {	×
45	Error::ParsingIncomplete(MoreDataNeeded::UnknownSize) => write!(	×
46	f,	×
47	"An unknown number of bytes of additional input was expected by the parser"	×
48	),	×
49	Error::ParsingIncomplete(MoreDataNeeded::Size(size)) => write!(	×
50	f,	×
51	"{size} bytes of additional input was expected by the parser"	×
52	),	×
53	Error::UnconsumedInput(i) => {	2✔
54	write!(f, "The parser did not consume the following input: \"{i}\"")	2✔
55	}
56	Error::ParsingError(i, e) => write!(	4✔
57	f,	4✔
58	"An error was encountered while parsing the expression \"{i}\": {e}"	4✔
59	),	4✔
60	Error::PeParsingError(p, e) => write!(	2✔
61	f,	2✔
62	"An error was encountered while reading the version fields of \"{}\": {}",	2✔
63	p.display(),	2✔
64	e	2✔
65	),	2✔
66	Error::IoError(p, e) => write!(	2✔
67	f,	2✔
68	"An error was encountered while accessing the path \"{}\": {}",	2✔
69	p.display(),	2✔
70	e	2✔
71	),	2✔
72	}
73	}	10✔
74	}
75
76	impl error::Error for Error {
77	fn source(&self) -> Option<&(dyn error::Error + 'static)> {	×
78	match self {	×
79	Error::ParsingError(_, e) => Some(e),	×
80	Error::PeParsingError(_, e) => Some(e.as_ref()),	×
81	Error::IoError(_, e) => Some(e),	×
82	_ => None,	×
83	}
84	}	×
85	}
86
87	#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
88	pub enum MoreDataNeeded {
89	/// It's not known how much more data are needed
90	UnknownSize,
91	/// Contains the number of bytes of data that are needed
92	Size(NonZeroUsize),
93	}
94
95	#[derive(Clone, Debug, Eq, PartialEq)]
96	pub struct ParsingError<I: fmt::Debug + fmt::Display> {
97	input: I,
98	kind: ParsingErrorKind,
99	}
100
101	impl<I: fmt::Debug + fmt::Display> From<(I, ErrorKind)> for ParsingError<I> {
102	fn from((input, kind): (I, ErrorKind)) -> Self {	×
103	use nom::error::ParseError;
104	ParsingError::from_error_kind(input, kind)	×
105	}	×
106	}
107
108	impl<I: fmt::Debug + fmt::Display> From<nom::error::Error<I>> for ParsingError<I> {
109	fn from(error: nom::error::Error<I>) -> Self {	764✔
110	use nom::error::ParseError;
111	ParsingError::from_error_kind(error.input, error.code)	764✔
112	}	764✔
113	}
114
115	impl<I: fmt::Debug + fmt::Display> fmt::Display for ParsingError<I> {
116	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {	×
117	write!(	×
118	f,	×
119	"An error was encountered while parsing the expression \"{}\": {}",	×
120	self.input, self.kind	×
121	)	×
122	}	×
123	}
124
125	impl<I: fmt::Debug + fmt::Display> error::Error for ParsingError<I> {
126	fn source(&self) -> Option<&(dyn error::Error + 'static)> {	×
127	self.kind.source()	×
128	}	×
129	}
130
131	impl<I: fmt::Debug + fmt::Display> nom::error::ParseError<I> for ParsingError<I> {
132	fn from_error_kind(input: I, kind: ErrorKind) -> Self {	764✔
133	ParsingError {	764✔
134	input,	764✔
135	kind: ParsingErrorKind::GenericParserError(kind.description().to_owned()),	764✔
136	}	764✔
137	}	764✔
138
139	fn append(_: I, _: ErrorKind, other: Self) -> Self {	17✔
140	other	17✔
141	}	17✔
142	}
143
144	#[derive(Clone, Debug, Eq, PartialEq)]
145	pub enum ParsingErrorKind {
146	InvalidRegexSyntax(String),
147	InvalidRegexUnknown,
148	InvalidCrc(ParseIntError),
149	PathEndsInADirectorySeparator(PathBuf),
150	PathIsNotInGameDirectory(PathBuf),
151	GenericParserError(String),
152	}
153
154	impl ParsingErrorKind {
155	pub fn at<I: fmt::Debug + fmt::Display>(self, input: I) -> ParsingError<I> {	18✔
156	ParsingError { input, kind: self }	18✔
157	}	18✔
158	}
159
160	impl From<regex::Error> for ParsingErrorKind {
161	fn from(error: regex::Error) -> Self {	1✔
162	match error {	1✔
163	regex::Error::Syntax(s) => ParsingErrorKind::InvalidRegexSyntax(s),	1✔
164	_ => ParsingErrorKind::InvalidRegexUnknown,	×
165	}
166	}	1✔
167	}
168
169	impl From<ParseIntError> for ParsingErrorKind {
170	fn from(error: ParseIntError) -> Self {	1✔
171	ParsingErrorKind::InvalidCrc(error)	1✔
172	}	1✔
173	}
174
175	impl error::Error for ParsingErrorKind {
176	fn source(&self) -> Option<&(dyn error::Error + 'static)> {	×
177	match self {	×
178	ParsingErrorKind::InvalidCrc(e) => Some(e),	×
179	_ => None,	×
180	}
181	}	×
182	}
183
184	impl fmt::Display for ParsingErrorKind {
185	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {	4✔
186	match self {	4✔
187	ParsingErrorKind::InvalidRegexSyntax(s) => write!(f, "{s}"),	1✔
188	ParsingErrorKind::InvalidRegexUnknown => write!(f, "Unknown regex parsing error"),	×
189	ParsingErrorKind::InvalidCrc(e) => e.fmt(f),	1✔
190	ParsingErrorKind::PathEndsInADirectorySeparator(p) => {	1✔
191	write!(f, "\"{}\" ends in a directory separator", p.display())	1✔
192	}
193	ParsingErrorKind::PathIsNotInGameDirectory(p) => {	1✔
194	write!(f, "\"{}\" is not in the game directory", p.display())	1✔
195	}
NEW 196	ParsingErrorKind::GenericParserError(e) => write!(f, "Error in parser: {e}"),	×
197	}
198	}	4✔
199	}

loot / loot-condition-interpreter / 14676016024

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous